Giao thức A2A: Giải thích và thực hành siêu đơn giản

Key Concepts

AI Agent, A2A (Agent to Agent), MCP (Model Context Protocol), Vertex AI, Gemini API, Large Language Models (LLM), Agent Card, A2A Server, A2A Client, Task, Message, Artifact, Part, Streaming, Post Notifications, Discovery, Initialization, Processing, Interaction, Completion, Google ADK, Langraph, Crew AI, Lama Index.

A2A (Agent to Agent) Protocol Explained

What is an AI Agent?

• An AI agent is a program with a clear objective.
• It can reason, typically using large language models (LLMs).
• It has access to tools to perform actions like sending emails, calling APIs, or writing code.
• AI agents are superior to traditional chatbots because they can:
  • Plan multi-step processes.
  • Track progress.
  • Act proactively (e.g., suggest options or request more information).
• Analogy: An AI agent is like a skilled intern who can independently find information and consult colleagues to complete a task.

The Need for A2A

• Businesses are increasingly deploying AI agents for tasks involving observation, decision-making, and execution.
• As the number of agents grows, they need to collaborate (e.g., an ordering agent communicating with an accounting agent).
• If each agent uses a different standard or "language," integration becomes complex.
• Google's A2A protocol aims to solve this problem by standardizing communication between AI agents.

A2A's Objectives

1. Standardize Agent Communication: Enable AI agents from different vendors or frameworks to exchange information and coordinate complex tasks easily.
2. Enhance Agent Autonomy: Allow agents to communicate with each other to divide and delegate tasks.

A2A Architecture

• AI Agent Structure: Each AI agent contains one or more "local agents."
  • The main AI agent is like a senior employee, managing memory, planning, and calling necessary tools.
  • Local agents are specialized assistants that handle smaller tasks to reduce the load on the main agent.
    • Example: In an order processing agent, local agents could handle shipping cost calculation, email confirmation, and database synchronization.
• Vertex AI (or LLM Platform): This is the central component providing AI capabilities (reasoning, memory, analysis) to both the main agent and local agents.
  • It can use Google's Gemini API or third-party models like Anthropic's Claude or Meta's Llama.
  • All models run on Vertex AI infrastructure within the Google ecosystem.
  • In non-Google ecosystems, this is generally referred to as a "large language model" (LLM).
• Agent Development Kit (ADK): A set of tools for building, integrating, and managing agents.
  • Provides resources, libraries, and APIs for agent development.
  • Helps agents connect to Vertex AI (including Gemini API) or third-party models.
  • Enables agents to communicate with external APIs and applications.

A2A vs. MCP (Model Context Protocol)

• MCP: A protocol that standardizes how AI applications and LLMs access external data sources and tools through a common interface.
  • Analogy: MCP is like a USB Type-C port on a laptop, allowing access to various peripherals.
• Key Difference: MCP enables AI to interact with external data and tools, while A2A enables AI agents to interact with each other.
• A2A is the key to overcoming technological barriers and enabling seamless communication between AI agents.

Core Components of A2A

Imagine building a food delivery service based on A2A:

1. Agent Card: A metadata file describing an agent's capabilities.
   • Analogy: A restaurant menu showing what the restaurant offers, its hours, and payment methods.
2. A2A Server: An agent that opens an HTTP port and implements A2A methods, receiving requests and coordinating task execution.
   • Analogy: A restaurant cashier who takes orders, records them, and sends them to the kitchen.
3. A2A Client: An application or AI agent that uses the A2A service to send requests to the A2A server's URL.
   • Analogy: A customer or delivery driver who sends an order to the cashier.
4. Task: The main unit of work. The client initiates a task by sending a message to the server. Each task has a unique ID and goes through states like submitted, working, input required, complete, failed, or canceled.
   • Analogy: A food order.
5. Message: Exchanges between the client and agent.
   • Analogy: Conversations between the customer and cashier (e.g., "I want two pizzas," "Do you want extra cheese?").
6. Artifact: The result created by the agent during task execution. This could be files or final data.
   • Analogy: The finished pizza or a PDF invoice.
7. Part: A basic content component within a message or artifact. It can be text, attached files, structured JSON, or forms.
8. Streaming: For long-running tasks, the server can support streaming, sending Server Sent Events (SSE) to the client with real-time progress updates.
   • Post Notifications: The server can proactively send task updates to the client via SSE.
   • Analogy: The restaurant sending real-time updates on the order's progress (e.g., dough being kneaded, pizza being baked).

Typical A2A Workflow

1. Discovery: The client retrieves the agent card from the server's URL.
   • Analogy: Browsing a restaurant's menu online.
2. Initialization: The client sends a request containing the initial user message and a unique task ID.
   • Analogy: Placing an order.
3. Processing:
   • Streaming Mode: The server sends SSE updates (status, artifacts) as the task is executed.
   • Non-Streaming Mode: The server processes synchronously and returns the final task object in the response.
   • Analogy: The kitchen preparing the food. With streaming, the restaurant sends continuous updates. Without streaming, the restaurant only provides the final result.
4. Interaction: (Optional) If the task requires more information from the client (input required), the client sends a message with the task ID.
   • Analogy: The kitchen asking if the customer wants extra toppings.
5. Completion: The task ends in a final state (complete, failed, or canceled).
   • Analogy: The order being successfully delivered, running out of ingredients, or being canceled by the customer.

Practical Example: Currency Conversion Agent

• Google provides simple agent examples (Google ADK, Langraph, Crew AI, Lama Index).
• The video demonstrates using the Langraph example for currency conversion.
• Steps:
  1. Clone the repository: git clone <repository_url>
  2. Navigate to the directory: cd sample/python_agents/langraph
  3. Create an environment file with the API key:
     • Get an API key from Google AI Studio.
     • Create a .env file and add the key: GOOGLE_API_KEY="your_api_key_here"
  4. Run the agent: python currency_converter_agent.py (runs on localhost port 10000 by default)
  5. Open another terminal and run the client: python client.py
• Demonstration:
  • When the client runs, it requests the agent.json file (the agent card) from the agent.
  • The agent card describes the agent's capabilities (e.g., converting currencies).
  • The client asks: "What is the currency conversion between USD and EUR?"
  • The agent processes the request and returns the answer (e.g., 1 USD = 0.88028 EUR).
  • The client receives stream events showing the progress of the request.
• Key Takeaways:
  • The client receives the agent card to understand the server agent's capabilities.
  • The client sends a request to the server.
  • The server processes the request and returns the result.
  • In practice, multiple agents can interact, with some acting as servers (listening for requests) and others as clients (sending requests).

Conclusion

A2A is Google's standard protocol that enables AI agents to interact and communicate easily. The video explains A2A, its differences from MCP, and demonstrates its practical application through a simple example. A2A facilitates seamless communication between agents by standardizing interactions and overcoming technological differences.

Additional Information

The video also mentions online courses related to AI, data science, and machine learning, including:

• Python and AI Fundamentals
• Data Science and Machine Learning Advanced
• Deep Learning for Computer Vision (Basic and Advanced)
• Mathematics for AI