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

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

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

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

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

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

मानसिक मॉडल

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

  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 — लाइव transport — उत्पन्न करे।
• RealtimeRunner उस session का मालिक है: यह events को पंप करता है, और जब model किसी tool के लिए पूछता है तो यह handler को निष्पादित करता है और परिणाम वापस भेजता है।
• IntegratedRealtimeRunner runner को रैप करता है और इसे ADK के बाकी हिस्सों से जोड़ता है — SessionService (transcript persistence), MemoryService (recall + storage), EnhancedPluginManager (hooks), और एक ब्रिज जो किसी भी adk-core Tool को realtime session में चलाने देता है। उदाहरण इसी का उपयोग करते हैं।

(एक उच्च-स्तरीय RealtimeAgent भी है जो सरल केवल-वॉयस agents और सीधे transports — WebRTC, LiveKit, Vertex AI Live — के लिए है, जो वहाँ प्रलेखित है।)

स्थापित करें

# Voice + tools + the integration layer (recommended)
adk-realtime = { version = "2.0.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",
));

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 models, आवाज़ें, एंडपॉइंट्स, प्रमाणीकरण।
3. टूल्स — सर्वर-साइड फ़ंक्शन कॉलिंग।
4. मल्टीमॉडल — वीडियो फ़्रेम भेजना।
5. भावनात्मक संवाद — भावना-जागरूक प्रतिक्रियाएँ।
6. मेमोरी — नॉलेज-ग्राफ दीर्घकालिक मेमोरी।
7. वेब ऐप्स बनाना — ब्राउज़र ब्रिज।
8. उदाहरण — चार चलाने योग्य ऐप्स।