फ़ंक्शन कॉलिंग का ट्यूटोरियल

Python Node.js Go Dart (Flutter) Android Swift वेब

फ़ंक्शन कॉलिंग की मदद से, स्ट्रक्चर्ड डेटा के आउटपुट आसानी से हासिल किए जा सकते हैं जनरेटिव मॉडल. इसके बाद, इन आउटपुट का इस्तेमाल करके अन्य एपीआई को कॉल किया जा सकता है और इन आउटपुट का इस्तेमाल किया जा सकता है मॉडल के लिए काम के रिस्पॉन्स डेटा का इस्तेमाल करती है. दूसरे शब्दों में, फ़ंक्शन कॉलिंग मदद करता है आप जनरेटिव मॉडल को बाहरी सिस्टम से जोड़ते हैं. इससे, जनरेट किया गया कॉन्टेंट में अप-टू-डेट और सटीक जानकारी होती है.

Gemini मॉडल में फ़ंक्शन की जानकारी दी जा सकती है. ये ऐसे फ़ंक्शन होते हैं जिन्हें आप अपने ऐप्लिकेशन की भाषा में लिखते हैं. इसका मतलब है कि ये Google Cloud फ़ंक्शन नहीं होते. मॉडल, आपकी क्वेरी को हैंडल करने में मदद करने के लिए, आपसे किसी फ़ंक्शन को कॉल करने और नतीजा भेजने के लिए कह सकता है.

अगर आपने अब तक ऐसा नहीं किया है, तो इसे देखें सीखने के लिए, फ़ंक्शन कॉलिंग के बारे में जानकारी ज़्यादा.

लाइटिंग कंट्रोल के लिए एपीआई का उदाहरण

मान लें कि आपके पास ऐप्लिकेशन प्रोग्रामिंग इंटरफ़ेस (एपीआई) वाला एक बुनियादी लाइटिंग कंट्रोल सिस्टम है और आपको उपयोगकर्ताओं को टेक्स्ट के आसान अनुरोधों की मदद से लाइटें कंट्रोल करने की अनुमति देनी है. फ़ंक्शन कॉलिंग की सुविधा का इस्तेमाल करके, उपयोगकर्ताओं से मिले लाइटिंग में बदलाव करने के अनुरोधों को समझा जा सकता है. साथ ही, लाइटिंग की वैल्यू सेट करने के लिए, उन्हें एपीआई कॉल में बदला जा सकता है. इस काल्पनिक लाइटिंग सिस्टम की मदद से, आपको लाइट की चमक और उसका कलर टेंपरेचर, जिन्हें दो अलग-अलग तरीकों से दिखाया गया है पैरामीटर:

आसानी के लिए, इस काल्पनिक लाइटिंग सिस्टम में सिर्फ़ एक लाइट है, ताकि उपयोगकर्ता को कमरे या जगह की जानकारी देने की ज़रूरत न पड़े. यहां JSON रिक्वेस्ट का एक उदाहरण दिया गया है. इसे लाइटिंग कंट्रोल एपीआई को भेजा जा सकता है, ताकि दिन के उजाले के कलर टेंपरेचर का इस्तेमाल करके, लाइट लेवल को 50% पर सेट किया जा सके:

{
  "brightness": "50",
  "colorTemperature": "daylight"
}

इस ट्यूटोरियल में, Gemini API के लिए फ़ंक्शन कॉल सेट अप करने का तरीका बताया गया है. इससे, उपयोगकर्ताओं के लाइटिंग अनुरोधों को समझने और उन्हें एपीआई सेटिंग में मैप करने में मदद मिलती है. इससे लाइट की चमक और कलर टेम्परेचर की वैल्यू को कंट्रोल किया जा सकता है.

शुरू करने से पहले: अपना प्रोजेक्ट और एपीआई पासकोड सेट अप करना

Gemini API को कॉल करने से पहले, आपको अपना प्रोजेक्ट सेट अप करना होगा और उसे कॉन्फ़िगर करना होगा आपकी एपीआई कुंजी.

// Access your API key as a Build Configuration variable
val apiKey = BuildConfig.apiKey

एपीआई फ़ंक्शन तय करना

