A2A INTEGRATION · CUSTOM TOOL

Use GitDealFlow A2A with Pydantic AI

Type-safe Python agent framework. Python builders who want strict typing on every agent input and output.

Crunchbase API: $20K/yr. GitDealFlow A2A: free, no signup.

Pydantic AI's Tool decorator enforces typed args and return shapes. Wrap our A2A endpoint as a single Tool that takes a skill enum and a typed args dict, and the agent gets compile-time checking on every call. The MCP server also works via pydantic-ai's experimental MCP support if you prefer.

Endpoint facts for Pydantic AI users

Whatever wiring you choose, the target is the same single endpoint. These are the fixed facts; nothing on this page changes them:

Protocol	A2A JSON-RPC 2.0 (protocolVersion 0.3.0)
Endpoint URL	`https://signals.gitdealflow.com/api/a2a`
Skills exposed	5, mirrored 1:1 with the MCP server tools (trending, sector, lookup, summary, methodology)
Auth	None; free in perpetuity, read-only
Freshness	Recomputed weekly; responses carry the data-as-of date
Best Pydantic AI path	Pydantic AI has no native MCP client yet, so the custom-tool path below (a thin JSON-RPC call) is the way in.

Install

pip install pydantic-ai

Typed Tool

from pydantic_ai import Agent, Tool, RunContext
from pydantic import BaseModel
from typing import Literal
import requests

A2A_URL = "https://signals.gitdealflow.com/api/a2a"

Skill = Literal[
    "get_trending_startups",
    "search_startups_by_sector",
    "get_startup_signal",
    "get_signals_summary",
    "get_methodology",
]

class A2AArgs(BaseModel):
    skill: Skill
    args: dict | None = None

async def gitdealflow_query(ctx: RunContext, params: A2AArgs) -> dict:
    """Call GitDealFlow A2A for live VC engineering signals."""
    body = {
        "jsonrpc": "2.0", "id": 1,
        "method": "message/send",
        "params": {"message": {"role": "user", "parts": [
            {"kind": "data", "data": {"skill": params.skill, "args": params.args or {}}},
        ]}},
    }
    return requests.post(A2A_URL, json=body, timeout=15).json()

agent = Agent(
    "openai:gpt-4o-mini",
    tools=[Tool(gitdealflow_query)],
    system_prompt="Use gitdealflow_query for live engineering signals.",
)

What you can ask

result = await agent.run('Who is trending in fintech?')
Compose with other Pydantic AI tools (web search, vector store) for an end-to-end deal-memo flow.
Stream tokens with agent.run_stream() while the tool fetches in the background.
Validate output with a result_type=DealMemo Pydantic model.

Gotchas

Pydantic AI revalidates tool args on every call, keep your A2AArgs model lean to avoid latency.
If you want the agent to use multiple skills in one turn, raise tool_call_limit (default 10) in Agent config.

When to pick which path

Because Pydantic AI currently lacks a native MCP client, your two options are the custom tool below (a thin JSON-RPC wrapper you register once) or switching the session to an MCP-capable host when you need the richer tool surface. For scheduled jobs and pipelines, the raw endpoint is usually the sturdier dependency: no client versioning to track.

4example prompts are listed under "What you can ask" below, and the gotchas section covers the 2 known failure modes Pydantic AI users hit with this endpoint. If a prompt fails, check the gotchas first: most misses are shape mismatches, not endpoint outages.

References

Try it without setup

The interactive playground lets you send live JSON-RPC requests against the A2A endpoint with no install, no auth. Pick a skill, hit send, see the response.

Full launch story: I made my VC deal flow callable by Claude.