Pydantic AI MCP

A normal function tool may be the simpler choice when the operation lives inside one Python application. MCP becomes useful when a tool service needs a standard connection boundary or serves more than one compatible application.

Use the same interpreter for installation and execution, and record the dependency versions with your project. The imports here use the standalone fastmcp package. Some other examples use a FastMCP class from the MCP SDK under a different import path. Do not combine snippets from those examples without checking which package and version each one expects.

import asyncio
from typing import Literal

from fastmcp import Client, FastMCP
from pydantic import BaseModel, ConfigDict

server = FastMCP("Fictional public catalogue")
records = {"LAB-101": {"code": "LAB-101", "topic": "Tool integration"}}


class LookupResult(BaseModel):
    model_config = ConfigDict(extra="forbid", strict=True)
    status: Literal["found", "not_found"]
    code: str | None
    topic: str | None


@server.tool
def lookup_lab(code: str) -> dict:
    """Look up one public fictional lab using a LAB- code."""
    if not code.startswith("LAB-"):
        raise ValueError("Expected a LAB- code")
    record = records.get(code)
    if record is None:
        return {"status": "not_found", "code": None, "topic": None}
    return {"status": "found", **record}


async def main():
    async with Client(server) as client:
        inventory = await client.list_tools()
        assert {tool.name for tool in inventory} == {"lookup_lab"}
        found = await client.call_tool("lookup_lab", {"code": "LAB-101"})
        value = LookupResult.model_validate(found.structured_content)
        assert value.status == "found" and value.code == "LAB-101"
        missing = await client.call_tool("lookup_lab", {"code": "LAB-999"})
        absent = LookupResult.model_validate(missing.structured_content)
        assert absent.status == "not_found" and absent.topic is None
        invalid = await client.call_tool(
            "lookup_lab", {"code": "wrong"}, raise_on_error=False
        )
        assert invalid.is_error
    print("PASS: inventory, found record, missing record and invalid argument.")


if __name__ == "__main__":
    asyncio.run(main())

This public catalogue has no authentication system. The LAB- check is input validation, not access control. Anyone who can call the local fixture can read the fictional record. If you add private records later, keep the authenticated caller’s scope in server-side context and test both allowed and rejected access. A perfectly formatted identifier does not grant permission.

from fastmcp import FastMCP

server = FastMCP("Fictional lab subprocess")


@server.tool
def get_practice_rule() -> dict[str, str]:
    """Return a public fictional lab rule; no files or accounts are accessed."""
    return {"rule": "Use synthetic data in the practice lab."}


if __name__ == "__main__":
    server.run(transport="stdio", show_banner=False)

Prefer the smallest permissions needed for the task. For example, reading a public catalogue should not require account administration or the ability to delete records. If a tool can write to a system, make that capability visible in the application review.