Dokumenten-Automatisierung mit KI-Agenten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Dokumenten-Automatisierung mit KI-Agenten behandelt

• Wie Du Dokumente mit KI-Agenten automatisch verarbeitest.
• Wie PDF-Extraktion, Klassifikation, Zusammenfassung und Tagging funktionieren.
• Wie Du Paperless-ngx, Nextcloud und eigene Skripte mit KI verbindest.
• Praxisbeispiele für Rechnungen, Verträge, Berichte und E-Mail-Anhänge.
• Best Practices für Genauigkeit, Sicherheit und Performance.

Einleitung: Dokumenten-Automatisierung mit KI-Agenten verständlich erklärt

Dokumenten-Automatisierung bedeutet, dass KI-Agenten Dokumente verarbeiten: PDFs lesen, Inhalte extrahieren, Dokumente klassifizieren, zusammenfassen, Tags vergeben. Statt manuell Dokumente zu sortieren und zu lesen, macht das ein Agent automatisch. Ein eingehendes PDF wird analysiert, der Inhalt extrahiert, das Dokument klassifiziert und mit Tags versehen.

Dieser Artikel richtet sich an Anwender, die Dokumentenverarbeitung automatisieren wollen. Du solltest verstehen, was KI-Agenten sind und wie Ollama funktioniert. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich Dokumenten-Automatisierung?

Stell Dir vor, Du bekommst täglich 20 PDFs: Rechnungen, Verträge, Berichte, Angebote. Jede musst Du lesen, klassifizieren, ablegen. Das kostet Stunden. Mit KI-Agenten: Das PDF wird automatisch analysiert, der Inhalt extrahiert, das Dokument klassifiziert, eine Zusammenfassung erstellt und das Dokument mit Tags versehen. Du siehst nur noch die Zusammenfassung und die Tags.

Dokumenten-Automatisierung mit KI-Agenten kurz erklärt

Dokumenten-Automatisierung nutzt KI-Agenten, um Dokumente zu verarbeiten. Der Agent liest das Dokument (PDF, Word, Text), extrahiert Inhalte, klassifiziert das Dokument, erstellt eine Zusammenfassung und vergibt Tags. Alles automatisch, ohne menschliches Eingreifen.

Der Kerngedanke lautet: Dokumente kommen rein, verarbeitete Dokumente kommen raus.

Für wen ist dieser Artikel gedacht?

• Büroarbeiter, die viele Dokumente verarbeiten.
• Buchhalter, die Rechnungen automatisch klassifizieren wollen.
• Anwälte, die Verträge automatisch analysieren wollen.
• Self-Hoster, die Paperless-ngx oder Nextcloud mit KI erweitern.

Vorkenntnisse in KI und Python sind hilfreich.

Wichtige Begriffe

• KI-Agenten - Programme mit Tools. Wann nützlich: für intelligente Dokumentenverarbeitung.
• PDF-Extraktion - Text aus PDF lesen. Wann nützlich: um PDFs zu verarbeiten.
• Klassifikation - Dokument in Kategorie einordnen. Wann nützlich: für automatische Sortierung.
• Zusammenfassung - Kernpunkte extrahieren. Wann nützlich: für schnelles Verständnis.
• Tagging - Schlagworte vergeben. Wann nützlich: für Suche und Filter.
• OCR - Optical Character Recognition. Wann nützlich: für gescannte Dokumente.
• Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
• Paperless-ngx - Dokumentenverwaltung. Wann nützlich: für Dokumenten-Management.
• Function Calling - Tool-Use. Wann nützlich: für strukturierte Extraktion.

Dokumenten-Pipeline

Eine typische Dokumenten-Pipeline:

1. Eingang: Dokument kommt an (E-Mail, Upload, Scan).
2. Extraktion: Text aus Dokument lesen (PDF, OCR).
3. Analyse: KI analysiert Inhalt.
4. Klassifikation: KI ordnet Kategorie zu.
5. Zusammenfassung: KI erstellt Zusammenfassung.
6. Tagging: KI vergibt Tags.
7. Ablage: Dokument wird abgelegt.

