टूल कॉलिंग

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

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

एलएलएम से उस जानकारी का ऐक्सेस देना जिसकी ट्रेनिंग नहीं की गई थी

• रेस्टोरेंट का रोज़ का मेन्यू या स्टोर की इन्वेंट्री की स्थिति.
• आपके ऐप्लिकेशन डोमेन के लिए खास जानकारी, जैसे कि प्रॉडक्ट की जानकारी.

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

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

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

एलएलएम से शुरू किए जाने पर कोई कार्रवाई करना

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

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

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

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

टूल कॉलिंग की खास जानकारी

हाई लेवल पर, किसी एलएलएम के साथ होने वाला टूल-कॉलिंग इंटरैक्शन आम तौर पर होता है ऐसा दिखता है:

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

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

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

Genkit से टूल कॉलिंग

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

मॉडल समर्थन

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

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

परिभाषित करने वाले टूल

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

const specialToolInputSchema = z.object({ meal: z.enum(["breakfast", "lunch", "dinner"]) });
const specialTool = defineTool(
  {
    name: "specialTool",
    description: "Retrieves today's special for the given meal",
    inputSchema: specialToolInputSchema,
    outputSchema: z.string(),
  },
  async ({ meal }): Promise<string> => {
    // Retrieve up-to-date information and return it. Here, we just return a
    // fixed value.
    return "Baked beans on toast";
  }
);

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

अपने प्रॉम्प्ट में टूल शामिल किए जा रहे हैं

अपने टूल तय करने के बाद, उन्हें इसके टूल पैरामीटर में बताएं generate():

const llmResponse = await generate({
  model: gemini15Flash,
  prompt,
  tools: [specialTool],
});

आपके पास कई टूल उपलब्ध कराने का विकल्प है; एलएलएम ज़रूरत पड़ने पर, टूल को प्रॉम्प्ट को पूरा करने के लिए.

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

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

let generateOptions: GenerateOptions = {
  model: gemini15Flash,
  prompt,
  tools: [specialTool],
  returnToolRequests: true,
};
let llmResponse;
while (true) {
  llmResponse = await 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 specialTool(specialToolInputSchema.parse(part.toolRequest?.input)),
            },
          };
        default:
          throw Error('Tool not found');
        }
      }));
    generateOptions.history = llmResponse.toHistory();
    generateOptions.prompt = toolResponses;
}