Oprava chyby ToolCallingAgentOutputParser Langchain.js pomocí Ollama LLM a vlastního nástroje

Pochopení a oprava chyb ToolCallingAgentOutputParser v Langchain.js

Při práci s Langchain.js v2 se vývojáři často snaží vytvořit efektivní agenty pomocí vlastních nástrojů a jazykových modelů, jako je Ollama. Integrace těchto součástí však může někdy vést k chybám, které se obtížně ladí.

Jednou z takových chyb je „parseResult on ToolCallingAgentOutputParser funguje pouze na výstupu ChatGeneration“, ke které může dojít při vytváření vlastního nástroje v rámci agenta. Pochopení hlavní příčiny tohoto problému je zásadní pro zajištění správného fungování agenta a nástroje.

Tento článek zkoumá jednoduchou implementaci vlastního nástroje, který přidává 2 k číselnému vstupu, pomocí createToolCallingAgent společnosti Langchain a modelu Ollama. Analýzou chyby a jejího kontextu můžeme lépe pochopit, jak ji odstranit.

Následující části vás provedou kódem, vysvětlí chybu a poskytnou řešení tohoto problému. Ať už jste v Langchain.js noví nebo zkušení, tento průvodce vám pomůže tento problém efektivně překonat.

Pochopení Custom Tool a Agent Error Handling v Langchain.js

V uvedeném příkladu pracujeme s Langchain.js v2 na vytvoření vlastního nástroje, který se integruje s Ollama jazykový model. Hlavním účelem nástroje je provést jednoduchou matematickou operaci: přičtení 2 ke vstupní hodnotě. Nástroj je vytvořen pomocí Langchain's nástroj funkce, která definuje opakovaně použitelné funkce, které může agent vyvolat. Aby bylo zajištěno správné fungování nástroje, je vstupní schéma ověřeno pomocí knihovny Zod, což zaručuje, že vstup je platným číslem. To zajišťuje správné zpracování chyb a zabraňuje selhání nástroje kvůli neplatným vstupům.

Vlastní nástroj je pak začleněn do agenta pomocí createToolCallingAgent funkce. Tento příkaz umožňuje agentovi zavolat nástroj v případě potřeby a agent je poháněn modelem Ollama, který je nakonfigurován se specifickými parametry, jako je teplota, pro řízení kreativity odpovědí. Pro usnadnění hladké interakce mezi agentem a nástrojem se používá šablona výzvy k chatu. Tato šablona organizuje konverzaci definováním různých typů zpráv, jako jsou systémové zprávy, lidské vstupy a zástupné symboly. Zástupné symboly, jako např Zástupný symbol zpráv, umožňují konverzaci, aby byla dynamická a obsahovala prvky, jako je historie chatu.

Jedním z klíčových problémů řešených v tomto příkladu je zpracování chyb při analýze výstupu agenta Langchain. Chybová zpráva "parseResult na ToolCallingAgentOutputParser funguje pouze na výstupu ChatGeneration" pochází z nesouladu mezi typem výstupu očekávaným analyzátorem a skutečným výstupem generovaným. Aby bylo možné tuto chybu zvládnout, je vlastní nástroj zabalen do robustní logiky, která zajišťuje, že všechny vstupy a výstupy odpovídají očekávaným formátům. Toto je dále řízeno AgentExecutor třída, která koordinuje provádění agenta a nástrojů a zajišťuje, že výstup dotazu a nástroje jsou správně synchronizovány.

Nakonec skripty implementují asynchronní provádění pomocí čekat, což umožňuje systému zpracovávat operace bez blokování jiných procesů. Agent před pokračováním čeká, až nástroj vrátí výsledek, čímž zajistí, že odpověď bude přesná a včasná. Kromě toho jsou zahrnuty testy jednotek, které ověřují funkčnost nástroje a zajišťují, že konzistentně produkuje správný výstup. Tyto testy nejen potvrzují matematické fungování nástroje, ale také ověřují, jak dobře zpracovává neplatný vstup, čímž zlepšuje celkovou spolehlivost řešení. Díky tomuto modulárnímu a chybám odolnému designu jsou skripty opakovaně použitelné a efektivní pro různé aplikace 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);
});

Prozkoumání role agentů v integraci Langchain.js a Ollama LLM

Při práci s Langchain.js integrace agenti s nástroji a jazykovými modely, jako je Ollama, je kritickým aspektem vytváření dynamických aplikací. Agent vám umožňuje připojit vlastní nástroj, který provádí specifické úkoly, k jazykovému modelu, který zpracovává konverzační nebo generativní úkoly. Pomocí agentů mohou vývojáři automatizovat pracovní postupy, kdy model nejen generuje odpovědi, ale také vyvolává nástroje pro provádění výpočtů nebo zpracování dat.

Klíčovou součástí této integrace je createToolCallingAgent funkce. Tato funkce umožňuje agentovi v případě potřeby spouštět specifické nástroje, což zajišťuje přesné a efektivní dokončení úkolů. Zatímco primární důraz je často kladen na vytvoření samotného nástroje, pochopení toho, jak spravovat pracovní postup agenta a vyhnout se chybám při analýze, je stejně důležité. Chyby jako „parseResult on ToolCallingAgentOutputParser funguje pouze na výstupu ChatGeneration“ se obvykle vyskytují, když výstup agenta není kompatibilní se systémem analýzy, což zdůrazňuje potřebu správného zarovnání mezi výstupem agenta a očekávaným formátem.

Použití šablon výzvy, jako je např ChatPromptTemplatedále obohacuje interakci tím, že umožňuje dynamické zprávy a zástupné symboly kontextu. To agentovi umožňuje upravit své odpovědi na základě historie chatu nebo zápisníku agenta. Optimalizace šablon výzvy a zajištění správné analýzy výstupů agenta může zabránit mnoha běžným chybám, díky čemuž budou vaše aplikace Langchain.js spolehlivější a efektivnější.