एपीआई अनुरोध करने वाला फ़ंक्शन बनाएं. इस फ़ंक्शन को तय किया जाना चाहिए आपके ऐप्लिकेशन के कोड में हो, लेकिन उससे बाहर की सेवाओं या एपीआई को कॉल कर सके आपका ऐप्लिकेशन. Gemini API, इस फ़ंक्शन को सीधे तौर पर कॉल नहीं करता है. इसलिए, आपको इस बात को कंट्रोल कर सकता है कि आपके ऐप्लिकेशन से इस फ़ंक्शन को कब और कैसे एक्ज़ीक्यूट किया जाए कोड. यह दिखाने के लिए, इस ट्यूटोरियल में एक मॉक एपीआई फ़ंक्शन के बारे में बताया गया है बस अनुरोध की गई लाइटिंग वैल्यू दिखाता है:

suspend fun setLightValues(
    brightness: Int,
    colorTemp: String
): JSONObject {
    // This mock API returns the requested lighting values
    return JSONObject().apply {
        put("brightness", brightness)
        put("colorTemperature", colorTemp)
    }
}

फ़ंक्शन के एलान बनाना

जनरेटिव मॉडल को भेजने के लिए, फ़ंक्शन का एलान करें. टास्क कब शुरू होगा का एलान करते हैं, तो आपको मॉडल के ज़रिए इस्तेमाल करने के लिए ज़्यादा से ज़्यादा जानकारी देनी होगी. फ़ंक्शन और पैरामीटर की जानकारी में जितना संभव हो सके. जनरेटिव मॉडल, इस जानकारी का इस्तेमाल यह तय करने के लिए करता है कि कौनसा फ़ंक्शन चुनना है और फ़ंक्शन कॉल में पैरामीटर की वैल्यू कैसे देनी है. यहां दिए गए कोड में, लाइटिंग कंट्रोल फ़ंक्शन को डिक्लेयर करने का तरीका बताया गया है:

val lightControlTool = defineFunction(
  name = "setLightValues",
  description = "Set the brightness and color temperature of a room light.",
  Schema.int("brightness", "Light level from 0 to 100. Zero is off and 100" +
    " is full brightness."),
  Schema.str("colorTemperature", "Color temperature of the light fixture" +
    " which can be `daylight`, `cool` or `warm`.")
) { brightness, colorTemp ->
    // Call the function you declared above
    setLightValues(brightness.toInt(), colorTemp)
}

मॉडल शुरू करने के दौरान, फ़ंक्शन बताएं

अगर आपको मॉडल के साथ फ़ंक्शन कॉलिंग का इस्तेमाल करना है, तो मॉडल ऑब्जेक्ट को शुरू करते समय आपको अपने फ़ंक्शन के एलान देने होंगे. मॉडल के tools पैरामीटर को सेट करके, फ़ंक्शन का एलान किया जाता है:

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",

    // Access your API key as a Build Configuration variable
    apiKey = BuildConfig.apiKey,

    // Specify the function declaration.
    tools = listOf(Tool(listOf(lightControlTool)))
)

फ़ंक्शन कॉल जनरेट करना

फ़ंक्शन के एलान की मदद से मॉडल को शुरू करने के बाद, तय किए गए फ़ंक्शन के साथ मॉडल को प्रॉम्प्ट किया जा सकता है. आपको चैट प्रॉम्प्ट (sendMessage()) का इस्तेमाल करके, फ़ंक्शन कॉलिंग का इस्तेमाल करना चाहिए. ऐसा इसलिए, क्योंकि फ़ंक्शन कॉलिंग में आम तौर पर, पिछले प्रॉम्प्ट और जवाबों का कॉन्टेक्स्ट होने से फ़ायदा मिलता है.

val chat = generativeModel.startChat()

val prompt = "Dim the lights so the room feels cozy and warm."

// Send the message to the generative model
var response = chat.sendMessage(prompt)

// Check if the model responded with a function call
response.functionCall?.let { functionCall ->
  // Try to retrieve the stored lambda from the model's tools and
  // throw an exception if the returned function was not declared
  val matchedFunction = generativeModel.tools?.flatMap { it.functionDeclarations }
      ?.first { it.name == functionCall.name }
      ?: throw InvalidStateException("Function not found: ${functionCall.name}")

  // Call the lambda retrieved above
  val apiResponse: JSONObject = matchedFunction.execute(functionCall)

  // Send the API response back to the generative model
  // so that it generates a text response that can be displayed to the user
  response = chat.sendMessage(
    content(role = "function") {
        part(FunctionResponsePart(functionCall.name, apiResponse))
    }
  )
}

// Whenever the model responds with text, show it in the UI
response.text?.let { modelResponse ->
    println(modelResponse)
}