How to Use the MyCase Legal MCP in Pydantic AI

Q: How do I configure MyCase Legal with Pydantic AI?

Install the slim package with the MCP extra. Initialize an MCPToolset pointing to your server URL and attach it to your Agent. The framework immediately enforces strict typing on all 16 endpoints.

Q: Can I use local models to manage my law firm data?

Yes. You route searchmycasematters through Ollama or vLLM. The MCP toolset layer abstracts the API communication so your local instance interacts with the endpoints just like GPT-4 would.

Q: How does Pydantic AI protect MyCase Legal client confidentiality?

Your getmycasecontact data flows through a zero-trust sandbox that disappears after the request. No persistent memory retains the client details. You maintain strict control over where the typed data goes after validation.

Build type-safe legal agents with Pydantic AI that validate every MyCase API response before touching your firm's database.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect MyCase Legal MCP to Pydantic AI

Create your Vinkius account to connect MyCase Legal to Pydantic AI 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 MyCase Legal with Pydantic AI

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Type-safe billing with Pydantic AI

Bad data in a law firm leads to disciplinary action. When your MCP agent calls `create_mycase_time_entry`, Pydantic AI validates the exact minute duration and matter ID against your strict schemas. If the LLM hallucinates a string instead of an integer, the framework fails loudly before hitting the billing system. You never have to worry about silent corruption. The agent retrieves records via `get_mycase_invoice` and maps them directly to your internal Python models. If the API returns unexpected nested objects, you get a clear validation error instead of a corrupted database.

Update legal cases without hallucination

Changing a case status requires absolute precision. Your agent executes `update_mycase_matter` to close files or reassign practice areas. Because you define the exact literal types for statuses like "closed" or "on_hold", the model cannot invent invalid categories. This strictness makes complex workflows possible. An agent pulls a list of files using `list_mycase_matters`, filters them by client, and updates them in bulk. You get the autonomy of an LLM with the rigid safety of compiled code.

Connect any model to your MCP Server

You aren't locked into a single provider. You use Anthropic for complex legal reasoning on `list_mycase_documents` and switch to a cheaper local model for basic routing. The framework handles the tool execution exactly the same way regardless of the brain behind it. Setup takes minutes using the unified toolset approach. You instantiate `MCPToolset` with your HTTP endpoint and pass it to the agent. The system automatically registers `get_client_mycase_cases` and every other endpoint with full type hinting.

Setup guide

Set up MyCase Legal MCP in Pydantic AI

Prerequisites

Python 3.10+ installed
pydantic-ai-slim[fastmcp] package
Active Vinkius subscription with a valid endpoint token

1

Install Pydantic AI with FastMCP
Run pip install "pydantic-ai-slim[fastmcp]". The FastMCP toolset replaces the deprecated MCPServerHTTP class with full protocol support.
2

Configure the FastMCPToolset
Pass a JSON-style config dict to FastMCPToolset with your Vinkius URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. Supports Streamable HTTP, SSE, and Stdio transports.
3

Create and run your agent
Pass the toolset to Agent(toolsets=[toolset]) and call agent.run(). Swap openai:gpt-4o for any supported model — Anthropic, Google, Mistral, or Groq.

agent.py

from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

toolset = FastMCPToolset({
    "mcpServers": {
        "mycase-legal-mcp": {
            "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
        }
    }
})

agent = Agent(
    "openai:gpt-4o",
    toolsets=[toolset],
    system_prompt="You have access to MyCase Legal tools.",
)

result = await agent.run("List recent MyCase Legal transactions")
print(result.output)

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 MyCase. 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 MyCase 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 MyCase Legal MCP in Pydantic AI

Install the slim package with the MCP extra. Initialize an `MCPToolset` pointing to your server URL and attach it to your Agent. The framework immediately enforces strict typing on all 16 endpoints.

The framework throws a runtime validation error immediately. Your agent will not process malformed payloads from `list_mycase_payments`, preventing bad data from entering your production systems.

Yes. You route `search_mycase_matters` through Ollama or vLLM. The MCP toolset layer abstracts the API communication so your local instance interacts with the endpoints just like GPT-4 would.

You choose between Streamable HTTP or SSE transports depending on your infrastructure. This prevents timeouts when pulling massive text blocks via `list_mycase_documents`.

Your `get_mycase_contact` data flows through a zero-trust sandbox that disappears after the request. No persistent memory retains the client details. You maintain strict control over where the typed data goes after validation.

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