Vom lokalen LLM zum werkzeugnutzenden Agenten

Vom lokalen LLM zum werkzeugnutzenden Agenten

Der Weg von der Ausführung eines großen Sprachmodells (LLM) auf eigener Hardware hin zur Entwicklung eines werkzeugnutzenden Agenten ist eine der transformativsten Entwicklungen in der angewandten KI heute. Während lokale LLMs Privatsphäre, Kontrolle und Offline-Fähigkeiten bieten, fehlt ihnen die Möglichkeit, mit externen Systemen zu interagieren – Datenbanken, APIs, Dateisystemen oder Webdiensten. Durch die Integration von Werkzeugnutzung verwandeln Sie ein statisches Modell in einen autonomen Agenten, der Informationen abrufen, Berechnungen durchführen und Aktionen ausführen kann. Dieser Artikel bietet eine praktische Schritt-für-Schritt-Anleitung, um diese Lücke zu schließen.

Warum von einem lokalen LLM zu einem Agenten wechseln?

Lokale LLMs wie jene, die von Llama, Mistral oder Phi betrieben werden, eignen sich hervorragend für Textgenerierung, Zusammenfassungen und Frage-Antwort-Aufgaben. Allerdings sind sie durch ihren Trainingsdaten-Cutoff und die Unfähigkeit, auf Echtzeitinformationen oder externe Werkzeuge zuzugreifen, eingeschränkt. Ein werkzeugnutzender Agent erweitert das LLM um eine Reihe von Funktionen, die es aufrufen kann – wie eine Suchmaschine, einen Taschenrechner oder ein Datenbankabfrage-Tool – und entscheidet basierend auf der Benutzeranfrage, wann diese eingesetzt werden.

Dieser Ansatz ist zentral für die moderne KI-Entwicklung. Wie in Branchen-Updates von OpenAI und Microsoft festgestellt, geht der Trend hin zu Modellen, die mehrstufige Aufgaben unter Nutzung externer Ressourcen planen und ausführen können. Für lokale Bereitstellungen bedeutet dies, dass Sie einen Agenten bauen können, der vollständig auf Ihrem Rechner läuft, Ihre Datenprivatsphäre respektiert und dennoch komplexe, datengesteuerte Aufgaben bewältigt.

Voraussetzungen

Stellen Sie vor dem Start sicher, dass Ihr System diese Anforderungen erfüllt:

• **Hardware**: Ein Computer mit mindestens 8 GB RAM (16 GB empfohlen). Eine GPU mit 6 GB+ VRAM (z. B. NVIDIA RTX 3060 oder höher) beschleunigt die lokale LLM-Inferenz erheblich.
• **Betriebssystem**: Linux (Ubuntu 22.04+), macOS (Ventura+) oder Windows (mit WSL2 für beste Kompatibilität).
• **Software**:
• Python 3.10 oder neuer
• pip (Python-Paketmanager)
• Git
• Eine lokale LLM-Laufzeitumgebung (z. B. Ollama, llama.cpp oder LM Studio)
• Grundlegende Vertrautheit mit der Kommandozeile

Schritt-für-Schritt-Installation

Wir verwenden **Ollama** für das lokale LLM und ein Python-Framework namens **LangChain**, um den Agenten zu bauen. LangChain bietet eine einfache Schnittstelle zur Definition von Werkzeugen und deren Verbindung mit dem LLM.

1. Ollama installieren und ein lokales LLM herunterladen

Ollama ist ein benutzerfreundliches Tool zur Ausführung lokaler LLMs. Installieren Sie es zuerst:

# Auf Linux oder macOS (mit dem offiziellen Skript)
curl -fsSL https://ollama.com/install.sh | sh

# Auf Windows das Installationsprogramm von ollama.com herunterladen und ausführen

Starten Sie nach der Installation den Ollama-Dienst:

ollama serve

Laden Sie nun ein leistungsfähiges Modell herunter. Für die Werkzeugnutzung empfehlen wir **Mistral 7B** oder **Llama 3.1 8B**:

# Mistral 7B herunterladen (ca. 4 GB)
ollama pull mistral

# Alternativ Llama 3.1 8B herunterladen
ollama pull llama3.1

Überprüfen Sie, ob das Modell funktioniert:

ollama run mistral "Hallo, wie heißt du?"

Sie sollten eine Antwort des Modells sehen.

2. Python-Umgebung einrichten

Erstellen Sie ein neues Verzeichnis für Ihr Agentenprojekt und richten Sie eine virtuelle Umgebung ein:

mkdir lokaler-agent
cd lokaler-agent
python3 -m venv venv
source venv/bin/activate   # Auf Windows: venv\Scripts\activate

