Ollama LLM మరియు కస్టమ్ టూల్‌తో Langchain.js యొక్క ToolCallingAgentOutputParser లోపాన్ని పరిష్కరించడం

Langchain.jsలో ToolCallingAgentOutputParser లోపాలను అర్థం చేసుకోవడం మరియు పరిష్కరించడం

Langchain.js v2తో పని చేస్తున్నప్పుడు, డెవలపర్‌లు తరచుగా కస్టమ్ టూల్స్ మరియు ఒల్లామా వంటి భాషా నమూనాలను ఉపయోగించి సమర్థవంతమైన ఏజెంట్‌లను సృష్టించాలని లక్ష్యంగా పెట్టుకుంటారు. అయినప్పటికీ, ఈ భాగాలను ఏకీకృతం చేయడం వలన కొన్నిసార్లు డీబగ్ చేయడం కష్టంగా ఉండే లోపాలకు దారితీయవచ్చు.

అటువంటి లోపం ఏమిటంటే, "ToolCallingAgentOutputParserలోని parseResult ChatGeneration అవుట్‌పుట్‌లో మాత్రమే పని చేస్తుంది," ఇది ఏజెంట్ ఫ్రేమ్‌వర్క్‌లో అనుకూల సాధనాన్ని రూపొందించేటప్పుడు సంభవించవచ్చు. ఏజెంట్ మరియు టూల్ సరిగ్గా పని చేస్తున్నాయని నిర్ధారించడానికి ఈ సమస్య యొక్క మూల కారణాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం.

ఈ కథనం Langchain యొక్క createToolCallingAgent మరియు Ollama మోడల్‌ని ఉపయోగించి సంఖ్య ఇన్‌పుట్‌కు 2ని జోడించే అనుకూల సాధనం యొక్క సరళమైన అమలును అన్వేషిస్తుంది. లోపాన్ని మరియు దాని సందర్భాన్ని విశ్లేషించడం ద్వారా, దాన్ని ఎలా పరిష్కరించాలో మనం బాగా గ్రహించవచ్చు.

కింది విభాగాలు మీకు కోడ్ ద్వారా మార్గనిర్దేశం చేస్తాయి, లోపాన్ని వివరిస్తాయి మరియు ఈ సమస్యను పరిష్కరించడానికి పరిష్కారాలను అందిస్తాయి. మీరు Langchain.jsకి కొత్తవారైనా లేదా అనుభవం ఉన్నవారైనా, ఈ గైడ్ ఈ సమస్యను సమర్థవంతంగా అధిగమించడంలో మీకు సహాయం చేస్తుంది.

Langchain.jsలో కస్టమ్ టూల్ మరియు ఏజెంట్ ఎర్రర్ హ్యాండ్లింగ్‌ను అర్థం చేసుకోవడం

అందించిన ఉదాహరణలో, మేము Langchain.js v2తో కలిసి కస్టమ్ సాధనాన్ని రూపొందించడానికి పని చేస్తున్నాము. ఒల్లమా భాషా నమూనా. సాధనం యొక్క ముఖ్య ఉద్దేశ్యం ఒక సాధారణ గణిత శాస్త్ర చర్యను నిర్వహించడం: ఇన్‌పుట్ విలువకు 2 జోడించడం. సాధనం లాంగ్‌చెయిన్‌లను ఉపయోగించి నిర్మించబడింది సాధనం ఫంక్షన్, ఇది ఏజెంట్ ద్వారా ప్రారంభించబడే పునర్వినియోగ విధులను నిర్వచిస్తుంది. సాధనం సరిగ్గా పని చేస్తుందని నిర్ధారించడానికి, ఇన్‌పుట్ స్కీమా Zod లైబ్రరీతో ధృవీకరించబడుతుంది, ఇన్‌పుట్ చెల్లుబాటు అయ్యే సంఖ్య అని హామీ ఇస్తుంది. ఇది సరైన లోపం నిర్వహణను నిర్ధారిస్తుంది మరియు చెల్లని ఇన్‌పుట్‌ల కారణంగా సాధనం విఫలం కాకుండా నిరోధిస్తుంది.

కస్టమ్ సాధనం ఉపయోగించి ఏజెంట్‌లో చేర్చబడుతుంది సృష్టించుToolCallingAgent ఫంక్షన్. ఈ కమాండ్ అవసరమైనప్పుడు సాధనాన్ని కాల్ చేయడానికి ఏజెంట్‌ను అనుమతిస్తుంది మరియు ఏజెంట్ ఒల్లామా మోడల్ ద్వారా శక్తిని పొందుతుంది, ఇది ప్రతిస్పందనల సృజనాత్మకతను నియంత్రించడానికి ఉష్ణోగ్రత వంటి నిర్దిష్ట పారామితులతో కాన్ఫిగర్ చేయబడింది. ఏజెంట్ మరియు సాధనం మధ్య సున్నితమైన పరస్పర చర్యను సులభతరం చేయడానికి, చాట్ ప్రాంప్ట్ టెంప్లేట్ ఉపయోగించబడుతుంది. ఈ టెంప్లేట్ సిస్టమ్ సందేశాలు, మానవ ఇన్‌పుట్ మరియు ప్లేస్‌హోల్డర్‌ల వంటి వివిధ రకాల సందేశాలను నిర్వచించడం ద్వారా సంభాషణను నిర్వహిస్తుంది. ప్లేస్‌హోల్డర్‌లు, వంటివి సందేశాలు ప్లేస్‌హోల్డర్, చాట్ చరిత్ర వంటి అంశాలతో సంభాషణ డైనమిక్‌గా ఉండటానికి అనుమతించండి.

లాంగ్‌చెయిన్ ఏజెంట్ అవుట్‌పుట్ పార్సింగ్ చుట్టూ ఉన్న ఎర్రర్ హ్యాండ్లింగ్ ఈ ఉదాహరణలో ప్రస్తావించబడిన ముఖ్య సమస్యలలో ఒకటి. "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తో పని చేస్తున్నప్పుడు, సమగ్రపరచడం ఏజెంట్లు ఒల్లామా వంటి సాధనాలు మరియు భాషా నమూనాలు డైనమిక్ అప్లికేషన్‌లను రూపొందించడంలో కీలకమైన అంశం. నిర్దిష్ట విధులను నిర్వర్తించే కస్టమ్ టూల్‌ను మరింత సంభాషణ లేదా ఉత్పాదక పనులను నిర్వహించే భాషా నమూనాకు కనెక్ట్ చేయడానికి ఏజెంట్ మిమ్మల్ని అనుమతిస్తుంది. ఏజెంట్లను ఉపయోగించడం ద్వారా, డెవలపర్లు వర్క్‌ఫ్లోలను ఆటోమేట్ చేయగలరు, ఇక్కడ మోడల్ ప్రతిస్పందనలను రూపొందించడమే కాకుండా లెక్కలు లేదా డేటా ప్రాసెసింగ్ చేయడానికి సాధనాలను కూడా ప్రేరేపిస్తుంది.

ఈ ఏకీకరణలో కీలకమైన అంశం సృష్టించుToolCallingAgent ఫంక్షన్. ఈ ఫంక్షన్ అవసరమైనప్పుడు నిర్దిష్ట సాధనాలను ట్రిగ్గర్ చేయడానికి ఏజెంట్‌ను అనుమతిస్తుంది, టాస్క్‌లు ఖచ్చితంగా మరియు సమర్ధవంతంగా పూర్తయ్యాయని నిర్ధారిస్తుంది. ప్రాథమిక దృష్టి తరచుగా సాధనాన్ని సృష్టించడంపైనే ఉంటుంది, ఏజెంట్ యొక్క వర్క్‌ఫ్లోను ఎలా నిర్వహించాలో మరియు పార్సింగ్ లోపాలను ఎలా నివారించాలో అర్థం చేసుకోవడం కూడా అంతే ముఖ్యం. ఏజెంట్ అవుట్‌పుట్ పార్సింగ్ సిస్టమ్‌కు అనుకూలంగా లేనప్పుడు, ఏజెంట్ అవుట్‌పుట్ మరియు ఆశించిన ఆకృతికి మధ్య సరైన అమరిక అవసరాన్ని హైలైట్ చేస్తూ, "ParseResult on ToolCallingAgentOutputParser ChatGeneration అవుట్‌పుట్‌లో మాత్రమే పని చేస్తుంది" వంటి లోపాలు సాధారణంగా సంభవిస్తాయి.

వంటి ప్రాంప్ట్ టెంప్లేట్‌ల ఉపయోగం ChatPrompt మూస, డైనమిక్ సందేశాలు మరియు కాంటెక్స్ట్ ప్లేస్‌హోల్డర్‌లను అనుమతించడం ద్వారా పరస్పర చర్యను మరింత మెరుగుపరుస్తుంది. ఇది చాట్ చరిత్ర లేదా ఏజెంట్ స్క్రాచ్‌ప్యాడ్ ఆధారంగా దాని ప్రతిస్పందనలను సర్దుబాటు చేయడానికి ఏజెంట్‌ను అనుమతిస్తుంది. ప్రాంప్ట్ టెంప్లేట్‌లను ఆప్టిమైజ్ చేయడం మరియు ఏజెంట్ యొక్క అవుట్‌పుట్‌లు సరిగ్గా అన్వయించబడ్డాయని నిర్ధారించుకోవడం వలన మీ Langchain.js అప్లికేషన్‌లను మరింత విశ్వసనీయంగా మరియు సమర్ధవంతంగా చేయడం ద్వారా అనేక సాధారణ లోపాలను నివారించవచ్చు.