Agentes en tiempo real y multimodales

Crea agentes que hablen, escuchen, vean y actúen en tiempo real, a través de una conexión activa de baja latencia con OpenAI's Realtime API o Gemini Live API de Google.

Un agente en tiempo real no es un chatbot de solicitud/respuesta. Mantiene una sesión abierta: el micrófono del usuario transmite continuamente, el modelo devuelve audio + una transcripción en directo, detecta cuándo el usuario empieza y deja de hablar, puede ser interrumpido a mitad de una frase (intervención), puede ver los fotogramas de una cámara y puede llamar a tus herramientas y pronunciar el resultado, todo ello sin terminar nunca la «llamada».

¿Es la primera vez que usas ADK-Rust? Lee primero la Introducción y la Guía de inicio rápido. Esta sección supone que sabes qué son un agente, una herramienta y una sesión.

Qué puedes crear

Capacidad	Qué significa	Página
Conversaciones de voz	Audio PCM16 bidireccional con VAD e interrupción	Arquitectura
Dos proveedores, un API	OpenAI Realtime (GA) o Gemini Live, intercambiables por sesión	Proveedores
Herramientas del lado del servidor	El modelo llama a `process_refund(...)`; tu código Rust lo ejecuta y el modelo expresa el resultado	Herramientas
Visión multimodal	Transmite fotogramas de la cámara: el agente ve lo que el usuario le muestra	Multimodal
Diálogo afectivo	El agente interpreta el tono emocional del usuario y se adapta (audio nativo de Gemini)	Diálogo afectivo
Memoria a largo plazo	Un grafo de conocimiento que el agente lee al inicio de la sesión y mantiene a medida que aprende	Memoria
Aplicaciones web	Una interfaz de navegador (micrófono + cámara) conectada a través de tu servidor	Creación de aplicaciones web

Luego consulta las cuatro aplicaciones de ejemplo ejecutables.

El modelo mental

Hay dos capas, y la mayoría de las aplicaciones usa la superior:

  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 (por ejemplo, OpenAIRealtimeModel, GeminiRealtimeModel) sabe cómo connect() y producir un RealtimeSession: el transporte en tiempo real.
RealtimeRunner administra esa sesión: procesa eventos y, cuando el modelo solicita una herramienta, ejecuta el controlador y envía el resultado de vuelta.
IntegratedRealtimeRunner envuelve el ejecutor y lo conecta con el resto de ADK: SessionService (persistencia de transcripciones), MemoryService (recuperación + almacenamiento), EnhancedPluginManager (hooks) y un puente que permite que cualquier adk-core Tool se ejecute en una sesión en tiempo real. Esto es lo que usan los ejemplos.

(También existe un RealtimeAgent de nivel superior para agentes sencillos que solo usan voz, y transportes directos: WebRTC, LiveKit, Vertex AI Live; allí se documentan.)

Instalación

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

Función	Añade
`openai`	OpenAI Realtime (WebSocket)
`gemini`	Gemini Live (WebSocket)
`integration`	`IntegratedRealtimeRunner` — sesiones, memoria, complementos, puente de herramientas
`openai-webrtc`	OpenAI sobre WebRTC (necesita `cmake`)
`vertex-live`	Gemini mediante Vertex AI Live (OAuth2 / ADC)
`livekit`	LiveKit WebRTC puente

Inicio rápido en 60 segundos

Una interacción de voz sin interfaz: conecta, pregunta por texto y consume la respuesta transmitida.

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

En una aplicación real, transmites el audio del micrófono con runner.send_audio(base64_pcm16) en lugar de send_text, y el VAD del servidor inicia las respuestas automáticamente, sin necesidad de create_response(). Consulta Construcción de aplicaciones web.

Qué hacer a continuación

Arquitectura — cómo encajan las piezas, el bucle de eventos y la canalización de audio.
Proveedores — modelos OpenAI y Gemini, voces, endpoints y autenticación.
Herramientas — invocación de funciones en el servidor.
Multimodal — envío de fotogramas de vídeo.
Diálogo afectivo — respuestas que tienen en cuenta las emociones.
Memoria — memoria a largo plazo basada en grafos de conocimiento.
Construcción de aplicaciones web — el puente del navegador.
Ejemplos — cuatro aplicaciones ejecutables.