Lokale LLMs mit Ollama: Selbst hosten, API anbinden & Praxisbeispiele

Hook – Der Moment, in dem Sie merken, dass die Cloud‑Bill‑spritzen nicht mehr tragbar sind

Stellen Sie sich vor, Sie arbeiten an einem internen Chat‑Bot für die Personalabteilung. Jedes Mal, wenn ein Mitarbeiter fragt: "Wie beantrage ich Elternzeit?", muss das System einen Request an OpenAI senden – und die Rechnung steigt schneller als Ihr Jahresurlaub. Das ist nicht nur teuer, das ist ein akutes Risiko für Datenschutz und Compliance. Hier kommt Ollama ins Spiel: mit nur wenigen Befehlen können Sie ein komplett off‑line LLM auf Ihrem eigenen Server betreiben, die Kosten halbieren und die Kontrolle zurückgewinnen. In diesem Artikel zeige ich Ihnen, wie Sie Ollama installieren, ein Modell pullen, es über die eingebaute REST‑API ansprechen und schließlich in eine Python‑Applikation einbetten. Meine persönliche Einschätzung: Für jede mittlere bis große Organisation ist das heute kein Nice‑to‑have mehr, sondern ein Must‑have – und das Ganze lässt sich in einem Nachmittag umsetzen.

Warum lokale LLMs?

Erklärung

Ein Large Language Model (LLM) ist im Prinzip ein riesiges statistisches Wörterbuch, das Texte generieren kann. Die meisten Anbieter (OpenAI, Anthropic, Cohere) bieten diese Modelle ausschließlich als SaaS an. Das bedeutet: Ihr Datenverkehr fließt über das öffentliche Internet, was bei sensiblen Unternehmensdaten problematisch ist. Außerdem erhalten Sie kaum Transparenz über das zugrundeliegende Modell‑Training – ein klassischer Black‑Box‑Falls.

Lokale LLMs lösen drei Kernprobleme:

1. Datenschutz – Keine externen API‑Calls, alles bleibt im eigenen Netzwerk.
2. Kostenkontrolle – Statt pro‑Token zu zahlen, bezahlen Sie einmalig für die Hardware.
3. Performance – Latenz im Millisekunden‑Bereich, weil das Modell direkt auf‑premises läuft.

Praxisbeispiel

Beispiel 1: HR‑Chatbot – Während ein externer Service 0,02 USD pro 1 000 Token verlangt, kostet ein lokales LLM nach dem Kauf (z. B. Mistral‑7B) ungefähr 200 USD für die GPU‑Hardware plus Strom. Der Break‑Even‑Point liegt bei rund 100 000 Tokens – und die meisten Unternehmens‑Chatbots erzeugen leicht mehrere Millionen Tokens pro Monat.

Einschätzung

Für Use‑Cases, bei denen Vertraulichkeit und Kosten im Vordergrund stehen, ist das Hosting eines LLMs mit Ollama heute das pragmatischste Vorgehen. Die Einstiegshürde ist niedrig, weil Ollama die gesamte Infrastruktur (Docker‑Container, Model‑Cache, API‑Server) abstrahiert.

Ollama installieren und ein Modell pullen

Erklärung

Ollama ist ein leichtgewichtiger Daemon, der verschiedene Open‑Source‑Modelle per HTTP‑API bereitstellt. Die Installation erfolgt über ein einzelnes Binary für Linux, macOS und Windows. Unter Linux empfiehlt sich die DEB‑Package‑Variante für Debian‑/Ubuntu‑Systeme.

Konkretes Beispiel 1 – Installation auf Ubuntu 22.04

# 1. System aktualisieren
sudo apt update && sudo apt upgrade -y

# 2. Ollama‑Package herunterladen (aktuellste Version 0.3.7)
wget https://ollama.com/download/ollama_0.3.7_amd64.deb -O /tmp/ollama.deb

# 3. Paket installieren
sudo dpkg -i /tmp/ollama.deb

# 4. Daemon starten und mit Systemd verknüpfen
sudo systemctl enable --now ollama

Nach dem Start lauscht Ollama standardmäßig auf Port 11434.

Konkretes Beispiel 2 – Modell pullen (Mistral‑7B‑Instruct)

# Ollama CLI nutzt das gleiche Befehlsschema wie Docker
ollama pull mistral:7b-instruct

