Behebung des ToolCallingAgentOutputParser-Fehlers von Langchain.js mit Ollama LLM und einem benutzerdefinierten Tool

ToolCallingAgentOutputParser-Fehler in Langchain.js verstehen und beheben

Bei der Arbeit mit Langchain.js v2 zielen Entwickler häufig darauf ab, mithilfe benutzerdefinierter Tools und Sprachmodelle wie Ollama effiziente Agenten zu erstellen. Allerdings kann die Integration dieser Komponenten manchmal zu Fehlern führen, die schwer zu debuggen sind.

Ein solcher Fehler ist „parseResult on ToolCallingAgentOutputParser funktioniert nur bei ChatGeneration-Ausgabe“, der beim Erstellen eines benutzerdefinierten Tools innerhalb des Agent-Frameworks auftreten kann. Um sicherzustellen, dass der Agent und das Tool ordnungsgemäß funktionieren, ist es wichtig, die Grundursache dieses Problems zu verstehen.

In diesem Artikel wird eine einfache Implementierung eines benutzerdefinierten Tools untersucht, das mithilfe von createToolCallingAgent von Langchain und dem Ollama-Modell 2 zu einer Zahleneingabe hinzufügt. Durch die Analyse des Fehlers und seines Kontexts können wir besser verstehen, wie wir ihn beheben können.

Die folgenden Abschnitte führen Sie durch den Code, erklären den Fehler und bieten Lösungen zur Behebung dieses Problems. Unabhängig davon, ob Sie neu bei Langchain.js sind oder bereits Erfahrung damit haben, hilft Ihnen dieser Leitfaden dabei, dieses Problem effizient zu lösen.

Verstehen der benutzerdefinierten Tool- und Agent-Fehlerbehandlung in Langchain.js

Im bereitgestellten Beispiel arbeiten wir mit Langchain.js v2, um ein benutzerdefiniertes Tool zu erstellen, das sich in das integrieren lässt Ollama Sprachmodell. Der Hauptzweck des Tools besteht darin, eine einfache mathematische Operation durchzuführen: das Addieren von 2 zum Eingabewert. Das Tool wird mit Langchains erstellt Werkzeug Funktion, die wiederverwendbare Funktionen definiert, die von einem Agenten aufgerufen werden können. Um sicherzustellen, dass das Tool ordnungsgemäß funktioniert, wird das Eingabeschema mit der Zod-Bibliothek validiert, um sicherzustellen, dass die Eingabe eine gültige Zahl ist. Dies stellt eine ordnungsgemäße Fehlerbehandlung sicher und verhindert, dass das Tool aufgrund ungültiger Eingaben ausfällt.

Das benutzerdefinierte Tool wird dann mithilfe von in einen Agenten integriert createToolCallingAgent Funktion. Dieser Befehl ermöglicht es dem Agenten, das Tool bei Bedarf aufzurufen, und der Agent basiert auf dem Ollama-Modell, das mit spezifischen Parametern wie der Temperatur konfiguriert ist, um die Kreativität der Antworten zu steuern. Um eine reibungslose Interaktion zwischen dem Agenten und dem Tool zu ermöglichen, wird eine Chat-Eingabeaufforderungsvorlage verwendet. Diese Vorlage organisiert die Konversation, indem sie verschiedene Arten von Nachrichten definiert, z. B. Systemnachrichten, menschliche Eingaben und Platzhalter. Die Platzhalter, wie z NachrichtenPlatzhalterermöglichen eine dynamische Konversation, wobei Elemente wie der Chatverlauf einbezogen werden.

Eines der Hauptprobleme, die in diesem Beispiel angesprochen werden, ist die Fehlerbehandlung rund um die Ausgabeanalyse des Langchain-Agenten. Die Fehlermeldung „parseResult on ToolCallingAgentOutputParser funktioniert nur bei ChatGeneration-Ausgabe“ ist auf eine Diskrepanz zwischen dem vom Parser erwarteten Ausgabetyp und der tatsächlich generierten Ausgabe zurückzuführen. Um diesen Fehler zu beheben, ist das benutzerdefinierte Tool in eine robuste Logik eingebettet, die sicherstellt, dass alle Ein- und Ausgaben den erwarteten Formaten entsprechen. Dies wird weiterhin von der verwaltet AgentExecutor Klasse, die die Ausführung des Agenten und der Tools koordiniert und sicherstellt, dass die Abfrage- und Tool-Ausgabe ordnungsgemäß synchronisiert werden.

Schließlich implementieren die Skripte die asynchrone Ausführung mithilfe von erwartenDadurch kann das System Vorgänge ausführen, ohne andere Prozesse zu blockieren. Der Agent wartet, bis das Tool sein Ergebnis zurückgibt, bevor er fortfährt, und stellt so sicher, dass die Antwort sowohl korrekt als auch zeitnah ist. Darüber hinaus sind Unit-Tests enthalten, um die Funktionalität des Tools zu validieren und sicherzustellen, dass es stets die richtige Ausgabe liefert. Diese Tests bestätigen nicht nur die mathematische Funktionsweise des Tools, sondern überprüfen auch, wie gut es mit ungültigen Eingaben umgeht, wodurch die Gesamtzuverlässigkeit der Lösung verbessert wird. Dieses modulare und fehlerresistente Design macht die Skripte für verschiedene Anwendungen innerhalb von Langchain.js wiederverwendbar und effektiv.

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);
});

Erkundung der Rolle von Agenten bei der Integration von Langchain.js und Ollama LLM

Bei der Arbeit mit Langchain.js ist die Integration Agenten mit Tools und Sprachmodellen wie Ollama ist ein entscheidender Aspekt beim Erstellen dynamischer Anwendungen. Mit einem Agenten können Sie ein benutzerdefiniertes Tool, das bestimmte Aufgaben ausführt, mit einem Sprachmodell verbinden, das eher konversationale oder generative Aufgaben übernimmt. Mithilfe von Agenten können Entwickler Arbeitsabläufe automatisieren, bei denen ein Modell nicht nur Antworten generiert, sondern auch Tools zur Durchführung von Berechnungen oder Datenverarbeitung aufruft.

Die Schlüsselkomponente dieser Integration ist die createToolCallingAgent Funktion. Mit dieser Funktion kann der Agent bei Bedarf bestimmte Tools auslösen und so sicherstellen, dass Aufgaben präzise und effizient erledigt werden. Während das Hauptaugenmerk oft auf der Erstellung des Tools selbst liegt, ist es ebenso wichtig zu verstehen, wie man den Arbeitsablauf des Agenten verwaltet und Analysefehler vermeidet. Fehler wie „parseResult on ToolCallingAgentOutputParser funktioniert nur bei ChatGeneration-Ausgabe“ treten normalerweise auf, wenn die Ausgabe des Agenten nicht mit dem Parsing-System kompatibel ist, was die Notwendigkeit einer ordnungsgemäßen Ausrichtung zwischen der Ausgabe des Agenten und dem erwarteten Format verdeutlicht.

Die Verwendung von Eingabeaufforderungsvorlagen, wie z ChatPromptTemplate, bereichert die Interaktion weiter, indem es dynamische Nachrichten und Kontextplatzhalter ermöglicht. Dadurch kann der Agent seine Antworten basierend auf dem Chat-Verlauf oder dem Notizblock des Agenten anpassen. Durch die Optimierung der Eingabeaufforderungsvorlagen und die Sicherstellung, dass die Ausgaben des Agenten korrekt analysiert werden, können viele häufige Fehler vermieden werden, wodurch Ihre Langchain.js-Anwendungen zuverlässiger und effizienter werden.