1. Python Quickstart: Build an A2A Agent

Python Quickstart Tutorial: Build an A2A Agent

Welcome to the Agent2Agent (A2A) Python quickstart tutorial!

In this tutorial, you’ll explore a simple “echo” A2A server using the Python SDK. This introduces the basic concepts and components of an A2A server. You’ll also see a more advanced example that integrates an LLM.

This hands-on guide will help you understand:

The core concepts behind the A2A protocol
How to set up a Python environment for A2A development with the SDK
How agent skills and AgentCards describe what an agent can do
How an A2A server processes tasks
How to interact with an A2A server using a client
How streaming and multi-turn interactions work
How to integrate an LLM into an A2A agent

By the end of this tutorial, you’ll have a functional understanding of A2A agents and a solid foundation for building or integrating A2A-compatible applications.

📚 Chapters

The tutorial is organized into these steps:

Introduction (this page) - Overview and learning goals
Environment setup - Prepare your Python environment and A2A SDK
Agent skills and AgentCard - Define what your agent can do and how it describes itself
Agent executor - Understand how agent logic is implemented
Start the server - Run the Hello World A2A server
Interact with the server - Send requests to your agent
Streaming and multi-turn - Explore advanced features (LangGraph example)
Next steps - Explore what’s next

🎯 Learning goals

After completing this tutorial, you will be able to:

Core concepts

✅ Understand A2A’s core components (AgentCard, Task, Message, Artifact)
✅ Understand agent discovery and communication basics
✅ Understand task lifecycle management

Practical development

✅ Set up an A2A Python development environment
✅ Create and configure agent skills
✅ Implement a basic A2A server
✅ Handle synchronous and asynchronous requests

Advanced capabilities

✅ Implement streaming and real-time updates
✅ Support multi-turn conversation
✅ Integrate an LLM
✅ Handle richer artifact outputs

🔧 Tech stack overview

This tutorial uses:

Core components

Python 3.8+ - Primary language
A2A Python SDK - Official SDK
FastAPI - Web framework (built into the SDK)
Pydantic - Validation and serialization

Advanced examples

LangGraph - Graph-based agent framework
OpenAI API - LLM service
Streaming - Server-Sent Events (SSE)

Developer tools

curl or an HTTP client - API testing
JSON tools - Formatting and inspection
Python debugger - Debugging

📋 Prerequisites

Helpful (not required)

FastAPI (or similar framework) experience
LLM API usage experience
Agentic/AI systems development experience

🏗️ Tutorial structure

This tutorial follows a progressive approach:

Phase 1: Foundations

Environment setup and SDK installation
Simple echo server implementation
Basic client interaction

Phase 2: Feature building

Agent skill definitions
Task handling logic
Error handling basics

Phase 3: Advanced features

Streaming implementation
Multi-turn conversation support
LLM integration examples

💡 Best-practice tips

Learning tips

Follow the order - Each chapter builds on the previous one
Run the code - Don’t just read; execute every example
Try modifications - After you understand the basics, experiment
Use the docs - Refer back to Core Topics as needed

Development tips

Use version control - Track your changes with Git
Use virtualenvs - Keep dependencies isolated
Add logging - Make debugging easier
Test-driven thinking - Write tests for your agent

🚀 Ready to begin

Now that you have an overview, let’s start building!

Next: Environment setup - Set up your environment and install required tools.

Tip: If you run into issues, check the FAQ or open an issue on GitHub. The community is happy to help.

2. Environment setup