Der Pull‑Vorgang lädt das Modell in ein lokales Cache‑Verzeichnis (~/.ollama/models). Für das erste Mal benötigen Sie etwa 4 GB Speicherplatz und eine schnelle Internetverbindung (≈ 30 GB/s). Ollama zeigt während des Downloads die Fortschrittsbalken und prüft die SHA‑256‑Hash‑Summe, um Integrität zu garantieren.

Einschätzung

Die Installation dauert weniger als 10 Minuten, selbst auf einer mittelklassigen VM (2 vCPU, 8 GB RAM). Der größte Kostenfaktor ist die GPU‑Hardware, wenn Sie Inference‑Beschleunigung benötigen. Für reine CPU‑Inference reicht jedoch bereits ein moderner Xeon‑ oder AMD‑Prozessor aus – die Latenz liegt dann bei etwa 600 ms pro Prompt, was für Chat‑Bots akzeptabel ist.

Modell per Ollama API ansprechen

Erklärung

Ollama stellt eine REST‑Ful‑API bereit, die exakt dem OpenAI‑Chat‑Endpoint ähnelt. Das macht die Migration von bestehenden Code‑Bases trivial, weil Sie lediglich die URL und das Modell anpassen müssen.

Konkretes Beispiel 3 – curl‑Request

curl http://localhost:11434/api/chat \
  -H "Content-Type: application/json" \
  -d '{
        "model": "mistral:7b-instruct",
        "messages": [{"role": "user", "content": "Erkläre mir den Unterschied zwischen IPv4 und IPv6 in drei Sätzen."}]
      }' | jq .

Die Ausgabe (gekürzt) sieht etwa so aus:

{
  "model": "mistral:7b-instruct",
  "created": 1698765432,
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "IPv4 nutzt 32‑Bit‑Adressen …"
    }
  }]
}

Konkretes Beispiel 4 – Python‑Wrapper

import requests, json

def ollama_chat(prompt: str) -> str:
    payload = {
        "model": "mistral:7b-instruct",
        "messages": [{"role": "user", "content": prompt}]
    }
    resp = requests.post(
        "http://localhost:11434/api/chat",
        headers={"Content-Type": "application/json"},
        data=json.dumps(payload)
    )
    resp.raise_for_status()
    return resp.json()["choices"][0]["message"]["content"]

print(ollama_chat("Wie richte ich einen LXC‑Container auf Proxmox ein?"))

Einschätzung

Da Ollama dieselbe JSON‑Struktur nutzt wie die OpenAI‑API, lässt sich vorhandener Code ohne größere Refactoring‑Arbeit übernehmen. Das spart Entwicklungszeit und reduziert das Risiko von Bugs – insbesondere, wenn Sie bereits ein Frontend‑Framework (React, Vue) mit einer OpenAI‑SDK‑Abstraktion nutzen.

Integration in eigene Anwendung

Erklärung

Der eigentliche Mehrwert entsteht, wenn das LLM in ein bestehendes Service‑Mesh integriert wird. Typischerweise bauen Unternehmen einen kleinen Microservice („LLM‑Gateway“) auf, der Anfragen entgegnet, Logging, Rate‑Limiting und Auditing übernimmt. Auf diese Weise behalten Sie die zentrale Kontrolle, obwohl das Modell lokal läuft.

Konkretes Beispiel 5 – FastAPI‑Gateway

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import requests, json

app = FastAPI(title="LLM‑Gateway")

class ChatRequest(BaseModel):
    prompt: str
    user: str | None = None

@app.post("/chat")
def chat(req: ChatRequest):
    payload = {
        "model": "mistral:7b-instruct",
        "messages": [{"role": "user", "content": req.prompt}]
    }
    try:
        resp = requests.post(
            "http://localhost:11434/api/chat",
            headers={"Content-Type": "application/json"},
            data=json.dumps(payload),
            timeout=10
        )
        resp.raise_for_status()
    except requests.RequestException as e:
        raise HTTPException(status_code=502, detail=str(e))
    return {"answer": resp.json()["choices"][0]["message"]["content"]}

Starten Sie das Gateway mit uvicorn:

uvicorn llm_gateway:app --host 0.0.0.0 --port 8000

Jetzt erreichen Sie das Modell über POST http://your‑host:8000/chat – ideal für interne Web‑Apps, Chat‑Interfaces oder Slack‑Bots.

Konkretes Beispiel 6 – Auditing per PostgreSQL Hook

