ट्यूटोरियल: Gemini API की मदद से फ़ंक्शन कॉल करना

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

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

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

अपना प्रोजेक्ट सेट अप करें

Gemini API को कॉल करने से पहले, आपको अपना Android प्रोजेक्ट सेट अप करना होगा. इसमें एपीआई पासकोड सेट अप करना, Android प्रोजेक्ट में SDK डिपेंडेंसी जोड़ना, और मॉडल शुरू करना शामिल है.

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

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 Iguana की नई झलक देखें. इसमें Gemini API Starter टेंप्लेट की नई झलक देखी जा सकती है (इसमें शुरू करने के लिए local.properties फ़ाइल मौजूद है).

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

अपने मॉड्यूल (ऐप्लिकेशन-लेवल) में Gradle कॉन्फ़िगरेशन फ़ाइल (जैसे <project>/<app-module>/build.gradle.kts), Android के लिए Google AI SDK के लिए डिपेंडेंसी जोड़ें:
```
dependencies {
  // ... other androidx dependencies

  // add the dependency for the Google AI client SDK for Android
  implementation("com.google.ai.client.generativeai:generativeai:0.5.0")
}
```
अपने Android प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करें.

जनरेटिव मॉडल को शुरू करना

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

val generativeModel = GenerativeModel(

    // Use a model that supports function calling, like Gemini 1.0 Pro.
    // See "Supported models" in the "Introduction to function calling" page.
    modelName = "MODEL_NAME",

    // Access your API key as a Build Configuration variable (see "Set up your API key" above).
    apiKey = BuildConfig.apiKey
)

फ़ंक्शन कॉल सेट अप करें

इस ट्यूटोरियल के लिए, आपके मॉडल को नीचे दिए गए पैरामीटर के साथ काम करने वाले काल्पनिक मुद्रा एक्सचेंज एपीआई के साथ इंटरैक्ट करना होगा:

पैरामीटर	टाइप	ज़रूरी है	ब्यौरा
`currencyFrom`	स्ट्रिंग	हां	जिस मुद्रा से बदलना है
`currencyTo`	स्ट्रिंग	हां	इसमें बदलने के लिए मुद्रा

एपीआई अनुरोध का उदाहरण

{
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

एपीआई से मिले रिस्पॉन्स का उदाहरण

{
  "base": "USD",
  "rates": {"SEK": 0.091}
}

पहला चरण: एपीआई अनुरोध करने वाला फ़ंक्शन बनाएं

अगर आपने पहले से ऐसा नहीं किया है, तो एपीआई अनुरोध करने वाला फ़ंक्शन बनाकर शुरुआत करें.

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

suspend fun makeApiRequest(
    currencyFrom: String,
    currencyTo: String
): JSONObject {
    // This hypothetical API returns a JSON such as:
    // {"base":"USD","rates":{"SEK": 0.091}}
    return JSONObject().apply {
        put("base", currencyFrom)
        put("rates", hashMapOf(currencyTo to 0.091))
    }
}

दूसरा चरण: फ़ंक्शन का एलान करना

फ़ंक्शन का एलान करें और जनरेटिव मॉडल को पास करें. यह ट्यूटोरियल का अगला चरण है.

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

val getExchangeRate = defineFunction(
  name = "getExchangeRate",
  description = "Get the exchange rate for currencies between countries",
  Schema.str("currencyFrom", "The currency to convert from."),
  Schema.str("currencyTo", "The currency to convert to.")
) { from, to ->
    // Call the function that you declared above
    makeApiRequest(from, to)
}

तीसरा चरण: मॉडल शुरू करने के दौरान फ़ंक्शन के एलान की जानकारी दें

जनरेटिव मॉडल को शुरू करते समय, फ़ंक्शन के एलान के बारे में बताने के लिए, उसे मॉडल के tools पैरामीटर में पास करें:

val generativeModel = GenerativeModel(
  // Use a model that supports function calling, like Gemini 1.0 Pro
  // (see "Supported models" in the "Introduction to function calling" page)
  modelName = "gemini-1.0-pro",
  // Access your API key as a Build Configuration variable (see "Set up your API key" above)
  apiKey = BuildConfig.apiKey,
  // Specify the function declaration.
  tools = listOf(Tool(listOf(getExchangeRate)))
)

चौथा चरण: फ़ंक्शन कॉल जनरेट करना

अब मॉडल को तय किए गए फ़ंक्शन के साथ निर्देश दिया जा सकता है.

हमारा सुझाव है कि फ़ंक्शन कॉलिंग का इस्तेमाल करने के लिए, चैट इंटरफ़ेस का इस्तेमाल करें. ऐसा इसलिए, क्योंकि फ़ंक्शन कॉल, चैट के मल्टी-टर्न स्ट्रक्चर में सही तरीके से फ़िट हो जाते हैं.

val chat = generativeModel.startChat()

val prompt = "How much is 50 US dollars worth in Swedish krona?"

// 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)
}