KI-Agenten lokal mit Ollama betreiben

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über KI-Agenten mit Ollama behandelt

• Wie Du KI-Agenten lokal mit Ollama als Backend betreibst.
• Welche Agent-Frameworks mit Ollama funktionieren und wie Du sie einrichtest.
• Wie Du Tool-Use, Memory und Multi-Agent-Setups umsetzt.
• Praxisbeispiele für autonome Agenten: Recherche, Code-Ausführung, Dateiverwaltung.
• Best Practices für Sicherheit, Performance und Zuverlässigkeit.

Einleitung: KI-Agenten mit Ollama verständlich erklärt

KI-Agenten sind Programme, die ein Sprachmodell nutzen, um eigenständig Aufgaben zu lösen. Sie planen, führen Tools aus, beobachten Ergebnisse und passen ihren Plan an. Mit Ollama als Backend laufen diese Agenten vollständig lokal, ohne Cloud, ohne API-Kosten, ohne Datenschutzbedenken.

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die autonome Agenten mit lokaler KI bauen wollen. Du solltest verstehen, was KI-Agenten sind, wie Ollama funktioniert und was Function Calling ist. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich lokale KI-Agenten?

Stell Dir vor, Du willst einen Agenten bauen, der Deine E-Mails sortiert, Termine verwaltet und Dokumente zusammenfasst. In der Cloud kostet jeder Agenten-Schritt Geld, jeder API-Call wird protokolliert, jeder Datenpunkt geht an einen Provider. Mit lokaler KI läuft alles auf Deiner Hardware, ohne Kosten pro Aufruf, ohne Datenabfluss.

Lokale Agenten sind besonders wertvoll, wenn Du mit sensiblen Daten arbeitest, wenn Du viele Agenten-Schritte brauchst (die in der Cloud teuer werden) oder wenn Du unabhängig von Cloud-Providern sein willst.

KI-Agenten mit Ollama kurz erklärt

Ein KI-Agent ist ein Programm, das einen Loop ausführt: Plan → Tool aufrufen → Ergebnis beobachten → Plan anpassen. Das Sprachmodell trifft Entscheidungen, der Code führt Tools aus. Mit Ollama als Backend läuft das Sprachmodell lokal, die Tools sind lokale Programme (Dateisystem, Shell, Web-Requests).

Der Kerngedanke lautet: Der Agent ist der Loop, Ollama ist das Gehirn, die Tools sind die Hände.

Für wen ist dieser Artikel gedacht?

• Entwicklerinnen und Entwickler, die autonome Agenten mit lokaler KI bauen wollen.
• Systemadministratoren, die Agenten für Automatisierung auf eigener Hardware betreiben.
• Forscherinnen und Forscher, die Agenten-Verhalten mit lokalen Modellen untersuchen.
• Self-Hoster, die unabhängig von Cloud-Providern sein wollen.

Vorkenntnisse in Python, Ollama und Function Calling sind erforderlich.

Wichtige Begriffe rund um KI-Agenten mit Ollama

• KI-Agent - Programm, das eigenständig Aufgaben löst. Wann nützlich: für autonome Workflows.
• Ollama - Lokaler Modellserver. Wann nützlich: als Gehirn des Agenten.
• Function Calling - Strukturierte KI-Antworten. Wann nützlich: damit der Agent Tools aufrufen kann.
• Tool - Funktion, die der Agent aufrufen kann. Wann nützlich: die Hände des Agenten.
• Memory - Gedächtnis des Agenten. Wann nützlich: damit der Agent sich an frühere Schritte erinnert.
• MCP - Model Context Protocol. Wann nützlich: Standard für Tool-Integration.
• OpenHands - Open-Source-Agenten-Plattform. Wann nützlich: fertiger Agent mit Ollama-Support.
• Agent-Loop - Der Kern-Loop: Plan → Tool → Observe → Adapt. Wann nützlich: das Herz jedes Agenten.

Agent-Frameworks mit Ollama-Support

LangChain mit Ollama

LangChain ist das bekannteste Framework für LLM-Anwendungen. Es unterstützt Ollama als Backend.

from langchain_community.llms import Ollama
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import Tool

# Ollama als Backend
llm = Ollama(model="llama3.1", base_url="http://localhost:11434")

# Tools definieren
def search_wikipedia(query):
    # Implementierung hier
    return f"Ergebnis für: {query}"

tools = [
    Tool(name="Wikipedia", func=search_wikipedia, description="Durchsucht Wikipedia")
]

# Agent erstellen
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

# Agent ausführen
result = executor.invoke({"input": "Was ist die Hauptstadt von Frankreich?"})
print(result)

LangGraph mit Ollama

LangGraph ist die Weiterentwicklung von LangChain für zustandsbehaftete Agenten. Es erlaubt komplexe Agenten-Graphen mit Cycles.

from langchain_community.llms import Ollama
from langgraph.graph import StateGraph, END

llm = Ollama(model="llama3.1")

# State definieren
from typing import TypedDict, List
class AgentState(TypedDict):
    messages: List[str]
    tool_results: List[str]