-- Tabelle für Auditing
CREATE TABLE llm_audit (
    id SERIAL PRIMARY KEY,
    user_name TEXT,
    prompt TEXT,
    response TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Im FastAPI‑Code ergänzen wir nach dem erfolgreichen Request:

import psycopg2

def store_audit(user, prompt, response):
    conn = psycopg2.connect("dbname=app user=app password=secret host=localhost")
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO llm_audit (user_name, prompt, response) VALUES (%s,%s,%s)",
        (user, prompt, response)
    )
    conn.commit()
    cur.close()
    conn.close()

Damit haben Sie vollständige Nachvollziehbarkeit – ein entscheidender Punkt für regulatorische Anforderungen.

Einschätzung

Der Aufbau eines kleinen Gateway‑Layers kostet weniger als 200 Zeilen Code, liefert aber Features, die ein reiner Direkt‑curl‑Aufruf nicht bieten kann: Auth, Monitoring, Auditing und zentrale Fehlermeldungen. Das ist das Produktiv‑Setup, das ich in den meisten Kundenprojekten empfehle.

Häufige Fehler und wie man sie vermeidet

1. Keine GPU‑Provisionierung – Auf CPUs laufen zwar alle Modelle, aber die Latenz kann ins Sekunden‑Bereich schießen. Setzen Sie mindestens eine NVIDIA‑A100 (oder eine günstige RTX 3080) ein, wenn Sie interaktive Anfragen erwarten.
2. Port‑Kollision – Der Standard‑Port 11434 wird häufig von anderen Dienste belegt. Prüfen Sie sudo lsof -i :11434 und passen Sie OLLAMA_PORT in /etc/default/ollama an.
3. Unzureichender Speicher – Die meisten 7‑B‑Modelle benötigen mindestens 8 GB VRAM. Bei zu wenig Speicher fällt das Modell in den Swap und ist unbrauchbar. Nutzen Sie nvidia-smi zur Überwachung.
4. Fehlende Rate‑Limiting – Ein lokales Service‑Daemon kann bei unkontrollierten Parallel‑Requests überlastet werden. Setzen Sie ein Middleware‑Rate‑Limiter (z. B. slowapi für FastAPI) ein.
5. Keine Monitoring‑Integration – Ohne Metriken (Prometheus‑Exporter ist in Ollama integriert) sehen Sie nicht, wann das Modell an seine Grenzen stößt. Fügen Sie scrape_configs zu Ihrer prometheus.yml hinzu.

Fazit und konkreter Next‑Step

Lokale LLMs mit Ollama verwandeln das klassische „Chat‑Bot‑Szenario“ in ein kontrolliertes, kosteneffizientes und datenschutzkonformes Projekt. Sie erhalten volle Transparenz, verhindern externe Datenexfiltration und können das Modell exakt an Ihre Infrastruktur‑Richtlinien anpassen.

Ihr nächster Schritt (in 7 Tagen):

1. Hardware bereitstellen – 2 vCPU, 8 GB RAM + mindestens 1 × NVIDIA‑GPU (8 GB VRAM). Installieren Sie das OS‑Image (Ubuntu 22.04 LTS) und aktivieren Sie das GPU‑Treiber‑Paket (sudo apt install nvidia-driver-525).
2. Ollama installieren (siehe Beispiel 1) und das Modell mistral:7b-instruct pullen.
3. FastAPI‑Gateway aus Beispiel 5 deployen, PostgreSQL‑Auditing aus Beispiel 6 anlegen und das System mit Prometheus‑Grafana überwachen.
4. Testen Sie das Setup mit einem kleinen internen Chat‑Client und messen Sie die Latenz; passen Sie die GPU‑Auslastung mit ollama config set gpu=true an.
5. Dokumentieren Sie das Auditing‑Schema und die Rate‑Limiting‑Regeln – das spart später Aufwand bei internen Audits.

Nach dieser Woche haben Sie ein produktives, selbstgehostetes LLM‑Backend, das Ihnen nicht nur Kosten spart, sondern auch Ihre digitale Souveränität stärkt. Und das alles mit weniger Aufwand, als ein externer SaaS‑Vertrag zu verhandeln.

Bleiben Sie neugierig, experimentieren Sie mit kleineren Modellen (Llama‑2‑7B, TinyLlama) und skalieren Sie erst, wenn Sie das Kosten‑/Performance‑Verhältnis genau kennen.