Agenten-Workflows mit Ollama

Was dieser Artikel über Agenten-Workflows behandelt

• Was KI-Agenten sind und wie sie funktionieren.
• Wie Agenten mit Werkzeugen umgehen.
• Wie man mehrstufige Workflows mit Ollama baut.
• Gedächtnis, Planung und Feedback-Schleifen.
• Praxisbeispiel mit Python.

Einleitung: Agenten-Workflows mit Ollama

Ein KI-Agent ist mehr als ein einfaches Sprachmodell. Ein Agent verfolgt ein Ziel, entscheidet selbst, welche Werkzeuge er nutzt, wertet Ergebnisse aus und passt sein Vorgehen an. Ollama bietet eine gute Basis für solche Agenten, weil Modelle lokal laufen und Tools einfach über Prompts angesprochen werden können. Wer mehrstufige Workflows baut, kann komplexe Aufgaben wie Recherche, Datenaufbereitung oder Code-Generierung automatisiert ablaufen lassen.

Dieser Artikel zeigt, wie man einen einfachen, aber funktionalen Agenten-Workflow mit Ollama implementiert.

Wichtige Begriffe

• Agent: System, das Ziele verfolgt und Aktionen plant.
• Tool: Externe Funktion, die der Agent aufruft.
• ReAct: Reasoning + Acting, Denken und Handeln abwechseln.
• Gedächtnis: Speicher vergangener Aktionen und Ergebnisse.
• Planung: Schrittweise Zielerreichung.
• Feedback-Schleife: Ergebnisse prüfen und Vorgehen anpassen.
• Observation: Beobachtung nach einer Aktion.
• Thought: Gedankenschritt des Agenten.

Agenten-Workflow im Überblick

Ein typischer Workflow sieht so aus:

1. Ziel festlegen.
2. Plan erstellen.
3. Ersten Schritt ausführen oder Tool aufrufen.
4. Ergebnis beobachten.
5. Nächsten Schritt planen.
6. Wiederholen, bis Ziel erreicht oder Maximalanzahl erreicht.
7. Endgültige Antwort ausgeben.

Einfacher ReAct-Workflow

import requests
import json

def ollama_chat(prompt, model="llama3.1"):
    url = "http://localhost:11434/api/generate"
    payload = {
        "model": model,
        "prompt": prompt,
        "stream": False
    }
    response = requests.post(url, json=payload)
    return response.json()["response"].strip()

def tool_recherche(query):
    return f"Ergebnisse zu {query}: Seite 1, Seite 2, Seite 3."

def tool_rechner(ausdruck):
    try:
        return str(eval(ausdruck))
    except:
        return "Fehler"

prompt = """Der Assistent ist ein Agent. Erstelle die nächste Aktion im Format:
Aktion: [SUCHE] Thema
oder
Aktion: [RECHNE] 2+2

Ziel: Wie viele Seiten hat der BotServ-Artikel "Ollama Befehle"?"""

antwort = ollama_chat(prompt)
print(antwort)

Werkzeuge registrieren

tools = {
    "SUCHE": tool_recherche,
    "RECHNE": tool_rechner,
}

Mehrstufiger Workflow

def run_agent(ziel, max_steps=10):
    gedaechtnis = []

    for step in range(max_steps):
        kontext = "\n".join(gedaechtnis)
        prompt = f"""Ziel: {ziel}\nBisherige Schritte:\n{kontext}\n\nEntscheide die nächste Aktion. Format: Aktion: [NAME] Parameter"""
        antwort = ollama_chat(prompt)

        if "ENDE" in antwort:
            return antwort.replace("Aktion: ENDE", "")

        if antwort.startswith("Aktion:"):
            _, rest = antwort.split(":", 1)
            name, param = rest.strip().split(" ", 1)
            name = name.replace("[", "").replace("]", "")
            ergebnis = tools.get(name, lambda x: f"Unbekanntes Tool {name}")(param)
            gedaechtnis.append(f"Schritt {step + 1}: {antwort}\nErgebnis: {ergebnis}")
        else:
            gedaechtnis.append(f"Schritt {step + 1}: {antwort}")

    return "Maximale Schrittzahl erreicht."

print(run_agent("Suche nach Ollama Befehle und addiere die Anzahl der gelisteten Seiten"))

Gedächtnis

Ein Agent braucht ein Gedächtnis, um zusammenhängend zu arbeiten. Einfache Ansätze:

• String mit bisherigen Schritten im Prompt.
• Liste, die Schritt für Schritt ergänzt wird.
• Vektordatenbank für längere Gespräche.
• Datei oder Datenbank zur dauerhaften Speicherung.

Planung

Vor der Ausführung kann das Modell einen Plan erstellen:

plan_prompt = f"""Erstelle einen kurzen Plan aus max. 5 Schritten für folgendes Ziel:

Ziel: {ziel}

Format:
1. Schritt
2. Schritt
"""

plan = ollama_chat(plan_prompt)
print(plan)

Feedback-Schleifen

Nach jedem Schritt prüft der Agent, ob das Ergebnis weiterhilft:

eval_prompt = f"""Bewerte kurz, ob dieses Ergebnis dem Ziel dient:

Ziel: {ziel}
Ergebnis: {ergebnis}

Antworte mit FORTFAHREN oder ZURUECKSETZEN."""

Tools richtig gestalten

• Klare Namen.
• Kurze Beschreibungen.
• Strikte Parameterformate.
• Fehlerbehandlung in der Ausführung.
• Rückgaben in definiertem Format.

Sicherheit

• Eingaben vor Tool-Ausführung validieren.
• Keine eval ohne Einschränkungen nutzen.
• Code-Tools isoliert ausführen.
• Keine unbegrenzten Schleifen erlauben.
• Logs führen.
• Keine sensiblen Daten ohne Schutz an Tools übergeben.

Weiterführende Links und Infos

• BotServ.de Ollama MCP
• BotServ.de Ollama Automatisierung
• BotServ.de Ollama Prompt-Engineering
• BotServ.de Agenten-Speicher

FAQ: Agenten-Workflows

Braucht man LangChain für Agenten? Nein, einfache Workflows funktionieren auch mit Python und Ollama.

Kann Ollama komplexe Agenten ausführen? Ja, solange die Logik klar strukturiert ist.

Wie viele Tools können gleichzeitig verfügbar sein? Mehrere, aber zu viele überfordern kleinere Modelle.

Was ist der Unterschied zwischen RAG und Agenten? RAG holt Wissen, Agenten planen und führen Aktionen aus.

Sind Agenten langsamer? Ja, weil mehrere Aufrufe nötig sind.

Quellen und weiterführende Literatur

• ReAct Paper: https://arxiv.org/abs/2210.03629
• LangChain Agents: https://python.langchain.com/docs/modules/agents/
• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md

Zusammenfassung: Agenten-Workflows mit Ollama

Agenten-Workflows erweitern Ollama um Planung, Werkzeugnutzung und Feedback-Schleifen. Mit einem klar strukturierten Prompt, einem Gedächtnis und einigen einfachen Tools lässt sich ein funktionaler Agent bauen. Wichtig sind strikte Aktionen, Input-Validierung und ein Schrittlimit, um Endlosschleifen zu vermeiden. Für komplexe Anwendungen können Frameworks wie LangChain helfen, aber für viele Use-Cases reicht eine eigene, leichtgewichtige Implementierung.