Dokumentenanalyse mit lokaler KI

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Dokumentenanalyse behandelt

• Wie Du Dokumente mit lokaler KI analysierst.
• Wie Textextraktion, Zusammenfassung und Metadaten-Extraktion funktionieren.
• Wie Du Dokumente automatisch klassifizierst und taggst.
• Praxisbeispiele für Rechnungen, Verträge, Berichte und Korrespondenz.
• Best Practices für Genauigkeit, Datenschutz und Performance.

Einleitung: Dokumentenanalyse verständlich erklärt

Dokumentenanalyse bedeutet: Die KI liest ein Dokument und versteht den Inhalt. Sie kann zusammenfassen, klassifizieren, Metadaten extrahieren und Fragen beantworten. Lokal mit Ollama bleiben alle Dokumente privat.

Dieser Artikel richtet sich an Anwender, die Dokumente mit KI analysieren wollen. Grundlagen findest Du in Dokumente und PDF und Ollama.

Warum brauche ich Dokumentenanalyse?

Stell Dir vor, Du hast 500 PDFs: Rechnungen, Verträge, Berichte. Statt jedes manuell zu lesen, analysiert die KI: „Das ist eine Rechnung von Firma X über 1.234 €, fällig am 15.03. Risiko: Keine Zahlungsbedingungen.” Die KI macht aus unstrukturierten Dokumenten strukturierte Daten.

Dokumentenanalyse kurz erklärt

Dokument → Text extrahieren (OCR falls nötig) → KI analysiert → Strukturierte Daten (Kategorie, Tags, Zusammenfassung, Metadaten). Alles lokal mit Ollama.

Der Kerngedanke lautet: Aus unstrukturiertem Text werden strukturierte Daten.

Für wen ist dieser Artikel gedacht?

• Büroarbeiter, die Dokumente automatisch verarbeiten.
• Unternehmen, die Rechnungen und Verträge analysieren.
• Entwickler, die Dokumenten-Pipelines bauen.
• Self-Hoster, die Dokumentenanalyse lokal betreiben.

Wichtige Begriffe

• Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
• OCR - Text aus Bildern. Wann nützlich: für gescannte Dokumente.
• Klassifikation - Dokumente kategorisieren. Wann nützlich: für Sortierung.
• Metadaten - Strukturierte Daten. Wann nützlich: für Datenbank.
• RAG - Dokumenten-Q&A. Wann nützlich: für Fragen.
• Vision-Modelle - Für Bilder. Wann nützlich: für Scans.

Die Pipeline

Dokument (PDF/Word/Bild)
    │
    ▼
Textextraktion
    ├─ Text vorhanden? → Direkt nutzen
    └─ Kein Text? → OCR (Tesseract/ Vision-Modell)
    │
    ▼
KI-Analyse (Ollama)
    ├─ Klassifizieren: Rechnung? Vertrag? Bericht?
    ├─ Tags generieren: Themen, Kategorien
    ├─ Zusammenfassen: Kerninhalte
    └─ Metadaten: Datum, Absender, Betrag, ...
    │
    ▼
Strukturierte Daten
    ├─ In Datenbank speichern
    ├─ In Ordner verschieben
    └─ Als JSON exportieren

Praxisbeispiel 1: Rechnungen analysieren

import requests
import json

def analyze_invoice(text):
    """Rechnung analysieren"""
    response = requests.post("http://ollama:11434/api/chat", json={
        "model": "llama3.1",
        "messages": [
            {"role": "system", "content": "Extrahiere Rechnungsdaten als JSON: rechnungsnummer, datum, betrag, waehrung, absender, faelligkeitsdatum, positionen (Array)."},
            {"role": "user", "content": f"Rechnung:\n{text[:4000]}"}
        ],
        "stream": False,
        "format": "json"
    })
    return json.loads(response.json()["message"]["content"])

# Beispiel
invoice_data = analyze_invoice(invoice_text)
# Output: {"rechnungsnummer": "RE-2024-1234", "betrag": 1234.56, "waehrung": "EUR", ...}

Praxisbeispiel 2: Verträge analysieren

