ઓલામા એલએલએમ અને કસ્ટમ ટૂલ સાથે Langchain.js ની ToolCallingAgentOutputParser ભૂલને ઠીક કરવી

Langchain.js માં ToolCallingAgentOutputParser ભૂલોને સમજવી અને ઠીક કરવી

Langchain.js v2 સાથે કામ કરતી વખતે, વિકાસકર્તાઓ ઘણીવાર કસ્ટમ ટૂલ્સ અને ઓલામા જેવા ભાષા મોડલ્સનો ઉપયોગ કરીને કાર્યક્ષમ એજન્ટ બનાવવાનું લક્ષ્ય રાખે છે. જો કે, આ ઘટકોને એકીકૃત કરવાથી કેટલીકવાર ભૂલો થઈ શકે છે જે ડિબગ કરવા મુશ્કેલ હોય છે.

આવી જ એક ભૂલ "ToolCallingAgentOutputParser પર parseResult માત્ર ChatGeneration આઉટપુટ પર કામ કરે છે," જે એજન્ટ ફ્રેમવર્કમાં કસ્ટમ ટૂલ બનાવતી વખતે આવી શકે છે. એજન્ટ અને સાધન યોગ્ય રીતે કાર્ય કરે છે તેની ખાતરી કરવા માટે આ સમસ્યાના મૂળ કારણને સમજવું મહત્વપૂર્ણ છે.

આ લેખ લેંગચેનના createToolCallingAgent અને ઓલામા મોડેલનો ઉપયોગ કરીને એક કસ્ટમ ટૂલના સરળ અમલીકરણની શોધ કરે છે જે નંબર ઇનપુટમાં 2 ઉમેરે છે. ભૂલ અને તેના સંદર્ભનું વિશ્લેષણ કરીને, અમે તેને કેવી રીતે નિવારવું તે વધુ સારી રીતે સમજી શકીએ છીએ.

નીચેના વિભાગો તમને કોડ દ્વારા માર્ગદર્શન આપશે, ભૂલ સમજાવશે અને આ સમસ્યાને ઉકેલવા માટે ઉકેલો પ્રદાન કરશે. ભલે તમે Langchain.js પર નવા હોવ અથવા અનુભવી હોવ, આ માર્ગદર્શિકા તમને આ સમસ્યાને અસરકારક રીતે પાર કરવામાં મદદ કરશે.

Langchain.js માં કસ્ટમ ટૂલ અને એજન્ટ એરર હેન્ડલિંગને સમજવું

આપેલા ઉદાહરણમાં, અમે એક કસ્ટમ ટૂલ બનાવવા માટે Langchain.js v2 સાથે કામ કરી રહ્યા છીએ જે ઓલામા ભાષા મોડેલ. સાધનનો મુખ્ય હેતુ સરળ ગાણિતિક કામગીરી કરવાનો છે: ઇનપુટ મૂલ્યમાં 2 ઉમેરવું. ટૂલ લેંગચેનનો ઉપયોગ કરીને બનાવવામાં આવ્યું છે સાધન ફંક્શન, જે ફરીથી વાપરી શકાય તેવા કાર્યોને વ્યાખ્યાયિત કરે છે જેને એજન્ટ દ્વારા બોલાવી શકાય છે. ટૂલ યોગ્ય રીતે કામ કરે છે તેની ખાતરી કરવા માટે, ઇનપુટ સ્કીમાને Zod લાઇબ્રેરી દ્વારા માન્ય કરવામાં આવે છે, જે ખાતરી આપે છે કે ઇનપુટ માન્ય નંબર છે. આ યોગ્ય એરર હેન્ડલિંગની ખાતરી કરે છે અને અમાન્ય ઇનપુટ્સને કારણે ટૂલને નિષ્ફળ થવાથી અટકાવે છે.

વૈવિધ્યપૂર્ણ ટૂલનો ઉપયોગ કરીને પછી એજન્ટમાં સમાવેશ થાય છે createToolCallingAgent કાર્ય આ આદેશ એજન્ટને જ્યારે જરૂર પડે ત્યારે ટૂલને કૉલ કરવાની મંજૂરી આપે છે, અને એજન્ટ ઓલામા મોડેલ દ્વારા સંચાલિત થાય છે, જે પ્રતિસાદોની સર્જનાત્મકતાને નિયંત્રિત કરવા માટે તાપમાન જેવા ચોક્કસ પરિમાણો સાથે ગોઠવવામાં આવે છે. એજન્ટ અને ટૂલ વચ્ચે સરળ ક્રિયાપ્રતિક્રિયાને સરળ બનાવવા માટે, ચેટ પ્રોમ્પ્ટ ટેમ્પલેટનો ઉપયોગ કરવામાં આવે છે. આ ટેમ્પલેટ વિવિધ પ્રકારના સંદેશાઓ, જેમ કે સિસ્ટમ સંદેશાઓ, માનવ ઇનપુટ અને પ્લેસહોલ્ડર્સને વ્યાખ્યાયિત કરીને વાતચીતનું આયોજન કરે છે. પ્લેસહોલ્ડર્સ, જેમ કે MessagesPlaceholder, વાતચીતને ગતિશીલ બનવાની મંજૂરી આપો, જેમાં ચેટ ઇતિહાસ જેવા ઘટકો શામેલ છે.

આ ઉદાહરણમાં સંબોધવામાં આવેલ મુખ્ય મુદ્દાઓમાંની એક છે લેંગચેન એજન્ટના આઉટપુટ પાર્સિંગની આસપાસની ભૂલ હેન્ડલિંગ. પાર્સર દ્વારા અપેક્ષિત આઉટપુટના પ્રકાર અને જનરેટ થયેલ વાસ્તવિક આઉટપુટ વચ્ચેની મેળ ખાતી ન હોવાને કારણે "ટૂલકૉલિંગ એજેન્ટ આઉટપુટ પાર્સર પર પાર્સ રિઝલ્ટ ફક્ત ચેટ જનરેશન આઉટપુટ પર જ કામ કરે છે" એ ભૂલ સંદેશો છે. આ ભૂલને હેન્ડલ કરવા માટે, કસ્ટમ ટૂલ મજબૂત તર્કમાં લપેટાયેલું છે, ખાતરી કરે છે કે તમામ ઇનપુટ્સ અને આઉટપુટ અપેક્ષિત ફોર્મેટને અનુરૂપ છે. આનું વધુ સંચાલન દ્વારા કરવામાં આવે છે એજન્ટ એક્ઝિક્યુટર વર્ગ, જે એજન્ટ અને ટૂલ્સના અમલને સંકલન કરે છે, ખાતરી કરે છે કે ક્વેરી અને ટૂલ આઉટપુટ યોગ્ય રીતે સમન્વયિત છે.

છેલ્લે, સ્ક્રિપ્ટો ઉપયોગ કરીને અસુમેળ અમલીકરણનો અમલ કરે છે રાહ જોવી, સિસ્ટમને અન્ય પ્રક્રિયાઓને અવરોધિત કર્યા વિના કામગીરી સંભાળવાની મંજૂરી આપે છે. એજન્ટ આગળ વધતા પહેલા ટૂલના પરિણામ પરત કરવાની રાહ જુએ છે, ખાતરી કરીને કે પ્રતિસાદ સચોટ અને સમયસર બંને છે. વધુમાં, સાધનની કાર્યક્ષમતાને માન્ય કરવા માટે એકમ પરીક્ષણોનો સમાવેશ કરવામાં આવે છે, તે સુનિશ્ચિત કરે છે કે તે સતત યોગ્ય આઉટપુટ ઉત્પન્ન કરે છે. આ પરીક્ષણો માત્ર ટૂલના ગાણિતિક કાર્યની પુષ્ટિ કરતા નથી પણ તે અમાન્ય ઇનપુટને કેટલી સારી રીતે હેન્ડલ કરે છે તે પણ તપાસે છે, ઉકેલની એકંદર વિશ્વસનીયતામાં સુધારો કરે છે. આ મોડ્યુલર અને ભૂલ-પ્રતિરોધક ડિઝાઇન Langchain.js ની અંદર વિવિધ એપ્લિકેશનો માટે સ્ક્રિપ્ટ્સને ફરીથી વાપરી શકાય તેવી અને અસરકારક બનાવે છે.

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { Ollama } from "@langchain/ollama";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { createToolCallingAgent } from "langchain/agents";
import { AgentExecutor } from "langchain/agents";
// Initialize LLM with Ollama
const llm = new Ollama({
    model: "llama3",
    temperature: 0.7,
});
// Custom tool to add 2 to the input number
const magicTool = tool(
    async (input) => {
        return input + 2;
    },
    {
        name: "magic_function",
        description: "Applies a magic function to an input",
        schema: z.object({ input: z.number() }),
    };
);
const tools = [magicTool];
// Setup ChatPromptTemplate with placeholders
const prompt = ChatPromptTemplate.fromMessages([
    ["system", "You are a helpful assistant called iHelp"],
    ["placeholder", "{chat_history}"],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
]);
// Agent configuration
const agent = createToolCallingAgent({ llm, tools, prompt });
// Execute agent query
const agentExecutor = new AgentExecutor({ agent, tools });
const query = "What is the value of magic_function(3)?";
await agentExecutor.invoke({ input: query });

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { Ollama } from "@langchain/ollama";
import { createToolCallingAgent } from "langchain/agents";
import { AgentExecutor } from "langchain/agents";
// Initialize LLM with Ollama
const llm = new Ollama({ model: "llama3", temperature: 0.7 });
// Custom tool with added error handling
const magicTool = tool(
    async (input) => {
        try {
            if (typeof input !== "number") throw new Error("Invalid input type!");
            return input + 2;
        } catch (err) {
            return err.message;
        }
    },
    {
        name: "magic_function",
        description: "Adds 2 to input and handles errors",
        schema: z.object({ input: z.number() }),
    }
);
const tools = [magicTool];
// Agent and execution
const agent = createToolCallingAgent({ llm, tools });
const agentExecutor = new AgentExecutor({ agent, tools });
const query = "magic_function('abc')"; // Test with invalid input
await agentExecutor.invoke({ input: query });
// Unit test example
import { expect } from "chai";
it("should return 5 when input is 3", async () => {
    const result = await magicTool(3);
    expect(result).to.equal(5);
});

