Åtgärda Langchain.js ToolCallingAgentOutputParser-fel med Ollama LLM och ett anpassat verktyg

Förstå och åtgärda ToolCallingAgentOutputParser-fel i Langchain.js

När man arbetar med Langchain.js v2 strävar utvecklare ofta efter att skapa effektiva agenter med hjälp av anpassade verktyg och språkmodeller som Ollama. Men att integrera dessa komponenter kan ibland leda till fel som är svåra att felsöka.

Ett sådant fel är "parseResult on ToolCallingAgentOutputParser fungerar bara på ChatGeneration-utdata", vilket kan uppstå när man bygger ett anpassat verktyg inom agentramverket. Att förstå grundorsaken till detta problem är avgörande för att säkerställa att agenten och verktyget fungerar korrekt.

Den här artikeln utforskar en enkel implementering av ett anpassat verktyg som lägger till 2 till en nummerinmatning, med hjälp av Langchains createToolCallingAgent och Ollama-modellen. Genom att analysera felet och dess sammanhang kan vi bättre förstå hur man felsöker det.

Följande avsnitt guidar dig genom koden, förklarar felet och ger lösningar för att lösa detta problem. Oavsett om du är ny på Langchain.js eller erfaren, hjälper den här guiden dig att komma förbi det här problemet på ett effektivt sätt.

Kommando	Exempel på användning
tool()	Denna funktion från Langchain.js definierar ett anpassat verktyg som utför en operation. I den här artikeln används det för att skapa ett verktyg som lägger till 2 till ett inmatat nummer, vilket lindar in logiken i en lätt anropbar struktur.
z.object()	En del av Zod-biblioteket, som används för schemavalidering i Langchain. Detta säkerställer att indata till det anpassade verktyget är ett nummer, vilket ger en stark indatavalidering för att förhindra fel under körning.
createToolCallingAgent()	Detta kommando skapar en agent som kan anropa de definierade verktygen som svar på användarfrågor. Det är nyckeln till att integrera verktyg med språkmodeller som Ollama, vilket gör det möjligt att anropa verktyg under samtal.
ChatPromptTemplate.fromMessages()	Används för att skapa en chattpromptmall med platshållare. Den här mallen organiserar olika typer av meddelanden (system, mänskliga, platshållare) för agenten att använda, vilket förbättrar dess konversationsflöde.
MessagesPlaceholder	Fungerar som en platshållare i promptmallen för dynamiskt innehåll, som chatthistorik eller agentscratchpad. Detta gör att konversationskontexten kan injiceras dynamiskt under exekvering.
AgentExecutor()	Denna klass hanterar exekveringen av agenter och verktyg. I exemplet hjälper det att köra frågan genom agenten och samla in resultatet från verktygets utdata.
await agentExecutor.invoke()	Används för att köra frågan genom agenten och vänta på resultatet asynkront. Detta är avgörande för att interagera med språkmodeller och verktyg, eftersom det säkerställer att koden väntar på att operationen ska slutföras innan den går vidare.
try-catch	Denna felhanteringsstruktur används i det anpassade verktyget för att fånga ogiltiga indatatyper. Genom att fånga undantag säkerställer det att systemet returnerar användbara felmeddelanden utan att bryta exekveringsflödet.
expect()	Från Chai assertion-biblioteket används expect() i enhetstestet för att verifiera resultatet från det anpassade verktyget. Det är viktigt för att testa om verktyget fungerar som förväntat.

Förstå det anpassade verktyget och agentfelhanteringen i Langchain.js

I exemplet som tillhandahålls arbetar vi med Langchain.js v2 för att skapa ett anpassat verktyg som integreras med språkmodell. Huvudsyftet med verktyget är att utföra en enkel matematisk operation: lägga till 2 till inmatningsvärdet. Verktyget är byggt med hjälp av Langchains funktion, som definierar återanvändbara funktioner som kan anropas av en agent. För att säkerställa att verktyget fungerar korrekt, valideras inmatningsschemat med Zod-biblioteket, vilket garanterar att inmatningen är ett giltigt nummer. Detta säkerställer korrekt felhantering och förhindrar att verktyget misslyckas på grund av ogiltiga inmatningar.

Det anpassade verktyget inkorporeras sedan i en agent med hjälp av fungera. Detta kommando låter agenten anropa verktyget när det behövs, och agenten drivs av Ollama-modellen, som är konfigurerad med specifika parametrar som temperatur för att styra kreativiteten i svaren. För att underlätta smidig interaktion mellan agenten och verktyget används en chattpromptmall. Den här mallen organiserar konversationen genom att definiera olika typer av meddelanden, såsom systemmeddelanden, mänsklig input och platshållare. Platshållarna, som t.ex , låt konversationen vara dynamisk, med element som chatthistoriken inkluderade.

En av nyckelfrågorna som tas upp i det här exemplet är felhanteringen kring Langchain-agentens utdataanalys. Felmeddelandet "parseResult på ToolCallingAgentOutputParser fungerar bara på ChatGeneration-utdata" härrör från en oöverensstämmelse mellan den typ av utdata som förväntas av parsern och den faktiska utdata som genereras. För att hantera detta fel är det anpassade verktyget insvept i robust logik, vilket säkerställer att alla ingångar och utgångar överensstämmer med förväntade format. Detta hanteras vidare av klass, som koordinerar exekveringen av agenten och verktygen, och ser till att frågan och verktygsutgången är korrekt synkroniserade.

Slutligen implementerar skripten asynkron exekvering med hjälp av , vilket gör att systemet kan hantera operationer utan att blockera andra processer. Agenten väntar på att verktyget ska returnera sitt resultat innan han fortsätter, och säkerställer att svaret är både korrekt och i rätt tid. Dessutom ingår enhetstester för att validera verktygets funktionalitet, vilket säkerställer att det konsekvent producerar rätt utdata. Dessa tester bekräftar inte bara verktygets matematiska funktion utan kontrollerar också hur väl det hanterar ogiltiga indata, vilket förbättrar lösningens övergripande tillförlitlighet. Denna modulära och felbeständiga design gör skripten återanvändbara och effektiva för olika applikationer inom 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);
});

Utforska agenternas roll i Langchain.js och Ollama LLM-integration

När du arbetar med Langchain.js, integrera med verktyg och språkmodeller som Ollama är en kritisk aspekt av att bygga dynamiska applikationer. En agent låter dig koppla ett anpassat verktyg, som utför specifika uppgifter, till en språkmodell, som hanterar mer konversations- eller generativa uppgifter. Genom att använda agenter kan utvecklare automatisera arbetsflöden där en modell inte bara genererar svar utan också anropar verktyg för att utföra beräkningar eller databearbetning.

Nyckelkomponenten i denna integration är fungera. Denna funktion låter agenten utlösa specifika verktyg när det behövs, vilket säkerställer att uppgifterna slutförs korrekt och effektivt. Även om det primära fokus ofta ligger på att skapa själva verktyget, är det lika viktigt att förstå hur man hanterar agentens arbetsflöde och undviker analysfel. Fel som "parseResult på ToolCallingAgentOutputParser fungerar bara på ChatGeneration-utdata" uppstår vanligtvis när agentens utdata inte är kompatibel med analyssystemet, vilket framhäver behovet av korrekt anpassning mellan agentens utdata och det förväntade formatet.

Användningen av promptmallar, som t.ex , berikar interaktionen ytterligare genom att tillåta dynamiska meddelanden och kontextplatshållare. Detta gör att agenten kan justera sina svar baserat på chatthistoriken eller agentens scratchpad. Att optimera promptmallarna och se till att agentens utdata analyseras korrekt kan förhindra många vanliga fel, vilket gör dina Langchain.js-applikationer mer tillförlitliga och effektiva.

1. Vad är en agent i Langchain.js?
2. En agent är en komponent som interagerar med verktyg och språkmodeller för att utföra specifika uppgifter baserat på en användarfråga. Den använder funktion för att utlösa verktyg.
3. Hur löser du felet "parseResult on ToolCallingAgentOutputParser"?
4. Det här felet uppstår när agentens utdata är inkompatibelt med parsern. Se till att utdata matchar vad parsern förväntar sig och använd en utdataformat.
5. Vad är syftet med ?
6. De hanterar exekveringen av agenten och dess verktyg, så att du kan köra komplexa arbetsflöden i Langchain.js-applikationer.
7. Hur gör arbete?
8. organiserar chattmeddelanden i ett strukturerat format, vilket gör att dynamiskt innehåll som chatthistorik och agentscratchpad kan infogas i konversationsflödet.
9. Varför är det används i verktyget?
10. används för indatavalidering, vilket säkerställer att indata till det anpassade verktyget är av rätt typ (t.ex. ett nummer), vilket minskar risken för fel.

Att lösa felet "parseResult on ToolCallingAgentOutputParser fungerar bara på ChatGeneration-utdata" kräver noggrann anpassning mellan utdata från din agent och dess parsningsförväntningar. Med rätt tillvägagångssätt kan detta fel undvikas.

Genom att använda lämpliga verktyg som Zod för validering och säkerställa att agenter, som de som byggts med Ollama, hanterar ingångar och utdata korrekt, kan du skapa robusta lösningar i Langchain.js utan att stöta på parsningsproblem.