How to Use the Nango (Unified API & Integration Platform) MCP in Pydantic AI

Q: Is the setup complicated?

It's straightforward. You install pydantic-ai-slimmcp, create an MCPToolset with the server URL, and add it to your agent. The framework handles all the validation behind the scenes.

Bring type-safe reliability to your integration management. Your Pydantic AI agent gets validated, predictable access to your Nango instance.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Nango (Unified API & Integration Platform) MCP to Pydantic AI

Create your Vinkius account to connect Nango (Unified API & Integration Platform) 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 Nango (Unified API & Integration Platform) with Pydantic AI

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Get Validated Connection Status

Stop writing defensive code to handle weird API responses. With this MCP server, when your agent calls `list_connections`, Pydantic AI validates the response against a strict schema. You get a clean list of connection objects, or a loud `ValidationError` if the data is malformed. This means you can trust the output. If `get_connection` returns an object, you know for a fact it has the expected fields like `provider`, `connection_id`, and `created`. No more `KeyError` exceptions from missing fields in production.

Trust Your Sync History

Auditing data syncs requires data you can depend on. The `list_syncs` tool returns a history of synchronization jobs, and every entry is guaranteed to match the Pydantic model. Your agent won't get confused by inconsistent timestamps or missing status fields. This correctness is critical for any agent using this MCP toolset. Your agent can confidently parse the output from `list_syncs` to build reports or trigger alerts, knowing the data structure is exactly what it expects. It removes an entire class of bugs.

Type-Safe Records with Pydantic AI

Nango unifies records from different sources, but this MCP Server ensures they arrive in your agent with a predictable structure. A call to `list_records` doesn't just return JSON; it returns Pydantic objects that have been rigorously checked. If an upstream API adds a new field or changes a data type unexpectedly, your agent won't silently corrupt its state. Pydantic AI will raise an exception immediately, pointing to the exact mismatch. It's how you build reliable systems on top of unreliable APIs.

Setup guide

Set up Nango (Unified API & Integration Platform) 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": {
        "nango-unified-api-integration-platform-mcp": {
            "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
        }
    }
})

agent = Agent(
    "openai:gpt-4o",
    toolsets=[toolset],
    system_prompt="You have access to Nango (Unified API & Integration Platform) tools.",
)

result = await agent.run("List recent Nango (Unified API & Integration Platform) 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 Nango. 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 Nango (Unified API & Integration Platform) 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 Nango (Unified API & Integration Platform) MCP in Pydantic AI

Because managing dozens of integrations means dealing with unpredictable API responses. Pydantic AI enforces correctness, ensuring that any data from Nango—be it connection metadata or synced records—is validated before your agent ever touches it.

It's straightforward. You install `pydantic-ai-slim[mcp]`, create an `MCPToolset` with the server URL, and add it to your agent. The framework handles all the validation behind the scenes.

If Nango's API returns something unexpected, Pydantic AI throws a `ValidationError` that tells you exactly which field is wrong. This makes debugging a data issue with `list_records` much faster than trying to figure out why your agent is misbehaving.

Yes. Pydantic AI is model-agnostic. You can use OpenAI, Anthropic, Gemini, or a local model to power your agent, and it will still get the same type-safe, validated tool access to your Nango MCP Server.

The server fetches Nango connection metadata, integration configurations, and sync records on your agent's behalf. Your Vinkius token authorizes these requests within a secure, single-tenant runtime. The key thing is that Pydantic AI validates this data on the client side, ensuring no malformed data like incomplete sync logs ever enters your application logic.

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