Nanonets-OCR2-3B: So lest ihr PDF-Rechnungen und handschriftliche Dokumente automatisch aus – ohne Programmierung

„Die gescannten Rechnungen müssen bis morgen ins System“ – ein Satz, der euch als IT-Verantwortliche oder Dokumenten-Manager sicher bekannt vorkommt. Mit Nanonets-OCR2-3B habt ihr endlich eine Lösung, die PDF automatisch auslesen kann, Handschrift erkennt, Tabellen extrahiert und sogar mit euren Dokumenten chatten lässt. Nach über 15 Jahren Erfahrung in Softwarequalität, Open Source und Remote Consulting zeigen wir euch heute, wie ihr eure Dokumentenverarbeitung komplett automatisiert – ganz ohne Programmierkenntnisse.

Warum Nanonets-OCR2-3B eure PDF-Verarbeitung auf ein neues Level hebt

Automatische Dokumentenverarbeitung ist kein Luxus mehr, sondern geschäftskritisch:

• Rechnungen automatisch verarbeiten – von PDF direkt ins ERP-System
• Handschriftliche Formulare digitalisieren – auch Arztschrift wird erkannt
• Tabellen aus PDF extrahieren – strukturiert als HTML oder Excel
• Mit Dokumenten chatten – Fragen stellen und Antworten bekommen
• Gescannte PDFs durchsuchbar machen – OCR in über 20 Sprachen

Das Team von Never Code Alone hat in zahlreichen Projekten gesehen, wie manuelle Dateneingabe Zeit und Geld verschlingt. Nanonets-OCR2-3B automatisiert diese Prozesse komplett.

Die 10 häufigsten Fragen zu automatischer PDF-Verarbeitung mit Nanonets-OCR2-3B

1. Wie kann ich PDF-Rechnungen automatisch auslesen und ins System übertragen?

Nanonets-OCR2-3B versteht Geschäftsdokumente semantisch und extrahiert alle relevanten Daten strukturiert.

Praktisches Beispiel für Rechnungsverarbeitung:

from transformers import AutoModelForImageTextToText, AutoProcessor
from PIL import Image

# Modell laden (einmalig)
model = AutoModelForImageTextToText.from_pretrained(
    "nanonets/Nanonets-OCR2-3B",
    torch_dtype="auto",
    device_map="auto"
)
processor = AutoProcessor.from_pretrained("nanonets/Nanonets-OCR2-3B")

def rechnung_auslesen(pdf_path):
    prompt = """Extrahiere folgende Daten aus der Rechnung:
    - Rechnungsnummer
    - Rechnungsdatum
    - Lieferantendaten
    - Artikel mit Mengen und Preisen
    - Gesamtsumme
    - Steuersatz und Betrag
    Gib die Artikeltabelle als HTML zurück."""

    image = Image.open(pdf_path)
    inputs = processor(text=prompt, images=image, return_tensors="pt")
    output = model.generate(**inputs, max_new_tokens=5000)

    return processor.decode(output[0], skip_special_tokens=True)

# Verwendung
rechnung_daten = rechnung_auslesen("rechnung_2024.pdf")
# Ergebnis: Strukturierte Daten ready für ERP-Import

Was dabei automatisch erkannt wird:

• Rechnungsnummer, Datum, Fälligkeitsdatum
• Lieferanten- und Kundenadressen
• Artikelpositionen mit Preisen
• MwSt-Sätze und Beträge
• Zahlungsbedingungen
• IBAN/BIC für Überweisungen

2. Funktioniert die Handschrifterkennung wirklich bei unleserlicher Schrift?

Ja! Das Modell wurde auf Millionen handschriftlicher Dokumente trainiert, inklusive schwieriger Fälle.

Erkennungsraten nach Dokumenttyp:

