How to Use the Kippy MCP in Pydantic AI

Q: How do I start using the Kippy tools with Pydantic AI?

Just install pydantic-ai-slimmcp and create an MCPToolset with your Vinkius server URL. Pass that toolset to your agent. It's a single line of code to give your agent access to all 13 Kippy tools.

Q: Can a Pydantic AI agent summarize performance reviews from Kippy?

Yes. You can build an agent that calls listappraisals and listfeedback for a specific user. Because the output is strongly typed, the agent can reliably extract the text and pass it to an LLM for summarization.

Build type-safe agents with Pydantic AI to guarantee correct handling of your Kippy performance and appraisal data.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Kippy MCP to Pydantic AI

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Eliminate bad data from your agent's workflow

Pydantic AI validates every response from the Kippy server against a Pydantic model. If the server sends back an unexpected field in a call to `list_kpi_scores`, your agent will raise a `ValidationError` immediately. No silent failures or corrupted data. This means you can trust the outputs. When you ask for `list_annual_scores` or `list_team_scores`, you know the data structure is exactly what your code expects. It forces correctness at the boundary.

Query organizational data with confidence

Your agent can navigate Kippy's organizational structure without guesswork. It can `list_users`, find their teams with `list_teams`, and then pull their performance reviews using `list_appraisals`. Each step is validated. Because every tool output is a typed object, your agent's logic becomes much simpler and more reliable. You're not parsing messy JSON; you're working with clean Python objects for everything from `list_projects` to `list_competencies`.

Build model-agnostic agents with this MCP Server

Pydantic AI isn't tied to one LLM provider. You can build your Kippy agent with an OpenAI model today and switch to a local model tomorrow without changing your tool-using code. The MCP server integration is completely portable. This lets you focus on the logic of your agent. Define the tasks—like summarizing notes from `list_feedback` or checking `list_audit_logs`—and let Pydantic AI handle the model interaction and data validation, no matter which backend you use.

Setup guide

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

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

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

It uses Pydantic models to validate the structure of every API response from the Kippy server. If a tool like `list_project_scores` returns data that doesn't match the expected schema, Pydantic AI stops execution and tells you exactly what went wrong.

Just install `pydantic-ai-slim[mcp]` and create an `MCPToolset` with your Vinkius server URL. Pass that toolset to your agent. It's a single line of code to give your agent access to all 13 Kippy tools.

Yes. You can build an agent that calls `list_appraisals` and `list_feedback` for a specific user. Because the output is strongly typed, the agent can reliably extract the text and pass it to an LLM for summarization.

No, it's designed to be simple. The tool-handling logic for Kippy is separate from the model client. You can swap out your `OpenAI` client for a `Gemini` or `Anthropic` client without rewriting how your agent uses `list_kpis` or other tools.

Your data, like user lists and competency records, is transmitted over a secure channel to the Vinkius server. The Pydantic AI library itself doesn't store this data; it just validates its structure in-memory during the request lifecycle before passing it to your agent code.

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