def analyze_contract(text):
    """Vertrag analysieren"""
    response = requests.post("http://ollama:11434/api/chat", json={
        "model": "llama3.1",
        "messages": [
            {"role": "system", "content": "Analysiere den Vertrag als JSON: vertragsart, partner, laufzeit, kuendigungsfrist, klauseln (Array), risiken (Array)."},
            {"role": "user", "content": f"Vertrag:\n{text[:6000]}"}
        ],
        "stream": False,
        "format": "json"
    })
    return json.loads(response.json()["message"]["content"])

Praxisbeispiel 3: Dokumente klassifizieren

def classify_document(text):
    """Dokument klassifizieren"""
    categories = [
        "rechnung", "vertrag", "bericht", "korrespondenz",
        "protokoll", "anleitung", "sonstiges"
    ]

    response = requests.post("http://ollama:11434/api/chat", json={
        "model": "llama3.1",
        "messages": [
            {"role": "system", "content": f"Klassifiziere das Dokument in eine dieser Kategorien: {', '.join(categories)}. Antworte nur mit der Kategorie."},
            {"role": "user", "content": f"Dokument:\n{text[:2000]}"}
        ],
        "stream": False
    })
    return response.json()["message"]["content"].strip().lower()

Praxisbeispiel 4: Tags generieren

def generate_tags(text, max_tags=5):
    """Tags für Dokument generieren"""
    response = requests.post("http://ollama:11434/api/chat", json={
        "model": "llama3.1",
        "messages": [
            {"role": "system", "content": f"Vergib {max_tags} relevante Tags für das Dokument. Antworte als JSON-Array."},
            {"role": "user", "content": f"Dokument:\n{text[:2000]}"}
        ],
        "stream": False,
        "format": "json"
    })
    return json.loads(response.json()["message"]["content"])

Praxisbeispiel 5: Vollständige Pipeline

import os
from pathlib import Path

def process_document(filepath):
    """Vollständige Dokumentenanalyse"""
    # 1. Text extrahieren
    text = extract_text(filepath)  # PDF, DOCX, TXT

    # 2. Klassifizieren
    category = classify_document(text)

    # 3. Tags generieren
    tags = generate_tags(text)

    # 4. Zusammenfassen
    summary = summarize(text)

    # 5. Metadaten extrahieren
    metadata = extract_metadata(text)

    # 6. Speichern
    result = {
        "file": filepath,
        "category": category,
        "tags": tags,
        "summary": summary,
        "metadata": metadata
    }

    save_to_database(result)
    move_to_folder(filepath, category)

    return result

Sicherheitshinweise

• Vertrauliche Dokumente: Alle Daten bleiben lokal bei Ollama. Bei Cloud-APIs gehen Dokumente raus. Siehe Datenschutz.
• Prompt Injection: Dokumente können Injections enthalten. Siehe Prompt Injection.
• OCR-Fehler: Gescannte Dokumente haben OCR-Fehler. KI-Ergebnisse können dadurch falsch sein.
• Validierung: KI-Extraktionen sollten für kritische Daten validiert werden.

Typische Stolpersteine

• OCR-Fehler: Schlechte Scans = schlechte Extraktion. Gute Qualität wichtig.
• Kontextlänge: Große Dokumente müssen ge-chunked werden. Siehe Kontextlänge.
• Falsche Klassifikation: KI kann falsch klassifizieren. Für kritische Dokumente menschliche Prüfung.
• Zu viele Tags: Mehr als 5-7 Tags sind unübersichtlich. Limitieren.
• Performance: Große Dokumente + viele KI-Aufrufe = langsam. Asynchron verarbeiten.

Weiterführende Links

• Dokumente und PDF - Übersicht.
• PDF-Chatbot - Mit Dokumenten chatten.
• Lokales RAG - Dokumenten-Q&A.
• Ollama - Modellserver.
• Prompt Injection - Sicherheit.
• Datenschutz - Privacy.

Key Takeaways:

• Dokumentenanalyse: Text extrahieren → KI analysiert → strukturierte Daten.
• Klassifizierung, Tags, Zusammenfassung, Metadaten, alles automatisch.
• Für Rechnungen, Verträge, Berichte und Korrespondenz.
• Lokal mit Ollama: alle Daten bleiben privat.
• OCR-Fehler und Prompt Injection beachten.

FAQ

Quellen und weiterführende Literatur

• Ollama - Lokaler Modellserver.
• Tesseract OCR - OCR-Engine.
• PyPDF2 - PDF-Textextraktion.
• python-docx - Word-Dokumente.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert