Gemini 1.5 Flash की कीमत में कमी, सभी डेवलपर के लिए बेहतर ऐक्सेस वगैरह! ज़्यादा जानें

इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

आपको अपना एपीआई पासकोड, Google Cloud जैसे सीक्रेट स्टोर में सेव करना चाहिए सीक्रेट मैनेजर.

इस ट्यूटोरियल में माना गया है कि एपीआई पासकोड को एनवायरमेंट के तौर पर ऐक्सेस किया जा रहा है वैरिएबल.

SDK टूल का पैकेज इंपोर्ट करना और अपनी एपीआई कुंजी कॉन्फ़िगर करना

अपने ऐप्लिकेशन में ये काम करें:

आपकी मॉड्यूल डायरेक्ट्री में, get Go SDK पैकेज:
```
go get github.com/google/generative-ai-go
```

पैकेज इंपोर्ट करें और एपीआई पासकोड की मदद से सेवा को कॉन्फ़िगर करें:

import (
  // import standard libraries
  // Import the GenerativeAI package for Go
  "github.com/google/generative-ai-go/genai"
  "google.golang.org/api/option"
)

ctx := context.Background()
// Access your API key as an environment variable
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// ...

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

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

func setLightValues(brightness int, colorTemp string) map[string]any {
    // This mock API returns the requested lighting values
    return map[string]any{
        "brightness":       brightness,
        "colorTemperature": colorTemp}
}

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

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

lightControlTool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{{
        Name:        "controlLight",
        Description: "Set the brightness and color temperature of a room light.",
        Parameters: &genai.Schema{
            Type: genai.TypeObject,
            Properties: map[string]*genai.Schema{
                "brightness": {
                    Type:        genai.TypeString,
                    Description: "Light level from 0 to 100. Zero is off and"+
                        " 100 is full brightness.",
                },
                "colorTemperature": {
                    Type:        genai.TypeString,
                    Description: "Color temperature of the light fixture which" +
                        " can be `daylight`, `cool` or `warm`.",
                },
            },
            Required: []string{"brightness", "colorTemperature"},
        },
    }},
}

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

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

// ...

lightControlTool := &genai.Tool{
    // ...
}

// Use a model that supports function calling, like a Gemini 1.5 model
model := client.GenerativeModel("gemini-1.5-flash")

// Specify the function declaration.
model.Tools = []*genai.Tool{lightControlTool}

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

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

// Start new chat session.
session := model.StartChat()

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

// Send the message to the generative model.
resp, err := session.SendMessage(ctx, genai.Text(prompt))
if err != nil {
    log.Fatalf("Error sending message: %v\n", err)
}

// Check that you got the expected function call back.
part := resp.Candidates[0].Content.Parts[0]
funcall, ok := part.(genai.FunctionCall)
if !ok {
    log.Fatalf("Expected type FunctionCall, got %T", part)
}
if g, e := funcall.Name, lightControlTool.FunctionDeclarations[0].Name; g != e {
    log.Fatalf("Expected FunctionCall.Name %q, got %q", e, g)
}
fmt.Printf("Received function call response:\n%q\n\n", part)

apiResult := map[string]any{
    "brightness":  "30",
    "colorTemperature":  "warm" }

// Send the hypothetical API result back to the generative model.
fmt.Printf("Sending API result:\n%q\n\n", apiResult)
resp, err = session.SendMessage(ctx, genai.FunctionResponse{
    Name:     lightControlTool.FunctionDeclarations[0].Name,
    Response: apiResult,
})
if err != nil {
    log.Fatalf("Error sending message: %v\n", err)
}

// Show the model's response, which is expected to be text.
for _, part := range resp.Candidates[0].Content.Parts {
    fmt.Printf("%v\n", part)
}