How to Use the Linear (Issue Tracking & PM) MCP in Pydantic AI

Build type-safe Python agents that inspect and audit your Linear (Issue Tracking & PM) workspace 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 Linear (Issue Tracking & PM) MCP to Pydantic AI

Create your Vinkius account to connect Linear (Issue Tracking & PM) 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 Linear (Issue Tracking & PM) with Pydantic AI

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Validate your Linear data at runtime with Pydantic AI

When your agent calls `list_issues`, every returned ticket is validated against strict Pydantic schemas at runtime. This prevents silent API failures or corrupted payloads from breaking your pipeline. If a field comes back missing or malformed, the system catches it immediately. This ensures your agent is always working with clean, reliable issue data from `get_issue`.

Track cycles with guaranteed schema correctness

The agent calls `list_cycles` to monitor active sprints without risking type errors in your pipeline. It parses cycle dates and boundaries into structured Python objects automatically. It maps these boundaries against `list_projects` to ensure your timeline calculations are accurate. This prevents off-by-one errors when calculating team velocity.

Audit team structures using a secure MCP Server

Your agent relies on `list_teams` and `list_labels` to parse active metadata tags and verify workspace boundaries. It identifies duplicate labels or abandoned teams that clutter up your views. It uses `list_users` and `get_viewer` to verify active team members and validate permissions. Because the data is strictly typed, your agent can safely automate access control reports.

Setup guide

Set up Linear (Issue Tracking & PM) 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": {
        "linear-issue-tracking-pm-mcp": {
            "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
        }
    }
})

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

result = await agent.run("List recent Linear (Issue Tracking & PM) 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 Linear. 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 Linear (Issue Tracking & PM) 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 Linear (Issue Tracking & PM) MCP in Pydantic AI

Use the unified toolset class pointing to your Vinkius MCP Server endpoint. Pass this toolset into the agent constructor using the toolsets parameter. This exposes all eight Linear tools to your agent with automatic runtime validation.

The framework will raise a validation error immediately instead of letting your agent hallucinate. This guarantees that tools like `list_issues` and `get_issue` only feed valid data into your model. It is perfect for production systems where correctness is non-negotiable.

Yes, the toolset integration fully supports Python's async ecosystem. You can run multiple tool calls like `list_cycles` and `list_projects` concurrently. This keeps your agent responsive even when processing large workspaces.

Yes, this toolset is completely model-agnostic. You can pair it with Ollama, Anthropic, or any other LLM provider supported by the framework. The agent will still use the same validated schemas for all tool calls.

Your authentication tokens are handled securely through the Vinkius gateway and never exposed to the agent code or LLM providers. Every request to fetch issues or team lists runs in a sandboxed environment. This setup prevents leaks and keeps your project metrics completely isolated.

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