Installieren Sie die erforderlichen Python-Pakete:

pip install langchain langchain-community langchain-ollama requests

• `langchain` – das Kernframework zum Bauen von Agenten
• `langchain-community` – von der Community gepflegte Integrationen
• `langchain-ollama` – direkte Integration mit Ollama
• `requests` – für HTTP-Aufrufe (von einigen Werkzeugen verwendet)

3. Werkzeuge definieren

Werkzeuge sind Funktionen, die der Agent aufrufen kann. Wir erstellen drei einfache Werkzeuge: einen Taschenrechner, einen Websuchsimulator (mit einem statischen Datensatz) und einen Dateileser.

Erstellen Sie eine Datei namens `tools.py`:

# tools.py
import requests
import json

def taschenrechner(ausdruck: str) -> str:
    """
    Einen mathematischen Ausdruck auswerten.
    Beispiel-Eingabe: "2 + 3 * 4"
    """
    try:
        ergebnis = eval(ausdruck)
        return str(ergebnis)
    except Exception as e:
        return f"Fehler: {e}"

def web_suche(abfrage: str) -> str:
    """
    Eine Websuche simulieren. In der Praxis würden Sie eine Such-API verwenden.
    Hier geben wir ein statisches Ergebnis zur Demonstration zurück.
    """
    # Ersetzen Sie dies durch einen echten API-Aufruf (z. B. DuckDuckGo, SerpAPI)
    fake_ergebnisse = {
        "Bevölkerung von Tokio": "Tokio hat eine Bevölkerung von etwa 14 Millionen (Schätzung 2024).",
        "Wetter in London": "Aktuelles Wetter in London: 15°C, teilweise bewölkt.",
        "Python-Version": "Python 3.12 ist die neueste stabile Version ab 2025."
    }
    return fake_ergebnisse.get(abfrage.lower(), f"Keine Ergebnisse für '{abfrage}' gefunden.")

def datei_lesen(dateipfad: str) -> str:
    """
    Den Inhalt einer Textdatei lesen.
    """
    try:
        with open(dateipfad, 'r') as f:
            return f.read()
    except Exception as e:
        return f"Fehler beim Lesen der Datei: {e}"

4. Agenten bauen

Erstellen Sie nun das Haupt-Agentenskript `agent.py`:

# agent.py
from langchain_ollama import ChatOllama
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from tools import taschenrechner, web_suche, datei_lesen

# Lokales LLM initialisieren
llm = ChatOllama(
    model="mistral",          # oder "llama3.1"
    temperature=0.7,
    num_predict=2048
)

# Liste der Werkzeuge definieren
werkzeuge = [
    Tool(
        name="Taschenrechner",
        func=taschenrechner,
        description="Nützlich zur Durchführung mathematischer Berechnungen. Die Eingabe sollte ein mathematischer Ausdruck sein."
    ),
    Tool(
        name="WebSuche",
        func=web_suche,
        description="Durchsucht das Web nach aktuellen Informationen. Die Eingabe sollte eine Suchanfrage sein."
    ),
    Tool(
        name="DateiLeser",
        func=datei_lesen,
        description="Liest den Inhalt einer Datei. Die Eingabe sollte ein gültiger Dateipfad sein."
    )
]

# Agenten initialisieren
agent = initialize_agent(
    werkzeuge,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    handle_parsing_errors=True
)

# Einfache Abfrage ausführen
if __name__ == "__main__":
    abfrage = "Wie hoch ist die Bevölkerung von Tokio? Berechne auch 15 * 23."
    antwort = agent.run(abfrage)
    print(antwort)

5. Agenten ausführen

Führen Sie den Agenten aus:

python agent.py

Sie sollten den Denkprozess des Agenten (im ausführlichen Modus) und eine endgültige Antwort sehen, die das Websuchergebnis und die Berechnung kombiniert.

Anwendungsbeispiele

Beispiel 1: Mehrere Werkzeuge gleichzeitig nutzen

Führen Sie den Agenten mit einer Abfrage aus, die sowohl Berechnung als auch Dateilesen erfordert:

# In agent.py die Abfrage ändern
abfrage = "Lies die Datei 'notizen.txt' und berechne dann, wie viele Zeichen sie enthält."
antwort = agent.run(abfrage)

Dies führt dazu, dass der Agent zuerst `DateiLeser` und dann `Taschenrechner` auf die Länge des zurückgegebenen Textes anwendet.

Beispiel 2: Benutzerdefiniertes Werkzeug – Aktuelle Uhrzeit abrufen

Fügen Sie ein neues Werkzeug in `tools.py` hinzu:

import datetime

