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

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

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

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

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

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

पैरामीटर टाइप ज़रूरी है ब्यौरा
brightness संख्या हां लाइट का लेवल 0 से 100 तक होता है. शून्य का मतलब है कि रोशनी बंद है और 100 का मतलब है कि रोशनी पूरी है.
colorTemperature स्ट्रिंग हां लाइट फ़िक्स्चर का कलर टेंपरेचर, जो daylight, cool या warm हो सकता है.

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

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

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

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

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

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

एपीआई अनुरोध करने वाला फ़ंक्शन बनाएं. इस फ़ंक्शन को तय किया जाना चाहिए आपके ऐप्लिकेशन के कोड में हो, लेकिन उससे बाहर की सेवाओं या एपीआई को कॉल कर सके आपका ऐप्लिकेशन. 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)
}