Corrigindo o erro ToolCallingAgentOutputParser de Langchain.js com Ollama LLM e uma ferramenta personalizada

Compreendendo e corrigindo erros ToolCallingAgentOutputParser em Langchain.js

Ao trabalhar com Langchain.js v2, os desenvolvedores geralmente buscam criar agentes eficientes usando ferramentas personalizadas e modelos de linguagem como Ollama. No entanto, a integração desses componentes às vezes pode levar a erros difíceis de depurar.

Um desses erros é o "parseResult em ToolCallingAgentOutputParser funciona apenas na saída ChatGeneration", que pode ocorrer ao construir uma ferramenta personalizada dentro da estrutura do agente. Compreender a causa raiz deste problema é crucial para garantir que o agente e a ferramenta funcionem corretamente.

Este artigo explora uma implementação simples de uma ferramenta personalizada que adiciona 2 a uma entrada numérica, usando createToolCallingAgent de Langchain e o modelo Ollama. Ao analisar o erro e seu contexto, podemos compreender melhor como solucioná-lo.

As seções a seguir guiarão você pelo código, explicarão o erro e fornecerão soluções para resolver esse problema. Quer você seja novo ou experiente em Langchain.js, este guia o ajudará a superar esse problema com eficiência.

Compreendendo a ferramenta personalizada e o tratamento de erros do agente em Langchain.js

No exemplo fornecido, estamos trabalhando com Langchain.js v2 para criar uma ferramenta personalizada que se integra ao Ollama modelo de linguagem. O principal objetivo da ferramenta é realizar uma operação matemática simples: adicionar 2 ao valor de entrada. A ferramenta é construída usando Langchain's ferramenta function, que define funções reutilizáveis ​​que podem ser invocadas por um agente. Para garantir que a ferramenta funcione corretamente, o esquema de entrada é validado com a biblioteca Zod, garantindo que a entrada seja um número válido. Isso garante o tratamento adequado de erros e evita que a ferramenta falhe devido a entradas inválidas.

A ferramenta personalizada é então incorporada a um agente usando o createToolCallingAgent função. Este comando permite que o agente chame a ferramenta quando necessário, e o agente é alimentado pelo modelo Ollama, que é configurado com parâmetros específicos como temperatura para controlar a criatividade das respostas. Para facilitar a interação suave entre o agente e a ferramenta, é usado um modelo de prompt de chat. Este modelo organiza a conversa definindo diferentes tipos de mensagens, como mensagens do sistema, entrada humana e espaços reservados. Os espaços reservados, como MensagensPlaceholder, permitem que a conversa seja dinâmica, incluindo elementos como o histórico do chat.

Um dos principais problemas abordados neste exemplo é o tratamento de erros na análise de saída do agente Langchain. A mensagem de erro "parseResult em ToolCallingAgentOutputParser funciona apenas na saída ChatGeneration" decorre de uma incompatibilidade entre o tipo de saída esperado pelo analisador e a saída real gerada. Para lidar com esse erro, a ferramenta personalizada é envolvida em uma lógica robusta, garantindo que todas as entradas e saídas estejam em conformidade com os formatos esperados. Isto é ainda gerido pelo AgenteExecutor classe, que coordena a execução do agente e das ferramentas, garantindo que a consulta e a saída da ferramenta estejam devidamente sincronizadas.

Finalmente, os scripts implementam execução assíncrona usando espere, permitindo que o sistema lide com operações sem bloquear outros processos. O agente espera que a ferramenta retorne o resultado antes de prosseguir, garantindo que a resposta seja precisa e oportuna. Além disso, testes unitários são incluídos para validar a funcionalidade da ferramenta, garantindo que ela produza consistentemente a saída correta. Esses testes não apenas confirmam a operação matemática da ferramenta, mas também verificam quão bem ela lida com entradas inválidas, melhorando a confiabilidade geral da solução. Este design modular e resistente a erros torna os scripts reutilizáveis ​​e eficazes para vários aplicativos dentro do 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 o papel dos agentes na integração Langchain.js e Ollama LLM

Ao trabalhar com Langchain.js, integrando agentes com ferramentas e modelos de linguagem como Ollama é um aspecto crítico na construção de aplicativos dinâmicos. Um agente permite conectar uma ferramenta personalizada, que executa tarefas específicas, a um modelo de linguagem, que lida com tarefas mais conversacionais ou generativas. Ao usar agentes, os desenvolvedores podem automatizar fluxos de trabalho onde um modelo não apenas gera respostas, mas também invoca ferramentas para realizar cálculos ou processamento de dados.

O componente chave nesta integração é o createToolCallingAgent função. Essa função permite que o agente acione ferramentas específicas quando necessário, garantindo que as tarefas sejam concluídas com precisão e eficiência. Embora o foco principal geralmente esteja na criação da ferramenta em si, é igualmente importante compreender como gerenciar o fluxo de trabalho do agente e evitar erros de análise. Erros como "parseResult em ToolCallingAgentOutputParser só funciona na saída ChatGeneration" geralmente ocorrem quando a saída do agente não é compatível com o sistema de análise, destacando a necessidade de alinhamento adequado entre a saída do agente e o formato esperado.

O uso de modelos de prompt, como Modelo de prompt de bate-papo, enriquece ainda mais a interação ao permitir mensagens dinâmicas e marcadores de contexto. Isso permite que o agente ajuste suas respostas com base no histórico de bate-papo ou no bloco de notas do agente. Otimizar os modelos de prompt e garantir que as saídas do agente sejam analisadas corretamente pode evitar muitos erros comuns, tornando seus aplicativos Langchain.js mais confiáveis ​​e eficientes.