A Langchain.js ToolCallingAgentOutputParser hibájának javítása az Ollama LLM és egy egyéni eszköz segítségével

A ToolCallingAgentOutputParser hibák megértése és javítása a Langchain.js fájlban

Amikor a Langchain.js v2-vel dolgozik, a fejlesztők gyakran arra törekednek, hogy hatékony ügynököket hozzanak létre egyéni eszközök és nyelvi modellek, például az Ollama segítségével. Azonban ezeknek az összetevőknek az integrálása néha olyan hibákhoz vezethet, amelyeket nehéz hibakeresni.

Az egyik ilyen hiba a "parseResult on ToolCallingAgentOutputParser csak a ChatGeneration kimeneten működik", amely akkor fordulhat elő, amikor egyéni eszközt készítenek az ügynökkereten belül. A probléma kiváltó okának megértése elengedhetetlen az ügynök és az eszköz megfelelő működéséhez.

Ez a cikk egy olyan egyéni eszköz egyszerű megvalósítását mutatja be, amely 2-t ad a számbevitelhez a Langchain createToolCallingAgent és az Ollama modell használatával. A hiba és kontextusának elemzésével jobban megérthetjük a hibaelhárítás módját.

A következő szakaszok végigvezetik a kódon, elmagyarázzák a hibát, és megoldásokat kínálnak a probléma megoldására. Akár új a Langchain.js-ben, akár tapasztalt, ez az útmutató segít a probléma hatékony megoldásában.

Parancs	Használati példa
tool()	Ez a Langchain.js függvény egy műveletet végrehajtó egyéni eszközt határoz meg. Ebben a cikkben egy olyan eszköz létrehozására szolgál, amely 2-t ad egy bemeneti számhoz, és a logikát egy könnyen hívható struktúrába csomagolja.
z.object()	A Zod-könyvtár egy része, amelyet a Langchain sémaellenőrzésére használnak. Ez biztosítja, hogy az egyéni eszköz bevitele szám legyen, és erős beviteli ellenőrzést biztosít a végrehajtás során előforduló hibák elkerülése érdekében.
createToolCallingAgent()	Ez a parancs létrehoz egy ügynököt, amely a felhasználói lekérdezésekre válaszul meghívhatja a megadott eszközöket. Kulcsfontosságú az eszközök integrálásához olyan nyelvi modellekkel, mint az Ollama, lehetővé téve az eszközök meghívását beszélgetés közben.
ChatPromptTemplate.fromMessages()	Helyőrzőket tartalmazó csevegési prompt sablon létrehozására szolgál. Ez a sablon különféle típusú üzeneteket (rendszer-, ember-, helyőrzők) rendszerez az ügynök számára, és javítja a beszélgetési folyamatot.
MessagesPlaceholder	Helyőrzőként működik a dinamikus tartalom prompt sablonjában, például a csevegési előzményekben vagy az ügynöki jegyzettömbben. Ez lehetővé teszi a beszélgetési kontextus dinamikus beillesztését a végrehajtás során.
AgentExecutor()	Ez az osztály kezeli az ügynökök és eszközök végrehajtását. A példában segít a lekérdezésnek az ügynökön keresztüli futtatásában és az eredmény összegyűjtésében az eszköz kimenetéből.
await agentExecutor.invoke()	A lekérdezés futtatására szolgál az ügynökön keresztül, és aszinkron módon várja az eredményt. Ez kulcsfontosságú a nyelvi modellekkel és eszközökkel való interakcióhoz, mivel biztosítja, hogy a kód megvárja a művelet befejezését, mielőtt továbblépne.
try-catch	Ezt a hibakezelési struktúrát az egyéni eszközön belül az érvénytelen beviteli típusok elfogására használják. A kivételek elfogásával biztosítja, hogy a rendszer a végrehajtási folyamat megszakítása nélkül hasznos hibaüzeneteket adjon vissza.
expect()	A Chai állítási könyvtárból az expect() az egységtesztben az egyéni eszköz kimenetének ellenőrzésére szolgál. Ez elengedhetetlen annak teszteléséhez, hogy az eszköz a vártnak megfelelően működik-e.

A Langchain.js egyéni eszköz- és ügynökhibakezelésének megértése

A bemutatott példában a Langchain.js v2-vel dolgozunk egy egyéni eszköz létrehozásán, amely integrálható a nyelvi modell. Az eszköz fő célja egy egyszerű matematikai művelet végrehajtása: 2 hozzáadásával a bemeneti értékhez. Az eszköz a Langchain segítségével készült függvény, amely újrafelhasználható függvényeket határoz meg, amelyeket egy ügynök hívhat meg. Az eszköz megfelelő működésének biztosítása érdekében a bemeneti séma érvényesítése a Zod könyvtárral történik, garantálva, hogy a bemenet érvényes szám legyen. Ez biztosítja a megfelelő hibakezelést, és megakadályozza, hogy a szerszám érvénytelen bemenetek miatt meghibásodjon.

Az egyéni eszköz ezután beépül egy ügynökbe a funkció. Ez a parancs lehetővé teszi az ügynök számára, hogy szükség esetén hívja az eszközt, és az ügynököt az Ollama modell hajtja, amely meghatározott paraméterekkel, például hőmérséklettel van beállítva a válaszok kreativitásának szabályozására. Az ügynök és az eszköz közötti zökkenőmentes interakció megkönnyítése érdekében csevegési prompt sablont használnak. Ez a sablon különféle típusú üzenetek, például rendszerüzenetek, emberi bevitel és helyőrzők meghatározásával szervezi a beszélgetést. A helyőrzők, mint pl , lehetővé teszi, hogy a beszélgetés dinamikus legyen, olyan elemekkel, mint a csevegési előzmények.