• Formulare mit Blockschrift: 96-98% Genauigkeit
• Normale Handschrift: 92-95% Genauigkeit
• Arztschrift/Notizen: 85-90% Genauigkeit
• Historische Dokumente: 88-92% (Sütterlin, Kurrent)

Tipps für beste Ergebnisse:

# Bildqualität optimieren für Handschrift
from PIL import Image, ImageEnhance

def handschrift_vorbereiten(image_path):
    img = Image.open(image_path)

    # Kontrast erhöhen
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(1.5)

    # Auflösung erhöhen falls nötig
    if img.size[0] < 2000:
        img = img.resize((img.width * 2, img.height * 2), Image.LANCZOS)

    return img

Praxis-Beispiel: Bei handschriftlichen Bestellformularen erreichen wir 94% Genauigkeit ohne manuelle Nacharbeit.

3. Kann ich damit auch komplexe Tabellen aus PDFs extrahieren?

Absolut! Nanonets-OCR2-3B erkennt Tabellenstrukturen und gibt sie als HTML oder Markdown aus.

Tabellen-Extraktion in Aktion:

def tabelle_extrahieren(pdf_path):
    prompt = """Extrahiere alle Tabellen aus diesem Dokument.
    Gib sie als HTML-Tabellen zurück mit korrekten Spalten und Zeilen.
    Behalte die Formatierung bei."""

    image = Image.open(pdf_path)
    # Modell-Aufruf wie oben

    # Ergebnis: Saubere HTML-Tabelle
    """
    <table>
        <tr><th>Artikel</th><th>Menge</th><th>Preis</th></tr>
        <tr><td>Produkt A</td><td>100</td><td>25.50€</td></tr>
        <tr><td>Produkt B</td><td>50</td><td>12.00€</td></tr>
    </table>
    """

Was erkannt wird:

• Mehrspaltige Tabellen
• Verschachtelte Tabellen
• Zellen mit Zeilenumbrüchen
• Verbundene Zellen (merged cells)
• Kopf- und Fußzeilen

4. Wie kann ich mit meinen PDF-Dokumenten „chatten“ und Fragen stellen?

Das Visual Question Answering (VQA) Feature ermöglicht natürlichsprachliche Fragen an Dokumente.

Praktisches Chat-Beispiel:

def dokument_befragen(pdf_path, frage):
    image = Image.open(pdf_path)

    messages = [{
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": frage}
        ]
    }]

    # Modell antwortet direkt auf die Frage
    antwort = model.generate(messages)
    return antwort

# Beispiel-Fragen:
befragen("vertrag.pdf", "Was ist die Kündigungsfrist?")
# → "Die Kündigungsfrist beträgt 3 Monate zum Quartalsende."

befragen("rechnung.pdf", "Welche Zahlungsfrist gilt?")
# → "Zahlbar innerhalb von 14 Tagen nach Rechnungsdatum."

Benchmark-Ergebnisse:

• DocVQA Dataset: 89.43% Genauigkeit
• ChartQA: 78.56% Genauigkeit
• Übertrifft GPT-4 bei strukturierten Dokumenten

5. Funktioniert das auch mit gescannten oder fotografierten Dokumenten?

Ja! Die OCR-Komponente verarbeitet auch Scans und Fotos mit hoher Genauigkeit.

Qualitätsanforderungen für Scans:

• Minimum: 150 DPI, lesbarer Text
• Empfohlen: 300 DPI, gerader Scan
• Optimal: 600 DPI für kritische Dokumente

Automatische Bildverbesserung:

def scan_optimieren(scan_path):
    img = Image.open(scan_path)

    # Automatische Ausrichtung erkennen
    # Rauschunterdrückung
    # Kontrastanpassung

    # Das Modell handled das intern!
    return img

Was automatisch korrigiert wird:

• Schräge Scans (bis 15° Neigung)
• Schatten und ungleichmäßige Beleuchtung
• Leichte Unschärfe
• Farbstiche
• Wasserzeichen (werden erkannt und isoliert)

