Agents en temps réel et multimodaux

Créez des agents qui parlent, écoutent, voient et agissent en temps réel — via une connexion active à faible latence à OpenAI's Realtime API ou à Gemini Live API de Google.

Un agent en temps réel n'est pas un chatbot requête/réponse. Il maintient une session ouverte : le microphone de l'utilisateur diffuse en continu, le modèle renvoie en continu de l'audio + une transcription en direct, détecte quand l'utilisateur commence et arrête de parler, peut être interrompu au milieu d'une phrase (prise de parole), peut voir les images d'une caméra et peut appeler vos outils et énoncer le résultat — le tout sans jamais mettre fin à « l'appel ».

Vous découvrez ADK-Rust ? Lisez d'abord l'Introduction et le Démarrage rapide. Cette section suppose que vous savez ce que sont un agent, un outil et une session.

Ce que vous pouvez créer

Consultez ensuite les quatre applications d’exemple exécutables.

Modèle mental

Il existe deux couches, et la plupart des applications utilisent la couche supérieure :

  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)

• Un RealtimeModel (par ex. OpenAIRealtimeModel, GeminiRealtimeModel) sait connect() et produire un RealtimeSession — le transport actif.
• RealtimeRunner possède cette session : il traite les événements et, lorsque le modèle demande un outil, il exécute le gestionnaire et renvoie le résultat.
• IntegratedRealtimeRunner encapsule le moteur d’exécution et le connecte au reste de ADK — SessionService (persistance de la transcription), MemoryService (rappel + stockage), EnhancedPluginManager (hooks), ainsi qu’un pont qui permet à n’importe quel adk-core Tool de s’exécuter dans une session en temps réel. C’est ce qu’utilisent les exemples.

(Il existe également un RealtimeAgent de niveau supérieur pour les agents vocaux simples, ainsi que des transports directs — WebRTC, LiveKit, Vertex AI Live — documentés à cet endroit.)

Installation

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

Démarrage rapide en 60 secondes

Un échange vocal sans interface : connectez-vous, posez une question par texte, puis diffusez la réponse au fur et à mesure.

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

Dans une véritable application, vous diffusez l’audio du microphone avec runner.send_audio(base64_pcm16) au lieu de send_text, et le VAD côté serveur déclenche automatiquement les réponses — aucun create_response() n’est nécessaire. Consultez Créer des applications web.

Pour aller plus loin

1. Architecture — comment les éléments s’articulent, la boucle d’événements et le pipeline audio.
2. Fournisseurs — OpenAI et modèles Gemini, voix, points de terminaison et authentification.
3. Outils — appels de fonctions côté serveur.
4. Multimodal — envoi d’images vidéo.
5. Dialogue affectif — réponses tenant compte des émotions.
6. Mémoire — mémoire à long terme fondée sur un graphe de connaissances.
7. Créer des applications web — le pont avec le navigateur.
8. Exemples — quatre applications exécutables.