Google A2A Agent Example

This repository implements a simple Agent-to-Agent (A2A) communication example based on Google's A2A protocol. A2A is Google's proposed standard for enabling AI agents to communicate with each other through a standardized API.

Overview

The implementation consists of two main components:

1. **Server (server.py)**: A Flask-based server acting as an AI agent. It implements the core A2A protocol endpoints:

• /.well-known/agent.json: Provides the agent's metadata (Agent Card), describing its capabilities and URL.
• /tasks/send: Accepts tasks from other agents (or clients like client.py), processes them using an AI model (OpenAI's GPT-4o-mini) and external tools (Brave Search via MCP), and returns the result.

2. **Client (client.py)**: A simple Python script demonstrating how to interact with the A2A server:

• Discovers the agent by fetching its Agent Card.
• Sends a task (a user query) to the agent's /tasks/send endpoint.
• Receives and prints the agent's response.

Architecture

The interaction flow can be visualized as follows:

sequenceDiagram
    participant C as Client (client.py)
    participant S as A2A Server (server.py)
    participant MCP as Brave MCP Server
    participant OAI as OpenAI API

    C->>S: GET /.well-known/agent.json (Discover Agent)
    S-->>C: Agent Card JSON
    C->>S: POST /tasks/send (Task Request with User Query)
    S->>OAI: Process Query (Initial processing)
    Note right of S: Agent decides to use Brave Search
    S->>MCP: Search Request
    MCP-->>S: Search Results
    S->>OAI: Process Query + Search Results
    OAI-->>S: Final Response Text
    S-->>C: Task Response (with Agent's Final Message)

• The Client initiates communication by discovering the A2A Server.
• The Client sends a task (e.g., "What is Google A2A?") to the Server.
• The Server uses the pydantic-ai library, which coordinates with:
• The OpenAI API to understand the request and generate responses.
• A Brave Search MCP Server (managed via MCPServerStdio) when web search is needed. MCP (Model Context Protocol) standardizes how AI models interact with external tools/data sources.
• The Server sends the final response back to the Client.

Setup

1. Clone the repository:

git clone 
    cd

2. Create and activate a virtual environment:

• Windows:

python -m venv venv
        .\venv\Scripts\activate

• macOS/Linux:

python3 -m venv venv
        source venv/bin/activate

3. **Create a .env file:**

Create a file named .env in the root directory and add your API keys:

OPENAI_API_KEY=your_openai_api_key
    BRAVE_API_KEY=your_brave_api_key

*(Replace your_openai_api_key and your_brave_api_key with your actual keys)*

4. Install dependencies:

pip install -r requirements.txt

5. Run the server:

Open a terminal, activate the virtual environment, and run:

python server.py

The server will start, typically on http://localhost:5000.

6. Run the client:

Open a *separate* terminal, activate the virtual environment, and run:

python client.py

The client will discover the server, send a predefined question, and print the agent's response.

A2A Protocol Details

Google's A2A protocol defines a standard way for agents to communicate via HTTP. Key concepts include:

• **Agent Card (/.well-known/agent.json)**: A standard JSON document describing an agent's identity, capabilities (e.g., streaming support), and API endpoints.
• **Task API (/tasks/send, /tasks/receive, etc.)**: Endpoints for exchanging tasks and messages. This example only implements the essential /tasks/send.
• Standardized Message Format: A consistent JSON structure for messages exchanged between agents, typically including roles (user, agent) and content parts.

For more in-depth information, refer to the official Google A2A protocol documentation (link if available).