सत्र

adk-rust में Sessions वार्तालाप संदर्भ प्रबंधन प्रदान करते हैं, जिससे एजेंट कई इंटरैक्शन में स्थिति बनाए रख सकते हैं। Sessions वार्तालाप इतिहास (events) और मनमानी स्थिति डेटा को संग्रहीत करते हैं जो पूरे वार्तालाप में बना रहता है।

अवलोकन

एक Session उपयोगकर्ता और एजेंट के बीच एक एकल वार्तालाप का प्रतिनिधित्व करता है। प्रत्येक Session:

का एक अद्वितीय पहचानकर्ता होता है
एक एप्लिकेशन (app_name) और उपयोगकर्ता (user_id) से संबंधित होता है
में events (वार्तालाप इतिहास) की एक सूची होती है
स्थिति डेटा (कुंजी-मूल्य जोड़े) बनाए रखता है
अंतिम अपडेट समय को ट्रैक करता है

Session ट्रेट

Session ट्रेट Session ऑब्जेक्ट के लिए इंटरफ़ेस को परिभाषित करता है:

use adk_session::{Events, State};
use chrono::{DateTime, Utc};

pub trait Session: Send + Sync {
    /// अद्वितीय सत्र पहचानकर्ता
    fn id(&self) -> &str;
    
    /// एप्लिकेशन का नाम जिससे यह सत्र संबंधित है
    fn app_name(&self) -> &str;
    
    /// उपयोगकर्ता पहचानकर्ता
    fn user_id(&self) -> &str;
    
    /// सत्र की स्थिति तक पहुंचें
    fn state(&self) -> &dyn State;
    
    /// संवाद की घटनाओं तक पहुंचें
    fn events(&self) -> &dyn Events;
    
    /// सत्र के अंतिम अपडेट का समय
    fn last_update_time(&self) -> DateTime<Utc>;
}

SessionService ट्रेट

SessionService ट्रेट Sessions के प्रबंधन के लिए संचालन को परिभाषित करता है:

use adk_session::{CreateRequest, GetRequest, ListRequest, DeleteRequest, Event, Session};
use adk_core::Result;
use async_trait::async_trait;

#[async_trait]
pub trait SessionService: Send + Sync {
    /// एक नया सत्र बनाएं
    async fn create(&self, req: CreateRequest) -> Result<Box<dyn Session>>;
    
    /// एक मौजूदा सत्र पुनः प्राप्त करें
    async fn get(&self, req: GetRequest) -> Result<Box<dyn Session>>;
    
    /// एक ऐप/उपयोगकर्ता के लिए सभी सत्रों को सूचीबद्ध करें
    async fn list(&self, req: ListRequest) -> Result<Vec<Box<dyn Session>>>;
    
    /// एक सत्र हटाएं
    async fn delete(&self, req: DeleteRequest) -> Result<()>;
    
    /// एक सत्र में एक इवेंट जोड़ें
    async fn append_event(&self, session_id: &str, event: Event) -> Result<()>;
}

अनुरोध प्रकार

CreateRequest

use adk_session::CreateRequest;
use std::collections::HashMap;

let request = CreateRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
    session_id: None,  // यदि None हो तो UUID स्वतः जनरेट करें
    state: HashMap::new(),  // प्रारंभिक स्थिति
};

GetRequest

use adk_session::GetRequest;

let request = GetRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
    session_id: "session_abc".to_string(),
    num_recent_events: Some(10),  // लौटाई गई घटनाओं को सीमित करें
    after: None,  // टाइमस्टैम्प के बाद की घटनाओं को फ़िल्टर करें
};

ListRequest

use adk_session::ListRequest;

let request = ListRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
};

DeleteRequest

use adk_session::DeleteRequest;

let request = DeleteRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
    session_id: "session_abc".to_string(),
};

SessionService कार्यान्वयन

ADK-Rust दो SessionService कार्यान्वयन प्रदान करता है:

InMemorySessionService

Session को मेमोरी में संग्रहीत करता है। विकास, परीक्षण और एकल-उदाहरण परिनियोजन (single-instance deployments) के लिए आदर्श।

use adk_session::{InMemorySessionService, SessionService, CreateRequest};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create the service
    let session_service = InMemorySessionService::new();
    
    // Create a session
    let session = session_service.create(CreateRequest {
        app_name: "my_app".to_string(),
        user_id: "user_123".to_string(),
        session_id: None,
        state: HashMap::new(),
    }).await?;
    
    println!("Session ID: {}", session.id());
    println!("App: {}", session.app_name());
    println!("User: {}", session.user_id());
    
    Ok(())
}

DatabaseSessionService

Session को एक SQLite डेटाबेस में संग्रहीत करता है। निरंतरता (persistence) की आवश्यकता वाले उत्पादन परिनियोजन (production deployments) के लिए उपयुक्त।

use adk_session::{DatabaseSessionService, SessionService, CreateRequest};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Connect to database
    let session_service = DatabaseSessionService::new("sqlite:sessions.db").await?;
    
    // Run migrations to create tables
    session_service.migrate().await?;
    
    // Create a session
    let session = session_service.create(CreateRequest {
        app_name: "my_app".to_string(),
        user_id: "user_123".to_string(),
        session_id: None,
        state: HashMap::new(),
    }).await?;
    
    println!("Session persisted: {}", session.id());
    
    Ok(())
}

ध्यान दें: DatabaseSessionService के लिए database फीचर फ्लैग की आवश्यकता होती है:
adk-session = { version = "0.2", features = ["database"] }

Session Lifecycle

1. निर्माण

Session को एक CreateRequest के साथ बनाया जाता है। यदि कोई session_id प्रदान नहीं किया जाता है, तो एक UUID स्वचालित रूप से उत्पन्न होता है।

use adk_session::{InMemorySessionService, SessionService, CreateRequest};
use std::collections::HashMap;

let service = InMemorySessionService::new();

// Create with auto-generated ID
let session = service.create(CreateRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
    session_id: None,
    state: HashMap::new(),
}).await?;

// Create with specific ID
let session = service.create(CreateRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
    session_id: Some("my-custom-id".to_string()),
    state: HashMap::new(),
}).await?;

2. पुनर्प्राप्ति

एक session को उसके पहचानकर्ताओं (identifiers) द्वारा पुनः प्राप्त करें:

use adk_session::GetRequest;

let session = service.get(GetRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
    session_id: "session_abc".to_string(),
    num_recent_events: None,
    after: None,
}).await?;

println!("Retrieved session: {}", session.id());
println!("Events: {}", session.events().len());

3. Event जोड़ना

जैसे-जैसे बातचीत आगे बढ़ती है, Event को session में जोड़ा जाता है। यह आमतौर पर Runner द्वारा नियंत्रित किया जाता है, लेकिन इसे मैन्युअल रूप से भी किया जा सकता है:

use adk_session::Event;

let event = Event::new("invocation_123");
service.append_event(session.id(), event).await?;

4. सूचीबद्ध करना

एक उपयोगकर्ता के लिए सभी session सूचीबद्ध करें:

use adk_session::ListRequest;

let sessions = service.list(ListRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
}).await?;

for session in sessions {
    println!("Session: {} (updated: {})", 
        session.id(), 
        session.last_update_time()
    );
}

5. विलोपन

जब एक session की आवश्यकता न हो, तो उसे हटा दें:

use adk_session::DeleteRequest;

service.delete(DeleteRequest {
    app_name: "my_app".to_string(),
    user_id: "user_123".to_string(),
    session_id: "session_abc".to_string(),
}).await?;

Runner के साथ सेशन का उपयोग करना

एजेंटों को निष्पादित करते समय सेशन आमतौर पर Runner द्वारा प्रबंधित किए जाते हैं। Runner:

एक सेशन बनाता या पुनः प्राप्त करता है
सेशन कॉन्टेक्स्ट को agent को पास करता है
बातचीत आगे बढ़ने पर घटनाओं को जोड़ता है
एजेंट क्रियाओं के आधार पर सेशन की स्थिति को अपडेट करता है

use adk_rust::prelude::*;
use adk_runner::{Runner, RunnerConfig};
use adk_session::InMemorySessionService;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.0-flash")?);

    let agent = LlmAgentBuilder::new("assistant")
        .model(model)
        .instruction("You are a helpful assistant.")
        .build()?;

    let session_service = Arc::new(InMemorySessionService::new());

    // Create runner with session service
    let runner = Runner::new(RunnerConfig {
        app_name: "my_app".to_string(),
        agent: Arc::new(agent),
        session_service,
        artifact_service: None,
        memory_service: None,
        run_config: None,
    })?;

    // Run with user and session IDs
    let user_content = Content::new("user").with_text("Hello!");
    let stream = runner.run(
        "user_123".to_string(),
        "session_abc".to_string(),
        user_content,
    ).await?;

    Ok(())
}

इवेंट्स

Events trait बातचीत के इतिहास तक पहुंच प्रदान करता है:

pub trait Events: Send + Sync {
    /// Get all events
    fn all(&self) -> Vec<Event>;
    
    /// Get number of events
    fn len(&self) -> usize;
    
    /// Get event at index
    fn at(&self, index: usize) -> Option<&Event>;
    
    /// Check if empty
    fn is_empty(&self) -> bool;
}

एक सेशन से इवेंट्स तक पहुंचें:

let events = session.events();
println!("Total events: {}", events.len());

for event in events.all() {
    println!("Event {} by {} at {}", 
        event.id, 
        event.author, 
        event.timestamp
    );
}

पूर्ण उदाहरण

use adk_session::{
    InMemorySessionService, SessionService, 
    CreateRequest, GetRequest, ListRequest, DeleteRequest,
    Event, KEY_PREFIX_USER,
};
use serde_json::json;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let service = InMemorySessionService::new();
    
    // Create session with initial state
    let mut initial_state = HashMap::new();
    initial_state.insert(format!("{}name", KEY_PREFIX_USER), json!("Alice"));
    initial_state.insert("topic".to_string(), json!("Getting started"));
    
    let session = service.create(CreateRequest {
        app_name: "demo".to_string(),
        user_id: "alice".to_string(),
        session_id: None,
        state: initial_state,
    }).await?;
    
    println!("Created session: {}", session.id());
    
    // Check state
    let state = session.state();
    println!("User name: {:?}", state.get("user:name"));
    println!("Topic: {:?}", state.get("topic"));
    
    // Append an event
    let event = Event::new("inv_001");
    service.append_event(session.id(), event).await?;
    
    // Retrieve session with events
    let session = service.get(GetRequest {
        app_name: "demo".to_string(),
        user_id: "alice".to_string(),
        session_id: session.id().to_string(),
        num_recent_events: None,
        after: None,
    }).await?;
    
    println!("Events: {}", session.events().len());
    
    // List all sessions
    let sessions = service.list(ListRequest {
        app_name: "demo".to_string(),
        user_id: "alice".to_string(),
    }).await?;
    
    println!("Total sessions: {}", sessions.len());
    
    // Delete session
    service.delete(DeleteRequest {
        app_name: "demo".to_string(),
        user_id: "alice".to_string(),
        session_id: session.id().to_string(),
    }).await?;
    
    println!("Session deleted");
    
    Ok(())
}