PDF-Extraktion

import PyPDF2
import pdfplumber

def extract_pdf_pypdf2(file_path):
    """Einfache Extraktion mit PyPDF2"""
    with open(file_path, "rb") as f:
        reader = PyPDF2.PdfReader(f)
        text = ""
        for page in reader.pages:
            text += page.extract_text()
    return text

def extract_pdf_pdfplumber(file_path):
    """Bessere Extraktion mit pdfplumber (Tabellen, Layout)"""
    text = ""
    with pdfplumber.open(file_path) as pdf:
        for page in pdf.pages:
            text += page.extract_text() + "\n"
    return text

OCR für gescannte Dokumente

import pytesseract
from PIL import Image

def extract_ocr(image_path):
    """OCR für gescannte Dokumente"""
    image = Image.open(image_path)
    text = pytesseract.image_to_string(image, lang="deu")
    return text

Klassifikation mit KI

def classify_document(text):
    """Dokument klassifizieren"""
    response = call_ollama([
        {"role": "system", "content": """Klassifiziere das Dokument in eine Kategorie:
- rechnung: Rechnung, Invoice, Zahlungsaufforderung
- vertrag: Vertrag, Contract, Vereinbarung
- bericht: Bericht, Report, Analyse
- angebot: Angebot, Quote, Offerte
- sonstiges: Alles andere

Antworte nur mit der Kategorie."""},
        {"role": "user", "content": text[:3000]}
    ])
    return response["message"]["content"].strip().lower()

Zusammenfassung mit KI

def summarize_document(text, max_sentences=5):
    """Dokument zusammenfassen"""
    response = call_ollama([
        {"role": "system", "content": f"Fasse das Dokument in {max_sentences} Sätzen zusammen."},
        {"role": "user", "content": text[:8000]}
    ])
    return response["message"]["content"]

Tagging mit KI

def tag_document(text):
    """Tags für Dokument generieren"""
    response = call_ollama([
        {"role": "system", "content": "Vergib 3-5 Tags für das Dokument. Antworte als JSON-Array."},
        {"role": "user", "content": text[:3000]}
    ], format="json")
    return json.loads(response["message"]["content"])

Vollständige Pipeline

def process_document(file_path):
    """Vollständige Dokumenten-Pipeline"""
    # 1. Text extrahieren
    if file_path.endswith(".pdf"):
        text = extract_pdf_pdfplumber(file_path)
    elif file_path.endswith((".png", ".jpg")):
        text = extract_ocr(file_path)
    else:
        with open(file_path) as f:
            text = f.read()

    # 2. Klassifizieren
    category = classify_document(text)

    # 3. Zusammenfassen
    summary = summarize_document(text)

    # 4. Tags generieren
    tags = tag_document(text)

    # 5. Metadaten extrahieren (Datum, Absender, Betreff)
    metadata = extract_metadata(text)

    return {
        "file": file_path,
        "category": category,
        "summary": summary,
        "tags": tags,
        "metadata": metadata
    }

Praxisbeispiel 1: Rechnungen automatisch verarbeiten

def process_invoice(pdf_path):
    """Rechnung verarbeiten"""
    text = extract_pdf_pdfplumber(pdf_path)

    # Strukturierte Daten extrahieren
    invoice_data = extract_invoice_data(text)

    # In Datenbank speichern
    save_invoice(invoice_data)

    # In Ordner verschieben
    move_to_folder(pdf_path, "rechnungen")

    return invoice_data

def extract_invoice_data(text):
    """Rechnungsdaten extrahieren"""
    response = call_ollama([
        {"role": "system", "content": """Extrahiere aus der Rechnung:
- Rechnungsnummer
- Datum
- Betrag
- Währung
- Absender
- Empfänger

Antworte als JSON."""},
        {"role": "user", "content": text}
    ], format="json")
    return json.loads(response["message"]["content"])

