De ToolCallingAgentOutputParser-fout van Langchain.js repareren met Ollama LLM en een aangepaste tool

ToolCallingAgentOutputParser-fouten in Langchain.js begrijpen en oplossen

Bij het werken met Langchain.js v2 streven ontwikkelaars er vaak naar efficiënte agenten te creëren met behulp van aangepaste tools en taalmodellen zoals Ollama. De integratie van deze componenten kan echter soms leiden tot fouten die moeilijk te debuggen zijn.

Eén zo'n fout is de "parseResult on ToolCallingAgentOutputParser werkt alleen op ChatGeneration-uitvoer", die kan optreden bij het bouwen van een aangepaste tool binnen het agentframework. Het begrijpen van de hoofdoorzaak van dit probleem is van cruciaal belang om ervoor te zorgen dat de agent en tool correct werken.

Dit artikel onderzoekt een eenvoudige implementatie van een aangepaste tool die 2 optelt bij een getalinvoer, met behulp van Langchain's createToolCallingAgent en het Ollama-model. Door de fout en de context ervan te analyseren, kunnen we beter begrijpen hoe we deze kunnen oplossen.

In de volgende secties wordt u door de code geleid, wordt de fout uitgelegd en worden oplossingen geboden om dit probleem op te lossen. Of u nu nieuw bent bij Langchain.js of ervaren bent, deze handleiding helpt u dit probleem efficiënt te omzeilen.

Inzicht in de aangepaste tool en agentfoutafhandeling in Langchain.js

In het gegeven voorbeeld werken we met Langchain.js v2 om een ​​aangepaste tool te maken die kan worden geïntegreerd met de Ollama taalmodel. Het belangrijkste doel van de tool is het uitvoeren van een eenvoudige wiskundige bewerking: het optellen van 2 bij de invoerwaarde. De tool is gebouwd met behulp van Langchain's hulpmiddel function, die herbruikbare functies definieert die door een agent kunnen worden aangeroepen. Om ervoor te zorgen dat de tool correct werkt, wordt het invoerschema gevalideerd met de Zod-bibliotheek, waardoor wordt gegarandeerd dat de invoer een geldig getal is. Dit zorgt voor een goede foutafhandeling en voorkomt dat de tool faalt vanwege ongeldige invoer.

De aangepaste tool wordt vervolgens opgenomen in een agent met behulp van de createToolCallingAgent functie. Met dit commando kan de agent de tool oproepen wanneer dat nodig is, en de agent wordt aangedreven door het Ollama-model, dat is geconfigureerd met specifieke parameters zoals temperatuur om de creativiteit van de reacties te controleren. Om een ​​soepele interactie tussen de agent en de tool te vergemakkelijken, wordt een chatprompt-sjabloon gebruikt. Deze sjabloon organiseert het gesprek door verschillende soorten berichten te definiëren, zoals systeemberichten, menselijke input en tijdelijke aanduidingen. De tijdelijke aanduidingen, zoals BerichtenPlaceholder, zorg ervoor dat het gesprek dynamisch is, waarbij elementen zoals de chatgeschiedenis worden opgenomen.

Een van de belangrijkste problemen die in dit voorbeeld aan de orde komen, is de foutafhandeling rond de uitvoerparsering van de Langchain-agent. De foutmelding "parseResult on ToolCallingAgentOutputParser werkt alleen op ChatGeneration-uitvoer" komt voort uit een discrepantie tussen het type uitvoer dat door de parser wordt verwacht en de feitelijk gegenereerde uitvoer. Om deze fout op te lossen, is de aangepaste tool verpakt in robuuste logica, waardoor wordt gegarandeerd dat alle invoer en uitvoer voldoen aan de verwachte formaten. Dit wordt verder beheerd door de AgentUitvoerder class, die de uitvoering van de agent en tools coördineert en ervoor zorgt dat de query- en tooluitvoer correct worden gesynchroniseerd.

Ten slotte implementeren de scripts asynchrone uitvoering met behulp van wachten, waardoor het systeem bewerkingen kan uitvoeren zonder andere processen te blokkeren. De agent wacht tot de tool het resultaat retourneert voordat hij verder gaat, zodat de reactie zowel accuraat als tijdig is. Bovendien zijn er unit-tests opgenomen om de functionaliteit van de tool te valideren, zodat deze consistent de juiste uitvoer produceert. Deze tests bevestigen niet alleen de wiskundige werking van de tool, maar controleren ook hoe goed deze omgaat met ongeldige invoer, waardoor de algehele betrouwbaarheid van de oplossing wordt verbeterd. Dit modulaire en foutbestendige ontwerp maakt de scripts herbruikbaar en effectief voor verschillende toepassingen binnen 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);
});

Onderzoek naar de rol van agenten in de integratie van Langchain.js en Ollama LLM

Bij het werken met Langchain.js, integreren agenten met tools en taalmodellen zoals Ollama is een cruciaal aspect bij het bouwen van dynamische applicaties. Met een agent kunt u een aangepaste tool, die specifieke taken uitvoert, koppelen aan een taalmodel dat meer conversatie- of generatieve taken afhandelt. Door agents te gebruiken kunnen ontwikkelaars workflows automatiseren waarbij een model niet alleen reacties genereert, maar ook tools aanroept om berekeningen of gegevensverwerking uit te voeren.

Het belangrijkste onderdeel van deze integratie is de createToolCallingAgent functie. Met deze functie kan de agent specifieke tools activeren wanneer dat nodig is, zodat taken nauwkeurig en efficiënt worden uitgevoerd. Hoewel de primaire focus vaak ligt op het maken van de tool zelf, is het net zo belangrijk om te begrijpen hoe u de workflow van de agent kunt beheren en parseerfouten kunt voorkomen. Fouten zoals "parseResult on ToolCallingAgentOutputParser werkt alleen op ChatGeneration-uitvoer" treden meestal op wanneer de uitvoer van de agent niet compatibel is met het parseersysteem, wat de noodzaak benadrukt van een goede afstemming tussen de uitvoer van de agent en het verwachte formaat.

Het gebruik van promptsjablonen, zoals ChatPrompt-sjabloon, verrijkt de interactie verder door dynamische berichten en tijdelijke aanduidingen voor context toe te staan. Hierdoor kan de agent zijn antwoorden aanpassen op basis van de chatgeschiedenis of het kladblok van de agent. Door de promptsjablonen te optimaliseren en ervoor te zorgen dat de uitvoer van de agent correct wordt geparseerd, kunnen veel veelvoorkomende fouten worden voorkomen, waardoor uw Langchain.js-applicaties betrouwbaarder en efficiënter worden.