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

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

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

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

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

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

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

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

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

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

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

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

अपना प्रोजेक्ट और एपीआई पासकोड सेट अप करने का तरीका देखने के लिए बड़ा करें

एपीआई पासकोड पाएं और उसे सुरक्षित बनाएं

Gemini API को कॉल करने के लिए, आपको एपीआई पासकोड की ज़रूरत होगी. अगर आपके पास पहले से कोई पासकोड नहीं है, तो Google AI Studio में जाकर पासकोड बनाएं.

एपीआई पासकोड पाना

हमारा सुझाव है कि आप अपने वर्शन कंट्रोल सिस्टम में एपीआई पासकोड की जांच न करें.

आपको अपनी एपीआई पासकोड को प्रोजेक्ट की रूट डायरेक्ट्री में मौजूद local.properties फ़ाइल में सेव करना चाहिए. साथ ही, इस फ़ाइल को वर्शन कंट्रोल से बाहर रखना चाहिए. प्रोडक्शन डिप्लॉयमेंट के लिए, अपनी एपीआई पासकोड को बिल्ड कॉन्फ़िगरेशन वैरिएबल के तौर पर पढ़ने के लिए, Android के लिए सीक्रेट ग्रेडल प्लग इन का इस्तेमाल करें.

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

इस ट्यूटोरियल में दिए गए सभी स्निपेट, इस सबसे सही तरीके का इस्तेमाल करते हैं. अगर आपको Secrets Gradle प्लग इन को लागू करने का तरीका देखना है, तो इस SDK टूल के लिए सैंपल ऐप्लिकेशन की समीक्षा करें या Android Studio के नए प्रीव्यू वर्शन का इस्तेमाल करें. इसमें Gemini API Starter टेंप्लेट शामिल है. इसमें आपको शुरू करने के लिए local.properties फ़ाइल भी मिलती है.

अपने प्रोजेक्ट में SDK टूल डिपेंडेंसी जोड़ना

अपने ऐप्लिकेशन डेवलपमेंट एनवायरमेंट में, यह तरीका अपनाएं:

अपने मॉड्यूल (ऐप्लिकेशन-लेवल) की Gradle कॉन्फ़िगरेशन फ़ाइल में, Android के लिए Google AI SDK टूल की डिपेंडेंसी जोड़ें:

Kotlin

// add to <project>/<app-module>/build.gradle.kts
dependencies {
  // ... other androidx dependencies

  // add the dependency for the Google AI client SDK for Android
  implementation("com.google.ai.client.generativeai:generativeai:0.7.0")
}

Java

// add to <project>/<app-module>/build.gradle
dependencies {
  // ... other androidx dependencies

  // add the dependency for the Google AI client SDK for Android
  implementation("com.google.ai.client.generativeai:generativeai:0.7.0")

  // Required for one-shot operations to use `ListenableFuture` from Guava Android
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations to use `Publisher` from Reactive Streams
  implementation("org.reactivestreams:reactive-streams:1.0.4")

}

अपने Android प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करें.

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

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