Langchain.js અને Ollama LLM એકીકરણમાં એજન્ટોની ભૂમિકાની શોધખોળ

Langchain.js સાથે કામ કરતી વખતે, એકીકરણ એજન્ટો ઓલામા જેવા ટૂલ્સ અને લેંગ્વેજ મોડલ્સ સાથે ગતિશીલ એપ્લીકેશન બનાવવાનું એક મહત્વપૂર્ણ પાસું છે. એજન્ટ તમને વૈવિધ્યપૂર્ણ ટૂલને કનેક્ટ કરવાની મંજૂરી આપે છે, જે ચોક્કસ કાર્યો કરે છે, ભાષા મોડેલ સાથે, જે વધુ વાતચીત અથવા જનરેટિવ કાર્યોને હેન્ડલ કરે છે. એજન્ટોનો ઉપયોગ કરીને, વિકાસકર્તાઓ વર્કફ્લોને સ્વચાલિત કરી શકે છે જ્યાં મોડેલ માત્ર પ્રતિભાવો જ જનરેટ કરતું નથી પરંતુ ગણતરીઓ અથવા ડેટા પ્રોસેસિંગ કરવા માટે ટૂલ્સનો પણ ઉપયોગ કરે છે.

આ એકીકરણમાં મુખ્ય ઘટક છે createToolCallingAgent કાર્ય આ કાર્ય એજન્ટને જ્યારે જરૂરી હોય ત્યારે ચોક્કસ સાધનોને ટ્રિગર કરવા દે છે, તે સુનિશ્ચિત કરે છે કે કાર્યો ચોક્કસ અને અસરકારક રીતે પૂર્ણ થાય છે. જ્યારે પ્રાથમિક ધ્યાન ઘણીવાર સાધન બનાવવા પર હોય છે, ત્યારે એજન્ટના વર્કફ્લોનું સંચાલન કેવી રીતે કરવું અને પાર્સિંગ ભૂલોને કેવી રીતે ટાળવી તે સમજવું પણ એટલું જ મહત્વનું છે. "ToolCallingAgentOutputParser પર parseResult માત્ર ChatGeneration આઉટપુટ પર કામ કરે છે" જેવી ભૂલો સામાન્ય રીતે ત્યારે થાય છે જ્યારે એજન્ટનું આઉટપુટ પાર્સિંગ સિસ્ટમ સાથે સુસંગત ન હોય, જે એજન્ટના આઉટપુટ અને અપેક્ષિત ફોર્મેટ વચ્ચે યોગ્ય ગોઠવણીની જરૂરિયાતને પ્રકાશિત કરે છે.

પ્રોમ્પ્ટ ટેમ્પ્લેટ્સનો ઉપયોગ, જેમ કે ChatPromptTemplate, ગતિશીલ સંદેશાઓ અને સંદર્ભ પ્લેસહોલ્ડર્સને મંજૂરી આપીને ક્રિયાપ્રતિક્રિયાને વધુ સમૃદ્ધ બનાવે છે. આ એજન્ટને ચેટ ઇતિહાસ અથવા એજન્ટના સ્ક્રેચપેડના આધારે તેના પ્રતિસાદોને સમાયોજિત કરવાની મંજૂરી આપે છે. પ્રોમ્પ્ટ ટેમ્પલેટ્સને ઑપ્ટિમાઇઝ કરીને અને એજન્ટના આઉટપુટનું યોગ્ય રીતે પદચ્છેદન કરવામાં આવ્યું છે તેની ખાતરી કરવાથી ઘણી સામાન્ય ભૂલો અટકાવી શકાય છે, જે તમારી Langchain.js એપ્લિકેશનને વધુ વિશ્વસનીય અને કાર્યક્ષમ બનાવે છે.