Ollama LLM ഉം ഒരു കസ്റ്റം ടൂളും ഉപയോഗിച്ച് Langchain.js-ൻ്റെ ToolCallingAgentOutputParser പിശക് പരിഹരിക്കുന്നു

Langchain.js-ലെ ToolCallingAgentOutputParser പിശകുകൾ മനസ്സിലാക്കുകയും പരിഹരിക്കുകയും ചെയ്യുന്നു

Langchain.js v2-ൽ പ്രവർത്തിക്കുമ്പോൾ, ഒല്ലാമ പോലുള്ള ഇഷ്‌ടാനുസൃത ഉപകരണങ്ങളും ഭാഷാ മോഡലുകളും ഉപയോഗിച്ച് കാര്യക്ഷമമായ ഏജൻ്റുമാരെ സൃഷ്ടിക്കാൻ ഡവലപ്പർമാർ പലപ്പോഴും ലക്ഷ്യമിടുന്നു. എന്നിരുന്നാലും, ഈ ഘടകങ്ങളെ സംയോജിപ്പിക്കുന്നത് ചിലപ്പോൾ ഡീബഗ് ചെയ്യാൻ ബുദ്ധിമുട്ടുള്ള പിശകുകളിലേക്ക് നയിച്ചേക്കാം.

അത്തരത്തിലുള്ള ഒരു പിശകാണ് "ToolCallingAgentOutputParser-ലെ parseResult ChatGeneration ഔട്ട്‌പുട്ടിൽ മാത്രമേ പ്രവർത്തിക്കൂ," ഏജൻ്റ് ചട്ടക്കൂടിനുള്ളിൽ ഒരു ഇഷ്‌ടാനുസൃത ഉപകരണം നിർമ്മിക്കുമ്പോൾ ഇത് സംഭവിക്കാം. ഏജൻ്റും ടൂളും ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഈ പ്രശ്നത്തിൻ്റെ മൂലകാരണം മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.

Langchain's createToolCallingAgent ഉം Ollama മോഡലും ഉപയോഗിച്ച് ഒരു നമ്പർ ഇൻപുട്ടിലേക്ക് 2 ചേർക്കുന്ന ഒരു ഇഷ്‌ടാനുസൃത ഉപകരണത്തിൻ്റെ ലളിതമായ നടപ്പാക്കൽ ഈ ലേഖനം പര്യവേക്ഷണം ചെയ്യുന്നു. പിശകും അതിൻ്റെ സന്ദർഭവും വിശകലനം ചെയ്യുന്നതിലൂടെ, അത് എങ്ങനെ പരിഹരിക്കാമെന്ന് നമുക്ക് നന്നായി മനസ്സിലാക്കാൻ കഴിയും.

ഇനിപ്പറയുന്ന വിഭാഗങ്ങൾ നിങ്ങളെ കോഡിലൂടെ നയിക്കുകയും പിശക് വിശദീകരിക്കുകയും ഈ പ്രശ്നം പരിഹരിക്കുന്നതിനുള്ള പരിഹാരങ്ങൾ നൽകുകയും ചെയ്യും. നിങ്ങൾ Langchain.js-ൽ പുതിയ ആളോ പരിചയസമ്പന്നനോ ആകട്ടെ, ഈ പ്രശ്‌നം കാര്യക്ഷമമായി മറികടക്കാൻ ഈ ഗൈഡ് നിങ്ങളെ സഹായിക്കും.

Langchain.js-ൽ കസ്റ്റം ടൂളും ഏജൻ്റ് പിശക് കൈകാര്യം ചെയ്യലും മനസ്സിലാക്കുന്നു

നൽകിയിരിക്കുന്ന ഉദാഹരണത്തിൽ, ഞങ്ങൾ Langchain.js v2-മായി സംയോജിപ്പിക്കുന്ന ഒരു ഇഷ്‌ടാനുസൃത ഉപകരണം സൃഷ്‌ടിക്കാൻ പ്രവർത്തിക്കുന്നു. ഒല്ലമ ഭാഷാ മാതൃക. ലളിതമായ ഒരു ഗണിത പ്രവർത്തനം നടത്തുക എന്നതാണ് ഉപകരണത്തിൻ്റെ പ്രധാന ലക്ഷ്യം: ഇൻപുട്ട് മൂല്യത്തിലേക്ക് 2 ചേർക്കുക. ലാങ്‌ചെയിൻ ഉപയോഗിച്ചാണ് ഉപകരണം നിർമ്മിച്ചിരിക്കുന്നത് ഉപകരണം ഫംഗ്‌ഷൻ, ഒരു ഏജൻ്റിന് അഭ്യർത്ഥിക്കാൻ കഴിയുന്ന പുനരുപയോഗിക്കാവുന്ന ഫംഗ്‌ഷനുകൾ നിർവചിക്കുന്നു. ഉപകരണം ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ, ഇൻപുട്ട് സ്കീമ Zod ലൈബ്രറിയിൽ സാധൂകരിക്കുന്നു, ഇൻപുട്ട് ഒരു സാധുവായ സംഖ്യയാണെന്ന് ഉറപ്പുനൽകുന്നു. ഇത് ശരിയായ പിശക് കൈകാര്യം ചെയ്യൽ ഉറപ്പാക്കുകയും അസാധുവായ ഇൻപുട്ടുകൾ കാരണം ടൂൾ പരാജയപ്പെടുന്നത് തടയുകയും ചെയ്യുന്നു.

