टूल कॉलिंग

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

टूल कॉलिंग के इस्तेमाल के उदाहरण, आम तौर पर इनमें से किसी एक थीम में आते हैं:

एलएलएम मॉडल को ऐसी जानकारी का ऐक्सेस देना जिस पर उसे ट्रेनिंग नहीं दी गई है

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

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

एलएलएम वर्कफ़्लो में डिटरमिनिज़्म की डिग्री को शामिल करना

  • ऐसी गणनाएं करना जिन्हें एलएलएम भरोसेमंद तरीके से खुद पूरा नहीं कर सकता.
  • कुछ खास मामलों में, एलएलएम को हूबहू टेक्स्ट जनरेट करने के लिए मजबूर करना. जैसे, किसी ऐप्लिकेशन की सेवा की शर्तों के बारे में सवाल का जवाब देते समय.

एलएलएम से शुरू की गई कार्रवाई करना

  • एलएलएम की मदद से काम करने वाली होम असिस्टेंट की मदद से लाइटें चालू और बंद करना
  • एलएलएम की मदद से काम करने वाले रेस्टोरेंट एजेंट की मदद से टेबल बुक करना

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

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

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

टूल कॉल करने की सुविधा के बारे में खास जानकारी

एलएलएम के साथ टूल कॉल करने की प्रोसेस इस तरह की होती है:

  1. कॉल करने वाला ऐप्लिकेशन, एलएलएम से अनुरोध करता है. साथ ही, प्रॉम्प्ट में उन टूल की सूची भी शामिल करता है जिनका इस्तेमाल करके एलएलएम जवाब जनरेट कर सकता है.
  2. एलएलएम, पूरा जवाब जनरेट करता है या किसी खास फ़ॉर्मैट में टूल कॉल के लिए अनुरोध जनरेट करता है.
  3. अगर कॉलर को पूरा जवाब मिल जाता है, तो अनुरोध पूरा हो जाता है और इंटरैक्शन खत्म हो जाता है. हालांकि, अगर कॉलर को टूल कॉल मिलता है, तो वह सही लॉजिक लागू करता है और एलएलएम को एक नया अनुरोध भेजता है. इस अनुरोध में ओरिजनल प्रॉम्प्ट या उसका कोई वैरिएशन शामिल होता है. साथ ही, टूल कॉल का नतीजा भी शामिल होता है.
  4. एलएलएम, नए प्रॉम्प्ट को दूसरे चरण की तरह ही मैनेज करता है.

यह सुविधा काम करे, इसके लिए कई ज़रूरी शर्तें पूरी करनी होंगी:

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

Genkit की मदद से कॉल करने वाला टूल

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

मॉडल से जुड़ी सहायता

टूल कॉलिंग की सुविधा, मॉडल, मॉडल एपीआई, और Genkit प्लग इन पर निर्भर करती है. टूल कॉलिंग की सुविधा काम करती है या नहीं, यह जानने के लिए काम के दस्तावेज़ देखें. इसके अलावा:

  • अगर किसी ऐसे मॉडल के लिए टूल इस्तेमाल करने की कोशिश की जाती है जो उनका इस्तेमाल नहीं करता, तो Genkit गड़बड़ी का मैसेज दिखाएगा.
  • अगर प्लग इन मॉडल के रेफ़रंस एक्सपोर्ट करता है, तो ModelInfo.Supports.Tools प्रॉपर्टी से पता चलेगा कि यह टूल कॉलिंग के साथ काम करती है या नहीं.

टूल तय करना

टूल की परिभाषाएं लिखने के लिए, genkit.DefineTool() फ़ंक्शन का इस्तेमाल करें:

import (
    "context"
    "log"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
    ctx := context.Background()

    g, err := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.0-flash"),
    )
    if err != nil {
      log.Fatal(err)
    }

    getWeatherTool := genkit.DefineTool(
        g, "getWeather", "Gets the current weather in a given location",
        func(ctx *ai.ToolContext, location string) (string, error) {
            // Here, we would typically make an API call or database query. For this
            // example, we just return a fixed value.
            return fmt.Sprintf("The current weather in %s is 63°F and sunny.", location);
        })
}

यहां दिया गया सिंटैक्स, genkit.DefineFlow() सिंटैक्स जैसा ही दिखता है. हालांकि, आपको ब्यौरा लिखना होगा. ब्यौरे में इस्तेमाल किए गए शब्दों और जानकारी पर खास ध्यान दें, क्योंकि एलएलएम को यह तय करने के लिए यह ज़रूरी है कि उसे सही तरीके से इस्तेमाल किया जाए.

टूल इस्तेमाल करना

कॉन्टेंट जनरेट करने के लिए, अपने प्रॉम्प्ट में तय किए गए टूल शामिल करें.

जनरेट करें

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("What is the weather in San Francisco?"),
    ai.WithTools(getWeatherTool),
)

DefinePrompt

weatherPrompt, err := genkit.DefinePrompt(g, "weatherPrompt",
    ai.WithPrompt("What is the weather in {{location}}?"),
    ai.WithTools(getWeatherTool),
)
if err != nil {
    log.Fatal(err)
}

resp, err := weatherPrompt.Execute(ctx,
    with.Input(map[string]any{"location": "San Francisco"}),
)

प्रॉम्प्ट फ़ाइल

---
system: "Answer questions using the tools you have."
tools: [getWeather]
input:
  schema:
    location: string
---

What is the weather in {{location}}?

इसके बाद, अपने कोड में प्रॉम्प्ट को इस तरह से लागू किया जा सकता है:

// Assuming prompt file named weatherPrompt.prompt exists in ./prompts dir.
weatherPrompt := genkit.LookupPrompt("weatherPrompt")
if weatherPrompt == nil {
    log.Fatal("no prompt named 'weatherPrompt' found")
}

resp, err := weatherPrompt.Execute(ctx,
    ai.WithInput(map[string]any{"location": "San Francisco"}),
)

अगर प्रॉम्प्ट का जवाब देने के लिए एलएलएम को getWeather टूल का इस्तेमाल करना पड़ता है, तो Genkit टूल कॉल को अपने-आप मैनेज करेगा.

टूल कॉल को साफ़ तौर पर मैनेज करना

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

getWeatherTool := genkit.DefineTool(
    g, "getWeather", "Gets the current weather in a given location",
    func(ctx *ai.ToolContext, location string) (string, error) {
        // Tool implementation...
    })

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("What is the weather in San Francisco?"),
    ai.WithTools(getWeatherTool),
    ai.WithReturnToolRequests(true),
)
if err != nil {
    log.Fatal(err)
}

parts := []*Part{}
for _, req := range resp.ToolRequests() {
    tool := genkit.LookupTool(g, req.Name)
    if tool == nil {
        log.Fatalf("tool %q not found", req.Name)
    }

    output, err := tool.RunRaw(ctx, req.Input)
    if err != nil {
        log.Fatalf("tool %q execution failed: %v", err)
    }

    parts = append(parts,
        ai.NewToolResponsePart(&ai.ToolResponse{
            Name:   req.Name,
            Ref:    req.Ref,
            Output: output,
        }))
}

resp, err = genkit.Generate(ctx, g,
    ai.WithMessages(resp.History()..., NewMessage(ai.RoleTool, nil, parts...)),
)
if err != nil {
    log.Fatal(err)
}