Echtzeit- und multimodale Agenten

Erstellen Sie Agenten, die in Echtzeit sprechen, zuhören, sehen und handeln – über eine Live-Verbindung mit geringer Latenz zu OpenAIs Realtime-API oder Googles Gemini Live API.

Ein Echtzeit-Agent ist kein Request-/Response-Chatbot. Er hält eine offene Sitzung: Das Mikrofon des Benutzers streamt kontinuierlich, das Modell streamt Audio + ein Live-Transkript zurück, erkennt, wann der Benutzer zu sprechen beginnt und aufhört, kann mitten im Satz unterbrochen werden (Barge-in), kann Bilder von einer Kamera sehen und Ihre Tools aufrufen und das Ergebnis aussprechen – und das alles, ohne den „Anruf“ jemals zu beenden.

Neu bei ADK-Rust? Lesen Sie zuerst die Einführung und den Schnellstart. In diesem Abschnitt wird vorausgesetzt, dass Sie wissen, was ein Agent, ein Tool und eine Sitzung sind.

Was Sie erstellen können

Dann siehe die vier ausführbaren Beispiel-Apps.

Das mentale Modell

Es gibt zwei Ebenen, und die meisten Anwendungen verwenden die obere:

  IntegratedRealtimeRunner          ← sessions, memory, tools, plugins (use this)
        │ wraps
  RealtimeRunner                    ← event loop + tool dispatch
        │ drives
  RealtimeSession  (a transport)    ← the live WebSocket to the provider
        │ created by
  RealtimeModel    (OpenAI | Gemini)

• Ein RealtimeModel (z. B. OpenAIRealtimeModel, GeminiRealtimeModel) weiß, wie man connect() und ein RealtimeSession erzeugt — den laufenden Transport.
• RealtimeRunner verwaltet diese Sitzung: Es verarbeitet Ereignisse, und wenn das Modell ein Tool anfordert, führt es den Handler aus und sendet das Ergebnis zurück.
• IntegratedRealtimeRunner kapselt den Runner und verbindet ihn mit dem Rest von ADK — SessionService (Transkriptpersistenz), MemoryService (Abruf + Speicherung), EnhancedPluginManager (Hooks) und eine Brücke, über die jeder adk-core Tool in einer Echtzeitsitzung ausgeführt werden kann. Dies verwenden die Beispiele.

(Es gibt außerdem eine übergeordnete RealtimeAgent für einfache sprachbasierte Agenten sowie direkte Transporte — WebRTC, LiveKit, Vertex AI Live — die dort dokumentiert sind.)

Installation

# Voice + tools + the integration layer (recommended)
adk-realtime = { version = "2.1.0", features = ["openai", "gemini", "integration"] }

Schnelleinführung in 60 Sekunden

Eine sprachbasierte, zustandslose Runde: Verbinden, per Text fragen und die gestreamte Antwort ausgeben.

use adk_realtime::config::{RealtimeConfig, VadConfig};
use adk_realtime::events::ServerEvent;
use adk_realtime::integration::{IntegratedRealtimeRunner, IntegrationConfig};
use adk_realtime::model::BoxedModel;
use adk_realtime::openai::OpenAIRealtimeModel;
use adk_session::{CreateRequest, InMemorySessionService, SessionService};
use std::sync::Arc;

# async fn run() -> anyhow::Result<()> {
let model: BoxedModel = Arc::new(OpenAIRealtimeModel::new(
    std::env::var("OPENAI_API_KEY")?,
    "gpt-realtime-2.1",
));

let config = RealtimeConfig::default()
    .with_instruction("You are a friendly assistant. Keep replies short.")
    .with_voice("marin")
    .with_audio_only()
    .with_vad(VadConfig::server_vad())   // model decides turn boundaries
    .with_transcription();               // emit a text transcript too

let sessions = Arc::new(InMemorySessionService::new());
sessions.create(CreateRequest {
    app_name: "demo".into(), user_id: "u1".into(),
    session_id: Some("s1".into()), state: Default::default(),
}).await?;

let runner = IntegratedRealtimeRunner::builder()
    .model(model)
    .config(config)
    .identity("demo", "u1", "s1")
    .session_service(sessions)
    .integration_config(IntegrationConfig::default())
    .build()?;

runner.connect().await?;
runner.send_text("Say hello in one short sentence.").await?;
runner.create_response().await?;       // text input needs an explicit trigger

while let Some(event) = runner.next_event().await {
    match event? {
        ServerEvent::TranscriptDelta { delta, .. } => print!("{delta}"),
        ServerEvent::AudioDelta { .. } => { /* PCM16 to play */ }
        ServerEvent::ResponseDone { .. } => break,
        _ => {}
    }
}
runner.close().await?;
# Ok(()) }

In einer echten App streamen Sie Mikrofon-Audio mit runner.send_audio(base64_pcm16) anstatt send_text, und serverseitiges VAD steuert Antworten automatisch — create_response() ist nicht erforderlich. Siehe Web-Apps erstellen.

Wie geht es weiter?

1. Architektur — wie die Komponenten zusammenspielen, die Ereignisschleife und die Audio-Pipeline.
2. Anbieter — OpenAI im Vergleich zu Gemini-Modellen, Stimmen, Endpunkte und Authentifizierung.
3. Tools — serverseitiger Funktionsaufruf.
4. Multimodalität — Senden von Videobildern.
5. Affektiver Dialog — emotionsbewusste Antworten.
6. Speicher — Langzeitgedächtnis auf Basis eines Wissensgraphen.
7. Web-Apps erstellen — die Browser-Brücke.
8. Beispiele — vier ausführbare Apps.