रीयलटाइम और मल्टीमॉडल एजेंट

ऐसे एजेंट बनाएँ जो रीयलटाइम में बात करें, सुनें, देखें और कार्य करें — OpenAI के Realtime API या Google के Gemini Live API से लाइव, कम-विलंबता वाले कनेक्शन के माध्यम से।

रीयलटाइम एजेंट कोई अनुरोध/प्रतिक्रिया चैटबॉट नहीं होता। यह एक खुला सत्र बनाए रखता है: उपयोगकर्ता का माइक्रोफ़ोन लगातार स्ट्रीम करता है, मॉडल ऑडियो + लाइव ट्रांसक्रिप्ट वापस स्ट्रीम करता है, यह पहचानता है कि उपयोगकर्ता कब बोलना शुरू और बंद करता है, इसे वाक्य के बीच में भी बाधित किया जा सकता है (बीच में हस्तक्षेप), यह कैमरे से फ़्रेम देख सकता है, और यह आपके टूल कॉल करके परिणाम बोल सकता है — और यह सब “कॉल” को कभी समाप्त किए बिना।

ADK-Rust में नए हैं? पहले परिचय और त्वरित शुरुआत पढ़ें। यह अनुभाग मानता है कि आप जानते हैं कि एजेंट, टूल और सत्र क्या होते हैं।

आप क्या बना सकते हैं

फिर चार चलने योग्य उदाहरण ऐप्स देखें।

मानसिक मॉडल

दो परतें हैं, और अधिकांश एप्लिकेशन ऊपरी परत का उपयोग करते हैं:

  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)

• एक RealtimeModel (जैसे OpenAIRealtimeModel, GeminiRealtimeModel) connect() करना और एक RealtimeSession — लाइव ट्रांसपोर्ट — तैयार करना जानता है।
• RealtimeRunner उस सेशन का स्वामी होता है: यह इवेंट्स को प्रोसेस करता है, और जब मॉडल किसी टूल के लिए अनुरोध करता है, तो यह हैंडलर को निष्पादित करके परिणाम वापस भेजता है।
• IntegratedRealtimeRunner रनर को रैप करता है और उसे ADK के बाकी हिस्सों से जोड़ता है — SessionService (ट्रांसक्रिप्ट का स्थायी संग्रहण), MemoryService (पुनःस्मरण + स्टोरेज), EnhancedPluginManager (हुक्स), और एक ब्रिज जो किसी भी adk-core Tool को रीयलटाइम सेशन में चलने देता है। उदाहरणों में यही उपयोग किया गया है।

(सरल, केवल-वॉइस एजेंट्स के लिए एक उच्च-स्तरीय RealtimeAgent भी है, और प्रत्यक्ष ट्रांसपोर्ट — WebRTC, LiveKit, Vertex AI Live — का दस्तावेज़ीकरण वहीं किया गया है।)

इंस्टॉल करें

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

60-सेकंड की त्वरित शुरुआत

एक हेडलेस वॉइस टर्न: कनेक्ट करें, टेक्स्ट द्वारा पूछें, और स्ट्रीम किए गए उत्तर को लगातार प्रोसेस करें।

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

वास्तविक ऐप में आप माइक्रोफ़ोन ऑडियो को runner.send_audio(base64_pcm16) के साथ स्ट्रीम करते हैं send_text के बजाय, और सर्वर VAD अपने-आप प्रतिक्रियाएँ संचालित करता है — create_response() की आवश्यकता नहीं होती। वेब ऐप बनाना देखें।

आगे कहाँ जाएँ

1. आर्किटेक्चर — हिस्से कैसे एक साथ काम करते हैं, इवेंट लूप, ऑडियो पाइपलाइन।
2. प्रदाता — OpenAI बनाम Gemini मॉडल, आवाज़ें, एंडपॉइंट, प्रमाणीकरण।
3. टूल — सर्वर-साइड फ़ंक्शन कॉलिंग।
4. मल्टीमॉडल — वीडियो फ़्रेम भेजना।
5. भावात्मक संवाद — भावनाओं से अवगत प्रतिक्रियाएँ।
6. मेमोरी — नॉलेज-ग्राफ दीर्घकालिक मेमोरी।
7. वेब ऐप बनाना — ब्राउज़र ब्रिज।
8. उदाहरण — चार चलने योग्य ऐप।