Langchain.js'i ToolCallingAgentOutputParseri vea parandamine Ollama LLM-i ja kohandatud tööriistaga

ToolCallingAgentOutputParseri vigade mõistmine ja parandamine failis Langchain.js

Langchain.js v2-ga töötades püüavad arendajad sageli luua tõhusaid agente, kasutades kohandatud tööriistu ja keelemudeleid, nagu Ollama. Kuid nende komponentide integreerimine võib mõnikord põhjustada vigu, mida on raske siluda.

Üks selline viga on "parseResult on ToolCallingAgentOutputParser töötab ainult ChatGenerationi väljundis", mis võib ilmneda kohandatud tööriista loomisel agendi raamistikus. Selle probleemi algpõhjuse mõistmine on agendi ja tööriista õige töö tagamiseks ülioluline.

See artikkel uurib kohandatud tööriista lihtsat rakendamist, mis lisab numbrisisendile 2, kasutades Langchaini CreateToolCallingAgenti ja Ollama mudelit. Viga ja selle konteksti analüüsides saame paremini aru, kuidas seda tõrkeotsingut teha.

Järgmised jaotised juhendavad teid koodiga, selgitavad viga ja pakuvad lahendusi selle probleemi lahendamiseks. Olenemata sellest, kas olete Langchain.js-i uus kasutaja või kogenud, aitab see juhend teil sellest probleemist tõhusalt mööda minna.

Langchain.js kohandatud tööriista ja agendi tõrkekäsitluse mõistmine

Esitatud näites töötame koos Langchain.js v2-ga, et luua kohandatud tööriist, mis integreerub rakendusega Ollama keelemudel. Tööriista põhieesmärk on sooritada lihtne matemaatiline tehe: lisada sisendväärtusele 2. Tööriist on ehitatud Langchaini abil tööriist funktsioon, mis määratleb korduvkasutatavad funktsioonid, mida agent saab käivitada. Tööriista õige töö tagamiseks valideeritakse sisendskeem Zodi teegiga, tagades, et sisend on kehtiv number. See tagab õige vigade käsitlemise ja hoiab ära tööriista rikke vigaste sisendite tõttu.

Seejärel lisatakse kohandatud tööriist agendisse, kasutades CreateToolCallingAgent funktsiooni. See käsk võimaldab agendil vajadusel tööriista kutsuda ja agenti toidab Ollama mudel, mis on konfigureeritud konkreetsete parameetritega, nagu temperatuur, et juhtida vastuste loovust. Agendi ja tööriista vahelise sujuva suhtlemise hõlbustamiseks kasutatakse vestluse viipa malli. See mall korraldab vestlust, määratledes eri tüüpi sõnumeid, nagu süsteemisõnumid, inimsisend ja kohahoidjad. Kohahoidjad, nagu näiteks SõnumidPlaceholder, võimaldab vestlusel olla dünaamiline, kaasates selliseid elemente nagu vestluste ajalugu.

Üks selles näites käsitletud põhiprobleeme on Langchaini agendi väljundi sõelumise vigade käsitlemine. Veateade "parseResult on ToolCallingAgentOutputParser töötab ainult ChatGenerationi väljundis" tuleneb parseri oodatava väljundi tüübi ja tegeliku loodud väljundi mittevastavusest. Selle vea käsitlemiseks on kohandatud tööriist pakitud tugevasse loogikasse, tagades, et kõik sisendid ja väljundid vastavad eeldatavatele vormingutele. Seda haldab veelgi AgentExecutor klass, mis koordineerib agendi ja tööriistade täitmist, veendudes, et päring ja tööriista väljund on korralikult sünkroonitud.

Lõpuks rakendavad skriptid asünkroonset täitmist kasutades ootama, mis võimaldab süsteemil toiminguid teha ilma teisi protsesse blokeerimata. Agent ootab enne jätkamist, kuni tööriist oma tulemuse tagastab, tagades, et vastus on nii täpne kui ka õigeaegne. Lisaks on tööriista funktsionaalsuse kinnitamiseks kaasatud ühikutestid, tagades, et see annab järjepidevalt õiget väljundit. Need testid mitte ainult ei kinnita tööriista matemaatilist toimimist, vaid kontrollivad ka seda, kui hästi see käsitleb kehtetut sisendit, parandades lahenduse üldist töökindlust. See modulaarne ja veakindel disain muudab skriptid korduvkasutatavaks ja tõhusaks mitmesugustes Langchain.js-i rakendustes.

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);
});

Agentide rolli uurimine rakenduses Langchain.js ja Ollama LLM-i integratsioon

Langchain.js-iga töötamisel integreerimine agendid tööriistade ja keelemudelitega nagu Ollama on dünaamiliste rakenduste loomise oluline aspekt. Agent võimaldab teil ühendada kohandatud tööriista, mis täidab konkreetseid ülesandeid, keelemudeliga, mis käsitleb vestlus- või generatiivsemaid ülesandeid. Agente kasutades saavad arendajad automatiseerida töövooge, kus mudel mitte ainult ei genereeri vastuseid, vaid kutsub ka tööriistu arvutuste tegemiseks või andmetöötluseks.

Selle integratsiooni põhikomponent on CreateToolCallingAgent funktsiooni. See funktsioon võimaldab agendil vajadusel konkreetseid tööriistu käivitada, tagades ülesannete täpse ja tõhusa täitmise. Kuigi põhirõhk on sageli tööriista enda loomisel, on sama oluline mõista, kuidas hallata agendi töövoogu ja vältida sõelumisvigu. Sellised vead nagu "parseResult on ToolCallingAgentOutputParser töötab ainult ChatGenerationi väljundis" ilmnevad tavaliselt siis, kui agendi väljund ei ühildu sõelumissüsteemiga, rõhutades vajadust agendi väljundi ja eeldatava vormingu õige joondamise järele.

Viipade mallide kasutamine, nt ChatPromptMall, rikastab suhtlust veelgi, võimaldades dünaamilisi sõnumeid ja kontekstikohahoidjaid. See võimaldab agendil kohandada oma vastuseid vestlusajaloo või agendi märkmiku põhjal. Viibamallide optimeerimine ja agendi väljundite õige sõelumise tagamine võib ära hoida paljusid levinud vigu, muutes teie Langchain.js rakendused töökindlamaks ja tõhusamaks.