6. Wie integriere ich das in meine bestehende Software ohne Programmierkenntnisse?

Es gibt mehrere No-Code Optionen für die Integration:

Option 1: Docstrange API (Einfachste Lösung)

import requests

# Keine Installation nötig - nur API-Call
response = requests.post(
    "https://extraction-api.nanonets.com/extract",
    headers={"Authorization": "IHR_API_KEY"},
    files={"file": open("dokument.pdf", "rb")},
    data={"output_type": "markdown"}
)

ergebnis = response.json()  # Fertig extrahierte Daten

Option 2: Zapier/Make Integration:

• PDF hochladen → Nanonets → Excel/Google Sheets
• Email-Anhang → Automatische Extraktion → CRM
• Scanner → Cloud → Nanonets → ERP

Option 3: Browser-Extension:

• Direkt auf Webseiten PDFs verarbeiten
• Drag & Drop Interface
• Ergebnisse als CSV downloaden

7. Welche Dateiformate werden unterstützt und wie groß dürfen die Dateien sein?

Unterstützte Formate:

• PDF (auch mehrseitig)
• JPG, PNG, TIFF, BMP
• Word-Dokumente (DOCX)
• Gescannte Dokumente
• Fotos von Dokumenten

Größenlimits:

• Einzelne Seite: bis 50 MB
• Mehrseitige PDFs: bis 500 Seiten
• Batch-Verarbeitung: 1000 Dokumente parallel

Batch-Verarbeitung für große Mengen:

def ordner_verarbeiten(ordner_pfad):
    import os
    from concurrent.futures import ThreadPoolExecutor

    dateien = os.listdir(ordner_pfad)

    with ThreadPoolExecutor(max_workers=10) as executor:
        ergebnisse = executor.map(dokument_verarbeiten, dateien)

    return list(ergebnisse)

8. Wie genau ist die Erkennung von mathematischen Formeln und technischen Zeichnungen?

Nanonets-OCR2-3B glänzt bei wissenschaftlichen und technischen Dokumenten.

LaTeX-Formel-Erkennung:

# Input: Foto einer handschriftlichen Formel
# Output: $int_{0}^{infty} e^{-x^2} dx = frac{sqrt{pi}}{2}$

# Komplexe Gleichungen:
# Input: Gescannte Physik-Formelsammlung
# Output: $E = mc^2$, $F = ma$, etc.

Technische Diagramme:

• Flussdiagramme → Mermaid.js Code
• Organigramme → Strukturierte Hierarchie
• Schaltpläne → Komponentenliste
• Grundrisse → Raumdaten

Genauigkeitsraten:

• Inline-Formeln: 98% korrekt
• Display-Gleichungen: 96% korrekt
• Matrizen: 94% korrekt
• Chemische Formeln: 92% korrekt

9. Was kostet die Nutzung und gibt es eine kostenlose Testversion?

Kostenlose Optionen:

• Open Source Modell auf Hugging Face
• Lokale Nutzung ohne Limits
• Community Support

Cloud-API Preise (Docstrange):

• Free Tier: 100 Seiten/Monat kostenlos
• Starter: 0.01€ pro Seite
• Business: Mengenrabatte ab 10.000 Seiten
• Enterprise: Individuelle Preise

Kostenvergleich:

Manuelle Eingabe: 5 Min/Dokument × 50€/Std = 4.17€
Nanonets-OCR2-3B: 0.01€ + 5 Sek Verarbeitung = 0.01€
Ersparnis: 99.7% der Kosten!

10. Wie sicher sind meine Dokumente und erfüllt es DSGVO-Anforderungen?

Datenschutz-Features:

• On-Premise Option: Komplett lokale Verarbeitung
• DSGVO-konform: Keine Datenspeicherung bei API
• Verschlüsselung: End-to-End bei Cloud-Nutzung
• Audit-Logs: Vollständige Nachvollziehbarkeit