Naprawianie błędu ToolCallingAgentOutputParser Langchain.js za pomocą Ollama LLM i narzędzia niestandardowego

Zrozumienie i naprawienie błędów ToolCallingAgentOutputParser w Langchain.js

Pracując z Langchain.js v2, programiści często dążą do stworzenia wydajnych agentów przy użyciu niestandardowych narzędzi i modeli językowych, takich jak Ollama. Jednak integracja tych komponentów może czasami prowadzić do błędów trudnych do debugowania.

Jednym z takich błędów jest „parseResult on ToolCallingAgentOutputParser działa tylko na danych wyjściowych ChatGeneration”, który może wystąpić podczas tworzenia niestandardowego narzędzia w środowisku agenta. Zrozumienie pierwotnej przyczyny tego problemu ma kluczowe znaczenie dla zapewnienia prawidłowego działania agenta i narzędzia.

W tym artykule omówiono prostą implementację niestandardowego narzędzia, które dodaje 2 do wprowadzanej liczby, przy użyciu metody createToolCallingAgent firmy Langchain i modelu Ollama. Analizując błąd i jego kontekst, możemy lepiej zrozumieć, jak go rozwiązać.

Poniższe sekcje przeprowadzą Cię przez kod, wyjaśnią błąd i przedstawią rozwiązania tego problemu. Niezależnie od tego, czy jesteś nowym użytkownikiem Langchain.js, czy doświadczonym, ten przewodnik pomoże Ci skutecznie pokonać ten problem.

Zrozumienie obsługi błędów narzędzia niestandardowego i agenta w Langchain.js

W podanym przykładzie pracujemy z Langchain.js v2, aby stworzyć niestandardowe narzędzie, które integruje się z Ollama model języka. Głównym celem narzędzia jest wykonanie prostej operacji matematycznej: dodanie 2 do wartości wejściowej. Narzędzie zbudowane jest przy użyciu Langchaina narzędzie funkcja, która definiuje funkcje wielokrotnego użytku, które może wywołać agent. Aby mieć pewność, że narzędzie działa poprawnie, schemat wejściowy jest sprawdzany za pomocą biblioteki Zod, co gwarantuje, że wprowadzone dane są poprawną liczbą. Zapewnia to prawidłową obsługę błędów i zapobiega awariom narzędzia z powodu nieprawidłowych danych wejściowych.

Niestandardowe narzędzie jest następnie włączane do agenta za pomocą utwórzToolCallingAgent funkcjonować. To polecenie umożliwia agentowi wywołanie narzędzia w razie potrzeby, a agent działa w oparciu o model Ollama, w którym skonfigurowano określone parametry, takie jak temperatura, w celu kontrolowania kreatywności odpowiedzi. Aby ułatwić płynną interakcję pomiędzy agentem a narzędziem, zastosowano szablon podpowiedzi czatu. Ten szablon organizuje konwersację, definiując różne typy wiadomości, takie jak wiadomości systemowe, informacje wprowadzane przez człowieka i symbole zastępcze. Elementy zastępcze, takie jak Symbol zastępczy Wiadomości, pozwól, aby rozmowa była dynamiczna i uwzględniała takie elementy, jak historia czatów.

Jednym z kluczowych problemów poruszonych w tym przykładzie jest obsługa błędów związanych z analizą wyników agenta Langchain. Komunikat o błędzie „parseResult on ToolCallingAgentOutputParser działa tylko na wynikach ChatGeneration” wynika z niezgodności pomiędzy typem wyniku oczekiwanym przez parser a rzeczywistym wygenerowanym wyjściem. Aby obsłużyć ten błąd, niestandardowe narzędzie jest wyposażone w solidną logikę, która zapewnia, że ​​wszystkie dane wejściowe i wyjściowe są zgodne z oczekiwanymi formatami. Jest to dalej zarządzane przez Wykonawca agenta class, która koordynuje wykonanie agenta i narzędzi, upewniając się, że zapytanie i dane wyjściowe narzędzia są odpowiednio zsynchronizowane.

Na koniec skrypty implementują wykonanie asynchroniczne za pomocą czekać na, pozwalając systemowi na obsługę operacji bez blokowania innych procesów. Agent czeka, aż narzędzie zwróci wynik, zanim przejdzie dalej, upewniając się, że odpowiedź jest zarówno dokładna, jak i terminowa. Dodatkowo dostępne są testy jednostkowe w celu sprawdzenia funkcjonalności narzędzia i zapewnienia, że ​​stale generuje ono prawidłowe dane wyjściowe. Testy te nie tylko potwierdzają matematyczne działanie narzędzia, ale także sprawdzają, jak dobrze radzi sobie ono z nieprawidłowymi danymi wejściowymi, poprawiając ogólną niezawodność rozwiązania. Ta modułowa i odporna na błędy konstrukcja sprawia, że ​​skrypty nadają się do wielokrotnego użytku i są skuteczne w różnych zastosowaniach w 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);
});

Odkrywanie roli agentów w integracji Langchain.js i Ollama LLM

Podczas pracy z Langchain.js, integracja agenci z narzędziami i modelami językowymi, takimi jak Ollama, jest krytycznym aspektem tworzenia dynamicznych aplikacji. Agent umożliwia połączenie niestandardowego narzędzia, które wykonuje określone zadania, z modelem językowym, który obsługuje bardziej konwersacyjne lub generatywne zadania. Korzystając z agentów, programiści mogą automatyzować przepływy pracy, w których model nie tylko generuje odpowiedzi, ale także wywołuje narzędzia do wykonywania obliczeń lub przetwarzania danych.

Kluczowym elementem tej integracji jest utwórzToolCallingAgent funkcjonować. Ta funkcja umożliwia agentowi uruchomienie określonych narzędzi, gdy jest to konieczne, zapewniając dokładne i wydajne wykonywanie zadań. Chociaż główny nacisk kładziony jest często na stworzenie samego narzędzia, równie ważne jest zrozumienie, jak zarządzać przepływem pracy agenta i unikać błędów analizy. Błędy takie jak „parseResult on ToolCallingAgentOutputParser działa tylko na wynikach ChatGeneration” zwykle pojawiają się, gdy dane wyjściowe agenta nie są kompatybilne z systemem analizowania, co uwydatnia potrzebę odpowiedniego wyrównania wyników agenta z oczekiwanym formatem.

Stosowanie szablonów podpowiedzi, np Szablon ChatPrompt, dodatkowo wzbogaca interakcję, umożliwiając dynamiczne komunikaty i elementy zastępcze kontekstu. Dzięki temu agent może dostosować swoje odpowiedzi na podstawie historii rozmów lub notatnika agenta. Optymalizacja szablonów podpowiedzi i zapewnienie prawidłowej analizy wyników agenta może zapobiec wielu typowym błędom, dzięki czemu aplikacje Langchain.js będą bardziej niezawodne i wydajne.