Datenanalyse mit Ollama

Was dieser Artikel über Datenanalyse mit Ollama behandelt

• Welche Analyse-Aufgaben Ollama übernehmen kann.
• Wie Texte, Tabellen und Logs ausgewertet werden.
• Wie man strukturierte Ausgaben bekommt.
• Beispiele für Klassifikation, Extraktion und Berichte.
• Tipps für Qualität, Performance und Datenschutz.

Einleitung: Datenanalyse mit Ollama

Sprachmodelle können nicht nur Texte generieren, sondern auch analysieren. Ollama eignet sich dafür besonders, weil die Daten lokal bleiben und sensible Inhalte nicht an externe Dienste gesendet werden müssen. E-Mails, Support-Tickets, Logdateien, Verträge oder Produktbeschreibungen lassen sich automatisch klassifizieren, zusammenfassen oder in strukturierte Daten überführen.

Dieser Artikel zeigt, welche Datenanalyse-Aufgaben Ollama übernehmen kann und wie man sie praktisch umsetzt.

Wichtige Begriffe

• Klassifikation: Zuordnung eines Textes zu einer Kategorie.
• Extraktion: Herausfiltern bestimmter Informationen.
• Zusammenfassung: Komprimierung eines Textes.
• Sentiment-Analyse: Erkennung der Stimmung.
• Structured Output: Ausgabe in einem definierten Format.
• Prompt-Template: Wiederkehrende Eingabestruktur.
• Named Entity Recognition: Erkennung von Namen, Orten oder Begriffen.
• Batch: Verarbeitung mehrerer Elemente gleichzeitig.

Anwendungsfälle

• E-Mails oder Tickets nach Kategorie sortieren.
• Kundenfeedback nach Stimmung bewerten.
• Verträge nach Schlagworten durchsuchen.
• Logdateien auf Fehlermuster prüfen.
• Produktbeschreibungen strukturieren.
• Dokumente zusammenfassen.
• Entitäten wie Personen oder Firmen extrahieren.
• Tabellen aus Texten ableiten.

Klassifikation

Ein einfaches Prompt für Kategorisierung:

import requests

def classify(text, model="llama3.1"):
    url = "http://localhost:11434/api/generate"
    prompt = f"""Klassifiziere den folgenden Text als eine der Kategorien:
    - Technisch
    - Finanziell
    - Persönlich
    - Spam

    Text: {text}

    Antwort nur mit der Kategorie."""

    response = requests.post(url, json={
        "model": model,
        "prompt": prompt,
        "stream": False
    })
    return response.json()["response"].strip()

print(classify("Meine Rechnung ist falsch."))

Zusammenfassung

def summarize(text, model="llama3.1"):
    prompt = f"Fasse den folgenden Text in drei Sätzen zusammen:\n\n{text}"
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Extraktion

def extract_entities(text, model="llama3.1"):
    prompt = f"""Extrahiere aus dem folgenden Text die Personennamen, Orte und Organisationen.
    Gib die Antwort als JSON zurück:

    {{"persons": [], "locations": [], "organizations": []}}

    Text: {text}"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Tabellenanalyse

Ollama kann auch CSV- oder Markdown-Tabellen auswerten:

def analyze_table(table_text, model="llama3.1"):
    prompt = f"""Analysiere die folgende Tabelle und nenne die drei wichtigsten Erkenntnisse:

    {table_text}"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Logdateien auswerten

def analyze_log(log_text, model="llama3.1"):
    prompt = f"""Analysiere die folgenden Logeinträge und nenne die häufigsten Fehlertypen:

    {log_text}"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Strukturierte Ausgaben

Für strukturierte Ergebnisse ist ein klares Format nötig:

Gib die Antwort ausschliesslich als JSON zurück:

{
  "category": "Technisch",
  "confidence": 0.9,
  "keywords": ["Netzwerk", "Fehler"]
}

Modelle geben aber nicht immer korrektes JSON. Deshalb sollten Ausgaben validiert werden.

Batch-Verarbeitung

import json

texts = ["Text eins", "Text zwei", "Text drei"]

results = []
for text in texts:
    result = classify(text)
    results.append({"text": text, "category": result})

with open("ergebnisse.json", "w") as f:
    json.dump(results, f, indent=2, ensure_ascii=False)

Tipps

• Kategorien klar und disjunkt definieren.
• Beispiele im Prompt geben, wenn nötig.
• Temperatur niedrig halten für konsistente Klassifikation.
• Ausgaben parsen und validieren.
• Modelle mit gutem Textverständnis nutzen.
• Bei langen Dokumenten zuerst chunken.
• Sensitive Daten lokal halten, nicht in externe Dienste senden.

Typische Stolpersteine

• Inkonsistente Ausgaben: Modell gibt mal JSON, mal freien Text.
• Zu viele Kategorien: Modell verwirft falsche Kategorien.
• Lange Dokumente: Kontextfenster reicht nicht.
• Falsches Format: Parsing schlägt fehl.
• Modell halluziniert: Extrahiert nicht vorhandene Daten.
• Zu hohe Temperatur: Unbeständige Ergebnisse.
• Prompt zu allgemein: Klassifikation wird unpräzise.

Weiterführende Links und Infos

• BotServ.de Ollama Befehle
• BotServ.de Ollama API-Bibliotheken
• BotServ.de Ollama Automatisierung
• BotServ.de Ollama Prompt-Engineering

FAQ: Datenanalyse mit Ollama

Kann Ollama Tabellen verstehen? Ja, besonders wenn sie als Markdown oder CSV vorliegen.

Ist die Klassifikation zuverlässig? Für einfache Kategorien meist ja, bei komplexen Domänen besser testen.

Wie viele Texte kann ich analysieren? So viele, wie Hardware und Zeit erlauben. Batch-Verarbeitung ist möglich.

Brauche ich JSON-Output? Nicht zwingend, aber es macht die Weiterverarbeitung einfacher.

Welches Modell ist am besten für Analyse? llama3.1, qwen2.5 oder mistral sind gute Allrounder.

Quellen und weiterführende Literatur

• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
• NER Overview: https://en.wikipedia.org/wiki/Named-entity_recognition
• JSON-Validierung in Python: https://docs.python.org/3/library/json.html

Zusammenfassung: Datenanalyse mit Ollama

Ollama eignet sich gut für lokale Datenanalyse. Texte lassen sich klassifizieren, zusammenfassen, auswerten und strukturieren. Mit klaren Prompts, einfachen Skripten und Batch-Verarbeitung lassen sich wiederkehrende Analyse-Aufgaben automatisieren. Wichtig sind definierte Kategorien, validierte Ausgaben und ein passendes Modell. Wer Daten lokal analysiert, bleibt datenschutzkonform und kann sensible Inhalte gefahrlos auswerten.