अब Gemini 1.5 Pro 2M कॉन्टेक्स्ट विंडो, कोड लागू करने की सुविधाएँ, और Gemma 2 उपलब्ध हैं. ज़्यादा जानें

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

हमारा सुझाव है कि आप अपने वर्शन कंट्रोल सिस्टम में एपीआई पासकोड की जांच न करें. इसके बजाय, आपको अपने एपीआई पासकोड को सीक्रेट स्टोर में सेव करना चाहिए (जैसे, Secret Manager).

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

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{"currencyDate", "currencyFrom"},
        },
    }},
}

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

जब आपको किसी मॉडल के साथ फ़ंक्शन कॉलिंग का इस्तेमाल करना हो, तो मॉडल ऑब्जेक्ट को शुरू करते समय, आपको फ़ंक्शन का एलान करना होगा. मॉडल के 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)
}