Praxisbeispiel 2: Verträge analysieren

def analyze_contract(pdf_path):
    """Vertrag analysieren"""
    text = extract_pdf_pdfplumber(pdf_path)

    # Risiken identifizieren
    risks = identify_risks(text)

    # Wichtige Klauseln extrahieren
    clauses = extract_clauses(text)

    # Zusammenfassung
    summary = summarize_document(text, max_sentences=10)

    return {
        "risks": risks,
        "clauses": clauses,
        "summary": summary
    }

def identify_risks(text):
    """Risiken im Vertrag identifizieren"""
    response = call_ollama([
        {"role": "system", "content": "Identifiziere Risiken im Vertrag. Liste sie auf."},
        {"role": "user", "content": text[:8000]}
    ])
    return response["message"]["content"]

Praxisbeispiel 3: Paperless-ngx mit KI

# Paperless-ngx Custom Script
# Wird bei jedem neuen Dokument aufgerufen

def on_document_processed(document):
    """Wird von Paperless-ngx aufgerufen"""
    text = document.content

    # Klassifizieren
    category = classify_document(text)
    document.tags.add(category)

    # Zusammenfassen
    summary = summarize_document(text)
    document.custom_fields["summary"] = summary

    # Tags
    tags = tag_document(text)
    for tag in tags:
        document.tags.add(tag)

Sicherheitshinweise

• Vertrauliche Dokumente: Dokumente können sensible Daten enthalten. Nutze lokale KI, nicht Cloud. Siehe Offline-KI.
• Eingaben validieren: Dokumente können Prompt Injection enthalten. Siehe Prompt Injection.
• Ausgaben validieren: KI kann Fehler machen. Prüfe kritische Extraktionen.
• Audit Logging: Protokolliere alle Dokumentenverarbeitungen. Siehe Protokollierung.
• Zugriffskontrolle: Nicht jeder sollte alle Dokumente sehen. Siehe Zugriffsschutz.

Typische Stolpersteine

• OCR-Fehler: Gescannte Dokumente haben OCR-Fehler. Prüfe kritische Daten.
• Kontextlänge: Große Dokumente müssen chunked werden. Nutze Kontextlänge.
• Falsche Klassifikation: KI kann falsch klassifizieren. Nutze Confidence-Scores oder menschliche Prüfung.
• Fehlerhafte Extraktion: KI kann Daten falsch extrahieren. Validiere kritische Felder.
• Performance: Große Dokumente brauchen Zeit. Nutze asynchrone Verarbeitung.
• Format-Probleme: Komplexe Layouts (Tabellen, Spalten) sind schwer zu extrahieren.

Weiterführende Links

• KI-Agenten Grundlagen - Was KI-Agenten sind.
• Ollama - Lokaler Modellserver.
• Lokales RAG - Dokumente durchsuchbar machen.
• Paperless-ngx - Dokumentenverwaltung.
• E-Mail-Automatisierung - E-Mail-Workflows.
• Prompt Injection - Sicherheit.
• Protokollierung - Logging.
• Kontextlänge - Kontext verstehen.

Key Takeaways:

• Dokumenten-Automatisierung: Extraktion, Klassifikation, Zusammenfassung, Tagging.
• PDF-Extraktion mit PyPDF2 oder pdfplumber, OCR für Scans.
• KI klassifiziert, fasst zusammen, vergibt Tags.
• Paperless-ngx kann mit Custom Scripts erweitert werden.
• Sicherheit: Validierung, Audit Logging, Zugriffskontrolle.

FAQ

Quellen und weiterführende Literatur

• pdfplumber - PDF-Extraktion.
• pytesseract - OCR.
• Paperless-ngx - Dokumentenverwaltung.
• Ollama - Lokaler Modellserver.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert