Oprava chyby ToolCallingAgentOutputParser Langchain.js pomocou Ollama LLM a vlastného nástroja

Pochopenie a oprava chýb ToolCallingAgentOutputParser v Langchain.js

Pri práci s Langchain.js v2 sa vývojári často zameriavajú na vytváranie efektívnych agentov pomocou vlastných nástrojov a jazykových modelov, ako je Ollama. Integrácia týchto komponentov však môže niekedy viesť k chybám, ktoré sa ťažko ladia.

Jednou z takýchto chýb je „parseResult on ToolCallingAgentOutputParser funguje iba na výstupe ChatGeneration“, ktorá sa môže vyskytnúť pri vytváraní vlastného nástroja v rámci agenta. Pochopenie hlavnej príčiny tohto problému je kľúčové na zabezpečenie správneho fungovania agenta a nástroja.

Tento článok skúma jednoduchú implementáciu vlastného nástroja, ktorý k číselnému vstupu pridáva 2, pomocou createToolCallingAgent spoločnosti Langchain a modelu Ollama. Analýzou chyby a jej kontextu môžeme lepšie pochopiť, ako ju odstrániť.

Nasledujúce časti vás prevedú kódom, vysvetlia chybu a poskytnú riešenia na vyriešenie tohto problému. Či už ste v Langchain.js nováčik alebo skúsený, táto príručka vám pomôže efektívne prekonať tento problém.

Pochopenie Custom Tool and Agent Error Handling v Langchain.js

V uvedenom príklade pracujeme s Langchain.js v2 na vytvorení vlastného nástroja, ktorý sa integruje s Ollama jazykový model. Hlavným účelom nástroja je vykonať jednoduchú matematickú operáciu: pridanie 2 k vstupnej hodnote. Nástroj je vytvorený pomocou Langchain's nástroj funkcia, ktorá definuje opätovne použiteľné funkcie, ktoré môže agent vyvolať. Aby sa zabezpečilo správne fungovanie nástroja, vstupná schéma je overená knižnicou Zod, čo zaručuje, že vstup je platným číslom. To zaisťuje správne spracovanie chýb a zabraňuje zlyhaniu nástroja v dôsledku neplatných vstupov.

Vlastný nástroj je potom začlenený do agenta pomocou createToolCallingAgent funkciu. Tento príkaz umožňuje agentovi zavolať nástroj, keď je to potrebné, a agent je poháňaný modelom Ollama, ktorý je nakonfigurovaný so špecifickými parametrami, ako je teplota, na kontrolu kreativity odpovedí. Na uľahčenie hladkej interakcie medzi agentom a nástrojom sa používa šablóna výzvy na rozhovor. Táto šablóna organizuje konverzáciu definovaním rôznych typov správ, ako sú systémové správy, ľudský vstup a zástupné symboly. Zástupné symboly, ako napr Zástupný symbol správ, umožňujú, aby bola konverzácia dynamická a obsahovala prvky ako história chatu.

Jedným z kľúčových problémov riešených v tomto príklade je spracovanie chýb pri analýze výstupu agenta Langchain. Chybové hlásenie „parseResult na ToolCallingAgentOutputParser funguje iba na výstupe ChatGeneration“ pochádza z nesúladu medzi typom výstupu očakávaným syntaktickým analyzátorom a skutočným generovaným výstupom. Na zvládnutie tejto chyby je vlastný nástroj zabalený do robustnej logiky, ktorá zaisťuje, že všetky vstupy a výstupy zodpovedajú očakávaným formátom. Toto ďalej riadi AgentExecutor triedy, ktorá koordinuje vykonávanie agenta a nástrojov, pričom zabezpečuje správnu synchronizáciu dotazu a výstupu nástroja.

Nakoniec skripty implementujú asynchrónne vykonávanie pomocou čakať, čo umožňuje systému zvládnuť operácie bez blokovania iných procesov. Agent pred pokračovaním čaká, kým nástroj vráti svoj výsledok, čím zabezpečí, že odpoveď je presná a včasná. Okrem toho sú zahrnuté testy jednotiek na overenie funkčnosti nástroja, čím sa zabezpečí, že bude konzistentne produkovať správny výstup. Tieto testy nielen potvrdzujú matematické fungovanie nástroja, ale tiež kontrolujú, ako dobre spracováva neplatný vstup, čím zlepšujú celkovú spoľahlivosť riešenia. Tento modulárny dizajn odolný voči chybám robí skripty opakovane použiteľnými a efektívnymi pre rôzne aplikácie v rámci 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);
});

Skúmanie úlohy agentov v integrácii Langchain.js a Ollama LLM

Pri práci s Langchain.js integrácia agentov s nástrojmi a jazykovými modelmi, ako je Ollama, je kritickým aspektom vytvárania dynamických aplikácií. Agent vám umožňuje pripojiť vlastný nástroj, ktorý vykonáva špecifické úlohy, k jazykovému modelu, ktorý zvláda viac konverzačných alebo generatívnych úloh. Pomocou agentov môžu vývojári automatizovať pracovné toky, kde model nielen generuje odpovede, ale tiež vyvoláva nástroje na vykonávanie výpočtov alebo spracovanie údajov.

Kľúčovým komponentom tejto integrácie je createToolCallingAgent funkciu. Táto funkcia umožňuje agentovi v prípade potreby spúšťať špecifické nástroje, čím sa zaistí, že úlohy budú dokončené presne a efektívne. Zatiaľ čo primárny dôraz je často kladený na vytvorenie samotného nástroja, rovnako dôležité je pochopiť, ako spravovať pracovný tok agenta a vyhnúť sa chybám pri analýze. Chyby ako „parseResult on ToolCallingAgentOutputParser funguje iba na výstupe ChatGeneration“ sa zvyčajne vyskytujú, keď výstup agenta nie je kompatibilný so systémom analýzy, čo zdôrazňuje potrebu správneho zarovnania medzi výstupom agenta a očakávaným formátom.

Využitie promptných šablón, ako napr ChatPromptTemplate, ďalej obohacuje interakciu tým, že umožňuje dynamické správy a zástupné symboly kontextu. To umožňuje agentovi upraviť svoje odpovede na základe histórie rozhovoru alebo zápisníka agenta. Optimalizácia šablón výziev a zabezpečenie správneho analyzovania výstupov agenta môže zabrániť mnohým bežným chybám, vďaka čomu budú vaše aplikácie Langchain.js spoľahlivejšie a efektívnejšie.