A2A Premiers pas

Créez et exécutez un agent de protocole A2A (Agent-à-Agent) en moins de 5 minutes.

Prérequis

• Rust 1.95.0 ou version ultérieure (rustup update stable)
• cargo-adk installé (cargo install cargo-adk)
• Une clé Google API (obtenez-en une ici)

Créer un projet A2A

La manière la plus rapide de commencer consiste à utiliser le modèle a2a :

cargo adk new my-a2a-agent --template a2a
cd my-a2a-agent

Cela génère un projet complet avec :

• Cargo.toml — adk-rust avec features = ["standard"] (inclut la prise en charge de A2A)
• src/main.rs — serveur A2A utilisant le builder API
• .env.example — espace réservé pour la clé API

Ajoutez votre clé API :

cp .env.example .env
# Edit .env and set GOOGLE_API_KEY=your-key-here

Exécutez :

cargo run

Votre agent A2A est maintenant disponible sur http://localhost:8080.

Autres fournisseurs

# OpenAI
cargo adk new my-agent --template a2a --provider openai

# Anthropic
cargo adk new my-agent --template a2a --provider anthropic

---

API pratique

ADK-Rust fournit A2aServer pour exposer n’importe quel agent via le protocole A2A sans configuration manuelle des routes.

Sans configuration : quick_start

L’approche la plus simple — un seul appel de fonction, avec des valeurs par défaut judicieuses :

use adk_rust::prelude::*;
use adk_rust::server::A2aServer;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;

    let model = GeminiModel::new(api_key, "gemini-3.7-flash")?;

    let agent: Arc<dyn Agent> = Arc::new(
        LlmAgentBuilder::new("my-agent")
            .description("A helpful AI assistant")
            .instruction("You are a helpful assistant exposed via A2A.")
            .model(Arc::new(model))
            .build()?,
    );

    let app = A2aServer::quick_start(agent);
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
    axum::serve(listener, app).await?;
    Ok(())
}

quick_start configure :

• Service de session en mémoire
• Carte d’agent à GET /.well-known/agent.json
• Point de terminaison JSON-RPC à POST /a2a
• Diffusion en continu activée

Configuration personnalisée : Builder

Utilisez le builder lorsque vous avez besoin de contrôler le port, les métadonnées ou le backend de session :

use adk_rust::prelude::*;
use adk_rust::server::A2aServer;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = GeminiModel::new(api_key, "gemini-3.7-flash")?;

    let agent: Arc<dyn Agent> = Arc::new(
        LlmAgentBuilder::new("my-agent")
            .description("Production A2A agent")
            .instruction("You are a helpful assistant.")
            .model(Arc::new(model))
            .build()?,
    );

    let server = A2aServer::builder()
        .agent(agent)
        .bind_addr("0.0.0.0:9090")
        .agent_card_name("My Production Agent")
        .agent_card_description("Handles customer queries via A2A")
        .agent_card_version("2.0.0")
        .streaming(true)
        .push_notifications(false)
        .build()?;

    server.serve().await?;
    Ok(())
}

---

Tester avec curl

Une fois votre agent en cours d’exécution, vérifiez-le avec ces commandes.

Récupérer la fiche de l’agent

curl http://localhost:8080/.well-known/agent.json | jq .

Réponse attendue :

{
  "name": "my-agent",
  "description": "A helpful AI assistant",
  "url": "http://localhost:8080",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": true
  },
  "skills": []
}

Envoyer un message (JSON-RPC)

curl -X POST http://localhost:8080/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "message/send",
    "params": {
      "message": {
        "role": "user",
        "parts": [{"kind": "text", "text": "What is the A2A protocol?"}],
        "messageId": "msg-1"
      }
    },
    "id": "req-1"
  }'

Réponse attendue :

{
  "jsonrpc": "2.0",
  "id": "req-1",
  "result": {
    "id": "task-uuid",
    "status": {"state": "completed"},
    "artifacts": [
      {
        "parts": [{"kind": "text", "text": "The A2A protocol is..."}]
      }
    ]
  }
}

Diffuser une réponse en continu

curl -X POST http://localhost:8080/a2a/stream \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "message/stream",
    "params": {
      "message": {
        "role": "user",
        "parts": [{"kind": "text", "text": "Explain Rust in 3 sentences."}],
        "messageId": "msg-2"
      }
    },
    "id": "req-2"
  }'

Cette commande renvoie des événements Server-Sent Events avec des mises à jour incrémentielles de l’état de la tâche.

---

Maintenir distinctes les limites de MCP et A2A

MCP connecte une application d’agent à des outils, des ressources et d’autres fonctionnalités publiées. A2A connecte des agents déployés indépendamment et transporte le cycle de vie de leur travail distant. Un pont peut effectuer la traduction entre les protocoles, mais ce pont est un composant déployé séparément, avec sa propre identité, son autorisation, son mappage de schéma, son mappage de l’état des tâches et son propre comportement en cas d’échec.

ADK-Rust ne fournit pas de binaire nommé mcp-a2a-server. Ne placez pas cette commande dans la configuration MCP, sauf si votre déploiement fournit et teste séparément un tel pont. Lorsque les deux parties sont des agents, utilisez directement le client A2A.

Se connecter depuis un autre agent ADK-Rust

Utilisez RemoteA2aAgent pour appeler votre agent A2A depuis une autre application ADK-Rust :

use adk_rust::server::RemoteA2aAgent;

let remote = RemoteA2aAgent::new(
    "my-remote-agent",
    "http://localhost:8080",
);

Cela crée un agent qui transmet les requêtes à votre serveur A2A sur le réseau.

---

Référence des points de terminaison

---

Étapes suivantes

• A2A Exemple de démarrage rapide — exemple minimal fonctionnel
• Intégration d’outils — ajoutez des outils personnalisés à votre agent A2A
• Sessions — conservez l’état de la conversation entre les requêtes
• Déploiement — déployez votre agent A2A en production

---

Précédent : Démarrage rapide | Suivant : LlmAgent