ADK-Rust

लॉन्चर

Launcher ADK एजेंटों को चलाने का एक सरल, एक-पंक्ति तरीका प्रदान करता है। डिफ़ॉल्ट न्यूनतम टियर में यह adk-runner से एक हल्का कंसोल लॉन्चर है। जब आपको पूर्ण CLI आर्ग्यूमेंट पार्सर और HTTP सर्वर मोड की आवश्यकता हो तो CLI जैसी ऑप्ट-इन cli-openai सुविधा सक्षम करें।

अवलोकन

लॉन्चर को एजेंट परिनियोजन को यथासंभव सरल बनाने के लिए डिज़ाइन किया गया है। कोड की एक पंक्ति के साथ, आप यह कर सकते हैं:

  • परीक्षण और विकास के लिए अपने एजेंट को एक इंटरैक्टिव कंसोल में चलाएं
  • जब cli-* सुविधा या cargo-adk api टेम्पलेट का उपयोग किया जाता है, तो अपने एजेंट को वेब UI के साथ HTTP सर्वर के रूप में परिनियोजित करें
  • एप्लिकेशन नाम और आर्टिफैक्ट स्टोरेज को अनुकूलित करें

मूल उपयोग

कंसोल मोड (डिफ़ॉल्ट)

लॉन्चर का उपयोग करने का सबसे सरल तरीका इसे अपने एजेंट के साथ बनाना और run() को कॉल करना है:

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);
    
    let agent = LlmAgentBuilder::new("my_agent")
        .description("A helpful assistant")
        .instruction("You are a helpful assistant.")
        .model(model)
        .build()?;
    
    // Run with the lightweight console launcher
    Launcher::new(Arc::new(agent)).run().await
}

अपने एजेंट को चलाएं:

# Interactive console (default)
cargo run

# Full CLI mode is available when your app enables a `cli-*` feature

सर्वर मोड

अपने एजेंट को वेब UI के साथ HTTP सर्वर के रूप में चलाने के लिए, api टेम्पलेट का उपयोग करें या cli-* सुविधा सक्षम करें:

cargo adk new my-api --template api
cd my-api
cargo run

सर्वर शुरू होगा और प्रदर्शित करेगा:

🚀 ADK Server starting on http://localhost:8080
📱 Open http://localhost:8080 in your browser
Press Ctrl+C to stop

कॉन्फ़िगरेशन विकल्प

कस्टम एप्लिकेशन नाम

डिफ़ॉल्ट रूप से, लॉन्चर एजेंट के नाम का उपयोग एप्लिकेशन नाम के रूप में करता है। आप इसे अनुकूलित कर सकते हैं:

Launcher::new(Arc::new(agent))
    .app_name("my_custom_app")
    .run()
    .await

कस्टम आर्टिफैक्ट सेवा

अपनी स्वयं की आर्टिफैक्ट सेवा कार्यान्वयन प्रदान करें:

use adk_artifact::InMemoryArtifactService;

let artifact_service = Arc::new(InMemoryArtifactService::new());

Launcher::new(Arc::new(agent))
    .with_artifact_service(artifact_service)
    .run()
    .await

कंसोल मोड विवरण

कंसोल मोड में, लॉन्चर:

  1. एक इन-मेमोरी सेशन सेवा बनाता है
  2. उपयोगकर्ता के लिए एक सेशन बनाता है
  3. एक इंटरैक्टिव REPL लूप शुरू करता है
  4. एजेंट प्रतिक्रियाओं को वास्तविक समय में स्ट्रीम करता है
  5. मल्टी-एजेंट सिस्टम में एजेंट ट्रांसफर को संभालता है

कंसोल इंटरेक्शन

🤖 Agent ready! Type your questions (or 'exit' to quit).

You: What is the capital of France?
Assistant: The capital of France is Paris.

You: exit
👋 Goodbye!

मल्टी-एजेंट कंसोल

मल्टी-एजेंट सिस्टम का उपयोग करते समय, कंसोल दिखाता है कि कौन सा एजेंट प्रतिक्रिया दे रहा है:

You: I need help with my order

[Agent: customer_service]
Assistant: I'll help you with your order. What's your order number?

You: ORDER-12345

🔄 [Transfer requested to: order_lookup]

[Agent: order_lookup]
Assistant: I found your order. It was shipped yesterday.

सर्वर मोड विवरण

सर्वर मोड में, लॉन्चर:

  1. अवलोकन क्षमता के लिए टेलीमेट्री को इनिशियलाइज़ करता है
  2. एक इन-मेमोरी सेशन सेवा बनाता है
  3. REST API एंडपॉइंट्स के साथ एक HTTP सर्वर शुरू करता है
  4. आपके एजेंट के साथ इंटरैक्ट करने के लिए एक वेब UI प्रदान करता है

प्रोडक्शन एस्केप हैच

कस्टम रूट्स, मिडलवेयर, मेट्रिक्स, या सर्व लूप के स्वामित्व की आवश्यकता वाले प्रोडक्शन एप्लिकेशन के लिए, build_app() का उपयोग करें:

let app = Launcher::new(Arc::new(agent))
    .with_a2a_base_url("https://agent.example.com")
    .build_app()?;

let app = app.merge(my_admin_routes());
let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
axum::serve(listener, app).await?;

