A2A Erste Schritte

Erstellen Sie in weniger als 5 Minuten einen A2A-Protokollagenten (Agent-to-Agent) und führen Sie ihn aus.

Voraussetzungen

• Rust 1.95.0 oder höher (rustup update stable)
• cargo-adk installiert (cargo install cargo-adk)
• Ein Google-API-Schlüssel (hier einen erhalten)

Ein A2A-Projekt erstellen

Der schnellste Einstieg ist die Vorlage a2a:

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

Dadurch wird ein vollständiges Projekt erstellt mit:

• Cargo.toml — adk-rust mit features = ["standard"] (einschließlich A2A-Unterstützung)
• src/main.rs — A2A-Server unter Verwendung des Builders API
• .env.example — Platzhalter für den API-Schlüssel

Fügen Sie Ihren API-Schlüssel hinzu:

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

Ausführen:

cargo run

Ihr A2A-Agent wird jetzt unter http://localhost:8080 bereitgestellt.

Andere Anbieter

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

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

---

Komfortables API

ADK-Rust stellt A2aServer bereit, um jeden Agenten über das A2A-Protokoll bereitzustellen, ohne Routen manuell konfigurieren zu müssen.

Ohne Konfiguration: quick_start

Der einfachste Ansatz – ein Funktionsaufruf mit sinnvollen Standardeinstellungen:

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 konfiguriert:

• In-Memory-Sitzungsdienst
• Agentenkarte unter GET /.well-known/agent.json
• JSON-RPC-Endpunkt unter POST /a2a
• Streaming aktiviert

Benutzerdefinierte Konfiguration: Builder

Verwenden Sie den Builder, wenn Sie Kontrolle über Port, Metadaten oder das Sitzungs-Backend benötigen:

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(())
}

---

Testen mit curl

Sobald Ihr Agent läuft, überprüfen Sie ihn mit diesen Befehlen.

Agentenkarte abrufen

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

Erwartete Antwort:

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

Eine Nachricht senden (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"
  }'

Erwartete Antwort:

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

Eine Antwort streamen

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"
  }'

Dies gibt Server-Sent Events mit inkrementellen Aktualisierungen des Aufgabenstatus zurück.

---

MCP- und A2A-Grenzen klar getrennt halten

MCP verbindet eine Agentenanwendung mit Tools, Ressourcen und anderen veröffentlichten Funktionen. A2A verbindet unabhängig bereitgestellte Agenten und überträgt die Lebensdauer ihrer entfernten Arbeit. Eine Bridge kann zwischen den Protokollen übersetzen, aber diese Bridge ist eine separat bereitgestellte Komponente mit eigener Identität, Autorisierung, Schemasemantik, Zuordnung des Aufgabenstatus und eigenem Fehlerverhalten.

ADK-Rust liefert keine Binärdatei namens mcp-a2a-server aus. Platzieren Sie diesen Befehl nicht in der Konfiguration von MCP, es sei denn, Ihre Bereitstellung stellt eine solche Bridge separat bereit und testet sie. Wenn beide Seiten Agenten sind, verwenden Sie direkt den A2A-Client.

Verbindung von einem anderen ADK-Rust-Agenten herstellen

Verwenden Sie RemoteA2aAgent, um Ihren A2A-Agenten von einer anderen ADK-Rust-Anwendung aus aufzurufen:

use adk_rust::server::RemoteA2aAgent;

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

Dadurch wird ein Agent erstellt, der Anfragen über das Netzwerk an Ihren A2A-Server weiterleitet.

---

Referenz der Endpunkte

---

Nächste Schritte

• A2A Schnellstartbeispiel — minimales funktionierendes Beispiel
• Tool-Integration — benutzerdefinierte Tools zu Ihrem A2A Agenten hinzufügen
• Sitzungen — den Konversationsstatus über mehrere Anfragen hinweg speichern
• Bereitstellung — Ihren A2A Agenten in der Produktion bereitstellen

---

Zurück: Schnellstart | Weiter: LlmAgent