Startseite / Artikel

Toolaufrufe in LangChain: Der Mechanismus hinter agilen Anwendungen

Registrieren Sie Python-Funktionen als LangChain-Tools und führen Sie den vierstufigen Zyklus aus, bei dem das Modell Tools auswählt, diese extern ausgeführt werden und die Ergebnisse als Nachrichten zurückgegeben werden.

Verlag: REACTAPP.TOP6 Min. Lesezeit1280 Wörter

Quellen: Agentic AI with LangChain — Part 3: Tool Calling in LangChain

Dies ist der dritte Beitrag in der Serie „Agentic AI mit LangChain“. Teil 2 entwickelte einen agierenden RAG-Arbeitsablauf mit LangGraph. Der nächste Schritt besteht darin, das System auf weitere Bereiche wie Kochen, Schwimmen, klassische Musik und sogar Echtzeit-Wetterdaten für Städte weltweit auszudehnen, ohne dass der Graph durch neue Knoten überlastet wird.

Entlang des Musters von Teil 2 könnte man pro Bereich einen Abrufknoten hinzufügen, wobei jeder seinen eigenen Pinecone-Index besitzt, sowie einen Wetterknoten, der auf eine öffentliche API zugreift. Wenn sich die Knoten vermehren, nehmen auch die Verbindungen und Verzweigungen zu, wodurch der Graph schwerer zu verwalten wird.

Die Aufrufung von Tools ist die Lösung. Anstelle eines Knotens pro Funktion sollten diese Funktionen als LangChain-Tools registriert werden, sodass das Modell entscheiden kann, wann sie aufgerufen werden, wie die Ergebnisse verwendet und wie sie in die endgültige Antwort integriert werden. Dadurch wird der Arbeitsablauf vereinfacht und das Modell um präzise Berechnungen, Datenbankabfragen, Websuche sowie Echtzeit-APIs erweitert.

Im Folgenden werden die Kernideen sowie ein Tool-Aufruf-Loop in LangChain erläutert. Diese Grundlagen bereiten den nächsten Artikel über ReAct vor. Wenn ReAct verstanden ist, kann der Arbeitsablauf in Teil 2 mithilfe derselben Konzepte vereinfacht werden. Der Code befindet sich im GitHub-Repository.

Themen:

  • Was Tool-Aufrufe sind und warum sie wichtig sind.
  • Wie LangChain-Tools implementiert werden.
  • Wie der vierstufige Tool-Aufruf-Loop funktioniert.

Wortschatz

  • LangChain-Tool: Eine Python-Funktion, die mit @tool dekoriert ist und deren Schema sowie Anleitung zur Verwendung dem Modell zugänglich macht.
  • Toolaufruf: Der Mechanismus, durch den das Modell einen Aufruf einer externen Funktion anfordert.
  • Tool-Nachricht: Die Nachrichtenart, die die Ergebnisse des Tools zurück zum Modell überträgt.
  • Tool-Aufruf-Loop: Der Zyklus, in dem das Modell ein Tool auswählt, das Tool außerhalb des Modells ausgeführt wird, die Ergebnisse zurückkehren und das Modell sie in die Antwort einbezieht.

Einrichtung

Erstellen Sie eine .env-Datei mit den Schlüsseln von OpenAI und Tavily.

OPENAI_API_KEY="<Your OpenAI API Key>"
TAVILY_API_KEY=<Your TAVILY API Key>

Laden Sie sie über eine Pydantic-Settings-Klasse.

class BaseConfig(BaseSettings):
    OPENAI_API_KEY: Optional[str]
    PINECONE_API_KEY: Optional[str]
    TAVILY_API_KEY: Optional[str]

model_config = SettingsConfigDict(env_file=".env", extra="ignore")

Das Projekt bewahrt die Tools in einem tools-Paket auf, zusammen mit einfachen Beispielen wie einem Hilfsprogramm für die Berechnung von Summen und einem Wettertool.

project/
|
├── tools
│   ├── get_sum.py    # a simple LangChain tool example
|   └── weather.py    # get_weather LangChain tool using open source APIs
|
|── tool_call.py      # implement tool-calling loop using LangChain tools
├── config.py         # pydantic BaseConfig
├── .env              # environment variable definition
├── .gitignore
└── requirements.txt  # package requirements

Was ein LangChain-Tool ist

Ein Tool ist eine gewöhnliche Python-Funktion mit dem @tool-Decorator. Der Decorator umhüllt die Funktion, erstellt ein Schema aus der Dokumentation und Typhinweisen sowie gibt dem Modell Anweisungen für den Aufruf.

from langchain.tools import tool


@tool
def get_sum(a: int, b: int) -> int:
    """
    get the summation of two integers
    :param a: int, input integer
    :param b: int, input integer
    :return: int, the sum of a and b
    """
    return a + b

Ein Wetterwerkzeug

get_weather nutzt die kostenlose Open-Meteo API. Zunächst werden die Koordinaten einer Stadt abgerufen, anschließend das aktuelle Wetter. Dieses Muster von Zuerst-Auflösung dann Abruf ist typisch für Echtzeit-Werkzeuge.

Der Werkzeugaufruf-Zyklus

Sobald die Werkzeuge vorhanden sind, stellt sich die nächste Frage: Wie verwendet das Modell sie? Die Antwort ist ein vierstufiger Zyklus.

  1. Der Benutzer sendet eine Anfrage.
  2. Das Modell entscheidet, welches oder welche Werkzeuge aufgerufen werden sollen, und sendet eine Nachricht mit Namen sowie Argumenten.
  3. Die Werkzeuge laufen außerhalb des Modells, und ihre Ergebnisse werden als Werkzeugnachrichten zurückgegeben.
  4. Das Modell integriert diese Ergebnisse und erzeugt eine endgültige Antwort.

Das Modell führt die Werkzeuge niemals selbst aus. Alles läuft extern, und die Ausgaben kommen als Werkzeugnachrichten zurück, über die das Modell anschließend nachdenkt.

Das Modell kann auch in einer einzigen Antwort mehrere Tools anfordern, was als parallele Toolaufrufe bezeichnet wird. Wenn nach der Temperatur in Boston sowie der Summe von drei und fünf gefragt wird, kann es gleichzeitig sowohl get_weather als auch get_sum aufrufen; der Loop führt beide Aufrufe aus, bevor eine Antwort gegeben wird.

Implementierung des Loops in LangChain

Eine WeatherAssistant-Klasse umschließt die Funktionen für Wetterinformationen und Web-Suche mithilfe von get_weather und tavily_search.

LLM und Tools

Der Konstruktor rüstet ein OpenAI-Modell, ein Dictionary mit Tools, ein LLM, das diese Tools aufrufen kann, eine Liste von Nachrichten sowie einen Systemprompt aus, der dem Modell mitteilt, wann jedes Tool verwendet werden soll.

class WeatherAssistant:
    def __init__(self):

        # initialize llm
        self.llm = ChatOpenAI(api_key=api_key, model="gpt-4o-mini", temperature=0)

        # initialize a tool dictionary
        self.tools = {"get_weather": get_weather,
                      "tavily_search": TavilySearch(max_results=3, tavily_api_key=TAVILY_API_KEY)}
        # bind LangChain tools to llm
        self.llm_with_tools = self.llm.bind_tools(list(self.tools.values()))

        # initialize messages to store message list
        self.messages = []

        # System prompt
        self.system_prompt = f"""You are a helpful assistant for question-answering tasks.
        When users ask about weather, use the get_weather tool to get weather. For other questions,
        use web_search. If you don't know the answer, just say that you don't know.
        Be conversational and helpful in your responses."""

        self.messages.append(SystemMessage(content=self.system_prompt))

Die Chat-Methode

chat fügt die Benachrichtigung des Nutzers hinzu, ruft das Modell auf und führt bei vorhandenen Tool-Aufrufen jedes Tool in einer Schleife aus, fügt jedes Ergebnis als ToolMessage hinzu und ruft anschließend erneut das Modell auf, um die endgültige Antwort zu erhalten. Dieses Muster bewältigt sowohl einzelne als auch parallele Aufrufe.

async def chat(self, message: str):
    # Wrap User message in a HumanMessage and add it to message list
    self.messages.append(HumanMessage(content=message))

    # Get AI response (it may or may not contain tool calls)
    response = await self.llm_with_tools.ainvoke(self.messages)
    self.messages.append(response)

    # If there is any tool calls in the AI response
    if response.tool_calls:

        # process tool calls
        for tool_call in response.tool_calls:

            # retrieve function name from tool_call, then
            # retrieve the tool from tool dictionary, and invoke it,
            # append resulting tool message to message list
            tool = self.tools[tool_call["name"]]
            tool_result = await tool.ainvoke(tool_call)
            self.messages.append(tool_result)

        # Get final response after tool execution
        final_response = await self.llm_with_tools.ainvoke(self.messages)
        self.messages.append(final_response)

Ein schneller Test

Ein kleiner asynchroner Hauptteil erstellt den Assistenten und fragt nach der Temperatur in Tokio.

async def main():
    print("hello tool calling!")
    assistant = WeatherAssistant()
    message = "What is the temperature in Tokyo?"
    await assistant.chat(message)
    for msg in assistant.messages:
        msg.pretty_print()
if __name__ == "__main__":
    asyncio.run(main())

Die Nachrichtenliste zeigt anschließend eine klare Abfolge: eine menschliche Nachricht mit der Frage, eine KI-Nachricht mit einem Aufruf des Tools get_weather, eine Tool-Nachricht mit dem Wetterinhalt sowie eine letzte KI-Nachricht mit der gesprochenen Antwort.

Hinweise zu Fehlern und Wiederholungsversuchen\n\nFalls ein Tool einen Fehler auslöst, sollte der Loop die Ausnahme erfassen, sie in eine klare Tool-Nachricht umwandeln und dem Modell überlassen, ob es erneut versuchen oder sich entschuldigen soll. Blinde Wiederholungsversuche mit denselben fehlerhaften Argumenten verschwenden Zeit; es ist besser, den Fehlertext sichtbar zu machen, damit das Modell entsprechend anpassen kann.\n\n## Warum das für die Serie wichtig ist

Die Aufrufung von Tools ist die Grundlage von ReAct sowie jedes Agents, das seine eigenen Aktionen entscheidet. Sobald der Zyklus stabil ist, bedeutet das Hinzufügen einer neuen Fähigkeit das Schreiben einer weiteren @tool-Funktion anstelle eines weiteren Graphenodes. Das ist die Vereinfachung, auf die der überfüllte Workflow von Teil 2 gewartet hat. Da die Tools einmal registriert sind, werden neue Domänen nicht mehr als neue Graphenodes betrachtet, sondern als neue Funktionen, die das Modell aus ihren Schemata und Dokumentationen entdecken kann. Der nächste Artikel baut auf diesem Zyklus mit dem ReAct-Muster auf und kehrt anschließend zum Graphen aus Teil 2 zurück, um zu zeigen, wie viel Verkabelung verschwindet, sobald die Entscheidungen durch die Aufrufung von Tools getroffen werden.