Solucionar el error ToolCallingAgentOutputParser de Langchain.js con Ollama LLM y una herramienta personalizada

Comprensión y corrección de errores de ToolCallingAgentOutputParser en Langchain.js

Cuando trabajan con Langchain.js v2, los desarrolladores suelen intentar crear agentes eficientes utilizando herramientas personalizadas y modelos de lenguaje como Ollama. Sin embargo, la integración de estos componentes a veces puede provocar errores difíciles de depurar.

Uno de esos errores es "parseResult en ToolCallingAgentOutputParser solo funciona en la salida de ChatGeneration", que puede ocurrir al crear una herramienta personalizada dentro del marco del agente. Comprender la causa raíz de este problema es fundamental para garantizar que el agente y la herramienta funcionen correctamente.

Este artículo explora una implementación simple de una herramienta personalizada que suma 2 a una entrada numérica, utilizando createToolCallingAgent de Langchain y el modelo Ollama. Al analizar el error y su contexto, podemos comprender mejor cómo solucionarlo.

Las siguientes secciones lo guiarán a través del código, explicarán el error y brindarán soluciones para abordar este problema. Ya sea que sea nuevo en Langchain.js o tenga experiencia, esta guía lo ayudará a superar este problema de manera eficiente.

Comprensión de la herramienta personalizada y el manejo de errores del agente en Langchain.js

En el ejemplo proporcionado, estamos trabajando con Langchain.js v2 para crear una herramienta personalizada que se integra con el Ollama modelo de lenguaje. El objetivo principal de la herramienta es realizar una operación matemática simple: sumar 2 al valor de entrada. La herramienta está construida utilizando Langchain. herramienta función, que define funciones reutilizables que pueden ser invocadas por un agente. Para garantizar que la herramienta funcione correctamente, el esquema de entrada se valida con la biblioteca Zod, garantizando que la entrada sea un número válido. Esto garantiza un manejo adecuado de los errores y evita que la herramienta falle debido a entradas no válidas.

Luego, la herramienta personalizada se incorpora a un agente utilizando el crearToolCallingAgent función. Este comando permite al agente llamar a la herramienta cuando sea necesario, y el agente funciona con el modelo Ollama, que está configurado con parámetros específicos como la temperatura para controlar la creatividad de las respuestas. Para facilitar una interacción fluida entre el agente y la herramienta, se utiliza una plantilla de mensaje de chat. Esta plantilla organiza la conversación definiendo diferentes tipos de mensajes, como mensajes del sistema, aportaciones humanas y marcadores de posición. Los marcadores de posición, como MensajesMarcador de posición, permite que la conversación sea dinámica, incluyendo elementos como el historial de chat.

Una de las cuestiones clave abordadas en este ejemplo es el manejo de errores en torno al análisis de salida del agente Langchain. El mensaje de error "parseResult en ToolCallingAgentOutputParser solo funciona en la salida de ChatGeneration" se debe a una falta de coincidencia entre el tipo de salida esperada por el analizador y la salida real generada. Para manejar este error, la herramienta personalizada está envuelta en una lógica sólida, lo que garantiza que todas las entradas y salidas se ajusten a los formatos esperados. Esto es gestionado además por el AgenteEjecutor clase, que coordina la ejecución del agente y las herramientas, asegurándose de que la consulta y la salida de la herramienta estén sincronizadas correctamente.

Finalmente, los scripts implementan la ejecución asincrónica usando esperar, permitiendo que el sistema maneje operaciones sin bloquear otros procesos. El agente espera a que la herramienta devuelva su resultado antes de continuar, asegurando que la respuesta sea precisa y oportuna. Además, se incluyen pruebas unitarias para validar la funcionalidad de la herramienta, asegurando que produzca consistentemente el resultado correcto. Estas pruebas no solo confirman el funcionamiento matemático de la herramienta, sino que también verifican qué tan bien maneja entradas no válidas, mejorando la confiabilidad general de la solución. Este diseño modular y resistente a errores hace que los scripts sean reutilizables y efectivos para diversas aplicaciones dentro 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);
});

Explorando el papel de los agentes en la integración de Langchain.js y Ollama LLM

Al trabajar con Langchain.js, integrar agentes con herramientas y modelos de lenguaje como Ollama es un aspecto crítico en la creación de aplicaciones dinámicas. Un agente le permite conectar una herramienta personalizada, que realiza tareas específicas, a un modelo de lenguaje, que maneja tareas más conversacionales o generativas. Al utilizar agentes, los desarrolladores pueden automatizar flujos de trabajo donde un modelo no solo genera respuestas sino que también invoca herramientas para realizar cálculos o procesamiento de datos.

El componente clave de esta integración es la crearToolCallingAgent función. Esta función permite al agente activar herramientas específicas cuando sea necesario, asegurando que las tareas se completen de manera precisa y eficiente. Si bien el enfoque principal suele ser la creación de la herramienta en sí, es igualmente importante comprender cómo administrar el flujo de trabajo del agente y evitar errores de análisis. Errores como "parseResult en ToolCallingAgentOutputParser solo funciona en la salida de ChatGeneration" generalmente ocurren cuando la salida del agente no es compatible con el sistema de análisis, lo que resalta la necesidad de una alineación adecuada entre la salida del agente y el formato esperado.

El uso de plantillas de avisos, como Plantilla de solicitud de chat, enriquece aún más la interacción al permitir mensajes dinámicos y marcadores de posición de contexto. Esto permite al agente ajustar sus respuestas según el historial de chat o el bloc de notas del agente. Optimizar las plantillas de mensajes y garantizar que los resultados del agente se analicen correctamente puede evitar muchos errores comunes, lo que hace que sus aplicaciones Langchain.js sean más confiables y eficientes.