Gemini में फ़ंक्शन कॉलिंग की सुविधा का इस्तेमाल करके, एपीआई के साथ इंटरैक्ट करने का तरीका

1. खास जानकारी

Gemini में फ़ंक्शन कॉलिंग क्या है?

Vertex AI Gemini API, Google DeepMind के बनाए गए जनरेटिव एआई मॉडल का एक परिवार है. इसे मल्टीमॉडल इस्तेमाल के लिए डिज़ाइन किया गया है. फ़ंक्शन कॉलिंग, Gemini मॉडल की एक सुविधा है. इससे डेवलपर को जनरेटिव मॉडल से स्ट्रक्चर्ड डेटा आउटपुट आसानी से मिल जाते हैं.

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

फ़ंक्शन कॉलिंग की सुविधा कैसे काम करती है

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

एपीआई इंटरफ़ेस

आपको क्या बनाना है

इस कोडलैब में, Vertex AI Gemini API और Python की मदद से, जनरेटिव एआई पाइपलाइन बनाई जाएगी. आपके ऐप्लिकेशन का इस्तेमाल करके, उपयोगकर्ता विनिमय दरों के बारे में पूछ सकते हैं. इसके बाद, सिस्टम किसी बाहरी एपीआई से नया डेटा फ़ेच करेगा और उपयोगकर्ता को जवाब देगा.

आपको क्या सीखने को मिलेगा

Python क्लाइंट लाइब्रेरी का इस्तेमाल करके, Gemini मॉडल के साथ इंटरैक्ट करने का तरीका
किसी फ़ंक्शन के एलान को कैसे तय करें और उसे टूल के तौर पर रजिस्टर कैसे करें
Gemini को कॉल करने और फ़ंक्शन कॉल का जवाब पाने का तरीका
फ़ंक्शन के जवाब को Gemini को वापस भेजने और उपयोगकर्ता को जवाब देने का तरीका

आपको किन चीज़ों की ज़रूरत होगी

Google Cloud प्रोजेक्ट
Chrome जैसा कोई ब्राउज़र
Python डेवलपमेंट एनवायरमेंट, जैसे कि Colab या Colab Enterprise

2. सेटअप और ज़रूरी शर्तें

Gemini में फ़ंक्शन कॉलिंग की सुविधा का इस्तेमाल करने से पहले, आपको Vertex AI API चालू करना होगा. साथ ही, Vertex AI Python क्लाइंट लाइब्रेरी का नया वर्शन इंस्टॉल करना होगा.

Vertex AI API चालू करना

Vertex AI API चालू करने के लिए, यह तरीका अपनाएं:

अपने ब्राउज़र में, Vertex AI API की सेवा से जुड़ी ज़्यादा जानकारी वाले पेज पर जाएं.
अपने Google Cloud प्रोजेक्ट में Vertex AI API को चालू करने के लिए, चालू करें बटन पर क्लिक करें.

Vertex AI के लिए Python क्लाइंट लाइब्रेरी इंस्टॉल करना

Vertex AI के लिए Python क्लाइंट लाइब्रेरी इंस्टॉल करने के लिए, यह तरीका अपनाएं:

अपने डेवलपमेंट एनवायरमेंट में एक टर्मिनल खोलें.
पुष्टि करें कि आपके पास Python डेवलपमेंट एनवायरमेंट है. अगर ज़रूरत हो, तो इन दिशा-निर्देशों को पढ़ें.
Vertex AI के लिए Python क्लाइंट लाइब्रेरी इंस्टॉल करने के लिए, यह कमांड चलाएं:
```
pip install --upgrade google-cloud-aiplatform
```
अगर आप नोटबुक एनवायरमेंट में काम कर रहे हैं, तो इंस्टॉल किए गए नए पैकेज का इस्तेमाल करने के लिए, आपको रनटाइम/कर्नल को रीस्टार्ट करना पड़ सकता है.

अब Vertex AI API का इस्तेमाल किया जा सकता है!

3. समस्या को समझना

क्या आपने कभी किसी लार्ज लैंग्वेज मॉडल या जनरेटिव एआई मॉडल से बातचीत की है और उससे रीयल-टाइम या मौजूदा जानकारी के बारे में पूछा है? क्या आपको जवाब में पुरानी या गलत जानकारी मिली है?

