Correzione dell'errore ToolCallingAgentOutputParser di Langchain.js con Ollama LLM e uno strumento personalizzato

Comprendere e correggere gli errori ToolCallingAgentOutputParser in Langchain.js

Quando lavorano con Langchain.js v2, gli sviluppatori spesso mirano a creare agenti efficienti utilizzando strumenti personalizzati e modelli linguistici come Ollama. Tuttavia, l'integrazione di questi componenti a volte può portare a errori difficili da eseguire il debug.

Uno di questi errori è "parseResult su ToolCallingAgentOutputParser funziona solo sull'output di ChatGeneration", che può verificarsi durante la creazione di uno strumento personalizzato all'interno del framework dell'agente. Comprendere la causa principale di questo problema è fondamentale per garantire che l'agente e lo strumento funzionino correttamente.

Questo articolo esplora una semplice implementazione di uno strumento personalizzato che aggiunge 2 a un numero immesso, utilizzando createToolCallingAgent di Langchain e il modello Ollama. Analizzando l'errore e il suo contesto, possiamo comprendere meglio come risolverlo.

Le sezioni seguenti ti guideranno attraverso il codice, spiegheranno l'errore e forniranno soluzioni per risolvere questo problema. Che tu sia nuovo o esperto di Langchain.js, questa guida ti aiuterà a superare questo problema in modo efficiente.

Comando	Esempio di utilizzo
tool()	Questa funzione di Langchain.js definisce uno strumento personalizzato che esegue un'operazione. In questo articolo viene utilizzato per creare uno strumento che aggiunge 2 a un numero di input, racchiudendo la logica in una struttura facilmente richiamabile.
z.object()	Una parte della libreria Zod, utilizzata per la convalida dello schema in Langchain. Ciò garantisce che l'input per lo strumento personalizzato sia un numero, fornendo una valida convalida dell'input per prevenire errori durante l'esecuzione.
createToolCallingAgent()	Questo comando crea un agente che può chiamare gli strumenti definiti in risposta alle query dell'utente. È fondamentale per integrare gli strumenti con modelli linguistici come Ollama, rendendo possibile invocare strumenti durante la conversazione.
ChatPromptTemplate.fromMessages()	Utilizzato per generare un modello di messaggio di chat con segnaposto. Questo modello organizza diversi tipi di messaggi (di sistema, umani, segnaposto) che l'agente può utilizzare, migliorandone il flusso di conversazione.
MessagesPlaceholder	Funziona come segnaposto nel modello di richiesta per contenuto dinamico, ad esempio cronologia chat o blocco appunti dell'agente. Ciò consente di inserire dinamicamente il contesto della conversazione durante l'esecuzione.
AgentExecutor()	Questa classe gestisce l'esecuzione di agenti e strumenti. Nell'esempio, aiuta a eseguire la query tramite l'agente e a raccogliere il risultato dall'output dello strumento.
await agentExecutor.invoke()	Utilizzato per eseguire la query tramite l'agente e attendere il risultato in modo asincrono. Ciò è fondamentale per interagire con modelli e strumenti linguistici, poiché garantisce che il codice attenda il completamento dell'operazione prima di procedere.
try-catch	Questa struttura di gestione degli errori viene utilizzata all'interno dello strumento personalizzato per individuare tipi di input non validi. Rilevando le eccezioni, garantisce che il sistema restituisca messaggi di errore utili senza interrompere il flusso di esecuzione.
expect()	Dalla libreria di asserzioni Chai, wait() viene utilizzato nel test unitario per verificare l'output dello strumento personalizzato. È essenziale per verificare se lo strumento funziona come previsto.

Comprensione dello strumento personalizzato e della gestione degli errori dell'agente in Langchain.js

Nell'esempio fornito, stiamo lavorando con Langchain.js v2 per creare uno strumento personalizzato che si integri con modello linguistico. Lo scopo principale dello strumento è eseguire una semplice operazione matematica: aggiungere 2 al valore immesso. Lo strumento è costruito utilizzando Langchain funzione, che definisce le funzioni riutilizzabili che possono essere richiamate da un agente. Per garantire il corretto funzionamento dello strumento, lo schema di input viene convalidato con la libreria Zod, garantendo che l'input sia un numero valido. Ciò garantisce una corretta gestione degli errori e impedisce allo strumento di fallire a causa di input non validi.

Lo strumento personalizzato viene quindi incorporato in un agente utilizzando il file funzione. Questo comando consente all'agente di chiamare lo strumento quando necessario e l'agente è alimentato dal modello Ollama, configurato con parametri specifici come la temperatura per controllare la creatività delle risposte. Per facilitare l'interazione fluida tra l'agente e lo strumento, viene utilizzato un modello di richiesta di chat. Questo modello organizza la conversazione definendo diversi tipi di messaggi, come messaggi di sistema, input umani e segnaposto. I segnaposto, come , consentono alla conversazione di essere dinamica, includendo elementi come la cronologia della chat.