यदि आप A2A रूट्स को स्पष्ट रूप से सक्षम करना चाहते हैं तो build_app_with_a2a(...) का उपयोग करें।

उपलब्ध एंडपॉइंट्स

सर्वर निम्नलिखित REST API एंडपॉइंट्स को उजागर करता है:

  • GET /health - हेल्थ चेक एंडपॉइंट
  • POST /run_sse - सर्वर-सेंट इवेंट्स स्ट्रीमिंग के साथ एजेंट चलाएं
  • GET /sessions - सेशन सूचीबद्ध करें
  • POST /sessions - एक नया सेशन बनाएं
  • GET /sessions/:app_name/:user_id/:session_id - सेशन विवरण प्राप्त करें
  • DELETE /sessions/:app_name/:user_id/:session_id - एक सेशन हटाएं

विस्तृत एंडपॉइंट विशिष्टताओं के लिए सर्वर API दस्तावेज़ देखें।

वेब UI

सर्वर में http://localhost:8080/ui/ पर सुलभ एक अंतर्निहित वेब UI शामिल है। UI प्रदान करता है:

  • इंटरैक्टिव चैट इंटरफ़ेस
  • सेशन प्रबंधन
  • वास्तविक समय स्ट्रीमिंग प्रतिक्रियाएं
  • मल्टी-एजेंट विज़ुअलाइज़ेशन

CLI आर्ग्यूमेंट्स

पूर्ण CLI लॉन्चर निम्नलिखित कमांड का समर्थन करता है जब cli-* सुविधा सक्षम होती है:

कमांडविवरणउदाहरण
(कोई नहीं)इंटरैक्टिव कंसोल (डिफ़ॉल्ट)cargo run
chatइंटरैक्टिव कंसोल (स्पष्ट)cargo run -- chat
serveHTTP server मोडcargo run -- serve
serve --port PORTHTTP server कस्टम पोर्ट परcargo run -- serve --port 3000

पूर्ण उदाहरण

यहां दोनों मोड दिखाने वाला एक पूर्ण उदाहरण दिया गया है:

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    // Load API key
    let api_key = std::env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");
    
    // Create model
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);
    
    // Create agent with tools
    let weather_tool = FunctionTool::new(
        "get_weather",
        "Get the current weather for a location",
        |params, _ctx| async move {
            let location = params["location"].as_str().unwrap_or("unknown");
            Ok(json!({
                "location": location,
                "temperature": 72,
                "condition": "sunny"
            }))
        },
    );
    
    let agent = LlmAgentBuilder::new("weather_agent")
        .description("An agent that provides weather information")
        .instruction("You are a weather assistant. Use the get_weather tool to provide weather information.")
        .model(model)
        .tool(Arc::new(weather_tool))
        .build()?;
    
    // Run with Launcher. Enable a `cli-*` feature for full CLI/server mode.
    Launcher::new(Arc::new(agent))
        .app_name("weather_app")
        .run()
        .await
}

कंसोल मोड में चलाएँ:

cargo run

एक जेनरेटेड API प्रोजेक्ट से सर्वर मोड में चलाएँ:

cargo adk new weather-api --template api
cd weather-api
cargo run

डिप्लॉयमेंट-पूर्व सत्यापन

अपने एजेंट को डिप्लॉय करने से पहले, यह सत्यापित करने के लिए cargo adk build का उपयोग करें कि प्रोजेक्ट वास्तव में डिप्लॉय किए बिना सही ढंग से संकलित होता है:

# Verify compilation (no deployment)
cargo adk build

# Build with release optimizations
cargo adk build --release

यह डिप्लॉयमेंट के लिए प्रतिबद्ध होने से पहले संकलन त्रुटियों, गुम हुई निर्भरताओं और कॉन्फ़िगरेशन समस्याओं को पकड़ता है। यह CI पाइपलाइनों में cargo adk deploy से पहले एक गेट के रूप में विशेष रूप से उपयोगी है।

पूर्ण कमांड दस्तावेज़ के लिए cargo adk build देखें।

सर्वोत्तम अभ्यास

  1. पर्यावरण चर: संवेदनशील कॉन्फ़िगरेशन (API कुंजियाँ) हमेशा पर्यावरण चर से लोड करें
  2. त्रुटि प्रबंधन: Result प्रकारों के साथ उचित त्रुटि प्रबंधन का उपयोग करें
  3. सभ्य शटडाउन: लॉन्चर दोनों मोड में Ctrl+C को शालीनता से संभालता है
  4. पोर्ट चयन: ऐसे पोर्ट चुनें जो अन्य सेवाओं के साथ विरोध न करें (डिफ़ॉल्ट 8080)
  5. सेशन प्रबंधन: उत्पादन में, इन-मेमोरी सेशन के बजाय PostgresSessionService या SqliteSessionService का उपयोग करने पर विचार करें
  6. डिप्लॉयमेंट-पूर्व जाँच: समस्याओं को जल्दी पकड़ने के लिए डिप्लॉय करने से पहले cargo adk build चलाएँ

संबंधित

  • Server API - विस्तृत REST API दस्तावेज़
  • Sessions - सेशन प्रबंधन
  • Artifacts - आर्टिफैक्ट स्टोरेज
  • Observability - टेलीमेट्री और लॉगिंग

पिछला: ← Telemetry | अगला: Server →

लॉन्चर - ADK-Rust दस्तावेज़ीकरण | ADK-Rust