ഇഷ്‌ടാനുസൃത ഉപകരണം ഉപയോഗിച്ച് ഒരു ഏജൻ്റിലേക്ക് സംയോജിപ്പിക്കുന്നു createToolCallingAgent പ്രവർത്തനം. ആവശ്യമുള്ളപ്പോൾ ഉപകരണത്തെ വിളിക്കാൻ ഈ കമാൻഡ് ഏജൻ്റിനെ അനുവദിക്കുന്നു, കൂടാതെ പ്രതികരണങ്ങളുടെ സർഗ്ഗാത്മകത നിയന്ത്രിക്കുന്നതിന് താപനില പോലുള്ള പ്രത്യേക പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന ഒല്ലാമ മോഡലാണ് ഏജൻ്റിനെ പവർ ചെയ്യുന്നത്. ഏജൻ്റും ടൂളും തമ്മിലുള്ള സുഗമമായ ഇടപെടൽ സുഗമമാക്കുന്നതിന്, ഒരു ചാറ്റ് പ്രോംപ്റ്റ് ടെംപ്ലേറ്റ് ഉപയോഗിക്കുന്നു. സിസ്റ്റം സന്ദേശങ്ങൾ, ഹ്യൂമൻ ഇൻപുട്ട്, പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ എന്നിങ്ങനെ വ്യത്യസ്ത തരത്തിലുള്ള സന്ദേശങ്ങൾ നിർവചിച്ചുകൊണ്ടാണ് ഈ ടെംപ്ലേറ്റ് സംഭാഷണം സംഘടിപ്പിക്കുന്നത്. പോലുള്ള പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ MessagesPlaceholder, ചാറ്റ് ചരിത്രം പോലുള്ള ഘടകങ്ങൾ ഉൾപ്പെടുത്തി സംഭാഷണം ചലനാത്മകമാക്കാൻ അനുവദിക്കുക.

ഈ ഉദാഹരണത്തിൽ പരാമർശിച്ചിരിക്കുന്ന പ്രധാന പ്രശ്നങ്ങളിലൊന്ന്, ലാങ്‌ചെയിൻ ഏജൻ്റിൻ്റെ ഔട്ട്‌പുട്ട് പാഴ്‌സിംഗിനെ ചുറ്റിപ്പറ്റിയുള്ള പിശക് കൈകാര്യം ചെയ്യുന്നതാണ്. "ParseResult on ToolCallingAgentOutputParser ChatGeneration ഔട്ട്‌പുട്ടിൽ മാത്രമേ പ്രവർത്തിക്കൂ" എന്ന പിശക് സന്ദേശം പാഴ്‌സർ പ്രതീക്ഷിക്കുന്ന ഔട്ട്‌പുട്ടും ജനറേറ്റുചെയ്യുന്ന യഥാർത്ഥ ഔട്ട്‌പുട്ടും തമ്മിലുള്ള പൊരുത്തക്കേടിൽ നിന്നാണ്. ഈ പിശക് കൈകാര്യം ചെയ്യുന്നതിന്, എല്ലാ ഇൻപുട്ടുകളും ഔട്ട്പുട്ടുകളും പ്രതീക്ഷിക്കുന്ന ഫോർമാറ്റുകൾക്ക് അനുസൃതമായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കിക്കൊണ്ട്, കസ്റ്റം ടൂൾ ശക്തമായ ലോജിക്കിൽ പൊതിഞ്ഞിരിക്കുന്നു. ഇത് കൂടുതൽ നിയന്ത്രിക്കുന്നത് ഏജൻ്റ് എക്സിക്യൂട്ടർ ചോദ്യവും ടൂൾ ഔട്ട്‌പുട്ടും ശരിയായി സമന്വയിപ്പിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പുവരുത്തുന്ന, ഏജൻ്റിൻ്റെയും ടൂളുകളുടെയും നിർവ്വഹണത്തെ ഏകോപിപ്പിക്കുന്ന ക്ലാസ്.

