Dokumenten-Agent: Dokumente mit KI verarbeiten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Dokumenten-Agenten behandelt

• Was ein Dokumenten-Agent ist und wie er funktioniert.
• Wie der Agent Dokumente analysiert, extrahiert und transformiert.
• Wie Du den Agenten mit Tools und RAG ausstattest.
• Praxisbeispiele für Rechnungen, Verträge, Berichte und Formulare.
• Best Practices für Genauigkeit, Sicherheit und Skalierung.

Einleitung: Dokumenten-Agent verständlich erklärt

Ein Dokumenten-Agent ist ein KI-Agent, der Dokumente autonom verarbeitet: Er liest, versteht, extrahiert Daten und führt Aktionen aus. Nicht nur „Text extrahieren”, sondern „Dokument verstehen und darauf reagieren”.

Dieser Artikel richtet sich an Anwender, die KI-Agenten für Dokumentenverarbeitung bauen wollen. Grundlagen findest Du in KI-Agenten und Dokumenten-Automatisierung.

Warum brauche ich einen Dokumenten-Agenten?

Stell Dir vor, Du bekommst täglich 50 Rechnungen. Ein klassisches System extrahiert Text. Ein Dokumenten-Agent: „Rechnung RE-2024-1234, Firma X, 1.234 €, fällig 15.03., Positionen: 3x Beratung à 400 €. Risiko: Keine Zahlungsbedingungen. Aktion: In Ordner Rechnungen, Zahlungserinnerung für 10.03.” Der Agent versteht und handelt.

Dokumenten-Agent kurz erklärt

Dokument → Agent analysiert (LLM) → Tools aufrufen (extrahieren, transformieren, speichern) → Aktion ausführen (archivieren, benachrichtigen, weiterleiten). Mit RAG für Dokumenten-Q&A.

Der Kerngedanke lautet: Nicht nur lesen, sondern verstehen und handeln.

Für wen ist dieser Artikel gedacht?

• Unternehmen, die Dokumente automatisch verarbeiten.
• Entwickler, die Dokumenten-Agenten bauen.
• Büroarbeiter, die Routineaufgaben reduzieren.
• Self-Hoster, die Agenten lokal betreiben.

Wichtige Begriffe

• KI-Agent - Autonomer Akteur. Wann nützlich: das Konzept.
• Tool-Calling - Werkzeuge aufrufen. Wann nützlich: für Aktionen.
• RAG - Dokumenten-Q&A. Wann nützlich: für Fragen.
• Ollama - Lokaler Modellserver. Wann nützlich: das Backend.
• n8n - Workflow-Tool. Wann nützlich: für Orchestrierung.

Architektur

Dokument kommt rein (E-Mail, Upload, Scan)
    │
    ▼
Dokumenten-Agent (Ollama + Tools)
    │
    ├─ Beobachten: Dokument lesen
    ├─ Verstehen: Was ist das? Was will der Absender?
    ├─ Planen: Welche Tools? Welche Aktionen?
    ├─ Handeln: Tools aufrufen
    │   ├─ extract_text: Text extrahieren
    │   ├─ extract_metadata: Metadaten
    │   ├─ classify: Klassifizieren
    │   ├─ summarize: Zusammenfassen
    │   └─ store: Speichern
    └─ Prüfen: Hat es funktioniert?
    │
    ▼
Aktionen
    ├─ In Ordner verschieben
    ├─ In Datenbank speichern
    ├─ Benachrichtigung senden
    └─ Workflow auslösen

Praxisbeispiel 1: Rechnungs-Agent

class InvoiceAgent:
    """Agent für Rechnungsverarbeitung"""

    async def process(self, pdf_path):
        """Rechnung verarbeiten"""
        # 1. Text extrahieren
        text = await self.extract_text(pdf_path)

        # 2. LLM analysiert
        analysis = await self.analyze(text)

        # 3. Tools aufrufen
        invoice = await self.extract_invoice_data(text)
        risks = await self.check_risks(text)

        # 4. Aktionen
        await self.store(invoice)
        await self.move_to_folder(pdf_path, "rechnungen")

        if risks:
            await self.notify(f"Risiken in Rechnung {invoice['number']}: {risks}")

        return invoice

    async def analyze(self, text):
        """LLM analysiert die Rechnung"""
        return await ollama.generate(f"""
Analysiere diese Rechnung:
{text[:4000]}

Extrahiere als JSON:
- rechnungsnummer
- datum
- betrag
- waehrung
- absender
- faelligkeitsdatum
- positionen (Array)
- risiken (Array)""", format="json")

