फ़ंक्शन से कॉल करने के लिए, Gemini API का इस्तेमाल करना


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

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

आप फ़ंक्शन कॉलिंग के बारे में ज़्यादा जानें सेक्शन पढ़ें.

शुरू करने से पहले

अगर आपने अब तक ऐसा नहीं किया है, तो 'Firebase के लिए Vertex AI' SDK टूल के बारे में शुरुआती जानकारी देने वाली गाइड. पक्का करें कि आपने ये सभी काम कर लिए हों:

  • नया या मौजूदा Firebase प्रोजेक्ट सेट अप करना. इसमें, ब्लेज़ प्राइसिंग प्लान और ज़रूरी एपीआई चालू करना.

  • अपने ऐप्लिकेशन को Firebase से कनेक्ट करना. इसमें ऐप्लिकेशन को रजिस्टर करना और आपके ऐप्लिकेशन के लिए Firebase कॉन्फ़िगरेशन.

  • SDK टूल जोड़ें. इसके बाद, Vertex AI सेवा और जनरेटिव मॉडल को शुरू करें आपके ऐप्लिकेशन में.

अपने ऐप्लिकेशन को Firebase से कनेक्ट करने, SDK टूल जोड़ने, और Vertex AI की सेवा और जनरेटिव मॉडल, क्या आप Gemini API को कॉल करने के लिए तैयार हैं.

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

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

पैरामीटर टाइप आवश्यक ब्यौरा
currencyFrom स्ट्रिंग हां जिस मुद्रा से कन्वर्ट करना है
currencyTo स्ट्रिंग हां जिस मुद्रा में बदलना है उसे

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

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

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

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

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

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

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

func makeAPIRequest(currencyFrom: String,
                    currencyTo: String) -> JSONObject {
  // This hypothetical API returns a JSON such as:
  // {"base":"USD","rates":{"SEK": 10.99}}
  return [
    "base": .string(currencyFrom),
    "rates": .object([currencyTo: .number(10.99)]),
  ]
}

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

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

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

let getExchangeRate = FunctionDeclaration(
  name: "getExchangeRate",
  description: "Get the exchange rate for currencies between countries",
  parameters: [
    "currencyFrom": Schema(
      type: .string,
      description: "The currency to convert from."
    ),
    "currencyTo": Schema(
      type: .string,
      description: "The currency to convert to."
    ),
  ],
  requiredParameters: ["currencyFrom", "currencyTo"]
)

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

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

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Initialize the generative model
// Use a model that supports function calling, like a Gemini 1.5 model
let model = vertex.generativeModel(
  modelName: "gemini-1.5-flash",
  // Specify the function declaration.
  tools: [Tool(functionDeclarations: [getExchangeRate])]
)

Gemini का मॉडल चुनने का तरीक़ा जानें और विकल्प के तौर पर कोई जगह आपके इस्तेमाल के उदाहरण और ऐप्लिकेशन के हिसाब से सही है.

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

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

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

let chat = model.startChat()

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

// 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 == "getExchangeRate" else {
  fatalError("Unexpected function called: \(functionCall.name)")
}
// Verify that the names and types of the parameters match the declaration
guard case let .string(currencyFrom) = functionCall.args["currencyFrom"] else {
  fatalError("Missing argument: currencyFrom")
}
guard case let .string(currencyTo) = functionCall.args["currencyTo"] else {
  fatalError("Missing argument: currencyTo")
}

// Call the hypothetical API
let apiResponse = makeAPIRequest(currencyFrom: currencyFrom, currencyTo: currencyTo)

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

तुम और क्या कर सकती हो?

Gemini API की अन्य सुविधाएँ आज़माएँ

कॉन्टेंट जनरेट करने की प्रोसेस को कंट्रोल करने का तरीका जानें

प्रॉम्प्ट और मॉडल कॉन्फ़िगरेशन के साथ भी एक्सपेरिमेंट करने के लिए, इनका इस्तेमाल किया जा सकता है Vertex AI Studio.

Gemini के मॉडल के बारे में ज़्यादा जानें

ज़्यादा जानने के लिए, अलग-अलग कामों के लिए उपलब्ध मॉडल और उनका कोटा और कीमत.


सुझाव दें 'Firebase के लिए Vertex AI' इस्तेमाल करने के आपके अनुभव के बारे में