def aktuelle_uhrzeit(format_string: str = "%Y-%m-%d %H:%M:%S") -> str:
    """Gibt das aktuelle Datum und die Uhrzeit zurück. Optional kann ein Format angegeben werden."""
    return datetime.datetime.now().strftime(format_string)

Registrieren Sie es dann in `agent.py`:

from tools import aktuelle_uhrzeit

werkzeuge.append(
    Tool(
        name="AktuelleUhrzeit",
        func=aktuelle_uhrzeit,
        description="Gibt das aktuelle Datum und die Uhrzeit zurück. Das Eingabeformat ist optional."
    )
)

Jetzt können Sie fragen: "Wie spät ist es gerade?" und der Agent wird das Werkzeug aufrufen.

Beispiel 3: Mit einem anderen lokalen LLM arbeiten

Um zu Llama 3.1 zu wechseln, ändern Sie einfach den Modellnamen in `agent.py`:

llm = ChatOllama(
    model="llama3.1",
    temperature=0.7
)

Denken Sie daran, das Modell zuerst mit `ollama pull llama3.1` herunterzuladen.

Wie der Agent unter der Haube funktioniert

Der Agent verwendet das **ReAct**-Muster (Reasoning + Acting). Wenn Sie eine Abfrage senden, führt das LLM folgende Schritte aus:

1. **Denken**: Überlegen, welches Werkzeug verwendet werden soll und warum. 2. **Handeln**: Das Werkzeug mit der entsprechenden Eingabe aufrufen. 3. **Beobachten**: Die Ausgabe des Werkzeugs betrachten. 4. **Wiederholen**: Bis genügend Informationen für eine Antwort vorliegen.

Dies wird in der ausführlichen Ausgabe sichtbar. Beispielsweise könnten Sie Folgendes sehen:

> Entering new AgentExecutor chain...
Gedanke: Ich muss die Bevölkerung von Tokio finden und 15*23 berechnen. Ich kann WebSuche für Ersteres und Taschenrechner für Letzteres verwenden.
Aktion: WebSuche
Aktionseingabe: Bevölkerung von Tokio
Beobachtung: Tokio hat eine Bevölkerung von etwa 14 Millionen (Schätzung 2024).
Gedanke: Jetzt muss ich 15*23 berechnen.
Aktion: Taschenrechner
Aktionseingabe: 15*23
Beobachtung: 345
Gedanke: Ich habe beide Informationen.
Endgültige Antwort: Die Bevölkerung von Tokio beträgt etwa 14 Millionen, und 15 * 23 ergibt 345.

Skalierung: Vom Lokalen zur Produktion

Während dieses Beispiel ein lokales LLM und einfache Werkzeuge verwendet, lässt sich dasselbe Muster auf Produktionsumgebungen skalieren. Unternehmen wie Microsoft und Anthropic haben Agenten demonstriert, die mit Datenbanken, Cloud-APIs und Unternehmenssystemen integriert sind. Die Hauptunterschiede sind:

• **Modellgröße**: Größere Modelle (70B+ Parameter) schneiden bei der Werkzeugauswahl oft besser ab.
• **Werkzeugkomplexität**: Praxisnahe Werkzeuge erfordern möglicherweise Authentifizierung, Ratenbegrenzung und Fehlerbehandlung.
• **Gedächtnis**: Produktionsagenten verwenden Vektordatenbanken, um Gesprächsverlauf und abgerufenen Kontext zu speichern.

Für lokale Bereitstellungen können Sie dieses Setup mit Werkzeugen erweitern für:

• SQL-Datenbankabfragen
• API-Aufrufe an Dienste wie Wetter oder Aktienkurse
• Bildgenerierung mit lokalen Modellen (z. B. Stable Diffusion)
• Dateiverwaltung (erstellen, bearbeiten, löschen)

Fazit

Die Umwandlung eines lokalen LLMs in einen werkzeugnutzenden Agenten eröffnet eine neue Stufe der Leistungsfähigkeit. Mit nur wenigen Zeilen Python und einem lokalen Modell können Sie einen Assistenten bauen, der nicht nur Text generiert, sondern auch berechnet, sucht und mit Ihren Dateien interagiert. Dieser Ansatz respektiert Ihre Privatsphäre, funktioniert offline und gibt Ihnen die volle Kontrolle über die Werkzeuge, die Ihr Agent verwenden kann.

Das hier bereitgestellte Beispiel ist ein Ausgangspunkt. Wenn Sie weitere Werkzeuge hinzufügen und die Aufforderungen des Agenten verfeinern, werden Sie sehen, wie er zunehmend komplexere Aufgaben bewältigt. Die Zukunft der lokalen KI liegt nicht nur im Ausführen von Modellen – es geht darum, Agenten zu bauen, die sicher und autonom in Ihrem Namen handeln.