Ihr erster KI-Agent zur Verwendung von Tools mit LangChain

Eine kurze Übung mit Python + LangChain erstellt einen agentenähnlichen Rechner, der bei Bedarf Hilfsfunktionen für Addition, Subtraktion, Multiplikation, Division oder Quadratwurzel aufrufen kann.

Die Arithmetik ist nur zweitrangig. Die wichtige Lektion besteht darin, zu beobachten, wie ein LLM Hilfsfunktionen erhält und entscheidet, welche Funktion in welchem Schritt aufgerufen werden soll.

Beispiele für Aufgaben, die der fertige Agent bewältigen kann:

Multiplizieren Sie 25 mit 4. Nehmen Sie anschließend die Quadratwurzel von 144 und multiplizieren Sie das Ergebnis mit 5.

Anstatt die genaue Rechenabfolge vorzuschreiben, werden mehrere Hilfsfunktionen registriert. Das Modell wählt aus ihnen entsprechend der Formulierung des Benutzers aus.

1. Das Modell initialisieren

Beginnen Sie damit, das Chat-Modell zu erstellen:

from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-4o-mini")

Bislang existiert noch nichts Agentähnliches – nur ein Textmodell, das lesen und schreiben kann.

2. Aufrufbare Hilfsfunktionen registrieren

Agenten werden nützlich, wenn sie über die reine Textgenerierung hinausgehen und Anwendungsfunktionen aufrufen können.

Definieren Sie fünf minimale Hilfsfunktionen:

from langchain.tools import tool
import math

@tool
def add(a: float, b: float) -> float:
    """Add two numbers."""
    return a + b

@tool
def subtract(a: float, b: float) -> float:
    """Subtract two numbers."""
    return a - b


@tool
def multiply(a: float, b: float) -> float:
    """Multiply two numbers."""
    return a * b


@tool
def divide(a: float, b: float) -> float:
    """Divide two numbers."""
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b


@tool
def square_root(a: float) -> float:
    """Calculate the square root of a number."""
    if a < 0:
        raise ValueError("Cannot calculate square root of a negative number.")
    return math.sqrt(a)

Durch das Dekorieren mit @tool wird jede Funktion in einer vom Agenten-Laufzeitumfeld verstandenen Form bereitgestellt.

Zwei Aspekte leiten das Modell:

1. Angegebene Parameter deklarieren die erwarteten Argumenttypen.

a: float
b: float

1. Dokumentationsstrings liefern Beschreibungen in Alltagssprache, die das Modell bei der Entscheidung über Relevanz liest.

Für Agenten-Tools ist die narrative Beschreibung einer Funktion Teil der Steueroberfläche und keine Dekoration.

"""Multiply two numbers."""

3. Der Agent verbinden

Fügen Sie die Hilfsfunktionen dem Modell hinzu:

from langchain.agents import create_agent

agent = create_agent(
    model=model,
    tools=[
        add,
        subtract,
        multiply,
        divide,
        square_root
    ],
)

Von hier an kann das Chatmodell als Agent statt als Einmalantworter fungieren.

Zu den typischen Schritten gehören:

1. Die Absicht des Benutzers analysieren

Bewerten, ob ein Hilfsprogramm benötigt wird

Ein Hilfsprogramm auswählen

Argumente bereitstellen

Den Rückgabewert des Hilfsprogramms verwenden

Entscheiden, ob ein weiterer Schritt erforderlich ist

Die endgültige Antwort ausgeben

In groben Zügen:

User
 ↓
Agent
 ↓
Should I use a tool?
 ↓
Choose tool
 ↓
Execute tool
 ↓
Get result
 ↓
Final response

Mehrschrittige Fragen können diesen Zyklus wiederholen.

4. Eine Ausführung starten

Ein einfacher Wrapper reicht aus, um dies zu steuern:

