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

Python Node.js जाएं Dart (Flutter) Android स्विफ़्ट वेब

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

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

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

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

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

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

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

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

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

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

enum APIKey {
  // Fetch the API key from `GenerativeAI-Info.plist`
  static var `default`: String {
    guard let filePath = Bundle.main.path(forResource: "GenerativeAI-Info", ofType: "plist")
    else {
      fatalError("Couldn't find file 'GenerativeAI-Info.plist'.")
    }
    let plist = NSDictionary(contentsOfFile: filePath)
    guard let value = plist?.object(forKey: "API_KEY") as? String else {
      fatalError("Couldn't find key 'API_KEY' in 'GenerativeAI-Info.plist'.")
    }
    if value.starts(with: "_") {
      fatalError(
        "Follow the instructions at https://ai.google.dev/tutorials/setup to get an API key."
      )
    }
    return value
  }
}

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

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

func setLightValues(brightness: String,
                    colorTemp: String) -> JSONObject {
  // This mock API returns the requested lighting values
  return [
    "brightness": .string(brightness),
    "colorTemperature": .string(colorTemp)
  ]
}

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

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

let controlLightFunctionDeclaration = FunctionDeclaration(
  name: "controlLight",
  description: "Set the brightness and color temperature of a room light.",
  parameters: [
    "brightness": Schema(
      type: .string,
      description: "Light level from 0 to 100. Zero is off and 100 is full brightness."
    ),
    "colorTemperature": Schema(
      type: .string,
      description: "Color temperature of the light fixture which can be `daylight`, `cool` or `warm`."
    ),
  ],
  requiredParameters: ["brightness", "colorTemperature"]
)

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

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

// Use a model that supports function calling, like a Gemini 1.5 model
let generativeModel = GenerativeModel(
  name: "gemini-1.5-flash",
  apiKey: apiKey,
  // Specify the function declaration.
  tools: [Tool(functionDeclarations: [controlLightFunctionDeclaration])]
)

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

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

let chat = generativeModel.startChat()

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

// Send the message to the generative model
let response1 = try await chat.sendMessage(prompt)

// Check if the model responded with a function call
guard let functionCall = response1.functionCalls.first else {
  fatalError("Model did not respond with a function call.")
}
// Print an error if the returned function was not declared
guard functionCall.name == "controlLight" else {
  fatalError("Unexpected function called: \(functionCall.name)")
}
// Verify that the names and types of the parameters match the declaration
guard case let .string(brightness) = functionCall.args["brightness"] else {
  fatalError("Missing argument: brightness")
}
guard case let .string(colorTemp) = functionCall.args["colorTemperature"] else {
  fatalError("Missing argument: colorTemperature")
}

// Call the hypothetical API
let apiResponse = setLightValues(brightness: brightness, colorTemperature: colorTemp)

// Send the API response back to the model so it can generate a text response that can be
// displayed to the user.
let response = try await chat.sendMessage([ModelContent(
  role: "function",
  parts: [.functionResponse(FunctionResponse(
    name: functionCall.name,
    response: apiResponse
  ))]
)])

// Log the text response.
guard let modelResponse = response.text else {
  fatalError("Model did not respond with text.")
}
print(modelResponse)