MCP, LLM/KI/AI Künstliche Intelligenz und Chatbot

1. Ollama einrichten
   1.1. Option A: Windows
   1.2. Option B: Linux:
   1.2.1. GPU und CUDA Treiber installieren
   1.2.2. Ollama installieren

---

1. Ollama einrichten

Ollama ist ein Tool für die lokale Ausführung großer neuronaler Netzmodelle / LLMs. Der Ollama Endpoint kann ein anderer Server sein als der, auf dem Dr.DOC installiert ist (OLLAMA_HOST). Es ist eine Ausführung des Ollama Servers im Rechenzentrum oder geeignetem Server im Unternehmen möglich.
Es wird eine große Zahl von KI Modellen angeboten, mit attraktiven Lizenzmodellen für die kommerzielle Nutzung (z.B. MIT Lizenz).
Für wenig erfahrene Administratoren, wenig GPU Leistung und wenig Linux Erfahrung empfehlen wir die Windows Installation. Bitte prüfen Sie die verfügbaren Treiber für Ihre Grafikkarte/GPU/TPU.

Bitte beachten Sie die erforderlichen Ressourcen (z.B. VRAM, RAM) für das gewählte Ollama KI Modell. Das Modell sollte für gute Performance vollständig ins VRAM geladen werden können.
Die GPU brauch ca. ein VRAM der Größe: Model Size * (1+25%)

Je nach Problem/Fragestellung ist es sehr hilfreich, die Context-Länge (in Einheit Tokens, nicht Zeichen) an Ihre konkrete Fragestellung anzupassen.
z.B. mit OLLAMA_CONTEXT_LENGTH in Env. Var. oder num_ctx im Modelfile
Ca. 0,4 bis 0,25 Tokens pro Zeichen. Einen guten Überglick gibt: https://platform.openai.com/tokenizer

Zur Vermeidung diverser Fehlerquellen empfehlen wir, einen gut dokumentierten Installations-/Konfigurations-Skript zu erstellen. Damit können Sie auf unterschiedlichen Systemen das gleiche, bereits validierte Ergebnis erzielen.

1.1. Option A: Windows

1. Installieren Sie ollama auf einem geeigneten Server, z.B. mit GPU und installiertem CUDA, z.B. den Nvodia Studio Treiber.
https://ollama.com/download/windows
Es kann eine andere Maschine sein, als die, auf der Dr.DOC Web läuft.

"C:\Users\Administrator\Downloads\OllamaSetup.exe" /DIR="C:\ollama"

2. ggf. Ollama Parameter ändern
2.1. Option A: Über Umgebungsvariablen:

setx OLLAMA_MODELS "D:\ollama\models" /M
setx OLLAMA_HOST "192.168.111.21:8080" /M
REM comma separated list of allowed origins
setx OLLAMA_ORIGINS "http://192.168.100.*,http://192.168.200.*" /M
REM The duration that models stay loaded in memory (default "5m")
setx OLLAMA_KEEP_ALIVE "1440m0s" /M
REM Debug Mode
setx OLLAMA_DEBUG "1" /M
REM Reserve a portion of VRAM per GPU (bytes)
setx OLLAMA_GPU_OVERHEAD "1" /M
setx OLLAMA_LOAD_TIMEOUT "3m0s" /M
REM Maximum number of parallel requests
setx OLLAMA_NUM_PARALLEL "2" /M
REM Context Length, default is 2048
setx OLLAMA_CONTEXT_LENGTH "16384" /M
REM for Nvidia GPUs, improve VRAM usage and token generation speed
setx OLLAMA_FLASH_ATTENTION "1" /M
REM KV Cache quantisation von fp16 auf q8_0 oder Q4_K_M ändern für weniger VRAM Verbrauch
setx OLLAMA_KV_CACHE_TYPE "Q4_K_M" /M

2.2. Option B: Durch Erstellen eines eigenen Modelfile:

FROM qwen2.5vl:7b
PARAMETER num_ctx 16384
PARAMETER temperature 0.0
PARAMETER seed 0

ollama create qwen2.5vl:7b --file Modelfile

3. Firewall Zugriff erlauben
netsh advfirewall firewall add rule name= "Ollama Server - TCP Port 8080" dir=in action=allow protocol=TCP localport=8080 program="C:\Ollama\ollama.exe" enable=yes

4. Model laden
ollama pull <model>
z.B. ollama pull llama3

5. Ollama Server starten
ollama serve

1.2. Option B: Linux:

1.2.1. GPU und CUDA Treiber installieren

# ggf. GPUCUDA Treiber installieren
# CUDA installiert?
nvidia-smi

# ggf. Alle Nvidia treiber entfernen für eine saubere CUDA Installation
# apt remove --autoremove --purge -V nvidia-driver\* libxnvctrl\*

# CUDA Toolkit installieren, je nach Plattform - bitte folgende Befehle an Ihre Grafikkarte anpassen (siehe Link)
# https://developer.nvidia.com/cuda-downloads?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=24.04&target_type=deb_network
# https://docs.nvidia.com/datacenter/tesla/driver-installation-guide/index.html
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get -y install cuda-toolkit-12-8
# sudo apt-get -y install cuda-toolkit
# sudo apt-get -y install cuda

# Treiber installieren
# sudo apt-get -y install nvidia-open
# sudo apt-get -y install cuda-drivers-570
sudo apt-get -y install cuda-drivers

# Env PATH anpassen
export PATH=/usr/local/cuda/bin:$PATH

