How to Use the AMcards MCP in Pydantic AI

Q: How do I add the AMcards tools to my Pydantic AI agent?

Create an MCPToolset instance with the server URL and pass it into the toolsets list when you initialize your Agent. The framework handles the rest.

Q: What happens if the AMcards API changes and my Pydantic AI agent isn't updated?

Your agent will raise ValidationError exceptions. This is the main benefit—it fails loudly and immediately if the data from tools like listdripcampaigns no longer matches your Pydantic models, preventing data corruption.

Connect AMcards to Pydantic AI for type-safe card sending. Get validated Pydantic models back from every tool call, guaranteed.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect AMcards MCP to Pydantic AI

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Guaranteed Correctness for Every Call

Pydantic AI validates every response from the AMcards MCP Server against your Pydantic models. When your agent calls `get_card_sending_history`, the list of results is parsed into a validated model. If the API returns a malformed date or a missing field, your agent will raise a `ValidationError` instead of silently failing later. This makes your agent predictable. You can call `send_greeting_card` and trust that the response—whether it's a success confirmation or an error—matches the schema you defined. There's no guesswork about what fields the AMcards server will return. If it's not in the model, the call fails loudly.

Use Any LLM with This MCP Server

This server works with whatever LLM you're using. Because Pydantic AI is model-agnostic, you can connect to AMcards using an agent powered by OpenAI, Anthropic, Gemini, or even a local model. The tool-calling logic is handled by Pydantic AI, not the model provider. You just add the `MCPToolset` to your agent's configuration. Your agent can then discover and use tools like `list_card_templates` and `list_drip_campaigns`. The framework ensures the outputs are parsed correctly, no matter which backend LLM is making the tool-use decision.

Build Agents That Don't Fail Silently

The `check_api_health` tool is a perfect fit for a correctness-focused framework like Pydantic AI. You can define a simple Pydantic model for the expected success response. This gives you a type-safe way to verify the AMcards service is up before your agent attempts any actions that cost money or affect customers. Imagine your agent needs to find a specific webhook. It calls `list_configured_webhooks`. Pydantic AI doesn't just pass back a raw JSON blob; it parses the response into a list of strongly-typed webhook objects. You can work with that data immediately, knowing every field and data type is exactly what you expect.

Setup guide

Set up AMcards 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": {
        "amcards-mcp": {
            "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
        }
    }
})

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

result = await agent.run("List recent AMcards 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 AMcards. 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 AMcards 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 AMcards MCP in Pydantic AI

Every response from the AMcards MCP Server is validated against a Pydantic model. If the API returns unexpected data from a tool like `get_card_sending_history`, Pydantic AI raises an error instead of letting your agent use bad data.

Yes. Pydantic AI is model-agnostic. As long as your model supports tool calling, you can connect it to the AMcards server to `send_greeting_card` or `list_card_templates`.

Create an `MCPToolset` instance with the server URL and pass it into the `toolsets` list when you initialize your `Agent`. The framework handles the rest.

Your agent will raise `ValidationError` exceptions. This is the main benefit—it fails loudly and immediately if the data from tools like `list_drip_campaigns` no longer matches your Pydantic models, preventing data corruption.

The server only handles the data required for its tools, primarily recipient contact info for `send_greeting_card`. Vinkius ensures data in transit is encrypted. Each request is processed within a single-use, isolated compute instance that is destroyed after the request is complete, leaving no data at rest.

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