Ollama für KI-Agenten einsetzen

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Ollama für KI-Agenten behandelt

• Wie Ollama als Modellserver für KI-Agenten funktioniert.
• Welche Frameworks Ollama unterstützen und wie Du sie verbindest.
• Wie Function Calling mit Ollama funktioniert und welche Modelle sich eignen.
• Wie Du einen einfachen Agenten mit Ollama und LangGraph aufbaust.
• Welche typischen Stolpersteine bei lokalen Agenten auftreten und wie Du sie löst.

Einleitung: Ollama als Modellserver für KI-Agenten

KI-Agenten sind Programme, die selbstständig planen, Tools aufrufen und Aufgaben erledigen. Sie brauchen ein Sprachmodell, das die Entscheidungen trifft und die Tool-Aufrufe generiert. Ollama ist ein lokaler Modellserver, der genau das bereitstellt: ein Modell, das über eine REST API erreichbar ist und Function Calling unterstützt.

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die KI-Agenten mit lokalen Modellen aufbauen wollen. Du solltest verstehen, was KI-Agenten sind, wie Tool-Calling funktioniert und wie man Ollama installiert. Grundkenntnisse in Python sind hilfreich für die Code-Beispiele. Wer Python lernen möchte, findet Tutorials auf IRC-Coding.de.

Warum brauche ich Ollama für KI-Agenten?

Stell Dir vor, Du baust einen Agenten, der E-Mails liest, klassifiziert und an die richtige Abteilung weiterleitet. Der Agent nutzt ein Sprachmodell, um die Kategorie zu bestimmen, und ruft Funktionen auf, um die E-Mail weiterzuleiten.

Wenn Du das Modell von einem Cloud-Anbieter mietest, zahlst Du für jede Anfrage. Bei 1000 E-Mails am Tag und 0,001 Euro pro Anfrage sind das 1 Euro pro Tag, 365 Euro im Jahr. Dazu kommen Datenschutzbedenken: Jede E-Mail geht an einen externen Anbieter.

Mit Ollama betreibst Du das Modell lokal. Nach der Hardware-Investition zahlst Du nur Strom. Die E-Mails verlassen Dein Netzwerk nicht. Du bist unabhängig von API-Limits, Preiserhöhungen oder Abschaltungen.

Ollama für KI-Agenten kurz erklärt

Ollama ist ein Modellserver, der lokal auf Deiner Hardware läuft. Er stellt eine REST API bereit, über die Du Modelle anfragen kannst. Für KI-Agenten ist besonders das Function Calling wichtig: Das Modell kann Funktionen definieren, die es aufrufen darf, und generiert strukturierte Aufrufe, die Dein Code ausführt.

Der Kerngedanke lautet: Ollama liefert das Modell, Dein Code liefert die Logik, das Modell entscheidet, welche Tools aufgerufen werden.

Für wen ist Ollama für KI-Agenten gedacht?

• Entwicklerinnen und Entwickler, die KI-Agenten mit lokalen Modellen aufbauen.
• Unternehmen, die datenschutzkritische Workloads nicht in die Cloud geben wollen.
• Hobby-Bastler, die Agenten für persönliche Automatisierung bauen.
• Forscherinnen und Forscher, die Modelle für Agenten-Workflows evaluieren.

Vorkenntnisse in Python, APIs und grundlegendem Prompt Engineering sind hilfreich. Wer noch nie mit Function Calling gearbeitet hat, sollte zuerst die Grundlagen lesen.

Wichtige Begriffe rund um Ollama und KI-Agenten

• Ollama - Lokaler Modellserver. Wann nützlich: als Modell-Backend für jeden lokalen Agenten.
• Function Calling - Fähigkeit des Modells, Funktionen aufzurufen. Wann nützlich: wenn der Agent Tools nutzen soll.
• LangGraph - Graph-basiertes Agenten-Framework. Wann nützlich: für komplexe Agenten mit Zuständen.
• CrewAI - Multi-Agenten-Framework. Wann nützlich: wenn mehrere Agenten zusammenarbeiten.
• OpenClaw - Open-Source-Agentenplattform. Wann nützlich: für Self-Hosting von Agenten.
• MCP - Model Context Protocol. Wann nützlich: um Agenten mit externen Tools zu verbinden.
• Ollama REST API - HTTP-API für Modell-Anfragen. Wann nützlich: wenn Du Ollama direkt ansprichst.

