Remedierea erorii ToolCallingAgentOutputParser de la Langchain.js cu Ollama LLM și un instrument personalizat

Înțelegerea și remedierea erorilor ToolCallingAgentOutputParser în Langchain.js

Când lucrează cu Langchain.js v2, dezvoltatorii urmăresc adesea să creeze agenți eficienți folosind instrumente personalizate și modele de limbaj precum Ollama. Cu toate acestea, integrarea acestor componente poate duce uneori la erori greu de depanat.

O astfel de eroare este „parseResult on ToolCallingAgentOutputParser funcționează numai pe ieșirea ChatGeneration”, care poate apărea la construirea unui instrument personalizat în cadrul agentului. Înțelegerea cauzei principale a acestei probleme este crucială pentru a vă asigura că agentul și instrumentul funcționează corect.

Acest articol explorează o implementare simplă a unui instrument personalizat care adaugă 2 la o intrare de număr, folosind createToolCallingAgent de la Langchain și modelul Ollama. Analizând eroarea și contextul acesteia, putem înțelege mai bine cum să o depanăm.

Următoarele secțiuni vă vor ghida prin cod, vă vor explica eroarea și vă vor oferi soluții pentru a rezolva această problemă. Indiferent dacă sunteți nou în Langchain.js sau experimentați, acest ghid vă va ajuta să treceți eficient peste această problemă.

Înțelegerea instrumentului personalizat și a gestionării erorilor agentului în Langchain.js

În exemplul oferit, lucrăm cu Langchain.js v2 pentru a crea un instrument personalizat care se integrează cu Ollama model de limbaj. Scopul principal al instrumentului este de a efectua o operație matematică simplă: adăugarea de 2 la valoarea de intrare. Instrumentul este construit folosind Langchain instrument funcția, care definește funcțiile reutilizabile care pot fi invocate de un agent. Pentru a vă asigura că instrumentul funcționează corect, schema de intrare este validată cu biblioteca Zod, garantând că intrarea este un număr valid. Acest lucru asigură gestionarea corectă a erorilor și previne defecțiunea instrumentului din cauza intrărilor nevalide.

Instrumentul personalizat este apoi încorporat într-un agent folosind createToolCallingAgent funcţie. Această comandă permite agentului să apeleze instrumentul atunci când este necesar, iar agentul este alimentat de modelul Ollama, care este configurat cu parametri specifici, cum ar fi temperatura, pentru a controla creativitatea răspunsurilor. Pentru a facilita interacțiunea lină între agent și instrument, se folosește un șablon de solicitare de chat. Acest șablon organizează conversația prin definirea diferitelor tipuri de mesaje, cum ar fi mesaje de sistem, intrare umană și substituenți. Substituenții, cum ar fi MesajePlaceholder, permite conversației să fie dinamică, cu elemente precum istoricul chatului fiind incluse.

Una dintre problemele cheie abordate în acest exemplu este gestionarea erorilor în jurul analizei de ieșire a agentului Langchain. Mesajul de eroare „parseResult on ToolCallingAgentOutputParser funcționează numai pe ieșirea ChatGeneration” provine dintr-o nepotrivire între tipul de ieșire așteptat de parser și rezultatul real generat. Pentru a gestiona această eroare, instrumentul personalizat este împachetat într-o logică robustă, asigurând că toate intrările și ieșirile sunt conforme cu formatele așteptate. Acest lucru este gestionat în continuare de către Agent Executor clasa, care coordonează execuția agentului și a instrumentelor, asigurându-se că interogarea și ieșirea instrumentului sunt sincronizate corect.

În cele din urmă, scripturile implementează execuția asincronă folosind asteapta, permițând sistemului să gestioneze operațiunile fără a bloca alte procese. Agentul așteaptă ca instrumentul să-și returneze rezultatul înainte de a continua, asigurându-se că răspunsul este atât corect, cât și în timp util. În plus, testele unitare sunt incluse pentru a valida funcționalitatea instrumentului, asigurându-se că acesta produce în mod constant rezultatul corect. Aceste teste nu numai că confirmă funcționarea matematică a instrumentului, dar verifică și cât de bine gestionează intrările nevalide, îmbunătățind fiabilitatea globală a soluției. Acest design modular și rezistent la erori face scripturile reutilizabile și eficiente pentru diverse aplicații din 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);
});

Explorarea rolului agenților în integrarea Langchain.js și Ollama LLM

Când lucrați cu Langchain.js, integrați agenţi cu instrumente și modele de limbaj precum Ollama este un aspect critic al construirii de aplicații dinamice. Un agent vă permite să conectați un instrument personalizat, care îndeplinește sarcini specifice, la un model de limbă, care se ocupă de sarcini mai conversaționale sau generative. Folosind agenți, dezvoltatorii pot automatiza fluxurile de lucru în care un model nu numai că generează răspunsuri, ci și invocă instrumente pentru a efectua calcule sau prelucrare a datelor.

Componenta cheie în această integrare este createToolCallingAgent funcţie. Această funcție permite agentului să declanșeze instrumente specifice atunci când este necesar, asigurându-se că sarcinile sunt îndeplinite cu acuratețe și eficient. În timp ce accentul principal este adesea pe crearea instrumentului în sine, înțelegerea modului de gestionare a fluxului de lucru al agentului și de a evita erorile de analiză este la fel de importantă. Erorile precum „parseResult on ToolCallingAgentOutputParser funcționează numai la ieșirea ChatGeneration” apar de obicei atunci când ieșirea agentului nu este compatibilă cu sistemul de analiză, evidențiind necesitatea unei alinieri adecvate între rezultatul agentului și formatul așteptat.

Utilizarea șabloanelor prompte, cum ar fi ChatPromptTemplate, îmbogățește și mai mult interacțiunea permițând mesaje dinamice și substituenți de context. Acest lucru îi permite agentului să își ajusteze răspunsurile în funcție de istoricul chatului sau de blocul de date al agentului. Optimizarea șabloanelor de prompt și asigurarea faptului că ieșirile agentului sunt analizate corect poate preveni multe erori comune, făcând aplicațiile dvs. Langchain.js mai fiabile și mai eficiente.