0Pricing
AI Engineering Academy · Lektion

Tools für Ihren Agenten definieren

Sie erstellen benutzerdefinierte Tools mit dem Dekorator @tool, verfassen klare Beschreibungen, anhand derer das LLM entscheidet, wann es ein Tool aufruft, und ergänzen die Eingabevalidierung mit Pydantic.

Tools für Ihren Agenten definieren ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Tools verleihen Agenten Superkräfte

Ein Agent ohne Tools kann nur über das nachdenken, was er bereits weiß – er kann weder das Web durchsuchen noch eine Datenbank abfragen oder eine E-Mail senden. Tools sind Python-Funktionen, die die Fähigkeiten des Agenten erweitern, indem sie ihm ermöglichen, Aktionen in der realen Welt auszuführen und aktuelle Informationen abzurufen. Eine klare Definition der Tools ist einer der wichtigsten Schritte beim Erstellen eines zuverlässigen Agenten.

Der @tool-Decorator in LangChain

Der @tool-Decorator von LangChain wandelt jede Python-Funktion in ein Tool um, das der Agent aufrufen kann. Der Docstring der Funktion wird zur Tool-Beschreibung, anhand derer das LLM entscheidet, wann es das Tool aufrufen soll. Eine klare und präzise Beschreibung verbessert die Genauigkeit der Tool-Auswahl durch den Agenten erheblich.

from langchain_core.tools import tool

@tool
def get_weather(city: str) -> str:
    '''Get the current weather conditions for a given city.
    Use this tool when the user asks about weather in a specific location.
    Input should be just the city name, e.g. 'London' or 'New York'.
    '''
    # Real implementation would call a weather API
    return f'The weather in {city} is 18 degrees Celsius and partly cloudy.'

print(get_weather.name)         # 'get_weather'
print(get_weather.description)  # The docstring above

Typannotationen und Schema-Generierung

LangChain generiert automatisch ein JSON Schema für jedes Tool aus dessen Python-Typannotationen. Der Agent erhält dieses Schema im System-Prompt und weiß dadurch, welche Argumente erforderlich sind, welche Typen sie haben und welche Einschränkungen gelten. Annotieren Sie Ihre Tool-Funktionen immer mit präzisen Typen.

from langchain_core.tools import tool

@tool
def calculate_compound_interest(
    principal: float,
    annual_rate: float,
    years: int
) -> float:
    '''Calculate compound interest earned over a number of years.
    Args:
        principal: Initial investment amount in dollars.
        annual_rate: Annual interest rate as a decimal (e.g. 0.05 for 5%).
        years: Number of years to compound.
    Returns:
        Final amount after compounding.
    '''
    return principal * (1 + annual_rate) ** years

# Inspect the auto-generated schema
print(calculate_compound_interest.args_schema.schema())

Eingabevalidierung mit Pydantic

Definieren Sie für Tools mit komplexen Eingaben ein Pydantic-Modell als args_schema. Dadurch erhalten Sie automatische Validierung, Typumwandlung und eine aussagekräftige Dokumentation auf Feldebene, die das LLM bei der Entscheidung über den Tool-Aufruf sieht.

from langchain_core.tools import tool
from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description='The search query to look up.')
    num_results: int = Field(default=5, ge=1, le=20, description='Number of results to return (1-20).')

@tool(args_schema=SearchInput)
def web_search(query: str, num_results: int = 5) -> str:
    '''Search the web for current information on any topic.
    Use this for facts that may have changed after the model training cutoff.
    '''
    return f'Searching for "{query}", returning {num_results} results...'

Effektive Tool-Beschreibungen verfassen

Die Beschreibung des Tools ist der wichtigste Teil Ihrer Tool-Definition — das LLM liest sie, um zu entscheiden, wann und wie das Tool aufgerufen werden soll. Eine gute Beschreibung beantwortet folgende Fragen: Was macht dieses Tool? Wann sollte es verwendet werden? Wie sollten die Eingaben aussehen? Wie sieht die Ausgabe aus?

  • Schlecht: „Suchtool.“
  • Gut: „Durchsuchen Sie das Web nach aktuellen Nachrichten, Fakten oder Daten. Verwenden Sie das Tool, wenn der Benutzer nach aktuellen Ereignissen oder Fakten fragt, die nicht in den Trainingsdaten enthalten sind. Eingabe: eine prägnante Suchanfrage.“

Rückgabetypen von Tools

Tools können Zeichenketten, Dictionaries oder strukturierte Pydantic-Objekte zurückgeben. Letztendlich benötigt der Agent das Ergebnis jedoch als Text, um es in die Konversation einzufügen. Wenn Sie ein Dict zurückgeben, serialisiert LangChain es in eine Zeichenkette. Bei komplexen verschachtelten Daten sollten Sie sie als gut lesbare Zusammenfassung statt als rohes JSON formatieren, damit das Modell besser damit arbeiten kann.

from langchain_core.tools import tool
import json

@tool
def get_stock_price(ticker: str) -> str:
    '''Look up the current stock price for a given ticker symbol.
    Input should be the stock ticker symbol in uppercase, e.g. AAPL or MSFT.
    '''
    # Stub — real implementation calls a financial API
    data = {'ticker': ticker, 'price': 182.50, 'currency': 'USD', 'change': '+1.2%'}
    return f'{ticker}: ${data["price"]} ({data["change"]})'

Tool-Fehler elegant behandeln