Praxisbeispiel 2: Vertrags-Agent

class ContractAgent:
    """Agent für Vertragsanalyse"""

    async def process(self, contract_text):
        """Vertrag analysieren"""
        # Mehrstufige Analyse
        summary = await self.summarize(contract_text)
        clauses = await self.extract_clauses(contract_text)
        risks = await self.assess_risks(contract_text)

        # Empfehlung
        recommendation = await self.recommend(
            summary, clauses, risks
        )

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

    async def assess_risks(self, text):
        """Risiken bewerten"""
        return await ollama.generate(f"""
Bewerte die Risiken in diesem Vertrag:
{text[:5000]}

Antworte als JSON:
{{"risks": [{{"type": "...", "severity": "low|medium|high", "description": "..."}}],
 "recommendation": "unterschreiben|aendern|ablehnen"}}""", format="json")

Praxisbeispiel 3: RAG-Agent für Dokumenten-Q&A

class DocumentQAAgent:
    """Agent für Fragen zu Dokumenten"""

    def __init__(self):
        self.vectorstore = QdrantClient("http://qdrant:6333")
        self.collection = "dokumente"

    async def ask(self, question):
        """Frage an Dokumente"""
        # RAG: Relevante Dokumente finden
        results = await self.vectorstore.search(
            collection=self.collection,
            query_vector=await self.embed(question),
            limit=5
        )

        context = "\n".join([r.payload["text"] for r in results])

        # LLM beantwortet
        answer = await ollama.generate(f"""
Beantworte die Frage basierend auf den Dokumenten.
Dokumente: {context}
Frage: {question}
Antworte mit Quellenangabe.""")

        return {
            "answer": answer,
            "sources": [r.payload["source"] for r in results]
        }

Tools für Dokumenten-Agenten

tools = [
    {
        "name": "extract_text",
        "description": "Text aus Dokument extrahieren (PDF, DOCX, Bild)",
        "function": extract_text
    },
    {
        "name": "extract_metadata",
        "description": "Metadaten extrahieren (Datum, Autor, Betrag, ...)",
        "function": extract_metadata
    },
    {
        "name": "classify_document",
        "description": "Dokument klassifizieren (Rechnung, Vertrag, ...)",
        "function": classify_document
    },
    {
        "name": "summarize",
        "description": "Dokument zusammenfassen",
        "function": summarize
    },
    {
        "name": "store_document",
        "description": "Dokument in Datenbank speichern",
        "function": store_document
    },
    {
        "name": "search_documents",
        "description": "Dokumente durchsuchen (RAG)",
        "function": search_documents
    }
]

Sicherheitshinweise

• Vertrauliche Dokumente: Alle Daten bleiben lokal. Siehe Datenschutz.
• Prompt Injection: Dokumente können Injections enthalten. Siehe Prompt Injection.
• Validierung: Kritische Extraktionen sollten validiert werden.
• Berechtigungen: Agent sollte nur nötige Berechtigungen haben. Siehe Tool-Berechtigungen.

Typische Stolpersteine

• OCR-Fehler: Schlechte Scans = schlechte Extraktion. Qualität prüfen.
• Kontextlänge: Große Dokumente müssen ge-chunked werden.
• Falsche Klassifikation: KI kann falsch klassifizieren. Für kritische Dokumente prüfen.
• Zu viele Tools: Mehr als 5-7 Tools überfordern das Modell.
• Kein Fallback: Bei Agent-Ausfall sollte ein manueller Prozess greifen.

Weiterführende Links

• KI-Agenten - Grundlagen.
• Dokumenten-Automatisierung - Workflow-Version.
• Dokumentenanalyse - Technik.
• Lokales RAG - Dokumenten-Q&A.
• Tool-Berechtigungen - Sicherheit.
• Ollama - Modellserver.

Key Takeaways:

• Dokumenten-Agent: Liest, versteht, extrahiert, handelt, autonom.
• Tools: extract_text, extract_metadata, classify, summarize, store, search.
• Für Rechnungen, Verträge, Berichte, Formulare.
• Mit RAG für Dokumenten-Q&A.
• Lokal mit Ollama: alle Daten bleiben privat.

FAQ

Quellen und weiterführende Literatur

• Ollama - Lokaler Modellserver.
• LangChain Agents - Agenten-Konzepte.
• Qdrant - Vektordatenbank.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert