Langchain.js ToolCallingAgentOutputParser klaidos taisymas naudojant Ollama LLM ir pasirinktinį įrankį

„ToolCallingAgentOutputParser“ klaidų supratimas ir taisymas Langchain.js

Dirbdami su Langchain.js v2, kūrėjai dažnai siekia sukurti efektyvius agentus naudodami pasirinktinius įrankius ir kalbos modelius, pvz., Ollama. Tačiau integruojant šiuos komponentus kartais gali atsirasti klaidų, kurias sunku derinti.

Viena iš tokių klaidų yra „parseResult on ToolCallingAgentOutputParser veikia tik su ChatGeneration išvestimi“, kuri gali atsirasti kuriant pasirinktinį įrankį agento sistemoje. Norint užtikrinti, kad agentas ir įrankis veiktų tinkamai, labai svarbu suprasti pagrindinę šios problemos priežastį.

Šiame straipsnyje nagrinėjamas paprastas pasirinktinio įrankio, kuris prideda 2 prie skaičiaus įvesties, įgyvendinimas naudojant Langchain CreateToolCallingAgent ir Ollama modelį. Analizuodami klaidą ir jos kontekstą, galime geriau suprasti, kaip ją pašalinti.

Tolesniuose skyriuose bus pateikta informacija apie kodą, paaiškinama klaida ir pateikiami šios problemos sprendimo būdai. Nesvarbu, ar esate Langchain.js naujokas, ar jau patyręs, šis vadovas padės efektyviai išspręsti šią problemą.

„Langchain.js“ tinkinto įrankio ir agento klaidų tvarkymo supratimas

Pateiktame pavyzdyje dirbame su Langchain.js v2, kad sukurtume tinkintą įrankį, kuris integruojasi su Ollama kalbos modelis. Pagrindinis įrankio tikslas – atlikti paprastą matematinį veiksmą: prie įvesties reikšmės pridėti 2. Įrankis sukurtas naudojant Langchain's įrankis funkcija, kuri apibrėžia daugkartinio naudojimo funkcijas, kurias gali iškviesti agentas. Kad įrankis veiktų tinkamai, įvesties schema patvirtinama naudojant Zod biblioteką, garantuojant, kad įvestis yra tinkamas skaičius. Tai užtikrina tinkamą klaidų tvarkymą ir neleidžia įrankiui sugesti dėl netinkamų įvesties.

Tada pasirinktinis įrankis įtraukiamas į agentą naudojant CreateToolCallingAgent funkcija. Ši komanda leidžia agentui prireikus iškviesti įrankį, o agentą maitina Ollama modelis, sukonfigūruotas naudojant specifinius parametrus, tokius kaip temperatūra, kad būtų galima valdyti atsakymų kūrybiškumą. Siekiant palengvinti sklandžią agento ir įrankio sąveiką, naudojamas pokalbio raginimo šablonas. Šis šablonas organizuoja pokalbį apibrėždamas skirtingus pranešimų tipus, pvz., sistemos pranešimus, žmogaus įvestį ir vietos rezervavimo ženklus. Vietos žymekliai, pvz MessagesPlaceholder, kad pokalbis būtų dinamiškas, įtraukiant tokius elementus kaip pokalbių istorija.

Viena iš pagrindinių šiame pavyzdyje nagrinėjamų problemų yra klaidų, susijusių su Langchain agento išvesties analizavimu, tvarkymas. Klaidos pranešimas „parseResult on ToolCallingAgentOutputParser veikia tik naudojant „ChatGeneration“ išvestį“ atsiranda dėl to, kad išvesties tipas, kurio tikimasi analizuoti, neatitinka tikrosios sugeneruotos išvesties. Norint ištaisyti šią klaidą, tinkintas įrankis yra suvyniotas į tvirtą logiką, užtikrinančią, kad visos įvesties ir išvestys atitiktų numatytus formatus. Tai toliau valdo Agentas Vykdytojas klasė, kuri koordinuoja agento ir įrankių vykdymą, užtikrindama, kad užklausa ir įrankio išvestis būtų tinkamai sinchronizuoti.

Galiausiai, scenarijai įgyvendina asinchroninį vykdymą naudodami laukti, leidžianti sistemai atlikti operacijas neblokuojant kitų procesų. Prieš tęsdamas agentas laukia, kol įrankis pateiks rezultatą, užtikrindamas, kad atsakymas būtų tikslus ir savalaikis. Be to, įtraukiami vienetų testai, siekiant patvirtinti įrankio funkcionalumą ir užtikrinti, kad jis nuosekliai duoda teisingą išvestį. Šie testai ne tik patvirtina matematinį įrankio veikimą, bet ir patikrina, kaip gerai jis apdoroja netinkamą įvestį, pagerindamas bendrą sprendimo patikimumą. Dėl šios modulinės ir klaidoms atsparios konstrukcijos scenarijus galima pakartotinai naudoti ir jie yra veiksmingi įvairioms Langchain.js programoms.

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

„Langchain.js“ ir „Ollama LLM integracijos“ agentų vaidmens tyrinėjimas

Dirbant su Langchain.js, integruojant agentai su įrankiais ir kalbos modeliais, tokiais kaip „Ollama“, yra svarbus dinaminių programų kūrimo aspektas. Agentas leidžia prijungti pasirinktinį įrankį, kuris atlieka konkrečias užduotis, su kalbos modeliu, kuris tvarko daugiau pokalbio ar generavimo užduotis. Naudodami agentus kūrėjai gali automatizuoti darbo eigą, kai modelis ne tik generuoja atsakymus, bet ir iškviečia įrankius skaičiavimams ar duomenų apdorojimui atlikti.

Pagrindinis šios integracijos komponentas yra CreateToolCallingAgent funkcija. Ši funkcija leidžia agentui prireikus paleisti konkrečius įrankius, užtikrinant, kad užduotys būtų atliekamos tiksliai ir efektyviai. Nors pagrindinis dėmesys dažnai skiriamas paties įrankio kūrimui, taip pat svarbu suprasti, kaip valdyti agento darbo eigą ir išvengti analizavimo klaidų. Klaidos, pvz., „parseResult on ToolCallingAgentOutputParser veikia tik su ChatGeneration išvestimi“, dažniausiai atsiranda, kai agento išvestis nesuderinama su analizavimo sistema, todėl pabrėžiamas poreikis tinkamai suderinti agento išvestį ir numatomą formatą.

Ragiklių šablonų naudojimas, pvz ChatPromptTemplate, dar labiau praturtina sąveiką leisdama dinamiškus pranešimus ir konteksto rezervuarus. Tai leidžia agentui koreguoti savo atsakymus pagal pokalbių istoriją arba agento bloknotą. Optimizavus raginimo šablonus ir užtikrinant, kad agento išvestis būtų tinkamai analizuojama, galima išvengti daugelio įprastų klaidų, todėl jūsų Langchain.js programos tampa patikimesnės ir efektyvesnės.