Agentes em tempo real e multimodais

Crie agentes que falam, ouvem, veem e agem em tempo real — por meio de uma conexão ativa e de baixa latência com o OpenAI Realtime API ou o Gemini Live API do Google.

Um agente em tempo real não é um chatbot de solicitação/resposta. Ele mantém uma sessão aberta: o microfone do usuário transmite continuamente, o modelo transmite áudio + uma transcrição ao vivo de volta, detecta quando o usuário começa e para de falar, pode ser interrompido no meio da frase (interrupção), pode ver quadros de uma câmera e pode chamar suas ferramentas e falar o resultado — tudo isso sem nunca encerrar a “chamada”.

Novo no ADK-Rust? Leia primeiro a Introdução e o Início rápido. Esta seção pressupõe que você saiba o que são um agente, uma ferramenta e uma sessão.

O que você pode criar

Em seguida, consulte os quatro aplicativos de exemplo executáveis.

Modelo mental

Há duas camadas, e a maioria dos aplicativos usa a camada 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)

• Um RealtimeModel (por exemplo, OpenAIRealtimeModel, GeminiRealtimeModel) sabe como connect() e produzir um RealtimeSession — o transporte ativo.
• RealtimeRunner gerencia essa sessão: processa eventos e, quando o modelo solicita uma ferramenta, executa o manipulador e envia o resultado de volta.
• IntegratedRealtimeRunner encapsula o executor e o conecta ao restante de ADK — SessionService (persistência da transcrição), MemoryService (recuperação + armazenamento), EnhancedPluginManager (ganchos) e uma ponte que permite que qualquer adk-core Tool seja executado em uma sessão em tempo real. É isso que os exemplos usam.

(Há também um RealtimeAgent de nível mais alto para agentes simples somente de voz, além de transportes diretos — WebRTC, LiveKit, Vertex AI Live — documentados lá.)

Instalação

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

Início rápido em 60 segundos

Uma interação de voz sem interface: conecte-se, faça uma pergunta por texto e processe a resposta transmitida em fluxo.

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

Em um aplicativo real, você transmite o áudio do microfone com runner.send_audio(base64_pcm16) em vez de send_text, e o VAD do servidor inicia as respostas automaticamente — sem a necessidade de create_response(). Consulte Criando aplicativos web.

Próximos passos

1. Arquitetura — como as peças se encaixam, o loop de eventos e o pipeline de áudio.
2. Provedores — OpenAI versus modelos Gemini, vozes, endpoints e autenticação.
3. Ferramentas — chamada de funções no servidor.
4. Multimodal — envio de quadros de vídeo.
5. Diálogo afetivo — respostas cientes de emoções.
6. Memória — memória de longo prazo baseada em grafos de conhecimento.
7. Criando aplicativos web — a ponte com o navegador.
8. Exemplos — quatro aplicativos executáveis.