Correction de l'erreur ToolCallingAgentOutputParser de Langchain.js avec Ollama LLM et un outil personnalisé

Comprendre et corriger les erreurs ToolCallingAgentOutputParser dans Langchain.js

Lorsqu'ils travaillent avec Langchain.js v2, les développeurs visent souvent à créer des agents efficaces à l'aide d'outils personnalisés et de modèles de langage comme Ollama. Cependant, l’intégration de ces composants peut parfois conduire à des erreurs difficiles à déboguer.

L'une de ces erreurs est « parseResult on ToolCallingAgentOutputParser ne fonctionne que sur la sortie ChatGeneration », qui peut se produire lors de la création d'un outil personnalisé dans la structure de l'agent. Comprendre la cause première de ce problème est crucial pour garantir le bon fonctionnement de l'agent et de l'outil.

Cet article explore une implémentation simple d'un outil personnalisé qui ajoute 2 à une entrée numérique, en utilisant createToolCallingAgent de Langchain et le modèle Ollama. En analysant l'erreur et son contexte, nous pouvons mieux comprendre comment la résoudre.

Les sections suivantes vous guideront à travers le code, expliqueront l'erreur et fourniront des solutions pour résoudre ce problème. Que vous soyez nouveau sur Langchain.js ou expérimenté, ce guide vous aidera à surmonter efficacement ce problème.

Comprendre la gestion des erreurs des outils personnalisés et des agents dans Langchain.js

Dans l'exemple fourni, nous travaillons avec Langchain.js v2 pour créer un outil personnalisé qui s'intègre au Ollama modèle de langage. L'objectif principal de l'outil est d'effectuer une opération mathématique simple : ajouter 2 à la valeur d'entrée. L'outil est construit à l'aide de Langchain outil function, qui définit des fonctions réutilisables pouvant être invoquées par un agent. Pour garantir le bon fonctionnement de l'outil, le schéma d'entrée est validé avec la bibliothèque Zod, garantissant que l'entrée est un nombre valide. Cela garantit une gestion appropriée des erreurs et empêche l’outil d’échouer en raison d’entrées non valides.

L'outil personnalisé est ensuite incorporé à un agent à l'aide du createToolCallingAgent fonction. Cette commande permet à l'agent d'appeler l'outil en cas de besoin, et l'agent est alimenté par le modèle Ollama, qui est configuré avec des paramètres spécifiques tels que la température pour contrôler la créativité des réponses. Pour faciliter une interaction fluide entre l'agent et l'outil, un modèle d'invite de discussion est utilisé. Ce modèle organise la conversation en définissant différents types de messages, tels que les messages système, les entrées humaines et les espaces réservés. Les espaces réservés, tels que MessagesPlaceholder, permettez à la conversation d'être dynamique, avec des éléments tels que l'historique des discussions inclus.

L'un des problèmes clés abordés dans cet exemple est la gestion des erreurs liées à l'analyse de la sortie de l'agent Langchain. Le message d'erreur « parseResult on ToolCallingAgentOutputParser ne fonctionne que sur la sortie ChatGeneration » provient d'une inadéquation entre le type de sortie attendu par l'analyseur et la sortie réelle générée. Pour gérer cette erreur, l'outil personnalisé est enveloppé dans une logique robuste, garantissant que toutes les entrées et sorties sont conformes aux formats attendus. Ceci est en outre géré par le AgentExécuteur classe, qui coordonne l’exécution de l’agent et des outils, en s’assurant que la sortie de la requête et de l’outil est correctement synchronisée.

Enfin, les scripts implémentent une exécution asynchrone en utilisant attendre, permettant au système de gérer les opérations sans bloquer d'autres processus. L'agent attend que l'outil renvoie son résultat avant de continuer, garantissant ainsi que la réponse est à la fois précise et opportune. De plus, des tests unitaires sont inclus pour valider la fonctionnalité de l'outil, garantissant ainsi qu'il produit systématiquement le résultat correct. Ces tests confirment non seulement le fonctionnement mathématique de l’outil, mais vérifient également dans quelle mesure il gère les entrées non valides, améliorant ainsi la fiabilité globale de la solution. Cette conception modulaire et résistante aux erreurs rend les scripts réutilisables et efficaces pour diverses applications au sein 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);
});

Explorer le rôle des agents dans l'intégration de Langchain.js et Ollama LLM

Lorsque vous travaillez avec Langchain.js, l'intégration agents avec des outils et des modèles de langage comme Ollama est un aspect essentiel de la création d'applications dynamiques. Un agent vous permet de connecter un outil personnalisé, qui effectue des tâches spécifiques, à un modèle de langage, qui gère des tâches plus conversationnelles ou génératives. En utilisant des agents, les développeurs peuvent automatiser les flux de travail dans lesquels un modèle génère non seulement des réponses, mais appelle également des outils pour effectuer des calculs ou un traitement de données.

L'élément clé de cette intégration est le createToolCallingAgent fonction. Cette fonction permet à l'agent de déclencher des outils spécifiques lorsque cela est nécessaire, garantissant ainsi que les tâches sont exécutées avec précision et efficacité. Même si l'accent est souvent mis sur la création de l'outil lui-même, il est tout aussi important de comprendre comment gérer le flux de travail de l'agent et éviter les erreurs d'analyse. Des erreurs telles que « parseResult on ToolCallingAgentOutputParser ne fonctionne que sur la sortie ChatGeneration » se produisent généralement lorsque la sortie de l'agent n'est pas compatible avec le système d'analyse, soulignant la nécessité d'un alignement approprié entre la sortie de l'agent et le format attendu.

L'utilisation de modèles d'invite, tels que Modèle d'invite de chat, enrichit encore l'interaction en autorisant des messages dynamiques et des espaces réservés de contexte. Cela permet à l’agent d’ajuster ses réponses en fonction de l’historique des discussions ou du bloc-notes de l’agent. L'optimisation des modèles d'invite et la garantie que les sorties de l'agent sont correctement analysées peuvent éviter de nombreuses erreurs courantes, rendant ainsi vos applications Langchain.js plus fiables et efficaces.