Agentes en Tiempo Real y Multimodales

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

Un agente en tiempo real no es un chatbot de solicitud/respuesta. Mantiene una session abierta: el micrófono del usuario transmite continuamente, el modelo transmite audio + una transcripción en vivo de vuelta, detecta cuándo el usuario empieza y deja de hablar, puede ser interrumpido a mitad de frase (barge-in), puede ver fotogramas de una cámara, y puede llamar a sus tools y pronunciar el resultado — todo sin terminar nunca la "llamada".

¿Nuevo en ADK-Rust? Lea primero la Introducción y la Guía de inicio rápido. Esta sección asume que sabe qué son un agent, un tool y una session.

Lo que puede construir

Capacidad	Lo que significa	Página
Conversaciones de voz	Audio PCM16 bidireccional con VAD e interrupción	Arquitectura
Dos proveedores, una API	OpenAI Realtime (GA) o Gemini Live, intercambiable por sesión	Proveedores
Herramientas del lado del servidor	El modelo llama a `process_refund(...)`; tu Rust lo ejecuta y el modelo comunica 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 lee 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 cura a medida que aprende	Memoria
Aplicaciones web	Un front-end de navegador (micrófono + cámara) conectado a través de tu servidor	Construcción de aplicaciones web

Luego, consulte las cuatro aplicaciones de ejemplo.

El modelo mental

Hay dos capas, y la mayoría de las aplicaciones utilizan 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 (p. ej., OpenAIRealtimeModel, GeminiRealtimeModel) sabe cómo connect() y generar una RealtimeSession — el transporte en vivo.
RealtimeRunner es propietario de esa sesión: bombea eventos, y cuando el modelo pide una Tool, ejecuta el manejador y envía el resultado de vuelta.
IntegratedRealtimeRunner envuelve al Runner 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 hay un nivel superior RealtimeAgent para agentes simples solo de voz, y transportes directos — WebRTC, LiveKit, Vertex AI Live — documentados allí.)

Instalar

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

Característica	Añade
`openai`	OpenAI Realtime (WebSocket)
`gemini`	Gemini Live (WebSocket)
`integration`	`IntegratedRealtimeRunner` — sesiones, memoria, complementos, puente de herramientas
`openai-webrtc`	OpenAI over WebRTC (necesita `cmake`)
`vertex-live`	Gemini via Vertex AI Live (OAuth2 / ADC)
`livekit`	LiveKit WebRTC bridge

Inicio rápido en 60 segundos

Una interacción de voz sin interfaz: conectar, preguntar por texto y enviar 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",
));

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 audio del micrófono con runner.send_audio(base64_pcm16) en lugar de send_text, y el VAD del servidor impulsa las respuestas automáticamente; no se necesita create_response(). Consulta Crear aplicaciones web.

Dónde ir a continuación

Arquitectura — cómo encajan las piezas, el bucle de eventos, la pipeline de audio.
Proveedores — modelos OpenAI vs Gemini, voces, endpoints, autenticación.
Herramientas — llamadas a funciones del lado del servidor.
Multimodal — envío de fotogramas de video.
Diálogo afectivo — respuestas con conciencia emocional.
Memoria — memoria a largo plazo de grafo de conocimiento.
Construcción de aplicaciones web — el puente del navegador.
Ejemplos — cuatro aplicaciones ejecutables.