How to Use the AdaptiveWork (Clarizen) MCP in Pydantic AI

Validate every AdaptiveWork project update at runtime using Pydantic AI type-safe agent workflows.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect AdaptiveWork (Clarizen) MCP to Pydantic AI

Create your Vinkius account to connect AdaptiveWork (Clarizen) 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 AdaptiveWork (Clarizen) with Pydantic AI

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Validate task structures with Pydantic AI and MCP

The `create_task` tool enforces rigid validation schemas on your project inputs before they ever hit the Clarizen API. When your agent attempts to add a new task, Pydantic AI inspects the task name and parent ID against strict Python type definitions. If the agent attempts to pass an invalid data type, the framework raises a runtime validation error immediately. This eliminates silent failures and ensures your project management database remains free of corrupted records.

Parse active projects into structured python models

The `list_projects` tool retrieves active project data and maps the JSON response directly to your defined Pydantic schemas. Your agent can safely extract status fields and state variables, knowing the data matches your application's expectations. When drilling down into specific project health metrics, the agent invokes `get_project_details` to return complex metadata. Because the framework is model-agnostic, you get consistent schema validation whether you use Anthropic, OpenAI, or local models.

Run validated CZQL database queries

The `run_query` tool lets you execute raw Clarizen Query Language statements while maintaining strict output validation. The raw query results are parsed into structured Python objects, making them safe to use in downstream application logic. You can combine this database access with `list_users` to cross-reference resource assignments against active project tasks. Pydantic AI guarantees that every user record returned matches your system's data models exactly.

Setup guide

Set up AdaptiveWork (Clarizen) 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": {
        "adaptivework-clarizen-mcp": {
            "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
        }
    }
})

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

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

Install the pydantic-ai-slim package with the mcp extra, then instantiate MCPToolset pointing to your Vinkius HTTP endpoint. Pass this toolset instance to your Agent constructor to automatically bind all six tools.

This combination ensures absolute type safety for your project management workflows. If the Clarizen API schema changes, your agent fails loudly and safely at the validation layer rather than corrupting your active project plans.

Yes, the MCPToolset supports both Streamable HTTP and Server-Sent Events transports. This flexibility allows your agent to maintain persistent, low-latency connections to the Vinkius managed server.

Yes, because Pydantic AI is completely model-agnostic. You can run a local model via Ollama and expose the Clarizen tools, letting your local agent safely execute `list_tasks` without sending data to third-party LLM providers.

Your raw CZQL queries and retrieved task lists are processed in an isolated V8 sandbox hosted by Vinkius. Temporary tokens ensure that your main credentials are never exposed to the client application or the LLM provider.

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