Uno dei problemi chiave affrontati in questo esempio è la gestione degli errori relativi all'analisi dell'output dell'agente Langchain. Il messaggio di errore "parseResult su ToolCallingAgentOutputParser funziona solo sull'output di ChatGeneration" deriva da una mancata corrispondenza tra il tipo di output previsto dal parser e l'effettivo output generato. Per gestire questo errore, lo strumento personalizzato è racchiuso in una logica robusta, garantendo che tutti gli input e gli output siano conformi ai formati previsti. Questo è ulteriormente gestito da classe, che coordina l'esecuzione dell'agente e degli strumenti, assicurandosi che la query e l'output dello strumento siano correttamente sincronizzati.

Infine, gli script implementano l'esecuzione asincrona utilizzando , consentendo al sistema di gestire le operazioni senza bloccare altri processi. L'agente attende che lo strumento restituisca il risultato prima di procedere, garantendo che la risposta sia accurata e tempestiva. Inoltre, sono inclusi test unitari per convalidare la funzionalità dello strumento, garantendo che produca costantemente l'output corretto. Questi test non solo confermano il funzionamento matematico dello strumento, ma controllano anche il modo in cui gestisce gli input non validi, migliorando l’affidabilità complessiva della soluzione. Questo design modulare e resistente agli errori rende gli script riutilizzabili ed efficaci per varie applicazioni all'interno di 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);
});

Esplorazione del ruolo degli agenti nell'integrazione di Langchain.js e Ollama LLM

Quando si lavora con Langchain.js, integrazione con strumenti e modelli linguistici come Ollama è un aspetto critico della creazione di applicazioni dinamiche. Un agente ti consente di connettere uno strumento personalizzato, che esegue attività specifiche, a un modello linguistico, che gestisce attività più conversazionali o generative. Utilizzando gli agenti, gli sviluppatori possono automatizzare i flussi di lavoro in cui un modello non solo genera risposte ma richiama anche strumenti per eseguire calcoli o elaborare dati.

Il componente chiave di questa integrazione è il funzione. Questa funzione consente all'agente di attivare strumenti specifici quando necessario, garantendo che le attività vengano completate in modo accurato ed efficiente. Sebbene l'obiettivo principale sia spesso la creazione dello strumento stesso, è altrettanto importante capire come gestire il flusso di lavoro dell'agente ed evitare errori di analisi. Errori come "parseResult su ToolCallingAgentOutputParser funziona solo sull'output di ChatGeneration" si verificano solitamente quando l'output dell'agente non è compatibile con il sistema di analisi, evidenziando la necessità di un corretto allineamento tra l'output dell'agente e il formato previsto.

L'uso di modelli di prompt, come , arricchisce ulteriormente l'interazione consentendo messaggi dinamici e segnaposto di contesto. Ciò consente all'agente di modificare le proprie risposte in base alla cronologia della chat o agli appunti dell'agente. L'ottimizzazione dei modelli di prompt e la garanzia che gli output dell'agente siano analizzati correttamente può prevenire molti errori comuni, rendendo le tue applicazioni Langchain.js più affidabili ed efficienti.

1. Cos'è un agente in Langchain.js?
2. Un agente è un componente che interagisce con strumenti e modelli linguistici per eseguire attività specifiche in base a una query dell'utente. Utilizza il funzione per attivare gli strumenti.
3. Come si risolve l'errore "parseResult on ToolCallingAgentOutputParser"?
4. Questo errore si verifica quando l'output dell'agente non è compatibile con il parser. Assicurati che l'output corrisponda a ciò che il parser si aspetta e usa a formato di uscita.
5. Qual è lo scopo del ?
6. IL gestisce l'esecuzione dell'agente e dei suoi strumenti, consentendo di eseguire flussi di lavoro complessi nelle applicazioni Langchain.js.
7. Come funziona lavoro?
8. organizza i messaggi di chat in un formato strutturato, consentendo di inserire contenuti dinamici come la cronologia della chat e gli appunti dell'agente nel flusso della conversazione.
9. Perché è utilizzato nello strumento?
10. viene utilizzato per la convalida dell'input, garantendo che l'input per lo strumento personalizzato sia del tipo corretto (ad esempio, un numero), riducendo le possibilità di errori.

La risoluzione dell'errore "parseResult su ToolCallingAgentOutputParser funziona solo sull'output di ChatGeneration" richiede un attento allineamento tra l'output dell'agente e le sue aspettative di analisi. Con il giusto approccio questo errore può essere evitato.

Utilizzando strumenti appropriati come Zod per la convalida e assicurando che gli agenti, come quelli creati con Ollama, gestiscano correttamente input e output, puoi creare soluzioni robuste in Langchain.js senza incontrare problemi di analisi.