चलो, अभी आज़माकर देखते हैं! सबसे पहले, हम काम के Python पैकेज इंपोर्ट करेंगे और Gemini मॉडल को शुरू करेंगे. इस कोड को Python डेवलपमेंट एनवायरमेंट में चलाया जा सकता है. जैसे, Colab या Colab Enterprise. इसके लिए, Vertex AI SDK for Python का नया वर्शन इंस्टॉल करें:

import vertexai
from vertexai.generative_models import GenerativeModel
model = GenerativeModel("gemini-1.5-pro-001")

अब, आज अलग-अलग मुद्राओं के लिए एक्सचेंज रेट के बारे में एक सवाल पूछते हैं:

response = model.generate_content(
    "What's the exchange rate for euros to dollars today?"
)
print(response.text)

मॉडल को आपके लिए, सीमित या पुराना जवाब जनरेट करना चाहिए. जैसे:

As an AI language model, I don't have access to real-time currency exchange
rates. However, as of my last update in September 2021, the approximate exchange
rate between euros (EUR) and US dollars (USD) was:

1 EUR ≈ 1.18 USD

Please note that currency exchange rates constantly fluctuate and can vary
depending on various factors such as economic conditions, supply and demand,
political events, and more. To obtain the most up-to-date and accurate exchange
rate, I recommend using a reliable currency converter or financial website that
provides live rates.

[...]

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

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

4. समस्या हल करने के सामान्य तरीके आज़माना

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

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

आइए, पिछले सेक्शन में पूछे गए सवाल को फिर से देखें और मॉडल के लिए कुछ और निर्देश जोड़ें. Gemini मॉडल को यह अनुरोध भेजकर देखें:

user_prompt = "What's the exchange rate from euros to US dollars today?"

response = model.generate_content("""
Your task is to extract parameters from the user's input and return it as a
structured JSON payload. The user will ask about the exchange rate and which
currency they are converting from and converting to.

User input: {user_prompt}

Please extract the currencies as parameters and put them in a JSON object.
""".format(user_prompt=user_prompt))
print(response.text)

इससे हमें यह टेक्स्ट रिस्पॉन्स मिलता है. यह मान्य JSON फ़ॉर्मैट में नहीं है. इसलिए, हम इसका इस्तेमाल नहीं कर सकते:

```json
{
  "currency_from": "euros",
  "currency_to": "US dollars"
}
```

खास तौर पर, टेक्स्ट वाले जवाब की पहली और आखिरी लाइनों में कोड ब्लॉक को अलग करने के लिए बैकटिक शामिल हैं. पहली लाइन में भाषा की जानकारी देने वाला शब्द शामिल है. साथ ही, JSON ऑब्जेक्ट में मौजूद वैल्यू, मुद्रा के तीन अक्षरों वाले ऐसे स्टैंडर्ड संक्षिप्त नाम नहीं हैं जो मुद्रा बदलने की सुविधा देने वाले एपीआई को इनपुट पैरामीटर के तौर पर चाहिए होते हैं.

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

हालांकि, इससे ज़्यादा सटीक तरीका भी है! आइए, Gemini में फ़ंक्शन कॉलिंग का इस्तेमाल करके, बाहरी सेवाओं में जानकारी खोजने और उपयोगकर्ताओं को काम के जवाब देने का तरीका जानें.

5. फ़ंक्शन कॉलिंग की सुविधा कैसे काम करती है

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

Gemini में फ़ंक्शन कॉलिंग की खास जानकारी

Gemini API में उपयोगकर्ता का इनपुट

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

Gemini API, फ़ंक्शन कॉल का जवाब देता है

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

एपीआई अनुरोध करना

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

Gemini को एपीआई से मिला जवाब वापस भेजना

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

6. अपना एपीआई चुनें

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

हम मुद्रा बदलने वाले अपने ऐप्लिकेशन के लिए, https://www.frankfurter.app/ पर मौजूद REST API का इस्तेमाल करेंगे. इससे हमें दुनिया भर की मुद्रा विनिमय दरों के बारे में नई जानकारी मिलेगी.

इस REST API के साथ इंटरैक्ट करने के लिए, हम Python में requests का इस्तेमाल करके, REST API कॉल कर सकते हैं. जैसे:

import requests
url = "https://api.frankfurter.app/latest"
response = requests.get(url)
response.text

या cURL का अनुरोध, जैसे कि:

curl https://api.frankfurter.app/latest

इससे ऐसा जवाब मिलता है:

{
  "amount": 1,
  "base": "EUR",
  "date": "2023-12-20",
  "rates": {
    "AUD": 1.6186, "BGN": 1.9558, "BRL": 5.3287,
    "CAD": 1.4609, "CHF": 0.946, "CNY": 7.8121,
    "CZK": 24.538, "DKK": 7.4565, "GBP": 0.86555,
    "HKD": 8.5439, "HUF": 385.23, "IDR": 16994,
    "ILS": 3.9983, "INR": 91.06, "ISK": 150.3,
    "JPY": 157.12, "KRW": 1425.62, "MXN": 18.6867,
    "MYR": 5.0977, "NOK": 11.2895, "NZD": 1.7421,
    "PHP": 60.991, "PLN": 4.3413, "RON": 4.9699,
    "SEK": 11.129, "SGD": 1.4562, "THB": 38.252,
    "TRY": 31.883, "USD": 1.0944, "ZAR": 20.111
  }
}

Gemini में फ़ंक्शन कॉलिंग की सुविधा, आपके लिए बाहरी एपीआई कॉल नहीं करती है. इसलिए, इस बात पर कोई पाबंदी नहीं है कि आपको किस तरह के एपीआई का इस्तेमाल करना है! इसके लिए, Cloud Run सेवा, Cloud फ़ंक्शन, Google Cloud सेवा के लिए एपीआई अनुरोध या किसी बाहरी REST API का इस्तेमाल किया जा सकता है.

7. किसी फ़ंक्शन और टूल को परिभाषित करना

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

पक्का करें कि आपने Vertex AI SDK for Python का नया वर्शन इंस्टॉल किया हो.

इसके बाद, Python SDK से ज़रूरी मॉड्यूल इंपोर्ट करें और Gemini मॉडल को शुरू करें:

from vertexai.generative_models import (
    Content,
    FunctionDeclaration,
    GenerativeModel,
    Part,
    Tool,
)

model = GenerativeModel("gemini-1.5-pro-001")

https://api.frankfurter.app/ पर मौजूद REST API के हिसाब से, यहां दिए गए इनपुट पैरामीटर इस्तेमाल किए जा सकते हैं:

पैरामीटर	टाइप	ब्यौरा
`from`	स्ट्रिंग	जिस मुद्रा को बदलना है
`to`	स्ट्रिंग	वह मुद्रा जिसमें बदलना है
`date`	स्ट्रिंग	एक्सचेंज रेट पाने के लिए तारीख

इन पैरामीटर का इस्तेमाल करके, इस REST API के लिए YAML फ़ॉर्मैट में OpenAPI स्पेसिफ़िकेशन का कुछ हिस्सा ऐसा दिखता है:

openapi: 3.0.0
info:
  title: Frankfurter Exchange Rate API
  description: This API provides current and historical exchange rates
  version: 1.0.0
servers:
  - url: https://api.frankfurter.app
paths:
  /{date}:
    get:
      summary: Get the latest currency exchange rates.
      parameters:
        - name: date
          in: path
          description: Get currency rates for a specific date or 'latest' if a date is not specified
          required: true
          schema:
            type: string
        - name: from
          in: query
          description: The currency to convert from.
          required: true
          schema:
            type: string
        - name: to
          in: query
          description: The currency to convert to.
          schema:
            type: string

अब, आइए इसे Gemini के लिए Python SDK का इस्तेमाल करके FunctionDeclaration के तौर पर रजिस्टर करें:

get_exchange_rate_func = FunctionDeclaration(
    name="get_exchange_rate",
    description="Get the exchange rate for currencies between countries",
    parameters={
    "type": "object",
    "properties": {
        "currency_date": {
            "type": "string",
            "description": "A date that must always be in YYYY-MM-DD format or the value 'latest' if a time period is not specified"
        },
        "currency_from": {
            "type": "string",
            "description": "The currency to convert from in ISO 4217 format"
        },
        "currency_to": {
            "type": "string",
            "description": "The currency to convert to in ISO 4217 format"
        }
    },
         "required": [
            "currency_from",
            "currency_date",
      ]
  },
)

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

आखिर में, आपको एक Tool तय करना होगा. इसमें फ़ंक्शन का एलान शामिल होगा:

exchange_rate_tool = Tool(
    function_declarations=[get_exchange_rate_func],
)

यहां, टूल में फ़ंक्शन के एलान का इस्तेमाल किया जा रहा है. हालांकि, ध्यान दें कि टूल में फ़ंक्शन के एक या उससे ज़्यादा एलान रजिस्टर किए जा सकते हैं. साथ ही, मॉडल रनटाइम में इस्तेमाल करने के लिए सही फ़ंक्शन चुनेगा. Gemini SDK for Python में FunctionDeclaration, Tool, और इनसे जुड़ी क्लास के बारे में ज़्यादा जानने के लिए, Gemini API में फ़ंक्शन कॉलिंग से जुड़ा दस्तावेज़ देखें.

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

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

अब जनरेटिव मॉडल को प्रॉम्प्ट दिया जा सकता है और आपने जो tool तय किया है उसे शामिल किया जा सकता है:

prompt = """What is the exchange rate from Australian dollars to Swedish krona?
How much is 500 Australian dollars worth in Swedish krona?"""

response = model.generate_content(
    prompt,
    tools=[exchange_rate_tool],
)

आइए, रिस्पॉन्स ऑब्जेक्ट पर एक नज़र डालते हैं:

print(response.candidates[0].content)

role: "model"
parts {
  function_call {
    name: "get_exchange_rate"
    args {
      fields {
        key: "currency_to"
        value {
          string_value: "SEK"
        }
      }
      fields {
        key: "currency_from"
        value {
          string_value: "AUD"
        }
      }
      fields {
        key: "currency_date"
        value {
          string_value: "latest"
        }
      }
    }
  }
}

ऐसा लगता है कि मॉडल ने उपलब्ध फ़ंक्शन में से एक को चुना है. साथ ही, पैरामीटर के साथ get_exchange_rate फ़ंक्शन के लिए फ़ंक्शन कॉल वापस किया है. साथ ही, पैरामीटर उस फ़ॉर्मैट में हैं जो हमें चाहिए था. जनरेटिव मॉडल से स्ट्रक्चर्ड जवाब पाने के लिए बधाई!

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

9. एपीआई अनुरोध करना

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

यहां, एक्सचेंज रेट REST API को कॉल करने के लिए, Python में requests लाइब्रेरी का इस्तेमाल किया जाएगा.

आइए, जवाब को Python डिक्शनरी में बदलते हैं:

params = {}
for key, value in response.candidates[0].content.parts[0].function_call.args.items():
    params[key[9:]] = value
params

अब हम requests या किसी अन्य तरीके से कॉल कर सकते हैं:

import requests
url = f"https://api.frankfurter.app/{params['date']}"
api_response = requests.get(url, params=params)
api_response.text

इससे आपको कुछ ऐसा जवाब मिलेगा:

'{"amount":1.0,"base":"AUD","date":"2024-01-16","rates":{"SEK":6.8682}}'

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

10. जवाब जनरेट करना

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

response = model.generate_content(
    [
    Content(role="user", parts=[
        Part.from_text(prompt + """Give your answer in steps with lots of detail
            and context, including the exchange rate and date."""),
    ]),
    Content(role="function", parts=[
        Part.from_dict({
            "function_call": {
                "name": "get_exchange_rate",
            }
        })
    ]),
    Content(role="function", parts=[
        Part.from_function_response(
            name="get_exchange_rate",
            response={
                "content": api_response.text,
            }
        )
    ]),
    ],
    tools=[exchange_rate_tool],
)


response.candidates[0].content.parts[0].text

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

The exchange rate from Australian dollars to Swedish krona on January 16, 2024,
is 1 Australian dollar is equal to 6.8663 Swedish krona.

So, 500 Australian dollars would be worth 500 * 6.8663 = 3,433.15 Swedish krona.

11. पूरा कोड उदाहरण देखें

इस चरण में, Cloud Run सेवा, Cloud फ़ंक्शन या किसी अन्य Cloud सेवा का इस्तेमाल करके, अपने Python कोड को बैकएंड एपीआई में रखा जा सकता है. साथ ही, एक ऐसा फ़्रंटएंड ऐप्लिकेशन डिप्लॉय किया जा सकता है जो मॉडल क्वेरी और एपीआई कॉल करने के लिए, इस बैकएंड एपीआई का इस्तेमाल करता है.

यहां हमारे फ़ाइनल समाधान के लिए, पूरे कोड का उदाहरण दिया गया है:

import requests
from vertexai.generative_models import (
    Content,
    FunctionDeclaration,
    GenerativeModel,
    Part,
    Tool,
)

model = GenerativeModel("gemini-1.5-pro-001")

get_exchange_rate_func = FunctionDeclaration(
    name="get_exchange_rate",
    description="Get the exchange rate for currencies between countries",
    parameters={
    "type": "object",
    "properties": {
        "currency_date": {
            "type": "string",
            "description": "A date that must always be in YYYY-MM-DD format or the value 'latest' if a time period is not specified"
        },
        "currency_from": {
            "type": "string",
            "description": "The currency to convert from in ISO 4217 format"
        },
        "currency_to": {
            "type": "string",
            "description": "The currency to convert to in ISO 4217 format"
        }
    },
         "required": [
            "currency_from",
            "currency_date",
      ]
  },
)

exchange_rate_tool = Tool(
    function_declarations=[get_exchange_rate_func],
)

prompt = """What is the exchange rate from Australian dollars to Swedish krona?
How much is 500 Australian dollars worth in Swedish krona?"""

response = model.generate_content(
    prompt,
    tools=[exchange_rate_tool],
)

response.candidates[0].content

params = {}
for key, value in response.candidates[0].content.parts[0].function_call.args.items():
    params[key[9:]] = value
params

import requests
url = f"https://api.frankfurter.app/{params['date']}"
api_response = requests.get(url, params=params)
api_response.text

response = model.generate_content(
    [
    Content(role="user", parts=[
        Part.from_text(prompt + """Give your answer in steps with lots of detail
            and context, including the exchange rate and date."""),
    ]),
    Content(role="function", parts=[
        Part.from_dict({
            "function_call": {
                "name": "get_exchange_rate",
            }
        })
    ]),
    Content(role="function", parts=[
        Part.from_function_response(
            name="get_exchange_rate",
            response={
                "content": api_response.text,
            }
        )
    ]),
    ],
    tools=[exchange_rate_tool],
)


response.candidates[0].content.parts[0].text

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

कोड के अन्य सैंपल के लिए, Gemini में फ़ंक्शन कॉल करने के लिए सैंपल नोटबुक देखें.

12. बधाई हो

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

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

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

एपीआई इंटरफ़ेस

क्लीन अप करें

इस कोडलैब में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते से शुल्क लिए जाने से बचने के लिए, यहां दी गई कार्रवाइयां करें:

अगर आपको प्रोजेक्ट की ज़रूरत नहीं है, तो Google Cloud Console का इस्तेमाल करके प्रोजेक्ट मिटाएं. इससे, Google Cloud के गैर-ज़रूरी शुल्क से बचा जा सकता है.
अगर आपको Vertex AI के लिए एपीआई बंद करने हैं, तो Vertex AI API सेवा के बारे में ज़्यादा जानकारी वाले पेज पर जाएं. इसके बाद, एपीआई बंद करें पर क्लिक करें और पुष्टि करें.

ज़्यादा जानें

इन गाइड और संसाधनों की मदद से, बातचीत वाले एआई और जनरेटिव एआई के बारे में ज़्यादा जानें:

लाइसेंस

इस काम के लिए, Creative Commons एट्रिब्यूशन 2.0 जेनेरिक लाइसेंस के तहत लाइसेंस मिला है.