Reparation af Langchain.js's ToolCallingAgentOutputParser-fejl med Ollama LLM og et brugerdefineret værktøj

Forståelse og rettelse af ToolCallingAgentOutputParser-fejl i Langchain.js

Når man arbejder med Langchain.js v2, sigter udviklere ofte efter at skabe effektive agenter ved hjælp af brugerdefinerede værktøjer og sprogmodeller som Ollama. Men integration af disse komponenter kan nogle gange føre til fejl, der er svære at fejlfinde.

En sådan fejl er "parseResult on ToolCallingAgentOutputParser virker kun på ChatGeneration-output", som kan opstå, når man bygger et brugerdefineret værktøj inden for agentrammen. At forstå årsagen til dette problem er afgørende for at sikre, at agenten og værktøjet fungerer korrekt.

Denne artikel udforsker en simpel implementering af et brugerdefineret værktøj, der tilføjer 2 til et tal-input ved hjælp af Langchains createToolCallingAgent og Ollama-modellen. Ved at analysere fejlen og dens kontekst kan vi bedre forstå, hvordan man fejlfinder den.

De følgende afsnit vil guide dig gennem koden, forklare fejlen og give løsninger til at løse dette problem. Uanset om du er ny til Langchain.js eller erfaren, vil denne guide hjælpe dig med at komme effektivt forbi dette problem.

Kommando	Eksempel på brug
tool()	Denne funktion fra Langchain.js definerer et brugerdefineret værktøj, der udfører en operation. I denne artikel bruges det til at oprette et værktøj, der føjer 2 til et inputnummer, og pakker logikken ind i en struktur, der er let at kalde.
z.object()	En del af Zod-biblioteket, der bruges til skemavalidering i Langchain. Dette sikrer, at input til det brugerdefinerede værktøj er et tal, hvilket giver stærk inputvalidering for at forhindre fejl under udførelse.
createToolCallingAgent()	Denne kommando opretter en agent, der kan kalde de definerede værktøjer som svar på brugerforespørgsler. Det er nøglen til at integrere værktøjer med sprogmodeller som Ollama, hvilket gør det muligt at påberåbe sig værktøjer under samtale.
ChatPromptTemplate.fromMessages()	Bruges til at generere en chat-promptskabelon med pladsholdere. Denne skabelon organiserer forskellige typer meddelelser (system, mennesker, pladsholdere), som agenten kan bruge, hvilket forbedrer dens samtaleflow.
MessagesPlaceholder	Fungerer som en pladsholder i promptskabelonen for dynamisk indhold, såsom chathistorik eller agentscratchpad. Dette gør det muligt for samtalekonteksten at blive injiceret dynamisk under udførelsen.
AgentExecutor()	Denne klasse styrer udførelsen af ​​agenter og værktøjer. I eksemplet hjælper det med at køre forespørgslen gennem agenten og indsamle resultatet fra værktøjets output.
await agentExecutor.invoke()	Bruges til at køre forespørgslen gennem agenten og vente på resultatet asynkront. Dette er afgørende for interaktion med sprogmodeller og værktøjer, da det sikrer, at koden venter på, at operationen er fuldført, før den går videre.
try-catch	Denne fejlhåndteringsstruktur bruges i det tilpassede værktøj til at fange ugyldige inputtyper. Ved at fange undtagelser sikrer det, at systemet returnerer nyttige fejlmeddelelser uden at bryde eksekveringsflowet.
expect()	Fra Chai assertion-biblioteket bruges expect() i enhedstesten til at verificere outputtet af det brugerdefinerede værktøj. Det er vigtigt for at teste, om værktøjet fungerer som forventet.

Forståelse af brugerdefineret værktøj og agentfejlhåndtering i Langchain.js

I det angivne eksempel arbejder vi med Langchain.js v2 for at skabe et brugerdefineret værktøj, der integreres med sprogmodel. Hovedformålet med værktøjet er at udføre en simpel matematisk operation: at tilføje 2 til inputværdien. Værktøjet er bygget ved hjælp af Langchain's funktion, som definerer genanvendelige funktioner, der kan aktiveres af en agent. For at sikre, at værktøjet fungerer korrekt, valideres inputskemaet med Zod-biblioteket, hvilket garanterer, at inputtet er et gyldigt tal. Dette sikrer korrekt fejlhåndtering og forhindrer, at værktøjet fejler på grund af ugyldige input.

Det brugerdefinerede værktøj inkorporeres derefter i en agent ved hjælp af fungere. Denne kommando giver agenten mulighed for at kalde værktøjet, når det er nødvendigt, og agenten drives af Ollama-modellen, som er konfigureret med specifikke parametre såsom temperatur for at kontrollere kreativiteten af ​​svarene. For at lette gnidningsfri interaktion mellem agenten og værktøjet bruges en chat-promptskabelon. Denne skabelon organiserer samtalen ved at definere forskellige typer meddelelser, såsom systemmeddelelser, menneskelige input og pladsholdere. Pladsholderne, som f.eks , lad samtalen være dynamisk, med elementer som chathistorikken inkluderet.

Et af de vigtigste problemer, der behandles i dette eksempel, er fejlhåndteringen omkring Langchain-agentens outputparsing. Fejlmeddelelsen "parseResult på ToolCallingAgentOutputParser virker kun på ChatGeneration-output" stammer fra et misforhold mellem den type output, der forventes af parseren, og det faktisk genererede output. For at håndtere denne fejl er det brugerdefinerede værktøj pakket ind i robust logik, der sikrer, at alle input og output er i overensstemmelse med forventede formater. Dette styres yderligere af klasse, som koordinerer udførelsen af ​​agenten og værktøjerne, hvilket sikrer, at forespørgslen og værktøjsoutputtet er korrekt synkroniseret.

Endelig implementerer scripterne asynkron eksekvering vha , hvilket gør det muligt for systemet at håndtere operationer uden at blokere andre processer. Agenten venter på, at værktøjet returnerer sit resultat, før han fortsætter, og sikrer, at svaret er både præcist og rettidigt. Derudover er enhedstest inkluderet for at validere værktøjets funktionalitet, hvilket sikrer, at det konsekvent producerer det korrekte output. Disse test bekræfter ikke kun værktøjets matematiske funktion, men kontrollerer også, hvor godt det håndterer ugyldige input, hvilket forbedrer løsningens overordnede pålidelighed. Dette modulære og fejlresistente design gør scripts genanvendelige og effektive til forskellige applikationer inden for 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);
});

Udforskning af agenternes rolle i Langchain.js og Ollama LLM-integration

Når du arbejder med Langchain.js, integrerer med værktøjer og sprogmodeller som Ollama er et kritisk aspekt af opbygningen af ​​dynamiske applikationer. En agent giver dig mulighed for at forbinde et tilpasset værktøj, som udfører specifikke opgaver, til en sprogmodel, som håndterer mere samtale eller generative opgaver. Ved at bruge agenter kan udviklere automatisere arbejdsgange, hvor en model ikke kun genererer svar, men også påberåber sig værktøjer til at udføre beregninger eller databehandling.

Nøglekomponenten i denne integration er fungere. Denne funktion lader agenten udløse specifikke værktøjer, når det er nødvendigt, hvilket sikrer, at opgaver udføres præcist og effektivt. Selvom det primære fokus ofte er på at skabe selve værktøjet, er det lige så vigtigt at forstå, hvordan man administrerer agentens arbejdsgang og undgår parsingsfejl. Fejl som "parseResult på ToolCallingAgentOutputParser virker kun på ChatGeneration-output" opstår normalt, når agentens output ikke er kompatibelt med parsingsystemet, hvilket fremhæver behovet for korrekt justering mellem agentens output og det forventede format.

Brugen af ​​promptskabeloner, som f.eks , beriger interaktionen yderligere ved at tillade dynamiske beskeder og kontekstpladsholdere. Dette giver agenten mulighed for at justere sine svar baseret på chathistorikken eller agentens scratchpad. At optimere promptskabelonerne og sikre, at agentens output er korrekt parset, kan forhindre mange almindelige fejl, hvilket gør dine Langchain.js-applikationer mere pålidelige og effektive.

1. Hvad er en agent i Langchain.js?
2. En agent er en komponent, der interagerer med værktøjer og sprogmodeller for at udføre specifikke opgaver baseret på en brugerforespørgsel. Den bruger funktion til at udløse værktøjer.
3. Hvordan løser du fejlen "parseResult on ToolCallingAgentOutputParser"?
4. Denne fejl opstår, når agentens output er inkompatibelt med parseren. Sørg for, at outputtet matcher, hvad parseren forventer, og brug en output format.
5. Hvad er formålet med ?
6. De styrer udførelsen af ​​agenten og dens værktøjer, så du kan køre komplekse arbejdsgange i Langchain.js-applikationer.
7. Hvordan gør arbejde?
8. organiserer chatbeskeder i et struktureret format, hvilket gør det muligt at indsætte dynamisk indhold såsom chathistorik og agentscratchpad i samtaleforløbet.
9. Hvorfor er bruges i værktøjet?
10. bruges til inputvalidering, hvilket sikrer, at input til det tilpassede værktøj er af den korrekte type (f.eks. et tal), hvilket reducerer chancerne for fejl.

At løse fejlen "parseResult på ToolCallingAgentOutputParser virker kun på ChatGeneration output" kræver omhyggelig justering mellem outputtet fra din agent og dens parsing forventninger. Med den rigtige tilgang kan denne fejl undgås.

Ved at bruge passende værktøjer som Zod til validering og sikre, at agenter, såsom dem, der er bygget med Ollama, håndterer input og output korrekt, kan du skabe robuste løsninger i Langchain.js uden at støde på parsingsproblemer.