# Nodes definieren
def call_model(state):
    response = llm.invoke(state["messages"][-1])
    return {"messages": state["messages"] + [response]}

def call_tool(state):
    # Tool-Ausführung
    return {"tool_results": ["Ergebnis"]}

# Graph bauen
workflow = StateGraph(AgentState)
workflow.add_node("model", call_model)
workflow.add_node("tool", call_tool)
workflow.add_edge("model", "tool")
workflow.add_edge("tool", "model")

CrewAI mit Ollama

CrewAI ist ein Framework für Multi-Agent-Systeme. Mehrere Agenten mit unterschiedlichen Rollen arbeiten zusammen.

from crewai import Agent, Task, Crew
from crewai.llms import Ollama

# LLM konfigurieren
llm = Ollama(model="llama3.1", base_url="http://localhost:11434")

# Agenten definieren
researcher = Agent(
    role="Rechercheur",
    goal="Informationen sammeln",
    backstory="Du bist ein erfahrener Rechercheur.",
    llm=llm
)

writer = Agent(
    role="Autor",
    goal="Einen Bericht schreiben",
    backstory="Du bist ein erfahrener Autor.",
    llm=llm
)

# Tasks definieren
research_task = Task(description="Recherchiere Thema X", agent=researcher)
write_task = Task(description="Schreibe einen Bericht", agent=writer)

# Crew erstellen
crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])
result = crew.kickoff()

OpenHands mit Ollama

OpenHands (früher OpenDevin) ist eine komplette Agenten-Plattform mit Web-UI. Sie unterstützt Ollama als Backend.

Siehe OpenHands einrichten für Details.

Tool-Use mit Ollama

Function Calling mit Ollama

Ollama unterstützt Function Calling, das der Agent nutzt, um Tools aufzurufen:

import requests

def call_ollama_with_tools(messages, tools):
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": messages,
            "tools": tools,
            "stream": False
        }
    )
    return response.json()

# Tools definieren
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Holt das Wetter für eine Stadt",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Stadtname"}
                },
                "required": ["city"]
            }
        }
    }
]

# Agenten-Loop
messages = [{"role": "user", "content": "Wie ist das Wetter in Berlin?"}]

while True:
    response = call_ollama_with_tools(messages, tools)
    msg = response["message"]

    if msg.get("tool_calls"):
        for tool_call in msg["tool_calls"]:
            # Tool ausführen
            result = execute_tool(tool_call)
            messages.append(msg)
            messages.append({
                "role": "tool",
                "content": result
            })
    else:
        print(msg["content"])
        break

MCP mit Ollama

Das Model Context Protocol (MCP) ist ein Standard für Tool-Integration. Ollama-Modelle können MCP-Server nutzen.

Siehe MCP Grundlagen für Details.

Memory für Agenten

Agenten brauchen Memory, um sich an frühere Schritte zu erinnern. Es gibt verschiedene Memory-Typen:

Short-Term Memory

Der aktuelle Kontext, also die letzten Nachrichten. Begrenzt durch die Kontextlänge des Modells.

messages = [
    {"role": "system", "content": "Du bist ein Agent."},
    {"role": "user", "content": "Schritt 1"},
    {"role": "assistant", "content": "Ergebnis 1"},
    {"role": "user", "content": "Schritt 2"},
    # ...
]

Long-Term Memory

Persistenter Speicher, z.B. in einer Vektordatenbank. Der Agent kann frühere Erkenntnisse abrufen.

from chromadb import Client

chroma = Client()
collection = chroma.create_collection("agent_memory")

# Erinnerung speichern
collection.add(
    documents=["Wichtige Erkenntnis aus Schritt 5"],
    ids=["step_5"]
)

# Erinnerung abrufen
results = collection.query(query_texts=["Was weiß ich über X?"], n_results=3)

Summary Memory

Wenn der Kontext zu lang wird, fasst der Agent alte Nachrichten zusammen.

def summarize_if_needed(messages, max_length=4000):
    total_length = sum(len(m["content"]) for m in messages)
    if total_length > max_length:
        # Zusammenfassen
        summary = call_ollama([
            {"role": "system", "content": "Fasse diese Konversation zusammen."},
            {"role": "user", "content": str(messages)}
        ])
        messages = [
            messages[0],  # System-Prompt behalten
            {"role": "system", "content": f"Zusammenfassung: {summary}"}
        ]
    return messages

Multi-Agent-Setups

Hierarchische Agenten

Ein Supervisor-Agent delegiert an spezialisierte Agenten:

def supervisor(task):
    # Supervisor entscheidet, welcher Agent dran ist
    decision = call_ollama([
        {"role": "system", "content": "Du bist ein Supervisor. Entscheide, welcher Agent dran ist: researcher, coder, oder writer."},
        {"role": "user", "content": task}
    ])

    if "researcher" in decision:
        return researcher_agent(task)
    elif "coder" in decision:
        return coder_agent(task)
    elif "writer" in decision:
        return writer_agent(task)

Parallele Agenten

Mehrere Agenten arbeiten parallel am selben Problem:

import concurrent.futures

def parallel_agents(task, agents):
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = [executor.submit(agent, task) for agent in agents]
        results = [f.result() for f in futures]
    return results