Welche Frameworks unterstützen Ollama?

Die meisten gängigen Agenten-Frameworks unterstützen Ollama als Modell-Backend. Die Integration ist meist einfach, weil Ollama eine OpenAI-kompatible API bietet.

Die Integration funktioniert meist so: Du installierst das Framework, konfigurierst Ollama als Modell-Backend und definierst Deine Tools. Das Framework ruft Ollama auf, wenn das Modell eine Entscheidung treffen soll, und führt die generierten Tool-Aufrufe aus.

Function Calling mit Ollama

Function Calling ist die wichtigste Fähigkeit für KI-Agenten. Das Modell bekommt eine Liste von Funktionen, die es aufrufen darf, und entscheidet anhand der Nutzeranfrage, welche Funktion relevant ist. Es generiert einen strukturierten Aufruf, den Dein Code ausführt.

Ollama unterstützt Function Calling seit Version 0.3.0. Modelle, die dafür geeignet sind, sind:

• Llama 3.1 8B - Klein, schnell, gut für einfache Agenten.
• Qwen 2.5 14B - Größer, besser in komplexen Tool-Aufrufen.
• Mistral Nemo 12B - Ausgewogen, gut in Tool-Selection.
• Llama 3.3 70B - Groß, falls Deine Hardware es zulässt.

Ein Beispiel mit der Ollama REST API:

import requests
import json

OLLAMA_URL = "http://localhost:11434/api/chat"

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Holt das aktuelle Wetter für einen Ort",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Ortsname, z.B. 'Berlin'"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = requests.post(OLLAMA_URL, json={
    "model": "llama3.1",
    "messages": [
        {"role": "user", "content": "Wie ist das Wetter in Berlin?"}
    ],
    "tools": tools,
    "stream": False
})

result = response.json()
print(json.dumps(result, indent=2, ensure_ascii=False))

Das Modell generiert einen Tool-Aufruf, der in der Antwort enthalten ist. Dein Code führt die Funktion get_weather aus und schickt das Ergebnis zurück an das Modell, das daraus die finale Antwort generiert.

Praxisbeispiel: Ein Agent mit Ollama und LangGraph

Stell Dir vor, Du willst einen Agenten, der Recherchen durchführt. Er soll das Internet durchsuchen, Ergebnisse zusammenfassen und eine finale Antwort generieren. Mit Ollama und LangGraph sieht das so aus:

from langchain_ollama import ChatOllama
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    next_step: str

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

def search_node(state: AgentState):
    # Simulierte Suchfunktion
    query = state["messages"][-1]["content"]
    results = f"Suchergebnisse für: {query}"
    return {"messages": [{"role": "system", "content": results}]}

def summarize_node(state: AgentState):
    # Zusammenfassung mit LLM
    context = "\n".join([m["content"] for m in state["messages"]])
    response = llm.invoke(f"Fasse zusammen: {context}")
    return {"messages": [{"role": "assistant", "content": response.content}]}

def should_continue(state: AgentState):
    if "suche" in state["messages"][-1]["content"].lower():
        return "search"
    return "summarize"

workflow = StateGraph(AgentState)
workflow.add_node("search", search_node)
workflow.add_node("summarize", summarize_node)
workflow.set_entry_point("search")
workflow.add_conditional_edges("search", should_continue)
workflow.add_edge("summarize", END)

app = workflow.compile()
result = app.invoke({"messages": [{"role": "user", "content": "Suche nach lokaler KI"}]})
print(result["messages"][-1]["content"])

Dieser Agent durchläuft mehrere Zustände: Suche, Zusammenfassung, Ende. Ollama liefert das Modell, LangGraph orchestriert den Ablauf. Das Modell entscheidet, ob weitere Schritte nötig sind.

Ollama mit MCP verbinden

Das Model Context Protocol (MCP) ist ein Standard, der es Agenten ermöglicht, auf externe Tools zuzugreifen. Statt für jeden Agenten eigene Tool-Definitionen zu schreiben, nutzt Du MCP-Server, die Tools bereitstellen.

