How to Use the Landbot MCP in Pydantic AI

Q: How do I use Landbot tools with a Pydantic AI agent?

Install pydantic-ai-slimmcp, then create an MCPToolset pointing to your server URL. Pass that toolset into the Agent constructor. Pydantic AI handles the discovery and schema validation for you.

Q: What happens if the Landbot API returns bad data to my Pydantic AI agent?

Your agent will immediately raise a ValidationError. This is the core benefit of Pydantic AI—it prevents your agent from working with malformed data, so you find out about API changes or bugs instantly.

Q: How does a Pydantic AI agent initiate a chat with a person in Landbot?

The agent uses the handofftoagent tool. You can build logic where the agent first checks who is available with listteamagents before making the handoff call, ensuring the request is routed correctly.

Build type-safe, reliable Landbot agents that never fail silently with Pydantic AI.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Landbot MCP to Pydantic AI

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Build Agents That Don't Break

Pydantic AI's main job is to enforce correctness. When your agent calls `get_customer_details`, the JSON response from Landbot is automatically parsed and validated against a Pydantic model. If Landbot ever adds a field, removes one, or changes a data type, your agent will raise a `ValidationError` immediately. This means no more silent data corruption. You can build automation around `update_customer_field` and trust that the data you're writing matches the exact schema you defined. It's reliability you can build a business on.

Control Landbot with Any LLM

Pydantic AI is model-agnostic. You can use the same code to control Landbot whether you're using OpenAI, Anthropic, Gemini, or a local model. Your agent can `list_active_bots`, decide which one to use, and `trigger_bot_flow` for a customer. If you decide to switch LLM providers, you don't have to rewrite any of your Landbot integration logic. The tools, like `send_proactive_text` or `handoff_to_agent`, are abstracted away by this MCP Server. Just swap out the LLM client, and your agent keeps working.

Type-Safe Bot and Agent Management

Managing a support queue requires accurate data. Your Pydantic AI agent can call `list_team_agents`, and you're guaranteed to get a list of objects matching your `Agent` model, or the program stops. No guessing if a field is null or a string. This strictness is perfect for building dependable workflows. An agent can get a list of all current users with `list_landbot_customers`, cross-reference them with an internal database, and then send a targeted `send_whatsapp_template`—all with the confidence that every data object is valid at every step.

Setup guide

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

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

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

Install `pydantic-ai-slim[mcp]`, then create an `MCPToolset` pointing to your server URL. Pass that toolset into the `Agent` constructor. Pydantic AI handles the discovery and schema validation for you.

Your agent will immediately raise a `ValidationError`. This is the core benefit of Pydantic AI—it prevents your agent from working with malformed data, so you find out about API changes or bugs instantly.

Yes. Pydantic AI is model-agnostic. As long as your local LLM is compatible with the framework, you can use it to call all the Landbot tools like `trigger_bot_flow` or `update_customer_field`.

The agent uses the `handoff_to_agent` tool. You can build logic where the agent first checks who is available with `list_team_agents` before making the handoff call, ensuring the request is routed correctly.

The server itself is ephemeral and doesn't log or store payloads. When your agent calls `get_customer_details`, the response is validated in-memory by your Pydantic models and then passed to your agent's logic. The Vinkius platform ensures the transport is encrypted, but the data's integrity is enforced on the client side by your schemas.

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