Tools können fehlschlagen. APIs sind nicht erreichbar, Netzwerk-Timeouts treten auf und Benutzer geben ungültige Eingaben an. Statt Ihre Agent-Schleife durch Exceptions abstürzen zu lassen, sollten Sie die Tool-Logik in try/except einschließen und eine beschreibende Fehlerzeichenkette zurückgeben. Der Agent kann dann den Fehler analysieren und entscheiden, ob er es erneut versucht oder einen anderen Ansatz verwendet.

from langchain_core.tools import tool
import requests

@tool
def fetch_url(url: str) -> str:
    '''Fetch the text content of a web page given its URL.
    Use for accessing specific documents or web pages the user references.
    '''
    try:
        resp = requests.get(url, timeout=10)
        resp.raise_for_status()
        return resp.text[:2000]  # Return first 2000 chars
    except requests.Timeout:
        return 'Error: Request timed out after 10 seconds.'
    except requests.HTTPError as e:
        return f'Error: HTTP {e.response.status_code}'
    except Exception as e:
        return f'Error fetching URL: {str(e)}'

Asynchrone Tools

Wenn Ihr Agent viele Tool-Aufrufe ausführt oder Ihre Tools netzwerkgebundene I/O-Anfragen stellen, definieren Sie asynchrone Tool-Funktionen, damit die Event-Schleife nicht blockiert wird. Der Agent-Executor von LangChain unterstützt asynchrone Tools nativ — verwenden Sie einfach async def in Ihrer Tool-Funktion.

from langchain_core.tools import tool
import httpx

@tool
async def async_fetch(url: str) -> str:
    '''Asynchronously fetch content from a URL.
    Preferred over fetch_url when making multiple concurrent requests.
    '''
    async with httpx.AsyncClient(timeout=10) as client:
        try:
            resp = await client.get(url)
            resp.raise_for_status()
            return resp.text[:2000]
        except Exception as e:
            return f'Error: {str(e)}'

Tools in einem Toolkit organisieren

Wenn Sie viele verwandte Tools haben, fassen Sie sie zu einem Toolkit zusammen — einer Klasse, die eine Liste von Tools zurückgibt. LangChain-Toolkits folgen einem einheitlichen Muster: Sie akzeptieren Konfigurationen wie API-Schlüssel im Konstruktor und stellen eine get_tools()-Methode bereit. Dadurch lässt sich die Verwaltung von Tools übersichtlich und agentübergreifend wiederverwendbar gestalten.

from langchain_core.tools import BaseTool
from typing import List

class WeatherToolkit:
    def __init__(self, api_key: str):
        self.api_key = api_key

    def get_tools(self) -> List[BaseTool]:
        return [
            get_weather,          # defined earlier with @tool
            get_weather_forecast,  # another tool
            get_weather_alert      # another tool
        ]

# Usage
toolkit = WeatherToolkit(api_key='your_weather_api_key')
tools = toolkit.get_tools()
print(f'Loaded {len(tools)} weather tools')

Tool-Zugriff nach Benutzerrolle beschränken

Nicht jeder Benutzer sollte Zugriff auf jedes Tool haben. Ein Benutzer mit Nur-Lese-Zugriff sollte kein send_email- oder delete_record-Tool auslösen können. Implementieren Sie einen rollenbasierten Tool-Zugriff, indem Sie anhand der Berechtigungen des authentifizierten Benutzers auswählen, welche Tools Sie an den Agent übergeben.

def get_tools_for_user(user_role: str) -> list:
    read_tools = [web_search, get_weather, calculate_compound_interest]
    write_tools = [send_email, create_calendar_event, update_record]

    if user_role == 'admin':
        return read_tools + write_tools
    elif user_role == 'member':
        return read_tools
    else:
        return [web_search]  # Guest: only public search

Best Practices für die Tool-Dokumentation

Gut dokumentierte Tools reduzieren Agent-Fehler deutlich. Befolgen Sie diese Best Practices: Verwenden Sie einen klaren Verb-Erst-Namen (search_web statt websearch), beschreiben Sie das erwartete Eingabeformat ausdrücklich, geben Sie an, wann das Tool NICHT verwendet werden sollte, um Fehlalarme zu vermeiden, und beschreiben Sie, wie die Ausgabe aussieht, damit das Modell sie korrekt verarbeiten kann.

Kurzer Check

Testen Sie Ihr Verständnis der Tool-Definition für LangChain-Agenten.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: Der @tool-Dekorator verwandelt Python-Funktionen mithilfe ihrer Docstrings als Beschreibungen in Tools, die von Agenten aufgerufen werden können, Pydantic-Schemas ergänzen validierte typisierte Eingaben und Tools sollten Fehler elegant behandeln, indem sie beschreibende Fehlerzeichenketten zurückgeben. Als Nächstes erstellen wir einen vollständigen ReAct-Agenten mit LangChain und verfolgen seine Denkschritte.

Häufig gestellte Fragen

Ist die Lektion „Tools für Ihren Agenten definieren“ kostenlos?

Ja — der vollständige Text von „Tools für Ihren Agenten definieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Tools für Ihren Agenten definieren“?

Sie erstellen benutzerdefinierte Tools mit dem Dekorator @tool, verfassen klare Beschreibungen, anhand derer das LLM entscheidet, wann es ein Tool aufruft, und ergänzen die Eingabevalidierung mit Pyd… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Engineering Academy zu starten?

Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Tools für Ihren Agenten definieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?

Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Das ReAct-Framework: Denken, Handeln, Beobachten
  2. Tools für Ihren Agenten definieren
  3. Einen ReAct-Agenten mit LangChain erstellen
  4. Fehler und Endlosschleifen von Agents behandeln
← Zurück zu AI Engineering Academy