def run_agent(question: str):
    """Run the agent and print the execution trace."""

    print(f"User: {question}")

    result = agent.invoke({
        "message": [("user", question)],
    })

    print("Agent:", result)

Auf eine einfache Frage aufrufen:

run_agent("What is 25 multiplied by 4?")

Es gibt keine Anweisung, die besagt „rufe multiply auf.“

Nur der Katalog der Hilfsprogramme wurde bereitgestellt.

Anhand der Formulierung und der Beschreibung jedes Hilfsprogramms kommt das Modell zu dem Schluss, dass eine Multiplikation angebracht ist.

5. Mehrere Hilfsprogramme hintereinander verwenden

Einen zusammengesetzten Prompt ausprobieren:

run_agent(
    "Calculate the square root of 144 and multiply the result by 5."
)

Zwei Operationen sind erforderlich.

Der konzeptionelle Ablauf sieht wie folgt aus:

User:

Calculate √144 × 5
        ↓
Agent chooses square_root
        ↓
square_root(144)
        ↓
12
        ↓
Agent chooses multiply
        ↓
multiply(12, 5)
        ↓
60
        ↓
Final answer

Diese Schleife – wählen, aufrufen, beobachten, erneut wählen – ist das Wesen von Werkzeugnutzenden Agenten.

Der Anwendungscode muss die vollständige Ablaufreihenfolge nicht im Voraus kodieren.

Das Modell kann den nächsten Schritt aus den verbleibenden Hilfsfunktionen und dem Gesprächszustand ableiten.

6. Vergleich mit einem einfachen LLM

Ohne Werkzeuge könnte ein Modell als Text „Die Antwort ist 60“ erfinden.

Mit registrierten Hilfsfunktionen kann es numerische Aufgaben an echte Funktionen übertragen.

Der Kontrollwechsel

Nur-Text-Pfad: Benutzer → Modell → Antwortzeichenkette

im Gegensatz zu:

Tool-using agent

User
  ↓
LLM
  ↓
Choose tool
  ↓
Execute code
  ↓
Observe result
  ↓
LLM
  ↓
Answer

Das Modell muss nicht mehr jede Berechnung selbst durchführen.

Es schlägt vor, welche Aktion als Nächstes ausgeführt werden soll; die Anwendung entscheidet, welche Aktionen vorhanden sind und wie sie ausgeführt werden.

7. Die Grenze, die geschützt werden muss

Die Rechenuhr ist ein Lehrspielzeug.

Die zentrale Idee besteht in der Trennung zwischen Modellurteil und Anwendungsautorität.

Das Verständnis natürlicher Sprache sowie die Auswahl von Aktionen passen gut zu großen Sprachmodellen.

Die Ausführung dieser Aktionen sollte unter Ihrer Kontrolle in Python erfolgen.

Das Modell kann zu dem Schluss kommen, dass eine Trennung notwendig ist.

Ihr Prozess ist für die Implementierung dieser Trennung sowie deren Nebeneffekte verantwortlich.

Ersetzen Sie die einfachen Mathematik-Hilfsfunktionen durch domänenspezifische Operationen wie:

get_customer()
search_transactions()
create_report()
send_email()
query_database()
get_weather()
create_ticket()

und das gleiche Orchestrierungsmuster beginnt, Designs für Produktionsagenten zu ähneln.

Zusammenfassung der Übung

Mehrere Module haben einen Agenten erstellt, der in der Lage ist:

• Freiformfragen zu interpretieren
• Aus mehreren registrierten Hilfsfunktionen auszuwählen
• Argumente korrekt zu verknüpfen
• Hilfsfunktionen innerhalb einer Sitzung zu kombinieren
• Die Ausgaben der Hilfsfunktionen wieder in spätere Überlegungen einzubringen

Beantworten Sie den Benutzer, nachdem die Kette abgeschlossen ist

Kurz gesagt: eine LLM, die Aktionen auswählt und ausführt, nicht eine, die nur Prosa erzeugt.