അവസാനമായി, സ്ക്രിപ്റ്റുകൾ ഉപയോഗിച്ച് അസിൻക്രണസ് എക്സിക്യൂഷൻ നടപ്പിലാക്കുന്നു കാത്തിരിക്കുക, മറ്റ് പ്രക്രിയകളെ തടയാതെ തന്നെ പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യാൻ സിസ്റ്റത്തെ അനുവദിക്കുന്നു. പ്രതികരണം കൃത്യവും സമയബന്ധിതവുമാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട്, തുടരുന്നതിന് മുമ്പ് ഉപകരണം അതിൻ്റെ ഫലം നൽകുന്നതിനായി ഏജൻ്റ് കാത്തിരിക്കുന്നു. കൂടാതെ, ഉപകരണത്തിൻ്റെ പ്രവർത്തനക്ഷമത സ്ഥിരീകരിക്കുന്നതിന് യൂണിറ്റ് ടെസ്റ്റുകൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, ഇത് സ്ഥിരമായി ശരിയായ ഔട്ട്പുട്ട് ഉത്പാദിപ്പിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. ഈ പരിശോധനകൾ ഉപകരണത്തിൻ്റെ ഗണിതശാസ്ത്ര പ്രവർത്തനം സ്ഥിരീകരിക്കുക മാത്രമല്ല, അത് അസാധുവായ ഇൻപുട്ട് എത്ര നന്നായി കൈകാര്യം ചെയ്യുന്നുവെന്നും പരിശോധിക്കുന്നു, ഇത് പരിഹാരത്തിൻ്റെ മൊത്തത്തിലുള്ള വിശ്വാസ്യത മെച്ചപ്പെടുത്തുന്നു. ഈ മോഡുലറും പിശക്-പ്രതിരോധശേഷിയുള്ളതുമായ ഡിസൈൻ, 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 പ്രവർത്തനം. ആവശ്യമുള്ളപ്പോൾ നിർദ്ദിഷ്ട ടൂളുകൾ പ്രവർത്തനക്ഷമമാക്കാൻ ഈ ഫംഗ്‌ഷൻ ഏജൻ്റിനെ അനുവദിക്കുന്നു, ടാസ്‌ക്കുകൾ കൃത്യമായും കാര്യക്ഷമമായും പൂർത്തിയാക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. പ്രാഥമിക ശ്രദ്ധ പലപ്പോഴും ഉപകരണം തന്നെ സൃഷ്ടിക്കുന്നതിലായിരിക്കുമ്പോൾ, ഏജൻ്റിൻ്റെ വർക്ക്ഫ്ലോ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നും പാഴ്‌സിംഗ് പിശകുകൾ ഒഴിവാക്കാമെന്നും മനസ്സിലാക്കുന്നത് ഒരുപോലെ പ്രധാനമാണ്. "ParseResult on ToolCallingAgentOutputParser ChatGeneration ഔട്ട്‌പുട്ടിൽ മാത്രമേ പ്രവർത്തിക്കൂ" എന്നതുപോലുള്ള പിശകുകൾ സാധാരണയായി സംഭവിക്കുന്നത് ഏജൻ്റിൻ്റെ ഔട്ട്‌പുട്ട് പാഴ്‌സിംഗ് സിസ്റ്റവുമായി പൊരുത്തപ്പെടാത്തപ്പോൾ, ഏജൻ്റിൻ്റെ ഔട്ട്‌പുട്ടും പ്രതീക്ഷിക്കുന്ന ഫോർമാറ്റും തമ്മിലുള്ള ശരിയായ വിന്യാസത്തിൻ്റെ ആവശ്യകത എടുത്തുകാണിക്കുന്നു.

പോലുള്ള പ്രോംപ്റ്റ് ടെംപ്ലേറ്റുകളുടെ ഉപയോഗം ChatPrompt ടെംപ്ലേറ്റ്, ഡൈനാമിക് സന്ദേശങ്ങളും സന്ദർഭ പ്ലെയ്‌സ്‌ഹോൾഡറുകളും അനുവദിച്ചുകൊണ്ട് ആശയവിനിമയത്തെ കൂടുതൽ സമ്പന്നമാക്കുന്നു. ചാറ്റ് ചരിത്രത്തെയോ ഏജൻ്റിൻ്റെ സ്‌ക്രാച്ച്‌പാഡിനെയോ അടിസ്ഥാനമാക്കി അതിൻ്റെ പ്രതികരണങ്ങൾ ക്രമീകരിക്കാൻ ഇത് ഏജൻ്റിനെ അനുവദിക്കുന്നു. പ്രോംപ്റ്റ് ടെംപ്ലേറ്റുകൾ ഒപ്റ്റിമൈസ് ചെയ്യുകയും ഏജൻ്റിൻ്റെ ഔട്ട്‌പുട്ടുകൾ ശരിയായി പാഴ്‌സ് ചെയ്‌തിരിക്കുന്നുവെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുന്നത്, നിങ്ങളുടെ Langchain.js ആപ്ലിക്കേഷനുകളെ കൂടുതൽ വിശ്വസനീയവും കാര്യക്ഷമവുമാക്കുന്ന നിരവധി സാധാരണ പിശകുകൾ തടയാൻ കഴിയും.