Ollama selbst ist kein MCP-Client, aber die meisten Agenten-Frameworks, die Ollama unterstützen, können auch MCP nutzen. LangGraph, CrewAI und OpenClaw haben MCP-Integrationen.

Ein typischer Setup:

1. Ollama läuft als Modellserver auf localhost:11434.
2. MCP-Server stellt Tools bereit (z. B. Dateisystem, Datenbank, Web-Suche).
3. Agenten-Framework verbindet Ollama mit dem MCP-Server.
4. Der Agent ruft Ollama auf, wenn er eine Entscheidung treffen muss.
5. Das Modell generiert einen Tool-Aufruf, das Framework führt ihn über MCP aus.

Details zum Aufbau eines eigenen MCP-Servers findest Du im Artikel MCP-Server bauen.

Modelle für Agenten wählen

Die Wahl des Modells beeinflusst die Qualität des Agenten massiv. Ein zu kleines Modell versteht Tool-Aufrufe nicht richtig, ein zu großes Modell ist langsam und braucht viel VRAM.

Wichtig ist, das Modell vor dem Einsatz zu testen. Der Artikel Ollama Evaluation zeigt, wie Du Modelle systematisch vergleichst. Für Function Calling solltest Du das Modell mit Deinen spezifischen Tools testen, weil nicht jedes Modell jedes Tool-Schema gleich gut versteht.

Typische Stolpersteine bei Ollama-Agenten

• Falsches Modell: Ein 7B-Modell ist nicht gut in komplexen Tool-Aufrufen. Vor dem Einsatz testen, ob das Modell die Tools richtig versteht.
• Keine Fehlerbehandlung: Wenn ein Tool-Aufruf fehlschlägt, muss der Agent das erkennen und reagieren. Ein Agent, der bei jedem Fehler abstützt, ist nicht einsatzbereit.
• Zu viele Tools: Ein Modell mit 20 Tools ist überfordert. Lieber wenige, gut definierte Tools als viele vage.
• Keine Begrenzung der Konversation: Ein Agent, der endlos weiterdenkt, braucht Tokens und Zeit. Maximale Anzahl an Schritten definieren.
• Sicherheit ignoriert: Ein Agent, der Tools aufrufen kann, kann auch Schaden anrichten. Tool-Berechtigungen und Sandboxing sind Pflicht.
• Kein Monitoring: Wer nicht mitbekommt, dass der Agent falsche Entscheidungen trifft, merkt das erst durch Schaden. Audit Logging ist wichtig.
• Menschliche Freigabe vergessen: Bei kritischen Aktionen braucht es eine menschliche Freigabe, nicht eine blinde Ausführung.

Weiterführende Links und Infos zu Ollama-Agenten

• Ollama Function Calling - Tools in Ollama definieren.
• Ollama REST API - API für Modell-Anfragen.
• LangGraph Framework - Komplexe Agenten aufbauen.
• CrewAI Framework - Multi-Agenten-Systeme.
• MCP Grundlagen - Tools für Agenten bereitstellen.
• Ollama Evaluation - Modelle systematisch vergleichen.
• Agentensicherheit - Agenten absichern.

Key Takeaways:

• Ollama ist ein lokaler Modellserver, der Function Calling für KI-Agenten unterstützt.
• Die meisten gängigen Frameworks (LangGraph, CrewAI, LangChain) unterstützen Ollama.
• Die Wahl des Modells beeinflusst die Qualität des Agenten massiv.
• MCP verbindet Agenten mit externen Tools, ohne dass Du jedes Tool selbst definieren musst.
• Sicherheit, Fehlerbehandlung und menschliche Freigaben sind Pflicht bei Agenten mit Tool-Zugriff.

FAQ: Ollama für KI-Agenten - Typische Fragen

Quellen und weiterführende Literatur

• Ollama Dokumentation - Offizielle Ollama-Docs.
• LangGraph - Agenten-Framework.
• CrewAI - Multi-Agenten-Framework.
• Model Context Protocol - Tool-Standard für Agenten.
• LangChain Ollama Integration - Ollama in LangChain.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert