How to Use the LEAP Legal MCP in OpenAI Agents SDK

Q: How does the OpenAI Agents SDK authenticate with LEAP Legal?

You paste your single Vinkius endpoint token into the MCPServerStreamableHttp parameter block. Vinkius handles the underlying OAuth handshake to connect the MCP Server to LEAP Legal. Your Python code never touches raw API keys or client credentials.

Q: How do agent handoffs work when processing legal documents?

You configure one agent to retrieve files using getmattercorrespondence and hand the data to a specialist agent. The second agent parses the correspondence list to find specific dates. This keeps your LLM prompts focused and saves token costs.

Run safe, production-grade OpenAI Agents SDK systems that query legal files and update contacts using this MCP Server.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect LEAP Legal MCP to OpenAI Agents SDK

Create your Vinkius account to connect LEAP Legal to OpenAI Agents SDK and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup LEAP Legal with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Run secure legal updates via the OpenAI Agents SDK MCP Server

`list_matters` identifies legal case IDs so your OpenAI Agents SDK system can fetch the right records. You pass the MCP Server to the Agent constructor using `mcp_servers=[server]`. The agent auto-discovers every available action without manual schema mapping. This setup lets your system match matter files against active client records. If the agent detects a missing address, it calls `create_new_card` to insert the new contact card. You monitor the entire tool execution trace directly inside your OpenAI developer dashboard.

Direct document retrieval with safety guardrails

`get_matter_documents_only` pulls files associated with specific cases straight to your OpenAI Agents SDK run. The SDK applies your custom runtime guardrails to verify the agent has permission to access these files before executing the call. You prevent unauthorized file access by setting strict system rules. Your agent reads the retrieved files to extract critical dates or case numbers. When running complex multi-agent handoffs, one agent can pull the files while another drafts the response. Setting `cacheToolsList=True` keeps these multi-agent operations running at peak speed.

Real-time contact synchronization

`update_existing_card` modifies contact details in your LEAP Legal database. The OpenAI Agents SDK executes this tool after confirming the new contact details match your schema requirements. This process runs within an async context manager to handle multiple concurrent updates. Paralegals avoid manual double-entry when client details change. Your agent checks existing contacts using `get_card_details` and applies modifications instantly. You see every modification logged in your central tracing panel.

Setup guide

Set up LEAP Legal MCP in OpenAI Agents SDK

Prerequisites

Python 3.10+ installed
openai-agents package (pip install openai-agents)
Active Vinkius subscription with a valid endpoint token

1

Install the SDK

Run pip install openai-agents to install the OpenAI Agents SDK. The MCP integration is built-in — no extra dependencies needed.
2

Connect via SSE transport

Use MCPServerSse with your Vinkius endpoint URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. The SDK auto-discovers all LEAP Legal tools at runtime.
3

Create your Agent

Pass the MCP to Agent(mcp_servers=[server]). The agent receives LEAP Legal tools as native definitions — JSON schemas resolve automatically.
4

Run the agent

Call Runner.run(agent, prompt) to execute. The agent invokes the appropriate LEAP Legal tools and returns structured results. Copy the full example on the right to get started.

agent.py

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerSse

async def main():
    async with MCPServerSse(
        url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
    ) as server:
        agent = Agent(
            name="LEAP Legal Agent",
            instructions="You have access to LEAP Legal tools.",
            mcp_servers=[server],
        )
        result = await Runner.run(agent, "List recent transactions")
        print(result.final_output)

asyncio.run(main())

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by LEAP Legal. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect LEAP Legal now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about LEAP Legal MCP in OpenAI Agents SDK

You paste your single Vinkius endpoint token into the `MCPServerStreamableHttp` parameter block. Vinkius handles the underlying OAuth handshake to connect the MCP Server to LEAP Legal. Your Python code never touches raw API keys or client credentials.

Yes, you control this by configuring your agent's system instructions or restricting the server context list. The SDK automatically registers the active tools during initialization. You can also deploy separate agents for read-only tasks like `list_cards` and write tasks like `create_new_card`.

The SDK handles rate limits by throwing standard execution errors when the LEAP API returns a 429 status. To avoid hitting these limits during peak hours, write a queue mechanism in your Python application. This prevents bulk operations from blocking critical calls like `get_matter_details`.

You configure one agent to retrieve files using `get_matter_correspondence` and hand the data to a specialist agent. The second agent parses the correspondence list to find specific dates. This keeps your LLM prompts focused and saves token costs.

Your contact cards, matter details, and legal documents remain isolated in ephemeral Vinkius sandboxes. Vinkius executes each MCP tool call in a secure V8 isolate container that destroys itself immediately after execution. No legal data is cached or stored on the hosting infrastructure.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript