टूल कॉलिंग

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

टूल तय करना

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

import { genkit, z } from 'genkit';
import { googleAI } from '@genkitai/google-ai';

const ai = genkit({
  plugins: [googleAI()],
  model: googleAI.model('gemini-2.0-flash'),
});

const getWeather = ai.defineTool(
  {
    name: 'getWeather',
    description: 'Gets the current weather in a given location',
    inputSchema: z.object({ 
      location: z.string().describe('The location to get the current weather for')
    }),
    outputSchema: z.string(),
  },
  async (input) => {
    // Here, we would typically make an API call or database query. For this
    // example, we just return a fixed value.
    return `The current weather in ${input.location} is 63°F and sunny.`;
  }
);

यहां दिया गया सिंटैक्स, defineFlow() सिंटैक्स जैसा ही दिखता है. हालांकि, name, description, और inputSchema पैरामीटर ज़रूरी हैं. टूल की परिभाषा लिखते समय, इन पैरामीटर के शब्दों और जानकारी पर खास ध्यान दें. उपलब्ध टूल का बेहतर तरीके से इस्तेमाल करने के लिए, एलएलएम के लिए ये एलिमेंट ज़रूरी हैं.

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

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

const response = await ai.generate({
  prompt: 'What is the weather in Baltimore?',
  tools: [getWeather],
});

const weatherPrompt = ai.definePrompt(
  {
    name: 'weatherPrompt',
    tools: [getWeather],
  },
  'What is the weather in {{location}}?'
);

const response = await weatherPrompt({ location: 'Baltimore' });

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

What is the weather in {{location}}?

// assuming prompt file is named weatherPrompt.prompt
const weatherPrompt = ai.prompt('weatherPrompt');

const response = await weatherPrompt({ location: 'Baltimore' });

const chat = ai.chat({
  system: 'Answer questions using the tools you have.',
  tools: [getWeather],
});

const response = await chat.send('What is the weather in Baltimore?');

// Or, specify tools that are message-specific 
const response = await chat.send({
  prompt: 'What is the weather in Baltimore?',
  tools: [getWeather],
});

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

रनटाइम के दौरान, डाइनैमिक तौर पर टूल तय करना

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

ai.dynamicTool फ़ंक्शन का इस्तेमाल करके, टूल को डाइनैमिक तौर पर तय किया जा सकता है. यह फ़ंक्शन, ai.defineTool तरीके से काफ़ी मिलता-जुलता है. हालांकि, Genkit रनटाइम, डाइनैमिक टूल को ट्रैक नहीं करता. इसलिए, इन टूल के साथ इंटरैक्ट करने के लिए, Genkit डेवलपर यूज़र इंटरफ़ेस का इस्तेमाल नहीं किया जा सकता. इसके बजाय, आपको इसे रेफ़रंस के ज़रिए ai.generate कॉल में पास करना होगा. सामान्य टूल के लिए, स्ट्रिंग टूल के नाम का भी इस्तेमाल किया जा सकता है.

import { genkit, z } from "genkit";
import { googleAI } from "@genkit-ai/googleai";

const ai = genkit({
  plugins: [googleAI()],
  model: googleAI.model("gemini-2.0-flash"),
});

const weatherFlow = ai.defineFlow("weatherFlow", async () => {
  const getWeather = ai.dynamicTool(
    {
      name: "getWeather",
      description: "Gets the current weather in a given location",
      inputSchema: z.object({
        location: z
          .string()
          .describe("The location to get the current weather for"),
      }),
      outputSchema: z.string(),
    },
    async (input) => {
      return `The current weather in ${input.location} is 63°F and sunny.`;
    }
  );

  const { text } = await ai.generate({
    prompt: "What is the weather in Baltimore?",
    tools: [getWeather],
  });

  return text;
});

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

const getWeather = ai.dynamicTool(
  {
    name: "getWeather",
    description: "Gets the current weather in a given location",
    inputJsonSchema: myInputJsonSchema,
    outputJsonSchema: myOutputJsonSchema,
  },
  async (input) => { /* ... */ }
);

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

const getWeather = ai.dynamicTool(
  {
    name: "getWeather",
    description: "Gets the current weather in a given location",
    inputJsonSchema: myInputJsonSchema,
    outputJsonSchema: myOutputJsonSchema,
  }
);

रुकावटों का इस्तेमाल करके, टूल लूप को रोकना

डिफ़ॉल्ट रूप से, Genkit बार-बार LLM को तब तक कॉल करता है, जब तक कि हर टूल कॉल को हल नहीं कर दिया जाता. आपके पास, अपनी ज़रूरत के हिसाब से, शर्त के हिसाब से एक्ज़ीक्यूशन रोकने का विकल्प होता है. उदाहरण के लिए:

• उपयोगकर्ता से कोई सवाल पूछें या यूज़र इंटरफ़ेस दिखाएं.
• उपयोगकर्ता से, किसी संभावित तौर पर खतरनाक कार्रवाई की पुष्टि करना.
• किसी कार्रवाई के लिए, अलग से अनुमति का अनुरोध करें.

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

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

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

const getWeather = ai.defineTool(
  {
    // ... tool definition ...
  },
  async ({ location }) => {
    // ... tool implementation ...
  },
);

const generateOptions: GenerateOptions = {
  prompt: "What's the weather like in Baltimore?",
  tools: [getWeather],
  returnToolRequests: true,
};

let llmResponse;
while (true) {
  llmResponse = await ai.generate(generateOptions);
  const toolRequests = llmResponse.toolRequests;
  if (toolRequests.length < 1) {
    break;
  }
  const toolResponses: ToolResponsePart[] = await Promise.all(
    toolRequests.map(async (part) => {
      switch (part.toolRequest.name) {
        case 'specialTool':
          return {
            toolResponse: {
              name: part.toolRequest.name,
              ref: part.toolRequest.ref,
              output: await getWeather(part.toolRequest.input),
            },
          };
        default:
          throw Error('Tool not found');
      }
    })
  );
  generateOptions.messages = llmResponse.messages;
  generateOptions.prompt = toolResponses;
}