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

Fähigkeit	Bedeutung	Seite
Sprachunterhaltungen	Bidirektionales PCM16-Audio mit VAD und Unterbrechung	Architektur
Zwei Anbieter, ein API	OpenAI Realtime (GA) oder Gemini Live, pro Sitzung austauschbar	Anbieter
Serverseitige Tools	Das Modell ruft `process_refund(...)` auf; Ihr Rust führt es aus und das Modell gibt das Ergebnis aus	Tools
Multimodales Sehen	Kamerabilder streamen – der Agent sieht, was der Benutzer ihm zeigt	Multimodal
Affektiver Dialog	Der Agent erfasst den emotionalen Ton des Benutzers und passt sich an (Gemini native-audio)	Affektiver Dialog
Langzeitspeicher	Ein Wissensgraph, den der Agent zu Sitzungsbeginn liest und beim Lernen pflegt	Speicher
Webanwendungen	Ein Browser-Frontend (Mikrofon + Kamera), das über Ihren Server verbunden ist	Webanwendungen erstellen

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

Funktion	Fügt hinzu
`openai`	OpenAI Realtime (WebSocket)
`gemini`	Gemini Live (WebSocket)
`integration`	`IntegratedRealtimeRunner` — Sitzungen, Speicher, Plugins, Werkzeugbrücke
`openai-webrtc`	OpenAI über WebRTC (benötigt `cmake`)
`vertex-live`	Gemini über Vertex AI Live (OAuth2 / ADC)
`livekit`	LiveKit WebRTC Brücke

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?

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