Praxisbeispiel 1: Recherche-Agent

Ein Agent, der ein Thema recherchiert, Quellen sammelt und einen Bericht schreibt.

def research_agent(topic):
    messages = [
        {"role": "system", "content": "Du bist ein Recherche-Agent. Nutze die Tools search_web und read_page."},
        {"role": "user", "content": f"Recherchiere: {topic}"}
    ]

    tools = [
        {"type": "function", "function": {"name": "search_web", "parameters": {"query": {"type": "string"}}}},
        {"type": "function", "function": {"name": "read_page", "parameters": {"url": {"type": "string"}}}}
    ]

    while True:
        response = call_ollama_with_tools(messages, tools)
        msg = response["message"]
        messages.append(msg)

        if msg.get("tool_calls"):
            for tc in msg["tool_calls"]:
                result = execute_tool(tc)
                messages.append({"role": "tool", "content": result})
        else:
            return msg["content"]

Praxisbeispiel 2: Code-Ausführungs-Agent

Ein Agent, der Code schreibt und ausführt, um Aufgaben zu lösen.

def coder_agent(task):
    messages = [
        {"role": "system", "content": "Du bist ein Code-Agent. Nutze write_code und run_code."},
        {"role": "user", "content": task}
    ]

    tools = [
        {"type": "function", "function": {"name": "write_code", "parameters": {"code": {"type": "string"}}}},
        {"type": "function", "function": {"name": "run_code", "parameters": {"file": {"type": "string"}}}}
    ]

    # Agent-Loop wie oben
    # WICHTIG: Code-Ausführung in Sandbox!

Siehe Sandbox-Umgebungen für Sicherheitshinweise.

Sicherheitshinweise

• Sandbox für Code-Ausführung: Agenten, die Code ausführen, müssen in einer Sandbox laufen. Siehe Sandbox-Umgebungen.
• Least Privilege: Agenten sollten nur die Tools bekommen, die sie brauchen. Siehe Least Privilege.
• Human-in-the-Loop: Für kritische Aktionen sollte der Agent menschliche Freigabe einholen. Siehe Menschliche Freigabe.
• Audit Logging: Alle Agenten-Aktionen sollten protokolliert werden. Siehe Audit Logging.
• Guardrails: Nutze Guardrails, um schädliche Aktionen zu verhindern. Siehe Guardrails konfigurieren.
• Prompt Injection Schutz: Schütze den Agenten vor Prompt Injection. Siehe Prompt Injection Schutz.

Performance-Tipps

• Kleines Modell für Planung: Nutze ein kleines Modell für Planungs-Schritte, ein größeres für komplexe Aufgaben.
• Kontextlänge beachten: Lange Agenten-Loops sprengen die Kontextlänge. Nutze Summary Memory.
• Caching: Cache Tool-Ergebnisse, um wiederkehrende Aufrufe zu sparen.
• Parallelisierung: Wenn möglich, führe Tools parallel aus.
• Modell wählen: Für Tool-Use eignen sich Modelle mit gutem Function Calling, z.B. llama3.1, qwen2.5, mistral.

Typische Stolpersteine

• Keine Sandbox: Agenten, die Code ausführen, ohne Sandbox sind ein Sicherheitsrisiko.
• Zu große Modelle: Ein 70B-Modell für jeden Agenten-Schritt ist langsam und teuer (an VRAM).
• Kein Error-Handling: Wenn ein Tool fehlschlägt, sollte der Agent das erkennen und adaptieren, nicht abstürzen.
• Kontextlänge überschritten: Lange Loops sprengen den Kontext. Nutze Summary Memory.
• Endlosschleifen: Agenten können in Loops feststecken. Begrenze die Anzahl der Schritte.
• Keine Guardrails: Ohne Guardrails kann der Agent schädliche Aktionen ausführen.

Weiterführende Links und Infos zu KI-Agenten mit Ollama

• Ollama installieren - Backend für Agenten.
• Function Calling - Tool-Use-Grundlagen.
• MCP Grundlagen - Model Context Protocol.
• KI-Agenten Grundlagen - Was KI-Agenten sind.
• OpenHands einrichten - Fertige Agenten-Plattform.
• Sandbox-Umgebungen - Sicherheit für Code-Agenten.
• Menschliche Freigabe - Human-in-the-Loop.
• Guardrails konfigurieren - Guardrails für Agenten.

Key Takeaways:

• KI-Agenten mit Ollama laufen vollständig lokal, ohne Cloud.
• Frameworks: LangChain, LangGraph, CrewAI, OpenHands.
• Tool-Use über Function Calling oder MCP.
• Memory: Short-Term, Long-Term, Summary.
• Multi-Agent: Hierarchisch oder parallel.
• Sicherheit: Sandbox, Least Privilege, Guardrails, Audit Logging.

FAQ: KI-Agenten mit Ollama - Typische Fragen

Quellen und weiterführende Literatur

• Ollama Dokumentation - Offizielle Ollama-Docs.
• LangChain Dokumentation - LangChain-Docs.
• CrewAI Dokumentation - CrewAI-Docs.
• OpenHands - Agenten-Plattform.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert