Lokale KI für KMU: Dokumente, E-Mails und Workflows automatisieren

Worum es geht

KI-Tools wie ChatGPT sind praktisch – aber für sensible Unternehmensdaten problematisch. Verträge, Kundeninformationen, interne Dokumente: Das gehört nicht auf fremde Server.

Lokale Mistral-Modelle lösen dieses Problem. Sie laufen auf dem eigenen Rechner, keine Daten verlassen das Unternehmen. Dieser Artikel zeigt konkrete Anwendungsfälle für KMU.

Was du brauchst

Rechner mit 32 GB RAM (Mac M1+ oder Linux mit GPU)
Ollama installiert
Mistral Small 3.1 oder Devstral Small 2

ollama pull mistral-small
# oder für längere Dokumente:
ollama pull devstral

PDFs und gescannte Dokumente verarbeiten

Bevor wir zu den Anwendungsfällen kommen: Wie bekommt man Dokumente überhaupt in ein Format, das lokale Modelle verarbeiten können?

Native PDFs (mit Text-Layer)

Die meisten modernen PDFs enthalten bereits maschinenlesbaren Text. Einfach extrahieren:

# Mit pdftotext (poppler-utils)
pdftotext vertrag.pdf vertrag.txt

# Oder mit pdfplumber (Python, bessere Tabellenextraktion)
pip install pdfplumber
python -c "import pdfplumber; print(pdfplumber.open('vertrag.pdf').pages[0].extract_text())"

Gescannte Dokumente (ohne Text-Layer)

Für Scans braucht man OCR (Optical Character Recognition):

Option 1: Tesseract (lokal, kostenlos)

# Installation
brew install tesseract tesseract-lang  # macOS
apt install tesseract-ocr tesseract-ocr-deu  # Linux

# Anwendung
tesseract scan.pdf output -l deu pdf txt

Option 2: Vision-Modelle über Ollama

Modelle wie LLaVA oder Granite3.2-Vision können Bilder direkt verarbeiten:

ollama pull llava
# Dann Seiten als Bilder exportieren und analysieren

Option 3: Mistral OCR API

Für komplexe Dokumente (Tabellen, Formeln, mehrsprachig) bietet Mistral eine OCR-API – ca. $2 pro 1.000 Seiten, bis zu 2.000 Seiten/Minute. Auch self-hosted verfügbar für sensible Daten.

Anwendungsfall 1: Verträge analysieren

Das Problem

Ein neuer Lieferantenvertrag liegt vor. 40 Seiten, juristische Sprache. Was sind die kritischen Punkte?

Die Lösung

# Erst PDF zu Text
pdftotext vertrag.pdf vertrag.txt

# Dann analysieren
ollama run mistral-small "Analysiere diesen Vertrag. 
Liste auf:
1. Kündigungsfristen
2. Haftungsklauseln
3. Preisanpassungsregeln
4. Ungewöhnliche Bedingungen

Vertrag:
$(cat vertrag.txt)"

Ergebnis

Das Modell extrahiert die relevanten Passagen und fasst sie verständlich zusammen. Keine juristische Beratung, aber ein guter erster Überblick.

Anwendungsfall 2: E-Mail-Entwürfe generieren

Das Problem

Kundenanfragen beantworten kostet Zeit. Die Antworten ähneln sich oft, aber Copy-Paste wirkt unpersönlich.

Die Lösung

Ein einfaches Script:

import subprocess
import sys

def generate_reply(customer_email, context=""):
    prompt = f"""Du bist Kundenservice-Mitarbeiter einer Webagentur.
Schreibe eine professionelle, freundliche Antwort auf diese Anfrage.
Halte dich kurz und konkret.

Kontext über den Kunden: {context}

Kundenanfrage:
{customer_email}

Antwortentwurf:"""
    
    result = subprocess.run(
        ["ollama", "run", "mistral-small", prompt],
        capture_output=True, text=True
    )
    return result.stdout

# Beispiel
email = """
Hallo, 
wir haben letzte Woche über eine neue Website gesprochen.
Können Sie mir ein Angebot schicken?
Gruß, Müller
"""

print(generate_reply(email, "Gespräch am 10.6., Interesse an Firmenwebsite"))

Ergebnis

Ein Antwortentwurf in Sekunden. Anpassen, absenden, fertig.

Anwendungsfall 3: Protokolle aus Meeting-Notizen

Das Problem

Nach Meetings liegen Stichpunkte vor. Ein ordentliches Protokoll zu schreiben dauert.

Die Lösung

ollama run mistral-small "Erstelle aus diesen Notizen ein strukturiertes Meeting-Protokoll.
Gliedere nach: Teilnehmer, besprochene Themen, Entscheidungen, nächste Schritte mit Verantwortlichen.

Notizen:
$(cat meeting-notizen.txt)"

Anwendungsfall 4: Angebote strukturieren

Das Problem

Aus einem Kundengespräch soll ein Angebot werden. Die Struktur ist immer ähnlich, der Inhalt variiert.

Die Lösung

ollama run mistral-small "Erstelle ein strukturiertes Angebot basierend auf diesem Briefing.
Verwende diese Struktur:
1. Zusammenfassung des Projekts
2. Leistungsumfang (als Liste)
3. Nicht enthalten (wichtig für Abgrenzung)
4. Zeitrahmen
5. Investition (Platzhalter für Preise)

Briefing:
Kunde möchte Website redesign, ca 10 Seiten, WordPress zu Astro Migration,
SEO wichtig, Launch in 8 Wochen, Budget unklar"

Ergebnis

Ein Gerüst, das nur noch mit Preisen und Details gefüllt werden muss.

Anwendungsfall 5: Code-Dokumentation generieren

Das Problem

Legacy-Code ohne Kommentare. Neue Teammitglieder brauchen Stunden zum Einarbeiten.

Die Lösung

Mit Devstral (besser für Code):

ollama run devstral "Analysiere diese JavaScript-Datei und erstelle:
1. Eine Kurzbeschreibung (2-3 Sätze)
2. Liste aller Funktionen mit Zweck
3. Abhängigkeiten und externe APIs
4. Potenzielle Probleme oder Tech Debt

Code:
$(cat src/legacy/payment.js)"

Anwendungsfall 6: Interne FAQ erstellen

Das Problem

Dieselben Fragen tauchen immer wieder auf. Onboarding neuer Mitarbeiter ist aufwendig.

Die Lösung

Vorhandene Dokumente (Handbücher, E-Mails, Wiki) sammeln und verarbeiten:

cat handbuch.txt prozesse.txt wiki-export.txt | \
ollama run mistral-small "Erstelle aus diesem Material eine FAQ-Liste.
Formuliere 15-20 typische Fragen, die neue Mitarbeiter haben könnten.
Beantworte jede Frage kurz und präzise."

Anwendungsfall 7: Datenbankabfragen aus natürlicher Sprache

Das Problem

Nicht jeder kann SQL. Aber jeder hat Fragen an die Daten.

Die Lösung

ollama run mistral-small "Du bist ein SQL-Experte.
Unsere Datenbank hat diese Tabellen:
- customers (id, name, email, created_at, region)
- orders (id, customer_id, total, status, created_at)
- products (id, name, price, category)
- order_items (order_id, product_id, quantity)

Erstelle eine SQL-Abfrage für:
'Zeige mir alle Kunden aus Bayern, die in den letzten 30 Tagen mehr als 500€ bestellt haben'"

Integration in bestehende Workflows

Als CLI-Tool

# ~/.bashrc oder ~/.zshrc
zusammenfassung() {
  cat "$1" | ollama run mistral-small "Fasse zusammen in 5 Stichpunkten:"
}

# Nutzung:
zusammenfassung dokument.txt

Als Python-Service

from flask import Flask, request, jsonify
import subprocess

app = Flask(__name__)

@app.route('/analyze', methods=['POST'])
def analyze():
    text = request.json.get('text')
    prompt = request.json.get('prompt', 'Analysiere diesen Text:')
    
    result = subprocess.run(
        ["ollama", "run", "mistral-small", f"{prompt}\n\n{text}"],
        capture_output=True, text=True
    )
    return jsonify({"result": result.stdout})

if __name__ == '__main__':
    app.run(port=5000)

Jetzt kann jede interne Anwendung die lokale KI nutzen.

Datenschutz-Checkliste

Bevor sensible Daten verarbeitet werden:

Ollama läuft lokal (nicht auf externem Server)
Keine Netzwerkfreigabe für Ollama aktiviert
Modelldateien auf verschlüsseltem Laufwerk
Keine Logs mit sensiblen Daten aktiviert
Mitarbeiter geschult (was darf/darf nicht)

Grenzen

Lokale Modelle sind leistungsfähig, aber nicht allmächtig:

Komplexe Rechtsfragen: Anwalt konsultieren, nicht nur KI
Medizinische Daten: Strengere Regulierung, ggf. zertifizierte Lösungen nötig
Sehr lange Dokumente: Bei 100+ Seiten in Abschnitte teilen
Echtzeit-Anforderungen: Lokale Modelle haben Latenz (2-10 Sekunden)

Einordnung

Lokale KI-Modelle ermöglichen Automatisierung ohne Datenschutz-Kompromisse. Die Anwendungsfälle in diesem Artikel sind Startpunkte – keine vollständigen Lösungen.

Der Einstieg ist niedrigschwellig: Ollama installieren, Modell laden, loslegen. Die Integration in bestehende Workflows erfordert mehr Aufwand, zahlt sich aber schnell aus.

Für KMU mit sensiblen Daten ist das oft der einzig gangbare Weg, KI produktiv zu nutzen.

Wer lokale LLMs und Ollama systematisch einsetzen möchte – von der Einrichtung bis zu eigenen Workflows – findet auf learn.casoon.dev einen praktischen Kurs dazu.