सेशन और लाइफ़साइकल मैनेज करना

उपयोगकर्ता के डिवाइस पर मौजूद एजेंटिक वर्कफ़्लो (AgentRunner क्लास का इस्तेमाल करके), मैनेज किए गए सिलसिलेवार बातचीत वाले सेशन उपलब्ध कराते हैं. ये सेशन, बातचीत के इतिहास को मेमोरी में अपने-आप रिकॉर्ड करते हैं. इससे आपको ट्रांसक्रिप्ट को मैन्युअल तरीके से मैनेज करने की ज़रूरत नहीं पड़ती. (अगर आपको चैट के इतिहास को सीधे तौर पर मैनेज करना है, तो डायरेक्ट मॉडल ऐक्सेस का इस्तेमाल करके, GenerateContentRequest ऑब्जेक्ट को List<Content> ऑब्जेक्ट पास किया जा सकता है. इसमें USER और MODEL भूमिकाओं के साथ-साथ sessionId वैल्यू भी शामिल होनी चाहिए.)

इस पेज पर, Android कॉम्पोनेंट की लाइफ़साइकल, कॉन्फ़िगरेशन में बदलावों, और मेमोरी को फिर से इस्तेमाल करने के दौरान, AgentSession इंस्टेंस को मैनेज करने के बारे में बताया गया है.

मल्टी-टर्न सेशन

runner.getOrCreateSession(sessionId) तरीके का इस्तेमाल करके, स्कोप किए गए AgentSession इंस्टेंस की मदद से, कई बार की जाने वाली बातचीत को मैनेज करें. सेशन के दौरान, बातचीत के टर्न (उपयोगकर्ता के मैसेज, टूल को कॉल करना, और मॉडल के जवाब) अपने-आप मेमोरी में रिकॉर्ड हो जाते हैं. session.runAsync(content) तरीके को बाद में किए जाने वाले कॉल, पिछले टर्न को कॉन्टेक्स्ट के तौर पर सेव रखते हैं.

सेशन आइडेंटिफ़ायर खाली नहीं होने चाहिए. इनमें ज़्यादा से ज़्यादा 128 वर्ण होने चाहिए. साथ ही, इनमें सिर्फ़ अक्षर और अंक, अंडरस्कोर, हाइफ़न या फ़ुल स्टॉप (^[a-zA-Z0-9_.-]+$, . और .. को छोड़कर) होने चाहिए. UUID.randomUUID().toString() तरीके का इस्तेमाल करके जनरेट की गई यूयूआईडी स्ट्रिंग, इन शर्तों के मुताबिक होती हैं.

मल्टी-टर्न बातचीत शुरू करने के लिए, सेशन आइडेंटिफ़ायर बनाएं और अपने AgentRunner इंस्टेंस से AgentSession इंस्टेंस पाएं:

val sessionId = "user_chat_${System.currentTimeMillis()}"
val session = runner.getOrCreateSession(sessionId)

session.runAsync(content) तरीके को हर बार कॉल करने पर, उस सेशन में एक नया प्रॉम्प्ट टर्न भेजा जाता है. यह मॉडल, बातचीत के पिछले टर्न के कॉन्टेक्स्ट को ध्यान में रखता है.

कॉन्फ़िगरेशन में बदलाव होने पर सेशन को बनाए रखना

AgentSession इंटरफ़ेस, मेमोरी में डायलॉग का इतिहास सेव रखता है और Parcelable इंटरफ़ेस को लागू नहीं करता. Android ऐप्लिकेशन में, कॉन्फ़िगरेशन में बदलाव होने पर, जैसे कि स्क्रीन रोटेशन, गतिविधियां और फ़्रैगमेंट खत्म हो जाते हैं और फिर से बनते हैं. अगर सेशन को सीधे किसी ऐक्टिविटी में सेव किया जाता है, तो रोटेशन होने पर बातचीत का इतिहास मिट जाता है.

कॉन्फ़िगरेशन में बदलाव होने पर भी बातचीत का इतिहास सेव रखने के लिए, AndroidX ViewModel क्लास में AgentSession इंस्टेंस को बनाए रखें:

package com.example.ai.agent.ui

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.mlkit.genai.agent.AgentRunner
import com.google.mlkit.genai.agent.AgentSession
import com.google.mlkit.genai.agent.textTokens
import com.google.mlkit.genai.prompt.Content
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch

class ChatViewModel(
    private val runner: AgentRunner,
    private val sessionId: String = "default_chat_session"
) : ViewModel() {

    // Retain the session inside the ViewModel to survive screen rotations
    private val session: AgentSession = runner.getOrCreateSession(sessionId)

    private val _responseText = MutableStateFlow("")
    val responseText: StateFlow<String> = _responseText.asStateFlow()

    fun sendMessage(userPrompt: String) {
        viewModelScope.launch {
            val content = Content.builder().text(userPrompt).build()
            session.runAsync(content)
                .textTokens()
                .collect { token ->
                    _responseText.update { it + token }
                }
        }
    }

    override fun onCleared() {
        super.onCleared()
        // Release session memory and cancel active coroutines when ViewModel is destroyed
        session.close()
    }
}

मेमोरी मैनेज करना और सेशन क्लीनअप

ऐप्लिकेशन की परफ़ॉर्मेंस को बेहतर बनाए रखने के लिए, इन-मेमोरी बातचीत की स्थिति को सीमित रखें:

  • सेशन को साफ़ तौर पर मिटाना: जब कोई उपयोगकर्ता बातचीत का थ्रेड छोड़ता है या "नई चैट" पर टैप करता है, तो session.delete() या runner.deleteSession(sessionId) तरीके को कॉल करें. इससे, पिछली बातचीत और टूल के आउटपुट के लिए असाइन की गई मेमोरी को सिंक्रोनस तरीके से खाली किया जा सकता है. इसके अलावा, session.close() वाले तरीके को कॉल करने पर, बैकग्राउंड में मौजूद ऐप्लिकेशन को हटाने की प्रोसेस शुरू हो जाती है.
  • साइन-आउट करने पर डेटा मिटाना: जब उपयोगकर्ता साइन आउट करे या ऐप्लिकेशन का डेटा मिटाए, तब runner.clearAllSessions() तरीके को कॉल करें.
  • लाइफ़साइकल के आखिर में सेशन क्लीनअप: जब आपकी ViewModel क्लास या पैरंट कॉम्पोनेंट को हमेशा के लिए खत्म कर दिया जाए, तब session.close() तरीके को कॉल करें. ऐसा onCleared() तरीके में करें. इससे, इन-फ़्लाइट कोरूटीन रद्द हो जाते हैं और उस बातचीत के सेशन के लिए, बैकग्राउंड में डेटा हटाने की प्रोसेस शुरू हो जाती है.

एक बार में पूरा होने वाला टास्क

एजेंट के ऐसे टास्क जो सिर्फ़ एक बार किए जाते हैं (जैसे, तुरंत खास जानकारी जनरेट करना, किसी इनपुट की पुष्टि करना या किसी सवाल का जवाब देना) और जिनके लिए पिछले कॉन्टेक्स्ट की ज़रूरत नहीं होती, उनके लिए सीधे runner.runSingleTurnAsync(content) तरीके को कॉल करें:

import com.google.mlkit.genai.agent.AgentEvent
import com.google.mlkit.genai.prompt.Content

val content = Content.builder()
    .text("Summarize order history for customer #1042: ...")
    .build()

runner.runSingleTurnAsync(content)
    .collect { event ->
        if (event is AgentEvent.TextMessage && !event.isPartial) {
            displaySummary(event.text)
        }
    }

runner.runSingleTurnAsync(content) तरीके को सीधे तौर पर शुरू करने पर, AgentRunner क्लास कुछ समय के लिए एक सेशन असाइन करती है. साथ ही, जवाब की स्ट्रीम पूरी होने या रद्द होने के बाद, बातचीत की स्थिति से जुड़ा सारा डेटा मेमोरी से अपने-आप मिटा देती है. इससे मेमोरी लीक होने से बचा जा सकता है.

अगले चरण