Retting av Langchain.js's ToolCallingAgentOutputParser-feil med Ollama LLM og et tilpasset verktøy

Forstå og fikse ToolCallingAgentOutputParser-feil i Langchain.js

Når de jobber med Langchain.js v2, har utviklere ofte som mål å lage effektive agenter ved å bruke tilpassede verktøy og språkmodeller som Ollama. Imidlertid kan integrering av disse komponentene noen ganger føre til feil som er vanskelige å feilsøke.

En slik feil er "parseResult on ToolCallingAgentOutputParser fungerer bare på ChatGeneration-utdata," som kan oppstå når du bygger et tilpasset verktøy innenfor agentrammeverket. Å forstå årsaken til dette problemet er avgjørende for å sikre at agenten og verktøyet fungerer riktig.

Denne artikkelen utforsker en enkel implementering av et tilpasset verktøy som legger til 2 til en tallinndata, ved å bruke Langchains createToolCallingAgent og Ollama-modellen. Ved å analysere feilen og dens kontekst kan vi bedre forstå hvordan vi feilsøker den.

De følgende delene vil veilede deg gjennom koden, forklare feilen og gi løsninger for å løse dette problemet. Enten du er ny på Langchain.js eller erfaren, vil denne veiledningen hjelpe deg å komme deg forbi dette problemet effektivt.

Forstå det tilpassede verktøyet og agentfeilhåndtering i Langchain.js

I eksemplet som er gitt, jobber vi med Langchain.js v2 for å lage et tilpasset verktøy som integreres med Ollama språkmodell. Hovedformålet med verktøyet er å utføre en enkel matematisk operasjon: å legge til 2 til inngangsverdien. Verktøyet er bygget ved hjelp av Langchains verktøy funksjon, som definerer gjenbrukbare funksjoner som kan påkalles av en agent. For å sikre at verktøyet fungerer riktig, valideres inndataskjemaet med Zod-biblioteket, og garanterer at inndata er et gyldig nummer. Dette sikrer riktig feilhåndtering og forhindrer at verktøyet svikter på grunn av ugyldige inndata.

Det tilpassede verktøyet blir deretter integrert i en agent ved hjelp av createToolCallingAgent funksjon. Denne kommandoen lar agenten ringe verktøyet ved behov, og agenten drives av Ollama-modellen, som er konfigurert med spesifikke parametere som temperatur for å kontrollere kreativiteten til svarene. For å lette jevn interaksjon mellom agenten og verktøyet, brukes en chat-promptmal. Denne malen organiserer samtalen ved å definere ulike typer meldinger, for eksempel systemmeldinger, menneskelig input og plassholdere. Plassholderne, som f.eks MeldingerPlassholder, la samtalen være dynamisk, med elementer som chatteloggen inkludert.

Et av hovedproblemene som tas opp i dette eksemplet er feilhåndteringen rundt Langchain-agentens utdataparsing. Feilmeldingen "parseResult on ToolCallingAgentOutputParser fungerer bare på ChatGeneration-utdata" stammer fra et misforhold mellom typen utdata som forventes av parseren og den faktiske utgangen som genereres. For å håndtere denne feilen er det tilpassede verktøyet pakket inn i robust logikk, som sikrer at alle innganger og utganger samsvarer med forventede formater. Dette administreres videre av AgentExecutor klasse, som koordinerer utførelsen av agenten og verktøyene, og sørger for at spørringen og verktøyutgangen er riktig synkronisert.

Til slutt implementerer skriptene asynkron kjøring ved hjelp av avvente, slik at systemet kan håndtere operasjoner uten å blokkere andre prosesser. Agenten venter på at verktøyet skal returnere resultatet før han fortsetter, og sikrer at svaret er både nøyaktig og rettidig. I tillegg er enhetstester inkludert for å validere verktøyets funksjonalitet, for å sikre at det konsekvent produserer riktig utgang. Disse testene bekrefter ikke bare verktøyets matematiske operasjon, men sjekker også hvor godt det håndterer ugyldige input, noe som forbedrer den generelle påliteligheten til løsningen. Denne modulære og feilbestandige designen gjør skriptene gjenbrukbare og effektive for ulike applikasjoner innenfor 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);
});

Utforsker rollen til agenter i Langchain.js og Ollama LLM-integrasjon

Når du arbeider med Langchain.js, integrerer agenter med verktøy og språkmodeller som Ollama er et kritisk aspekt ved å bygge dynamiske applikasjoner. En agent lar deg koble et tilpasset verktøy, som utfører spesifikke oppgaver, til en språkmodell, som håndterer mer samtale eller generative oppgaver. Ved å bruke agenter kan utviklere automatisere arbeidsflyter der en modell ikke bare genererer svar, men også påkaller verktøy for å utføre beregninger eller databehandling.

Nøkkelkomponenten i denne integrasjonen er createToolCallingAgent funksjon. Denne funksjonen lar agenten utløse spesifikke verktøy når det er nødvendig, og sikrer at oppgavene utføres nøyaktig og effektivt. Mens hovedfokuset ofte er på å lage selve verktøyet, er det like viktig å forstå hvordan man administrerer agentens arbeidsflyt og unngår parsefeil. Feil som "parseResult på ToolCallingAgentOutputParser fungerer bare på ChatGeneration-utdata" oppstår vanligvis når agentens utdata ikke er kompatibelt med parsingsystemet, noe som fremhever behovet for riktig justering mellom agentens utdata og det forventede formatet.

Bruken av ledetekstmaler, som f.eks ChatPromptTemplate, beriker interaksjonen ytterligere ved å tillate dynamiske meldinger og kontekstplassholdere. Dette lar agenten justere svarene sine basert på chatteloggen eller agentens skrapelodd. Å optimalisere forespørselsmalene og sikre at agentens utdata er korrekt analysert kan forhindre mange vanlige feil, noe som gjør Langchain.js-applikasjonene dine mer pålitelige og effektive.