Correcció de l'error ToolCallingAgentOutputParser de Langchain.js amb Ollama LLM i una eina personalitzada

Comprensió i correcció dels errors de ToolCallingAgentOutputParser a Langchain.js

Quan treballen amb Langchain.js v2, els desenvolupadors sovint pretenen crear agents eficients mitjançant eines personalitzades i models de llenguatge com Ollama. Tanmateix, la integració d'aquests components de vegades pot provocar errors difícils de depurar.

Un d'aquests errors és "parseResult on ToolCallingAgentOutputParser només funciona amb la sortida de ChatGeneration", que es pot produir quan es construeix una eina personalitzada dins del marc de l'agent. Entendre la causa principal d'aquest problema és crucial per garantir que l'agent i l'eina funcionin correctament.

Aquest article explora una implementació senzilla d'una eina personalitzada que afegeix 2 a una entrada de nombre, utilitzant el createToolCallingAgent de Langchain i el model Ollama. Si analitzem l'error i el seu context, podem entendre millor com solucionar-lo.

Les seccions següents us guiaran a través del codi, explicaran l'error i proporcionaran solucions per solucionar aquest problema. Tant si sou nou a Langchain.js com si sou experimentat, aquesta guia us ajudarà a superar aquest problema de manera eficient.

Entendre l'eina personalitzada i la gestió d'errors de l'agent a Langchain.js

A l'exemple proporcionat, estem treballant amb Langchain.js v2 per crear una eina personalitzada que s'integra amb el Ollama model lingüístic. L'objectiu principal de l'eina és realitzar una operació matemàtica senzilla: afegir 2 al valor d'entrada. L'eina es construeix amb Langchain eina funció, que defineix funcions reutilitzables que poden ser invocades per un agent. Per garantir que l'eina funciona correctament, l'esquema d'entrada es valida amb la biblioteca Zod, garantint que l'entrada és un número vàlid. Això garanteix un tractament adequat dels errors i evita que l'eina falli a causa d'entrades no vàlides.

A continuació, l'eina personalitzada s'incorpora a un agent mitjançant l' createToolCallingAgent funció. Aquesta ordre permet a l'agent trucar a l'eina quan sigui necessari, i l'agent està alimentat pel model Ollama, que es configura amb paràmetres específics com la temperatura per controlar la creativitat de les respostes. Per facilitar una interacció fluida entre l'agent i l'eina, s'utilitza una plantilla de sol·licitud de xat. Aquesta plantilla organitza la conversa definint diferents tipus de missatges, com ara missatges del sistema, entrada humana i marcadors de posició. Els marcadors de posició, com ara Missatges Marcador de posició, permeten que la conversa sigui dinàmica, amb elements com l'historial de xat inclòs.

Un dels problemes clau tractats en aquest exemple és la gestió d'errors al voltant de l'anàlisi de sortida de l'agent Langchain. El missatge d'error "parseResult on ToolCallingAgentOutputParser només funciona a la sortida de ChatGeneration" prové d'una discrepància entre el tipus de sortida esperat per l'analitzador i la sortida real generada. Per gestionar aquest error, l'eina personalitzada s'embolica en una lògica robusta, que garanteix que totes les entrades i sortides s'ajustin als formats esperats. Això és gestionat a més per la AgentExecutor classe, que coordina l'execució de l'agent i les eines, assegurant-se que la consulta i la sortida de l'eina estan correctament sincronitzades.

Finalment, els scripts implementen l'execució asíncrona utilitzant esperar, permetent al sistema gestionar operacions sense bloquejar altres processos. L'agent espera que l'eina torni el seu resultat abans de continuar, assegurant-se que la resposta és precisa i oportuna. A més, s'inclouen proves d'unitat per validar la funcionalitat de l'eina, assegurant que produeixi constantment la sortida correcta. Aquestes proves no només confirmen el funcionament matemàtic de l'eina, sinó que també comproven com de bé gestiona les entrades no vàlides, millorant la fiabilitat global de la solució. Aquest disseny modular i resistent als errors fa que els scripts siguin reutilitzables i efectius per a diverses aplicacions dins de 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);
});

Explorant el paper dels agents a la integració de Langchain.js i Ollama LLM

Quan es treballa amb Langchain.js, la integració agents amb eines i models de llenguatge com Ollama és un aspecte crític per crear aplicacions dinàmiques. Un agent permet connectar una eina personalitzada, que realitza tasques específiques, a un model de llenguatge, que gestiona tasques més conversacionals o generatives. Mitjançant l'ús d'agents, els desenvolupadors poden automatitzar fluxos de treball on un model no només genera respostes, sinó que també invoca eines per realitzar càlculs o processament de dades.

El component clau d'aquesta integració és el createToolCallingAgent funció. Aquesta funció permet a l'agent activar eines específiques quan sigui necessari, assegurant que les tasques es completen amb precisió i eficàcia. Tot i que sovint l'enfocament principal és crear l'eina mateixa, és igual d'important entendre com gestionar el flux de treball de l'agent i evitar errors d'anàlisi. Els errors com "parseResult on ToolCallingAgentOutputParser només funciona a la sortida de ChatGeneration" solen produir-se quan la sortida de l'agent no és compatible amb el sistema d'anàlisi, posant de manifest la necessitat d'una alineació adequada entre la sortida de l'agent i el format esperat.

L'ús de plantilles d'indicadors, com ara ChatPromptTemplate, enriqueix encara més la interacció permetent missatges dinàmics i marcadors de posició de context. Això permet a l'agent ajustar les seves respostes en funció de l'historial de xat o del bloc de notes de l'agent. Optimitzar les plantilles d'indicadors i assegurar-vos que les sortides de l'agent s'analitzin correctament pot evitar molts errors comuns, fent que les vostres aplicacions Langchain.js siguin més fiables i eficients.