# CUDA installiert?
nvcc --version
nvidia-smi
cat /proc/driver/nvidia/version
grep nvidia /etc/modprobe.d/* /lib/modprobe.d/*
# Nach Modul/Treiber Änderung evtl. initramfs Archive in /boot updaten
# sudo update-initramfs -u

# neu starten
systemctl reboot

1.2.2. Ollama installieren

# Ollama API Doku
# https://github.com/ollama/ollama/blob/main/docs/api.md

# Doku Install Doku:
# https://github.com/ollama/ollama/blob/main/docs/linux.md
curl -fsSL https://ollama.com/install.sh | sh

# Installationsort rausfinden
whereis ollama

sudo useradd -r -s /bin/false -U -m -d /usr/local/bin/ollama ollama
sudo usermod -a -G ollama $(whoami)

# Hostname und IP dieser Maschine rausfinden
hostname && hostname -I

# Env PATH anpassen
export OLLAMA_HOST=159.100.240.33:80

# Bind und Listen auf niedrigen Ports erlauben, z.B. Port 80 erlauben
sudo setcap CAP_NET_BIND_SERVICE=+eip /usr/local/bin/ollama

# Ollama Dienst erstellen
# ggf. IP und Port anpassen
sudo bash -c 'cat <<'EOF' >> /etc/systemd/system/ollama.service
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/local/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin"
Environment="OLLAMA_HOST=159.100.240.33:80"

[Install]
WantedBy=default.target

EOF'

# Ollama Dienst laden und starten
sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl restart ollama

# Ollama Installation prüfen
/usr/local/bin/ollama --version
sudo systemctl status ollama

# Optional: Firewall anpasen; nur noch Zugriffe vom Netzwerk in dem Dr.DOC läuft bzw. der Dr.DOC Maschine aus zulassen
# FW Port öffnen
sudo ufw status
# ssh erlauben
sudo ufw allow proto tcp to any port 22
# sudo ufw allow proto tcp to any port 8081
# sudo ufw allow from 192.168.1.50
# FW nur folgende externe Remote IPs zulassen (statt Auth)
sudo ufw allow from 217.92.78.156 to any proto tcp port 80
# FW aus dem internen Netzwerk erlauben
sudo ufw allow from 192.168.1.0/24 to any proto tcp port 80
sudo ufw allow from 159.100.240.0/24 to any proto tcp port 80
# FW prüfen, bevor sie aktiv wird, da SSH Verbindungen und Remotezugriff gekappt werden könnte
sudo ufw status
sudo ufw enable
sudo ufw reload

# Ollama Modell laden
# Bitte Hardware Ressourcen für das jeweilige KI Modell prüfen
/usr/local/bin/ollama pull llama3.3:70b

# Ollama Modelle auflisten
/usr/local/bin/ollama list

# Läuft das Modell auf der GPU?
/usr/local/bin/ollama ps && nvidia-smi

# Ollama Modell starten zum testen
/usr/local/bin/ollama run llama3.3:70b

# Ollama aktualisieren
/usr/local/bin/ollama update

# Ollama API Test
http://159.100.240.33/api/version

# Logs
journalctl -u ollama --no-pager

Dr.DOC Web hat einen MCP Server seit 01.07.2025 integriert.

Das Model Context Protocol (MCP) ist ein offener Standard und Open-Source-Framework, das vom US-Unternehmen Anthropic entwickelt wurde, um die Integration und den Datenaustausch zwischen künstlicher Intelligenz (KI), insbesondere großen Sprachmodellen (LLMs), und externen Tools, Systemen sowie Datenquellen zu standardisieren.

MCP ist also ein Protokoll, mit welchem AI Agents Funktionsaufrufe sowie deren Parameter und Ressourcen über die MCP Server Schnittstelle von Fachanwendungen zugreifen können (einsehen und aufrufen). Damit kann strukstrukturiert und automatisiert auf Ressourcen zugegriffen werden, mit Hilfe von Tools, welche der MCP Server dem AI Agent (MCP Client) zur Verfügung stellt.

MCP basiert auf JSON RPC 2.0, und das wiederrum auf HTTP, und das auf TCP bzw. heutzutage UDP.

Schnittstellenpfad: /mcp
Z.B. https://drdoc.com/mcp

Die Funktionen CreateArchive und DeleteField sind experimentell und sollten nur zu Test/Entwicklungszwecken aufgerufen werden.

Um die Bedeutung (Kontext) von Dr.DOC Feldern für den MCP Server zu beschreiben, können Sie eine ASCII Import Feldauswahl mit dem Name DD_FIELD_DESC anlegen.
Geben Sie eine detaillierte Beschreibung für relevante Felder ein.

1. Anforderungen definieren
2. Umsetzungsprozess
   2.1. Risikobewertung und Datenschutz-Folgeabschätzung
   2.2. AI Model wählen
   2.3. Hardware und Depolyment wählen
   2.3.1. GPU Kauf
   2.3.2. GPU Miete
   2.3.3. API/Pay per Token
   2.4. Optimieren / Iterieren
3. Implementierung Entwicklungs- und Testsystem
   3.1. Planung/Aufbau Entwicklungs-System (Evaluation)
   3.1.1. Optimieren / Iterieren
   3.2. Implementierung Test-System (Validierung)
   3.3. Produktiv-System ausrollen (Betrieb)
4. Beispiel
   4.1. Datenverarbeitung und Datenschutz
   4.2. Qualität - Modell wählen
   4.3. Performance - Hardware wählen
   4.4. GPU Hardware und AI Model Vergleich

---

Wir empfehlen grundsätzlich folgenden Ablauf.

1. Anforderungen definieren

• Datenverarbeitung:
  • Welche Dookumentarten/Geschäftsfälle in welchen Prozessen sollen archiviert werden?
  • Klassifizierung und/oder Verschlagwortung?
  • Nur erste Seite verarbeiten?
• Datenschutz: (-> Lokales Deployment?)
  • Was wird verarbeitet?
  • Was ist schützenswert?
• Performance (-> Welche GPU?)
  • Durchsatz ausrechnen in Anzahl Seiten pro Tag
  • Peak Load?
• Qualität (-> Reasoning)
• AI Tools Support
• AI Vision

2. Umsetzungsprozess

2.1. Risikobewertung und Datenschutz-Folgeabschätzung

Siehe Checkliste und Umsetzunglsleitfaden: https://drdoc.com/node/de/products/web/doku/dsfa-umsetzungsleitfaden

Systematische Beschreibung der Verarbeitungsvorgänge und Zwecke: Wir empfehlen Ihnen, sich strukturiert und kritisch mit den Risiken der Datenverarbeitung auseinanderzusetzen, und das zu dokumentieren.
Z.B. mit einer Risikobewertung und Abschätzung für die KI-Datenverarbeitung, etwa im Rahmen einer Datenschutz-Folgeabschärtung (DSFA) nach DSGVO Art. 35.

• Systematische Beschreibung
  • Was wird verarbeitet? z.B. Personenbezogene Daten?
  • Wie wird verarbeitet? z.B. Klassifizierung oder/und Verschlagwortung?
  • Wie ist der Verabeitungsprozess? Mit Human-in-the-Loop?
• Verhältnismäßigkeitsprüfung
• Risikobewertung: Voraussichtlichs Risiko (Wahrscheinlichkeit, Schweregrad) für die Rechte und Freiheiten natürlicher Personen?
• Maßnahmen zur Risikominimierung

Beispiel für wichtige Fragen:

• Voraussichtlich hohes Risiko für Rechte und Freiheiten von natürlichen Personen

2.2. AI Model wählen

Das AI Modell muss zur Aufgabe passen (z.B. Handschrift OCR, Tools Support, Reasoning etc.), die passende Performance haben (Durchsatz) bei entsprechender Qualität (Richtigkeit, Vollständigkeit).

• z.B. qwen3 vs. gemma3
• Vision
• Tools Support

2.3. Hardware und Depolyment wählen

Die Hardware sollte genug "Raum" für die verwendeten AI Models sowie den gewünschten Durchsatz (Seiten/Strunde) bieten.
Je nach Datenschutz-Anforderungen und Auslastung sollten Sie die Risiken/Limitierungen/Vorteile/Nachteile des jeweiligen Deployments berücksichtigen.
Das primäre Limit/Flaschenhals ist i.d.R. das VRAM und die Leistung bzw. Durchsatz.

Dr.DOC Web kann mit einem AI Ollama/OpenAI Entpoint kommunizieren und ist flexibel. Daher kann der Endpoint auf der gleichen Maschine, im gleichen Netzwerk/andere Maschine oder im RZ stehen.

Limits:

• VRAM: Das Model sollte samt Output Layer ins dedizierte VRAM der GPU passen. Wenn das Modell nicht in den Videospeicher (VRAM) passt, müssen Daten in den (viel langsameren) System-RAM ausgelagert werden. Die Performance bricht dann massiv ein.
• Speicherbandbreite: Die Geschwindigkeit, mit der der Text beim LLM KI Inferencing generiert wird (Tokens pro Sekunde), skaliert fast linear mit der Speicherbandbreite
• Tensor Cores: Schnellere Antwortzeit bis zum ersten Token.
• Software/Treiber-Support

Betriebssystem:
Werden auf der Maschine primär AI Aufgaben ausgeführt, sollten Sie das gewählte Betriebssystem vom Treiber-Support der GPU abhängig machen. Auf die Frage, "Linux oder Windows", empfehlen wir, die verfügbaren Treiber für Ihre GPU je OS zu prüfen z.B. in puncto Stabilität, Performance und aktivem Treiber Support. Auch sollte berücksichtigt werden, welches Betribssystem/Distro für Ihre IT-Abteilung/IT-Systemhaus im Betrieb einfacher zu warten ist.

2.3.1. GPU Kauf

Achten Sie zwingend auf ECC (Error Correcting Code)

Empfehlungen:

• Testen Sie die Hardware zuvor, z.B. durch GPU Miete im Rechenzentrum
• Achten Sie zwingend auf ECC (Error Correcting Code), denn Sie wollen keinen Bit Flip oder diesen zumindest erkennen
• Achten Sie auf die Maße/Dimensionierung:
  • PCIe Plätze / Einbaugröße
• Achten Sie auf den PCIe Standard u.a. wg. Bandbreite
• Verfügbares VRAM je nach Wunsch-AI-Model; das Model sollte samt Output Layer ins dedizierte VRAM der GPU passen.
• Anzahl Tensor-Cores sowie evtl. Anzahl CUDA/Stream Processors-Recheneinheiten
• KI-TOPS
• Energieverbrauch wg. Netzteil und Kosten
• Schnelle SSD für schnelles Modell Laden
• evtl. MIG Support

Beispiele je nach Workload:

• RTX 5070 Ti; ca. 13 Sek./Seite (inkl. 17k Token Kontext, Reasoning, magische Archivierung in Dr.DOC Web: AI Klassifizierung, AI Verschlagwortung, Archivierung)
• RTX 5090; ca. 8 Sek./Seite
• RTX PRO 6000

2.3.2. GPU Miete

GPU im Rechenzentrum mieten.
Vorteile: Sinnvoll bei sehr geringer Jahres-Auslastung aber hoher, zeitlich planbarer Peak-Auslastung. Zeitliche Planung notwending wg. Model Loading in Speicher; hohe variable Kosten, keine Fixkosten
Nachteile: bei durchgängiger Buchung: hohe Fixkosten

2.3.3. API/Pay per Token

Bezahlung pro Input-/Output Token.
Risiken: Datenschutz: Sollte bei hohen Datenschutzanforderungen vermieden werden.
Vorteile: keine Fixkosten, nur variable Kosten
Nachteile: Datenschutz hoch problematisch, da strukturierte, personenbezogene oder Sicherheits-/IP-relevante Informationen übertragen werden.

2.4. Optimieren / Iterieren

siehe Implementierung Entwicklungs- und Testsystem -> Planung/Aufbau Entwicklungs-System (Evaluation).

3. Implementierung Entwicklungs- und Testsystem

Anleitung Ollama Installation in Windown und Linux:
https://drdoc.com/node/de/products/web/doku/ai-kuenstliche-intelligenz/installation

Hinweis Um den Aufwand zu minimieren, kann in einfachen Umgebungen, Entwicklung und Test initial zusammengefasst werden.

Langfristig empfehlen wir jedoch die Etablierung eines iterativen Optimierungsprozesses in einer strukturierten Umgebung:

3.1. Planung/Aufbau Entwicklungs-System (Evaluation)

Entwicklungs-System mit einer Miet-GPU im RZ aufzubauen, um erste Erfahrungen zu sammeln.

• Scope: Definition der Aufgaben und Auswahl des passenden AI-Modells.
  • Welche Aufgaben sollen erledigt werden?
• Sizing: Ermittlung der Hardware-Anforderungen basierend auf der erwarteten Last (Durchsatz).
  • Welches AI Modell passt zu uns und den Aufgaben?
  • Welche Hardware benötigen wir für das AI Model und die zu erwartende Last (Durchsatz bzw. Seiten/Stunde)?
• Analyse: Umgebung zur Untersuchung von Fehlern aus Prod/Test. Einsatz von Standard-Test-Cases, zur Optimierung der Performance/Qualität (siehe Optimierung).

3.1.1. Optimieren / Iterieren

• Context Length: Je nach Problem/Fragestellung ist es sehr hilfreich, die Context-Länge (in Einheit Tokens, nicht Zeichen) an Ihre konkrete Fragestellung anzupassen.
  z.B. mit OLLAMA_CONTEXT_LENGTH in Env. Var. oder num_ctx im Modelfile
  Ca. 0,4 bis 0,25 Tokens pro Zeichen. Einen guten Überglick gibt: https://platform.openai.com/tokenizer
• Quantisation
• Anzahl zu ladender Seiten bei KI Verarbeitung in Dr.DOC Web durch AI_MaxPagesCount / AI max. Seitenzahl
• Rekursive Document Encoder in Dr.DOC Web anpassen an den spezifischen Geschäftsfall
• System Prompt oder eigener Modelfile
• Mehr auf Anfrage..

Feedback Loop / iterieren: Entwicklung-/Testsystem optimieren

3.2. Implementierung Test-System (Validierung)

Übernahme funktionierender Stände aus der Entwicklung.

Test as you fly, fly as you test

• Versionierung: Sicherung vor jeder Änderung (Snapshots).
• Doku: Klare Protokollierung aller Anpassungen.
• Testing: Einsatz von Standard-Test-Cases und Real-Tests, zur Validierung der ordnungsgemäßen Funktionsweise.

3.3. Produktiv-System ausrollen (Betrieb)

• Rollout: Übertragung ausschließlich getesteter Änderungen aus dem Testsystem.
• Integrität: Strukturierte Übernahme inkl. Dokumentation und Versionierung (für Rollback).

4. Beispiel

4.1. Datenverarbeitung und Datenschutz

Anforderung	Bewertung	Aktionen
Stapelverarbeitung	MUSS	-> Stapelverarbeitung durch automatische IMAP E-Mail-Archivierung und magischer Archivierung in Dr.DOC Web
AI Klassifizierung	MUSS	-> Magische Archivierung in Dr.DOC Web aktivieren
AI Verschlagwortung	MUSS	-> entsprechende Document Encoder in Dr.DOC Web aktivieren/erweitern/anpassen
AI MCP / Tools Support	/	(würde AI Modell mit Tools-Support erfordern)
AI Vision / Handschrift OCR	/	(würde AI Modell mit Vision-Support erfordern)
1 bis 2-Seiteige Dok.	MUSS	-> Dr.DOC Optimierung: Für einige Gesachäftsfälle nur die ersten 2 Seiten verarbeiten
20-Seiteige Dok.	KANN	-> AI Model Context-Length auf 32k bis 64k anheben + testen
100-Seiteige Dok.	/	(Viele Seiten erfordern größere Context Length und damit auch größeres VRAM)
Verarbeitung Dok.: von personenbezogene Daten	20%	-> Lokales Deployment
Verarbeitung Dok.: kritisches Know How/Rezepte etc.	20%	-> Lokales Deployment
Verarbeitung Dok.: Rest	60%	-> Make or buy Analyse durchführen; evtl. je nach Menge für diese Geschäftsfälle einen extenen Ollama/OpenAI Endpoint wählen

4.2. Qualität - Modell wählen

Anforderung	Bewertung	Aktionen
AI Prompt mit Logik	MUSS	-> Qualität wichtiger als Performance -> AI Reasoning Modelle wählen, z.B. qwen3 -> AI Modelle testen und vergleichen anhand von Test-Validierungs-Dok.

4.3. Performance - Hardware wählen

Anforderung	Bewertung	Aktionen
Anzahl Seiten pro Tag Median	MUSS 1000 Seiten / Tag
Anzahl Seiten pro Tag Peak	SOLL 500 Seiten in 1h	-> Hardware: bei 500 Seiten in einer Stunde am Morgen wären das ~14 Sek./Seite -> Hardware: Performance unterschiedlicher GPUs im RZ testen. -> Hardware wählen: z.B. RTX 5090

4.4. GPU Hardware und AI Model Vergleich

Anforderung definieren, z.B.:
500 Seiten in einer Stunde bzw. max. Verarbeitungsdauer von 14 Sek./Seite, bei 100% Qualität und Vollständigkeit, bei lokaler Verarbeitung, von Rechnungen, [...] anhand der Validierungs-Dateien [...].

HW GPU	AI Modell	AI Mode	AI Quantisation	AI Context Length	Input Datei	Input Anzahl Seiten	Output Dauer [s]	Output Dauer / Seite	Output Richtigkeit	Output Vollständigkeit
RTX 5090	qwen3:14b	chat	Q4_K_M	16k	Test.pdf	2	10	5	100%	100%
	gemma3