Az ebben a példában tárgyalt egyik legfontosabb probléma a Langchain ügynök kimeneti elemzése körüli hibakezelés. A "parseResult on ToolCallingAgentOutputParser csak a ChatGeneration kimeneten működik" hibaüzenet az elemző által várt kimenet típusa és a ténylegesen generált kimenet közötti eltérésből ered. A hiba kezeléséhez az egyéni eszközt robusztus logikába csomagolják, biztosítva, hogy minden bemenet és kimenet megfeleljen az elvárt formátumoknak. Ezt kezeli tovább a osztály, amely koordinálja az ügynök és az eszközök végrehajtását, ügyelve a lekérdezés és az eszközkimenet megfelelő szinkronizálására.

Végül a szkriptek aszinkron végrehajtást valósítanak meg a használatával , lehetővé téve a rendszer számára, hogy más folyamatok blokkolása nélkül kezelje a műveleteket. Az ügyintéző megvárja, amíg az eszköz visszaadja az eredményt, mielőtt folytatná, és gondoskodik arról, hogy a válasz pontos és időszerű legyen. Ezenkívül egységteszteket is tartalmaznak az eszköz működőképességének ellenőrzésére, biztosítva, hogy az folyamatosan a megfelelő kimenetet adja. Ezek a tesztek nemcsak az eszköz matematikai működését igazolják, hanem azt is, hogy mennyire jól kezeli az érvénytelen bevitelt, javítva a megoldás általános megbízhatóságát. Ez a moduláris és hibaálló kialakítás a szkripteket újrafelhasználhatóvá és hatékonysá teszi a Langchain.js különböző alkalmazásaiban.

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

Az ügynökök szerepének feltárása a Langchain.js-ben és az Ollama LLM-integrációban

Amikor a Langchain.js-szal dolgozik, az integráció olyan eszközökkel és nyelvi modellekkel, mint az Ollama, a dinamikus alkalmazások építésének kritikus szempontja. Az ügynök lehetővé teszi, hogy egy egyedi eszközt, amely meghatározott feladatokat hajt végre, összekapcsoljon egy nyelvi modellel, amely több párbeszédes vagy generatív feladatokat kezel. Az ügynökök használatával a fejlesztők automatizálhatják azokat a munkafolyamatokat, amelyek során a modell nemcsak válaszokat generál, hanem eszközöket is hív meg számítások vagy adatfeldolgozás elvégzéséhez.

Ennek az integrációnak a kulcseleme a funkció. Ez a funkció lehetővé teszi, hogy az ügynök szükség esetén speciális eszközöket indítson el, biztosítva a feladatok pontos és hatékony végrehajtását. Bár az elsődleges hangsúly gyakran magának az eszköznek a létrehozásán van, ugyanilyen fontos annak megértése, hogy miként kezelhető az ügynök munkafolyamata és elkerülhetőek az elemzési hibák. Az olyan hibák, mint a „parseResult on ToolCallingAgentOutputParser csak a ChatGeneration kimeneten működik”, általában akkor fordulnak elő, ha az ügynök kimenete nem kompatibilis az elemző rendszerrel, ami rávilágít az ügynök kimenete és a várt formátum megfelelő összehangolására.

A prompt sablonok használata, mint pl , tovább gazdagítja az interakciót azáltal, hogy lehetővé teszi a dinamikus üzeneteket és a kontextus helyőrzőit. Ez lehetővé teszi az ügynök számára, hogy a csevegési előzmények vagy az ügynök firkálólapja alapján módosítsa válaszait. A prompt sablonok optimalizálásával és az ügynök kimeneteinek helyes elemzésével sok gyakori hiba megelőzhető, így a Langchain.js alkalmazásai megbízhatóbbá és hatékonyabbá válhatnak.

1. Mi az ügynök a Langchain.js-ben?
2. Az ügynök egy olyan összetevő, amely kölcsönhatásba lép eszközökkel és nyelvi modellekkel, hogy a felhasználói lekérdezések alapján meghatározott feladatokat hajtson végre. Használja a funkció az eszközök kiváltására.
3. Hogyan lehet megoldani a „parseResult on ToolCallingAgentOutputParser” hibát?
4. Ez a hiba akkor fordul elő, ha az ügynök kimenete nem kompatibilis az elemzővel. Győződjön meg arról, hogy a kimenet megegyezik az elemző elvárásával, és használja a kimeneti formátum.
5. Mi a célja a ?
6. A kezeli az ügynök és eszközeinek végrehajtását, lehetővé téve összetett munkafolyamatok futtatását a Langchain.js alkalmazásokban.
7. Hogyan munka?
8. strukturált formátumba rendezi a csevegőüzeneteket, lehetővé téve a dinamikus tartalmak, például a csevegési előzmények és az ügynöki jegyzettömb beillesztését a beszélgetési folyamatba.
9. Miért van használt az eszközben?
10. a bemenet érvényesítésére szolgál, biztosítva, hogy az egyéni eszköz bemenete megfelelő típusú legyen (pl. szám), ami csökkenti a hibák esélyét.

A "parseResult on ToolCallingAgentOutputParser csak a ChatGeneration kimeneten működik" hiba megoldásához az ügynök kimenete és az elemzési elvárások gondos összehangolása szükséges. A megfelelő megközelítéssel ez a hiba elkerülhető.

Ha megfelelő eszközöket, például Zod-ot használ az érvényesítéshez, és biztosítja, hogy az ügynökök, például az Ollamával építettek megfelelően kezeljék a bemeneteket és a kimeneteket, robusztus megoldásokat hozhat létre a Langchain.js-ben anélkül, hogy elemzési problémák merülnének fel.