karlsCORE KI-Gemeinschaft KI-Wissen Systemisch Denken Erstgespräch Anmelden

Eine robuste Umgebung für Deine KI-Experimente

Dieses Dokument führt Dich Schritt für Schritt durch die Einrichtung eines vollständigen, lokalen KI-Servers. Ziel ist es, eine stabile, sichere und vollständig selbstbestimmbare Umgebung zu schaffen, mit der Du künstliche Intelligenz einsetzen, testen, kombinieren und automatisieren kannst; ohne Cloud-Abhängigkeiten, ohne Datenabfluss, vollständig unter Deiner Kontrolle.

Getestet mit: Debian 13 (Trixie), x86_64, PHP 8.4, Python 3.13, MariaDB 11.8, Qdrant 1.16, ArangoDB 3.11, Ollama 0.20. NVIDIA RTX 4000 SFF Ada (20 GB VRAM) für GPU-beschleunigte Komponenten. Die Anleitung funktioniert grundsätzlich auch auf Ubuntu 24.04 und neueren Debian-Versionen, einzelne Paketnamen und Versionsnummern können abweichen.

Scope: Dieses Dokument beschreibt einen lokalen KI-Server. Alle KI-Kernkomponenten (Sprachmodelle, Vektordatenbank, Graph-Datenbank, OCR) laufen lokal auf dem eigenen Server. Einzelne Infrastrukturdienste wie DNS und Zertifikatsausstellung (Let's Encrypt) setzen externe Anbieter voraus.

Die Anleitung ist so aufgebaut, dass motivierte Einsteiger mit Lernbereitschaft und Geduld jeden Abschnitt nachvollziehen können. Erfahrung mit der Kommandozeile ist hilfreich, aber keine Voraussetzung. Alle Werkzeuge und Technologien werden erklärt, jede Entscheidung ist begründet, jeder Befehl wird in seinem Zusammenhang erläutert. Es sind keine Vorkenntnisse nötig in Serveradministration oder KI-Systemen ... nur ein bisschen Konzentration, Neugier und ein klein wenig Geduld.

Vielleicht erscheint das Setup für den Anfang etwas umfangreich, aber jedes Modul hat seine begründete Funktion: Sowohl bei der Entwicklung als auch später im Produktivbetrieb:

Hardware-Empfehlung:

Für den produktiven Einsatz verwende ich in dieser Anleitung ein dediziertes Root-Server System mit folgender Konfiguration:

Warum ist diese Konfiguration sinnvoll?

Diese Hardware ist ein idealer Kompromiss zwischen Leistung, Stromverbrauch und Investitionsaufwand. Sie eignet sich für produktive Umgebungen, interne Testsysteme oder als leistungsfähige Entwicklungsplattform.

Aber jetzt lass uns loslegen:

System aktualisieren und Grundpakete installieren

Diese Pakete stellen sicher, dass der Server alle grundlegenden Funktionen für Netzwerkinstallation, Paketverwaltung, Entwicklung und Verschlüsselung bereitstellt.

  1. Systempakete aktualisieren:
  1. Wichtige Werkzeuge installieren:
  1. Installation der Werkzeuge:

Das System ist damit vollständig vorbereitet für alle weiteren Installationsschritte.

Benutzer anlegen und SSH-Zugang vorbereiten

Ein dedizierter Systembenutzer trennt administrativen Zugriff von Anwendungsprozessen. Der Zugriff erfolgt ausschließlich per kryptografischem SSH-Schlüssel.

  1. Auf dem lokalen Client einen SSH-Schlüssel erzeugen (falls nicht vorhanden):
  1. Neuen Benutzer auf dem Server erstellen:
  1. Benutzer zur sudo-Gruppe hinzufügen:
  1. SSH-Verzeichnis für den Benutzer vorbereiten:
  1. Öffentlichen Schlüssel auf den Server übertragen und speichern:
  1. Besitzrechte korrekt setzen:

Der Benutzer aiadmin ist nun vorbereitet für einen sicheren SSH-Zugang per Schlüssel.

Root-Login über SSH deaktivieren

Zur Erhöhung der Systemsicherheit wird der direkte SSH-Zugang für root abgeschaltet. Zukünftig erfolgt der Zugriff ausschließlich über dedizierte Benutzer mit sudo-Rechten.

  1. SSH-Konfigurationsdatei öffnen:
  1. Folgende Zeile setzen oder anpassen:
  1. Änderung aktivieren:
  1. Verbindung zum Server neu aufbauen, aber ab sofort mit dem neuen Benutzer:

Alle weiteren Installationsschritte erfolgen ausschließlich unter dem Benutzer aiadmin mit sudo-Rechten.

Noch mehr intensive KI-Impulse »

Firewall einrichten und aktivieren

Die UFW-Firewall (Uncomplicated Firewall) schützt den Server durch gezielte Freigabe benötigter Ports. Es werden nur Dienste zugelassen, die ausdrücklich aktiviert wurden.

  1. UFW installieren:
  1. Standardregeln setzen:
  1. Erforderliche Dienste freigeben:
  1. Firewall aktivieren:
  1. Status prüfen:

Die Ausgabe sollte nun wie folgt aussehen:

Die Firewall ist nun aktiv und schützt das System zuverlässig. Nur SSH, HTTP und HTTPS sind für eingehende Verbindungen erlaubt.

Hinweis zu internen Diensten: Ollama (Port 11434), Qdrant (Port 6333), ArangoDB (Port 8529) und Chandra (Port 8010) sind standardmäßig an localhost gebunden und von außen nicht erreichbar. Die Firewall blockiert diese Ports zusätzlich. Falls später ein externer Zugriff auf einen dieser Dienste nötig wird, lässt sich das über einen Reverse Proxy (z.B. Apache oder Nginx) mit Authentifizierung lösen, statt die Ports direkt zu öffnen.

Fail2Ban installieren und konfigurieren

Fail2Ban schützt den Server vor automatisierten Angriffsversuchen, indem es IP-Adressen temporär blockiert, die mehrfach fehlgeschlagene Loginversuche erzeugen. Die Konfiguration erfolgt über sogenannte Jails.

  1. Fail2Ban installieren:
  1. Standardkonfiguration duplizieren:
  1. Datei jail.local öffnen und bearbeiten:
  1. Abschnitt [sshd] konfigurieren. Dieser sollte wie folgt aussehen:
  1. Optional: Weitere sinnvolle Jails aktivieren
  1. Fail2Ban starten und dauerhaft aktivieren:
  1. Status und Funktion prüfen:

Fail2Ban ist jetzt aktiv. Der SSH-Dienst und der Apache-Webserver sind gegen typische Brute-Force- und Exploitversuche abgesichert. Angreifer werden nach fünf Versuchen für eine Stunde blockiert.

Apache Webserver installieren und aktivieren

Apache stellt den Webserver bereit, über den später PHP-Anwendungen, APIs und Webinterfaces ausgeliefert werden. Der Dienst wird systemweit installiert und automatisch gestartet.

  1. Apache installieren:
  1. Dienst beim Systemstart aktivieren:
  1. Dienst sofort starten:
  1. Status des Webservers prüfen:
  1. Funktionsprüfung im Browser:

Apache ist jetzt betriebsbereit. Die Konfiguration erfolgt später über virtuelle Hosts und optional SSL-Zertifikate.

PHP und Standard-Erweiterungen installieren

PHP-FPM (en: FastCGI Process Manager) wird hier direkt als Primärpfad installiert. Damit läuft PHP als eigenständiger Dienst, und Apache leitet nur bei Bedarf Anfragen dorthin weiter.

PHP wird als serverseitige Scriptsprache benötigt. Die folgenden Pakete installieren PHP-FPM und gängige Erweiterungen für Webanwendungen.

  1. PHP und empfohlene Erweiterungen installieren:
  1. Apache neustarten, damit die neuen Pakete geladen werden. Die Anbindung an PHP-FPM erfolgt im nächsten Schritt:
  1. PHP-Version prüfen:
  1. Funktionsprüfung: PHP-Testseite im Browser anzeigen
  1. Entferne die Testdatei dann wieder.

PHP ist nun vollständig installiert und mit Apache verknüpft. Webanwendungen können ab sofort ausgeführt werden.

PHP-FPM einrichten

PHP-FPM wurde im vorherigen Schritt bereits installiert. Jetzt wird die Verbindung zwischen Apache und dem FPM-Dienst eingerichtet, damit Apache PHP-Anfragen an den FPM-Prozesspool weiterleitet.

Aktivierung (die Versionsnummer 8.4 an die tatsächlich installierte PHP-Version anpassen):

sudo a2enmod proxy_fcgi setenvif
sudo a2enconf php8.4-fpm
sudo systemctl restart apache2
sudo systemctl enable php8.4-fpm
sudo systemctl start php8.4-fpm

Der FPM-Dienst verwaltet einen Pool von PHP-Prozessen und skaliert automatisch je nach Last.

Ob FPM läuft, lässt sich prüfen mit:

sudo systemctl status php8.4-fpm

Die Konfiguration des Prozesspools liegt in /etc/php/8.4/fpm/pool.d/www.conf. Für den Anfang reichen die Standardwerte. Wer später mehr Last erwartet, kann dort die Anzahl der Worker-Prozesse anpassen.

MariaDB installieren und absichern

MariaDB ist ein relationales Datenbanksystem und speichert strukturierte Daten für Anwendungen. Nach der Installation erfolgt eine interaktive Absicherung der Datenbankinstanz.

  1. MariaDB installieren:
  1. Datenbankdienst aktivieren und starten:
  1. Sicherheitskonfiguration durchführen:

Es folgen mehrere interaktive Eingaben. Die empfohlene Antwort ist jeweils angegeben.

  1. Datenbankverbindung testen:

MariaDB ist jetzt sicher eingerichtet und bereit zur Verwendung. Benutzer, Datenbanken und Berechtigungen werden später eingerichtet.

Für alle, die wirklich mehr wissen und umsetzen möchten ...

Zur KI-Gemeinschaft »

Subdomain oder Domain auf den Server zeigen lassen (DNS-A-Record)

Bevor ein SSL-Zertifikat mit Let's Encrypt eingerichtet werden kann, muss sichergestellt sein, dass die gewünschte Domain oder Subdomain korrekt auf den Server zeigt.

  1. Im DNS-Provider (z. B. IONOS, Cloudflare, All-Inkl, etc.) einen A-Record anlegen:
  1. Optional: Wildcard- oder Hauptdomain konfigurieren
  1. DNS-Änderung überprüfen:

Erst wenn der A-Record korrekt auf den Server zeigt, kann Let's Encrypt ein gültiges SSL-Zertifikat ausstellen. Falls du mehrere Domains oder Subdomains nutzt, muss jede von ihnen vorab aufgelöst werden können.

Apache VirtualHost einrichten

Bevor ein SSL-Zertifikat eingerichtet werden kann, braucht Apache eine VirtualHost-Konfiguration. Ein VirtualHost definiert, welche Domain auf welches Verzeichnis zeigt und wie der Server auf Anfragen reagiert.

Eine neue Site-Konfiguration anlegen:

sudo nano /etc/apache2/sites-available/meine-domain.conf

Inhalt (die Domain und das Verzeichnis an die eigene Situation anpassen):

<VirtualHost *:80>
    ServerName meine-domain.de
    ServerAlias www.meine-domain.de
    DocumentRoot /var/www/meine-domain/public

    <Directory /var/www/meine-domain/public>
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/meine-domain-error.log
    CustomLog ${APACHE_LOG_DIR}/meine-domain-access.log combined
</VirtualHost>

Site aktivieren und Apache neu laden:

sudo a2ensite meine-domain.conf
sudo apache2ctl configtest
sudo systemctl reload apache2

Der Befehl configtest prüft die Konfiguration auf Syntaxfehler, bevor Apache neu geladen wird. Erst wenn Syntax OK erscheint, ist der Reload sicher.

Im nächsten Schritt kann Certbot auf dieser VirtualHost-Konfiguration aufsetzen und automatisch ein SSL-Zertifikat einrichten.

Let's Encrypt installieren und SSL-Zertifikat einrichten

Let's Encrypt stellt kostenlose, vertrauenswürdige SSL-Zertifikate bereit. Diese verschlüsseln die Verbindung zwischen Browser und Server über HTTPS. Voraussetzung ist, dass die gewünschte Domain oder Subdomain per DNS korrekt auf die IP-Adresse des Servers zeigt.

  1. Vorbereitend: A-Record im DNS anlegen
  1. Certbot und Apache-Plugin installieren:

  1. Apache-Module aktivieren (falls noch nicht aktiv):

  2. Apache-Module aktivieren (für SSL- und Weiterleitungsfunktionen):

Alle drei Module sind für den sicheren und standardkonformen Betrieb eines HTTPS-Webservers erforderlich. Nach der Aktivierung müssen die Änderungen durch einen Apache-Neustart wirksam gemacht werden:

  1. SSL-Zertifikat automatisch ausstellen und konfigurieren lassen:
  1. Browserprüfung:
  1. Automatische Verlängerung testen:

Der Server ist nun über HTTPS erreichbar. Die Verbindung ist verschlüsselt und durch ein offiziell signiertes Zertifikat abgesichert.

Logrotate einrichten

Auf einem Server mit mehreren Diensten (Ollama, Qdrant, ArangoDB, eigene Worker) wachsen Logdateien schnell. Logrotate archiviert und komprimiert alte Logs automatisch, damit die Festplatte nicht vollläuft und die Protokolle trotzdem nachvollziehbar bleiben.

Logrotate ist auf den meisten Debian-Systemen vorinstalliert. Prüfen:

logrotate --version

Falls nicht vorhanden:

sudo apt install logrotate

Eine Konfiguration für die eigenen KI-Dienste anlegen:

sudo nano /etc/logrotate.d/ki-services

Inhalt:

/var/log/nc2ragcli/*.log
/var/log/email2rag/*.log
{
    daily
    rotate 14
    compress
    delaycompress
    missingok
    notifempty
    create 0640 root adm
}

Was die einzelnen Optionen bedeuten:

Testen, ob die Konfiguration funktioniert:

sudo logrotate -d /etc/logrotate.d/ki-services

Das Flag -d simuliert die Rotation ohne sie auszuführen. So lässt sich prüfen, ob die Pfade stimmen und die Optionen korrekt sind.

Python und virtuelle Umgebung einrichten

Python ist eine weit verbreitete Programmiersprache, die in vielen modernen Tools und KI-Systemen verwendet wird. Für den sicheren und wartbaren Betrieb ist es wichtig, projektbezogene Python-Pakete isoliert zu verwalten. Dies geschieht über sogenannte virtuelle Umgebungen.

  1. Python, pip und das venv-Modul installieren:

Diese Pakete erfüllen folgende Funktionen:

  1. Virtuelle Umgebung erstellen:

Dieser Befehl erstellt im Benutzerverzeichnis einen neuen Ordner mit dem Namen venv. Darin befindet sich eine vollständige, aber isolierte Python-Installation. Diese Umgebung enthält ein eigenes pip, ein eigenes python und eigene Pfade. Alle Pakete, die später installiert werden, betreffen nur diese Umgebung.

  1. Virtuelle Umgebung aktivieren:

Nach der Aktivierung erscheint vor dem Terminal-Prompt der Zusatz (venv). Das bedeutet: Alle folgenden Python- oder pip-Befehle wirken sich nur auf diese Umgebung aus. Die globale Python-Installation bleibt unangetastet.

  1. Aktualisierung des Paketmanagers innerhalb der Umgebung:

Damit wird die neueste Version von pip in der virtuellen Umgebung installiert. Dies vermeidet Kompatibilitätsprobleme und stellt sicher, dass moderne Bibliotheken korrekt installiert werden.

Die virtuelle Python-Umgebung ist jetzt bereit für projektbezogene Installationen, zum Beispiel qdrant-client, sentence-transformers, spacy oder interne Tools. Sie lässt sich jederzeit aktivieren, ohne das restliche System zu verändern.

WICHTIG: Die nächsten Installationsschritte (Systemdienste und weitere Pakete) erfolgen im globalen Systemkontext. Verlasse die virtuelle Umgebung mit deactivate. Später im Dokument werden Python-Pakete wie SpaCy, sentence-transformers und qdrant-client installiert. Diese gehören in eine Projekt-venv (z.B. ~/venv) und werden dort mit aktivierter Umgebung installiert.

Noch mehr intensive KI-Impulse »

NVIDIA GPU-Treiber und CUDA einrichten

Viele KI-Werkzeuge auf diesem Server nutzen die GPU für Berechnungen: Ollama für Sprachmodelle, Chandra für OCR, PyTorch für Embeddings. Damit das funktioniert, braucht der Server die NVIDIA-Treiber und das CUDA-Toolkit (en: Compute Unified Device Architecture).

Zuerst prüfen, ob eine NVIDIA GPU erkannt wird:

lspci | grep -i nvidia

Wenn hier eine Grafikkarte aufgelistet wird, lassen sich die Treiber installieren:

sudo apt install nvidia-driver firmware-misc-nonfree
sudo reboot

Nach dem Neustart prüfen, ob der Treiber geladen ist:

nvidia-smi

Die Ausgabe zeigt den GPU-Namen, den verfügbaren Speicher und die Treiberversion. Auf diesem Server:

NVIDIA RTX 4000 SFF Ada Generation, 20475 MiB

Für PyTorch und andere Python-Bibliotheken, die CUDA direkt nutzen, das CUDA-Toolkit installieren:

sudo apt install nvidia-cuda-toolkit

Ob CUDA verfügbar ist, lässt sich direkt prüfen:

nvcc --version
ls /usr/lib/x86_64-linux-gnu/libcuda.so*

Wenn nvcc eine Versionsnummer ausgibt und die CUDA-Bibliothek vorhanden ist, ist die GPU-Beschleunigung einsatzbereit. Ollama erkennt die GPU automatisch. Für Python-Bibliotheken wie PyTorch oder sentence-transformers lässt sich die GPU-Erkennung später im jeweiligen Projekt testen, sobald torch in der Projekt-venv installiert ist.

Ollama installieren und starten (im Root-Kontext über sudo)

Ollama ist eine lokale Ausführungsumgebung für KI-Sprachmodelle wie LLaMA, Mistral oder Phi. Mit Ollama kannst Du leistungsfähige KI-Modelle direkt auf Deinem eigenen Server ausführen, ohne Cloud-Zugriff, ohne API, vollständig unter Deiner Kontrolle. Ideal für sensible Daten, Offline-Betrieb oder interne Systeme.

Die Installation erfolgt systemweit mit Root-Rechten. Weil Du zuvor den direkten Root-Zugang via SSH gesperrt hast (sicher und korrekt), verwendest Du dafür den Befehl sudo -i, um temporär in den Root-Kontext zu wechseln.

Ollama ist nun vollständig installiert, als systemweiter Dienst aktiv und kann für eigene KI-Anwendungen genutzt werden: Lokal, offline und datenschutzfreundlich.

Chandra OCR Server einrichten

Chandra ist ein Vision-Language-Model (en: Vision-Language Model), das PDFs, Bilder und gescannte Dokumente in strukturierten Text umwandelt. Im Gegensatz zu klassischem OCR wie Tesseract versteht Chandra auch Layouts, Tabellen und mehrspaltige Dokumente. Das Modell läuft lokal auf der GPU und benötigt keine Cloud-Verbindung.

Voraussetzung: Eine NVIDIA GPU mit mindestens 8 GB VRAM (auf diesem Server: RTX 4000 SFF Ada mit 20 GB). Die NVIDIA-Treiber und CUDA müssen installiert sein (siehe vorheriges Kapitel).

Installation in einer eigenen Python-Umgebung:

sudo mkdir -p /opt/chandra-ocr
sudo python3 -m venv /opt/chandra-ocr
/opt/chandra-ocr/bin/pip install chandra-ocr

Chandra als HTTP-Server starten (lauscht auf Port 8010):

sudo /opt/chandra-ocr/bin/python /opt/chandra-ocr/server.py

Für den Dauerbetrieb lässt sich ein Systemd-Service einrichten (das Muster dafür steht weiter unten im Kapitel zu Systemd-Services). Ein Health-Check:

curl http://localhost:8010/health

Im Zusammenspiel mit der Dokumentenverarbeitung (z.B. nc2rag) wird Chandra als primärer OCR-Server verwendet. Tesseract dient als Fallback, falls Chandra nicht erreichbar ist oder die GPU ausgelastet ist.

Tesseract OCR installieren

Tesseract ist ein klassisches OCR-Werkzeug (en: Optical Character Recognition), das Text aus Bildern und gescannten PDFs extrahiert. Es dient als Fallback, wenn Chandra nicht verfügbar ist oder wenn einfache Dokumente ohne komplexes Layout verarbeitet werden.

sudo apt install tesseract-ocr tesseract-ocr-deu tesseract-ocr-eng

Das installiert Tesseract mit den Sprachpaketen für Deutsch und Englisch. Ein schneller Test:

tesseract --version
tesseract test-bild.png output -l deu

Tesseract erkennt Text zeilenweise und liefert reinen Fließtext ohne Layoutinformationen. Für Tabellen, mehrspaltige Layouts oder handschriftliche Notizen ist Chandra die bessere Wahl. Für einfache, sauber gedruckte Dokumente reicht Tesseract vollkommen aus.

pdftotext und poppler-utils installieren

pdftotext extrahiert Text direkt aus PDFs, die bereits einen Textlayer enthalten (also nicht gescannte Dokumente). Das ist die schnellste Methode: kein OCR nötig, kein GPU-Einsatz, Ergebnis in Millisekunden.

sudo apt install poppler-utils

Ein Test:

pdftotext dokument.pdf -

Der Bindestrich am Ende gibt den Text auf der Konsole aus statt in eine Datei zu schreiben.

In der Praxis wird pdftotext als erster Schritt eingesetzt: Wenn das Ergebnis weniger als 20 Zeichen pro Seite enthält, handelt es sich wahrscheinlich um ein gescanntes Dokument, und der Text wird stattdessen über Tesseract oder Chandra OCR extrahiert.

Pandoc installieren

Pandoc ist ein universeller Dokumentenkonverter. Er wandelt DOCX, ODT, PPTX, HTML und viele andere Formate in Markdown, HTML oder reinen Text um. Für die Dokumentenverarbeitung ist Pandoc das Werkzeug der Wahl, wenn es nicht um PDFs geht.

sudo apt install pandoc

Ein paar Beispiele:

# Word-Dokument zu Markdown
pandoc dokument.docx -t markdown -o dokument.md

# PowerPoint zu reinem Text
pandoc praesentation.pptx -t plain -o praesentation.txt

# HTML zu Markdown
pandoc seite.html -t markdown -o seite.md

Pandoc versteht die Struktur der Quelldokumente: Überschriften, Listen, Tabellen und Formatierungen werden korrekt übernommen. Das Ergebnis ist sauberer als eine manuelle Extraktion und lässt sich direkt in die RAG-Pipeline einspeisen.

Qdrant installieren und einrichten

Qdrant ist eine Vektordatenbank (en: Vector Database), geschrieben in Rust und optimiert auf Performance. Sie speichert Texte als mathematische Vektoren und findet semantisch ähnliche Inhalte in Millisekunden. Das ist die Grundlage für RAG (en: Retrieval-Augmented Generation), bei dem das Sprachmodell vor der Antwort relevante Dokumente aus der eigenen Wissensbasis erhält.

Auf unserem KI-Server läuft Qdrant neben Ollama als zentrale Wissensbasis für alle Projekte. Die Installation:

Hinweis: Das folgende Kommando lädt ein Installationsskript herunter und führt es direkt aus. Bei Bedarf lässt sich das Skript vorher herunterladen und prüfen.

curl -fsSL https://packages.qdrant.io/install.sh | sh
sudo systemctl enable qdrant
sudo systemctl start qdrant

Ob Qdrant läuft, lässt sich mit einem HTTP-Request prüfen:

curl http://localhost:6333

Die Antwort enthält den Titel "qdrant" und die Versionsnummer. Qdrant lauscht standardmäßig auf Port 6333 (HTTP). Die Daten werden persistent auf der Festplatte gespeichert. In der Standardkonfiguration hält Qdrant die Vektoren zusätzlich im RAM für schnelle Suche.

Eine Collection anlegen und einen ersten Vektor speichern (Python):

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

client = QdrantClient(host="localhost", port=6333)

# Collection mit 1024 Dimensionen (z.B. mxbai-embed-large)
client.create_collection(
    collection_name="dokumente",
    vectors_config=VectorParams(size=1024, distance=Distance.COSINE)
)

# Vektor speichern
client.upsert(
    collection_name="dokumente",
    points=[
        PointStruct(
            id=1,
            vector=[0.1, 0.2, ...],  # 1024 Werte
            payload={
                "text": "Inhalt des Abschnitts",
                "quelle": "handbuch.pdf",
                "seite": 42
            }
        )
    ]
)

Die Dimension (hier 1024) und das Vergleichsmaß (hier Cosine) lassen sich beim Erstellen der Collection festlegen, aber nachträglich nicht mehr ändern. Bei einem Wechsel des Einbettungsmodells muss eine neue Collection erstellt und alle Dokumente neu eingebettet werden.

Wer tiefer einsteigen will: Im RAG-System Ebook gibt es eine ausführliche Beschreibung von Collections, Domains, Payload-Struktur und Suchstrategien.

ArangoDB installieren und einrichten

ArangoDB ist eine Graph-Datenbank (en: Graph Database), die Beziehungen zwischen Begriffen, Konzepten und Entitäten speichert und durchsuchbar macht. Während die SQL-Datenbank Struktur speichert und Qdrant Bedeutung speichert, bildet ArangoDB die Zusammenhänge ab: "Einstein" entwickelte die "Relativitätstheorie", "Datenschutz" gehört zu "DSGVO".

Im Zusammenspiel der drei Datenbanken (MariaDB, Qdrant, ArangoDB) entsteht die Drei-Schichten-Architektur, die im Stolpersteine-Artikel beschrieben ist.

Installation über das offizielle Repository:

# ArangoDB Repository hinzufügen (Debian/Ubuntu, signed-by Methode)
curl -fsSL https://download.arangodb.com/arangodb311/DEBIAN/Release.key | sudo gpg --dearmor -o /usr/share/keyrings/arangodb.gpg
echo "deb [signed-by=/usr/share/keyrings/arangodb.gpg] https://download.arangodb.com/arangodb311/DEBIAN/ /" | sudo tee /etc/apt/sources.list.d/arangodb.list
sudo apt-get update
sudo apt-get install arangodb3

Während der Installation wirst Du nach einem Root-Passwort für ArangoDB gefragt. Das ist nicht das System-Root-Passwort, sondern ein eigenes Passwort für die ArangoDB-Verwaltung.

sudo systemctl enable arangodb3
sudo systemctl start arangodb3

ArangoDB hat ein Web-Interface, das standardmäßig auf Port 8529 erreichbar ist:

curl http://localhost:8529/_api/version

ArangoDB organisiert Graphdaten in zwei Typen von Collections:

Die Abfragesprache AQL (en: ArangoDB Query Language) ermöglicht Mehrsprungpfade: Von einem Startknoten aus entlang der Kanten zu verwandten Knoten navigieren. Zwei bis drei Ebenen Tiefe reichen für die meisten Anwendungsfälle.

Wer tiefer einsteigen will: Im RAG-System Ebook gibt es eine ausführliche Beschreibung von Vertex/Edge-Collections, AQL-Queries und der Integration in die Suchstrategie.

SpaCy und das deutsche Sprachmodell installieren

Hinweis: Aktiviere vor der Installation die virtuelle Python-Umgebung: source ~/venv/bin/activate

SpaCy ist eine Python-Bibliothek für natürliche Sprachverarbeitung (en: Natural Language Processing). Sie erkennt in Texten automatisch Personen, Organisationen, Orte und Fachbegriffe (en: Named Entity Recognition). Diese Entitäten sind die Knoten im Knowledge Graph.

pip install spacy
python3 -m spacy download de_core_news_md

Das Modell de_core_news_md ist ein deutsches Sprachmodell mittlerer Größe. Es erkennt vier Kategorien:

Ein schneller Test:

python3 -c "
import spacy
nlp = spacy.load('de_core_news_md')
doc = nlp('Albert Einstein entwickelte die Relativitaetstheorie in Berlin.')
for ent in doc.ents:
    print(ent.text, ent.label_)
"

Die Verarbeitung liegt im zweistelligen Millisekundenbereich pro Textabschnitt. SpaCy läuft komplett lokal und benötigt keine GPU.

Lokale Einbettungsmodelle mit sentence-transformers installieren

Hinweis: Aktiviere vor der Installation die virtuelle Python-Umgebung: source ~/venv/bin/activate

Einbettungsmodelle (en: Embedding Models) wandeln Texte in mathematische Vektoren um. Diese Vektoren werden in Qdrant gespeichert und ermöglichen die semantische Suche: "Finde Dokumente, die ähnlich bedeuten wie meine Frage."

Ollama kann Einbettungen erzeugen, aber für größere Pipelines mit Tausenden von Dokumenten ist ein spezialisiertes Modell über sentence-transformers oft schneller und flexibler.

pip install sentence-transformers torch

Ein Modell laden und einen Text einbetten:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("mixedbread-ai/mxbai-embed-large-v1")
vector = model.encode("Datenschutz-Folgenabschätzung nach DSGVO")
print(f"Dimensionen: {len(vector)}")  # 1024

Das Modell mxbai-embed-large-v1 erzeugt Vektoren mit 1024 Dimensionen und versteht sowohl Deutsch als auch Englisch. Es läuft auf der CPU in akzeptabler Geschwindigkeit (ca. 50 Texte pro Sekunde) und deutlich schneller auf der GPU, falls CUDA verfügbar ist.

Wer tiefer einsteigen will: Im Beitrag Embedding Modelle Benchmark gibt es ausführliche Tests und Vergleiche verschiedener Modelle.

PyMuPDF und pymupdf4llm installieren

Hinweis: Aktiviere vor der Installation die virtuelle Python-Umgebung: source ~/venv/bin/activate

PyMuPDF ist eine Python-Bibliothek für die Verarbeitung von PDF-Dokumenten. Die Erweiterung pymupdf4llm erzeugt aus PDFs strukturiertes Markdown oder JSON mit Layoutanalyse. Das ist besonders nützlich für mehrspaltige Dokumente, Tabellen und komplexe Seitenlayouts.

pip install pymupdf4llm

Ein PDF in Markdown umwandeln:

import pymupdf4llm

md = pymupdf4llm.to_markdown("dokument.pdf")
print(md[:500])

pymupdf4llm erkennt Überschriften, Absätze, Listen und Tabellen und erzeugt daraus sauberes Markdown. Das Ergebnis lässt sich direkt als Eingabe für die Textzerlegung (Chunking) und anschließende Einbettung verwenden.

Der Unterschied zu pdftotext: pdftotext extrahiert reinen Text ohne Formatierung. pymupdf4llm erhält die Dokumentstruktur. Für einfache Dokumente reicht pdftotext. Für Rechnungen, Verträge oder wissenschaftliche Arbeiten ist pymupdf4llm die bessere Wahl.

python-arango installieren

Hinweis: Aktiviere vor der Installation die virtuelle Python-Umgebung: source ~/venv/bin/activate

python-arango ist der offizielle Python-Client für ArangoDB. Er ermöglicht den Zugriff auf Datenbanken, Collections, Graphen und AQL-Abfragen direkt aus Python heraus.

pip install python-arango

Verbindung herstellen und eine Abfrage ausführen:

from arango import ArangoClient

client = ArangoClient(hosts="http://localhost:8529")
db = client.db("nc2ragdb", username="root", password="...")

# Alle Entitäten vom Typ ORG abfragen
cursor = db.aql.execute(
    "FOR e IN entities FILTER e.entity_type == @type RETURN e",
    bind_vars={"type": "ORG"}
)
for entity in cursor:
    print(entity["name"])

Für Graph-Traversal (Mehrsprungpfade entlang von Beziehungen):

# Direkte Nachbarn einer Entitaet finden
cursor = db.aql.execute("""
    FOR v, e IN 1..2 ANY @start GRAPH 'nc2rag_knowledge'
    RETURN {name: v.name, type: v.entity_type, relation: e.relation_type}
""", bind_vars={"start": "entities/einstein"})

Die Suchtiefe (hier 1..2) bestimmt, wie viele Ebenen der Graph durchlaufen wird. Zwei Ebenen reichen für die meisten Anwendungsfälle.

qdrant-client installieren

Hinweis: Aktiviere vor der Installation die virtuelle Python-Umgebung: source ~/venv/bin/activate

qdrant-client ist der offizielle Python-Client für Qdrant. Er wird für alle Operationen benötigt, die aus Python heraus mit der Vektordatenbank arbeiten: Collections anlegen, Vektoren speichern, Suchen ausführen.

pip install qdrant-client

Die Grundlagen (Collection anlegen, Vektoren speichern) sind im Qdrant-Kapitel weiter oben beschrieben. Hier ein Beispiel für die semantische Suche:

from qdrant_client import QdrantClient

client = QdrantClient(host="localhost", port=6333)

# Suche: Die 5 ähnlichsten Dokumente zu einem Vektor
results = client.search(
    collection_name="dokumente",
    query_vector=[0.1, 0.2, ...],  # 1024 Werte
    limit=5,
    score_threshold=0.7
)

for hit in results:
    print(f"Score: {hit.score:.3f}")
    print(f"Text: {hit.payload['text'][:100]}")
    print(f"Quelle: {hit.payload['quelle']}")
    print()

Der score_threshold filtert Ergebnisse unterhalb einer Mindestähnlichkeit. Welcher Wert hier passt, hängt vom Einbettungsmodell und vom Datenbestand ab (siehe das Kapitel zur Ähnlichkeitsberechnung im Stolpersteine-Artikel).

Eigene Systemd-Services einrichten

Dienste wie Ollama und Qdrant bringen ihre eigenen Systemd-Units mit. Für eigene Anwendungen (z.B. einen OCR-Server, einen Worker-Prozess oder eine Python-API) lässt sich das gleiche Muster verwenden.

Eine Service-Datei anlegen:

sudo nano /etc/systemd/system/mein-dienst.service

Inhalt (an den eigenen Dienst anpassen):

[Unit]
Description=Mein KI-Dienst
After=network.target

[Service]
Type=simple
User=meinbenutzer
WorkingDirectory=/var/www/mein-projekt
ExecStart=/var/www/mein-projekt/venv/bin/python server.py
Restart=on-failure
RestartSec=10
StandardOutput=append:/var/log/mein-dienst/server.log
StandardError=append:/var/log/mein-dienst/server.log

[Install]
WantedBy=multi-user.target

Bevor der Dienst gestartet werden kann, den Service-Benutzer und die Verzeichnisse vorbereiten:

# Systembenutzer anlegen (ohne Login-Shell, ohne Home)
sudo useradd --system --no-create-home --shell /usr/sbin/nologin meinbenutzer

# Arbeitsverzeichnis dem Benutzer zuweisen
sudo chown -R meinbenutzer:meinbenutzer /var/www/mein-projekt

# Log-Verzeichnis anlegen und Rechte setzen
sudo mkdir -p /var/log/mein-dienst
sudo chown meinbenutzer:adm /var/log/mein-dienst

Was die einzelnen Felder in der Service-Datei bedeuten:

Dienst registrieren und starten:

sudo mkdir -p /var/log/mein-dienst
sudo systemctl daemon-reload
sudo systemctl enable mein-dienst
sudo systemctl start mein-dienst
sudo systemctl status mein-dienst

Dieses Muster lässt sich für jeden eigenen Dienst wiederverwenden: OCR-Server, Embedding-Services, Queue-Worker, API-Server.

Backup und Restore

Ein Server ohne Backup-Strategie ist ein Server auf Abruf. Gerade bei drei Datenbanken (MariaDB, Qdrant, ArangoDB) plus Dateisystem ist das kein optionaler Punkt.

MariaDB:

# Backup aller Datenbanken
mysqldump --all-databases --single-transaction > /backup/mariadb-$(date +%Y%m%d).sql

# Einzelne Datenbank
mysqldump meine_datenbank --single-transaction > /backup/meine_datenbank-$(date +%Y%m%d).sql

# Restore
mysql < /backup/mariadb-20260410.sql

Qdrant:

# Snapshot einer Collection erstellen
curl -X POST http://localhost:6333/collections/dokumente/snapshots

# Snapshots auflisten
curl http://localhost:6333/collections/dokumente/snapshots

# Snapshot herunterladen
curl http://localhost:6333/collections/dokumente/snapshots/snapshot-name.snapshot -o /backup/qdrant-dokumente.snapshot

ArangoDB:

# Dump aller Datenbanken
arangodump --server.database nc2ragdb --output-directory /backup/arangodb-$(date +%Y%m%d)

# Restore
arangorestore --server.database nc2ragdb --input-directory /backup/arangodb-20260410

Dateisystem:

# Konfigurationen und eigene Daten
tar czf /backup/config-$(date +%Y%m%d).tar.gz /etc/apache2 /etc/php /etc/systemd/system/*.service /var/www/

Für den produktiven Betrieb gehören vier Punkte dazu:

Die obigen Befehle lassen sich als Cron-Job automatisieren. Ein minimaler Cronjob für nächtliche Backups:

0 3 * * * mysqldump --all-databases --single-transaction | gzip > /backup/mariadb-$(date +\%Y\%m\%d).sql.gz 2>> /var/log/backup.log

Betrieb und Gesundheitschecks

Ein laufender Server ist nicht automatisch ein gesunder Server. Dienste können abstürzen, Festplatten volllaufen, Prozesse hängen. Ein Minimalsatz an regelmäßigen Prüfungen hilft, Probleme zu erkennen, bevor sie sich auswirken.

Dienststatus prüfen:

# Alle eigenen Dienste auf einen Blick
for svc in apache2 php8.4-fpm mariadb ollama qdrant arangodb3 fail2ban; do
    echo "$svc: $(systemctl is-active $svc)"
done

Festplattenplatz:

df -h / /var /tmp

Wenn eine Partition über 85% belegt ist, lohnt sich ein Blick auf große Logdateien oder alte Backups.

GPU-Status (falls vorhanden):

nvidia-smi

Zeigt Speicherauslastung, Temperatur und laufende Prozesse auf der GPU.

Lokale Endpunkte prüfen:

# Ollama
curl -s http://localhost:11434/api/tags | head -1

# Qdrant
curl -s http://localhost:6333

# ArangoDB
curl -s http://localhost:8529/_api/version

# Chandra OCR
curl -s http://localhost:8010/health

Wenn einer dieser Endpunkte nicht antwortet, ist der zugehörige Dienst entweder gestoppt oder hat ein Problem. Ein Blick in die Logs hilft dann weiter:

journalctl -u ollama --since "1 hour ago" --no-pager
journalctl -u qdrant --since "1 hour ago" --no-pager

Für den Dauerbetrieb lassen sich diese Prüfungen als Skript zusammenfassen und per Cron regelmäßig ausführen. Bei einem Fehlschlag kann das Skript eine Benachrichtigung auslösen (z.B. per E-Mail oder Webhook).

Für alle, die wirklich mehr wissen und umsetzen möchten ...

Zur KI-Gemeinschaft »

Wo bekomme ich die Hardware her?

Für einen dedizierten Root-Server mit GPU gibt es in Deutschland mehrere Anbieter. Die Konfiguration aus dieser Anleitung (Intel i5-13500, RTX 4000 SFF Ada, 64 GB RAM, 2x NVMe SSD) lässt sich beispielsweise bei Hetzner, netcup oder OVH als dedizierter Server mit GPU-Option bestellen. Nicht jeder Anbieter hat GPU-Server im Standardkatalog, oft lohnt sich eine direkte Anfrage.

Worauf bei der Auswahl zu achten ist:

Was kostet das im Monat?

Die Kosten hängen vom Anbieter und der Konfiguration ab. Als Orientierung: Ein dedizierter Server mit GPU in der Klasse dieser Anleitung liegt bei den meisten deutschen Anbietern zwischen 150 und 250 Euro pro Monat. Darin enthalten sind Hardware, Strom, Netzwerkanbindung und eine feste IP-Adresse.

Dazu kommen keine laufenden Lizenzkosten für die Software. Alle Komponenten in dieser Anleitung (Debian, Apache, MariaDB, Qdrant, ArangoDB, Ollama, SpaCy, Chandra, Tesseract, Pandoc) sind Open Source. Die einzigen potenziellen Zusatzkosten entstehen durch Domains (ca. 10 Euro pro Jahr) und SSL-Zertifikate (kostenlos über Let's Encrypt).

Wie viel Festplattenplatz brauche ich mindestens?

Für die Grundinstallation aller Komponenten reichen 50 GB. Der tatsächliche Bedarf hängt davon ab, was danach passiert:

Mit 500 GB Gesamtspeicher lässt sich komfortabel arbeiten. Die RAID-1 Konfiguration aus dieser Anleitung (2x 1,92 TB) bietet reichlich Reserve.

Wie aktualisiere ich das System später?

Jede Komponente hat ihren eigenen Update-Pfad:

Vor jedem größeren Update: Backup erstellen (siehe Kapitel Backup und Restore). Nach dem Update die Gesundheitschecks durchlaufen lassen (siehe Kapitel Betrieb und Gesundheitschecks).

Wie sichere ich die Datenbank-Passwörter?

Passwörter für MariaDB und ArangoDB gehören nicht in den Quellcode und nicht in Git. Übliche Ansätze:

MariaDB mit unix_socket (Standardkonfiguration ab 10.4) benötigt für lokale Zugriffe oft gar kein Passwort, weil die Authentifizierung über den Systembenutzernamen läuft.

Wie richte ich einen zweiten Benutzer ein?

Für den produktiven Betrieb lohnt es sich, verschiedene Systembenutzer für verschiedene Aufgaben zu verwenden. Das begrenzt den Schaden, falls ein Dienst kompromittiert wird.

# Benutzer für Webentwicklung
sudo adduser webentwickler
sudo usermod -aG www-data webentwickler

# Benutzer nur für KI-Dienste (ohne SSH-Zugang)
sudo useradd --system --no-create-home --shell /usr/sbin/nologin ki-worker

Wichtig ist die Trennung: Der Webserver läuft unter www-data, eigene KI-Dienste unter einem dedizierten Service-Benutzer, und der SSH-Zugang erfolgt über einen persönlichen Benutzer mit sudo-Rechten. So lässt sich nachvollziehen, wer was getan hat.

Wie teste ich, ob alles zusammen funktioniert?

Ein minimaler End-to-End-Test prüft die gesamte Kette: Text einbetten, in Qdrant speichern, suchen, Ergebnis an Ollama übergeben.

source ~/venv/bin/activate

python3 -c "
from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
import requests, json

# 1. Embedding erzeugen
model = SentenceTransformer('mixedbread-ai/mxbai-embed-large-v1')
text = 'Der Server läuft mit Debian und einer RTX 4000.'
vector = model.encode(text).tolist()

# 2. In Qdrant speichern
qc = QdrantClient(host='localhost', port=6333)
try:
    qc.create_collection('test', vectors_config=VectorParams(size=1024, distance=Distance.COSINE))
except: pass
qc.upsert('test', [PointStruct(id=1, vector=vector, payload={'text': text})])

# 3. Suchen
results = qc.search('test', query_vector=model.encode('Welches Betriebssystem?').tolist(), limit=1)
context = results[0].payload['text']

# 4. An Ollama übergeben
r = requests.post('http://localhost:11434/api/generate', json={
    'model': 'gemma3:4b-it-qat',
    'prompt': f'Kontext: {context}\n\nFrage: Welches Betriebssystem läuft auf dem Server?',
    'stream': False
})
print(json.loads(r.text)['response'])

# 5. Aufräumen
qc.delete_collection('test')
print('End-to-End-Test bestanden.')
"

Wenn am Ende eine sinnvolle Antwort und "End-to-End-Test bestanden." erscheinen, arbeiten Embedding-Modell, Qdrant und Ollama korrekt zusammen.

Wie überwache ich den GPU-Speicherverbrauch?

Für eine einmalige Momentaufnahme:

nvidia-smi

Für eine laufende Überwachung, die sich alle 2 Sekunden aktualisiert:

watch -n 2 nvidia-smi

Die Ausgabe zeigt den belegten und freien GPU-Speicher, die Temperatur, die aktuelle Auslastung und welche Prozesse die GPU nutzen. Wenn der Speicher voll ist, lehnt Ollama neue Modelle ab oder lagert Teile auf die CPU aus, was die Inferenz deutlich verlangsamt.

Für eine automatische Überwachung lässt sich ein Cronjob einrichten, der bei hoher Auslastung warnt:

# GPU-Speicher prüfen (in Cron oder Monitoring-Skript)
nvidia-smi --query-gpu=memory.used,memory.total --format=csv,noheader,nounits

Was tun, wenn ein Dienst nach dem Reboot nicht startet?

Wenn alle Dienste korrekt mit systemctl enable registriert wurden (wie in dieser Anleitung beschrieben), starten sie nach einem Reboot automatisch. Falls ein Dienst trotzdem nicht läuft:

# Status prüfen
sudo systemctl status ollama

# Logs der letzten Minuten ansehen
journalctl -u ollama --since "5 minutes ago" --no-pager

# Manuell starten
sudo systemctl start ollama

Häufige Ursachen:

Wie migriere ich das Setup auf einen neuen Server?

Die Migration besteht aus drei Teilen: Software, Daten, Konfiguration.

Software: Diese Anleitung auf dem neuen Server von vorne durcharbeiten. Die Installationsschritte sind reproduzierbar.

Daten:

Konfiguration:

Nach der Migration: Gesundheitschecks durchlaufen, DNS auf die neue IP umstellen, altes System erst abschalten wenn der neue Server stabil läuft.

Welches Ollama-Modell lade ich als Erstes?

Für den Einstieg mit einer RTX 4000 (20 GB VRAM) eignet sich gemma3:4b-it-qat als Allround-Modell. Es ist kompakt genug für flüssige Inferenz, versteht Deutsch gut und lässt genug GPU-Speicher frei für parallele Embedding-Aufgaben.

ollama pull gemma3:4b-it-qat
ollama run gemma3:4b-it-qat "Erkläre in drei Sätzen, was ein RAG-System ist."

Für anspruchsvollere Aufgaben (Zusammenfassungen langer Texte, Code-Generierung, komplexe Reasoning-Aufgaben) lohnt sich ein größeres Modell wie llama3.1:8b oder qwen3:8b. Diese belegen etwa 5 bis 8 GB VRAM.

Mehrere Modelle lassen sich gleichzeitig vorhalten. Ollama lädt das jeweils angeforderte Modell in den GPU-Speicher und entlädt es, wenn ein anderes gebraucht wird.

Welches Embedding-Modell nehme ich für deutsche Texte?

Für deutsche Texte hat sich mixedbread-ai/mxbai-embed-large-v1 bewährt. Es erzeugt Vektoren mit 1024 Dimensionen, versteht sowohl Deutsch als auch Englisch und liefert in Benchmarks für deutsche Texte konsistent gute Ergebnisse.

Alternativ über Ollama (ohne sentence-transformers):

ollama pull mxbai-embed-large
curl -s http://localhost:11434/api/embeddings -d '{"model":"mxbai-embed-large","prompt":"Testtext auf Deutsch"}'

Wichtig: Das Embedding-Modell und die Qdrant-Collection verwenden dieselbe Dimensionszahl (1024). Ein Wechsel des Modells erfordert eine neue Collection und eine Neueinbettung aller Dokumente (siehe das Kapitel zu Qdrant).

Wer verschiedene Modelle vergleichen will: Im Beitrag Embedding Modelle Benchmark gibt es ausführliche Tests und ein interaktives Vergleichswerkzeug.

Wie verbinde ich die drei Datenbanken zu einem RAG-System?

Diese Anleitung installiert die Infrastruktur. Der nächste Schritt ist, die Komponenten zu einem funktionierenden RAG-System zu verbinden. Die Architektur:

Der typische Ablauf: Dokument in MariaDB speichern, in Abschnitte zerlegen, jeden Abschnitt einbetten und in Qdrant speichern, Entitäten extrahieren und in ArangoDB speichern. Bei einer Suchanfrage: Qdrant nach ähnlichen Abschnitten durchsuchen, ArangoDB nach verwandten Konzepten durchsuchen, Ergebnisse zusammenführen und an Ollama übergeben.

Eine ausführliche Anleitung mit Quellcode und Dokumentation für genau dieses System gibt es im Beitrag Ein KI-RAG-System mit SQL-, Vektor- und Graph-Datenbank.

Brauche ich Nginx zusätzlich zu Apache?

Für die Grundinstallation in dieser Anleitung reicht Apache allein. Apache übernimmt Webserver, PHP-FPM-Anbindung, VirtualHosts und SSL.

Nginx kommt dann ins Spiel, wenn zusätzliche Anforderungen entstehen:

Ein typisches Setup für größere Projekte: Nginx als Frontend (Port 80/443), Apache als Backend (interner Port), PHP-FPM als separater Dienst. Für den Anfang ist Apache allein ausreichend.

Wie groß darf die Qdrant-Collection werden?

Qdrant hält die Vektoren standardmäßig im RAM für schnelle Suche. Der Speicherbedarf hängt von der Anzahl der Vektoren und ihrer Dimension ab.

Faustformel für 1024-dimensionale Vektoren:

Mit 64 GB RAM auf dem Server und den anderen Diensten (Ollama, ArangoDB, MariaDB, Apache) bleibt für Qdrant realistisch etwa 10 bis 20 GB übrig. Das reicht für 2 bis 4 Millionen Vektoren.

Wenn der Datenbestand darüber hinaus wächst, bietet Qdrant zwei Optionen:

Für den Einstieg reicht die Standardkonfiguration. Der Speicherverbrauch lässt sich über den Gesundheitscheck beobachten.

So weit, so gut.

Du hast jetzt eine ordentliche Umgebung für Deine KI-Experimente und kannst damit jetzt leistungsfähige KI-Anwendungen erstellen.

Für alle, die wirklich mehr wissen und umsetzen möchten ...

Zur KI-Gemeinschaft »

Optional, aber sehr empfehlenswert: tmux verwenden

tmux (Abkürzung für "Terminal Multiplexer") ist ein Werkzeug, das Dir ermöglicht, mehrere getrennte Terminal-Sitzungen gleichzeitig laufen zu lassen, und das alles in nur einem Fenster. Es ist ideal für Serverarbeiten, bei denen Du Prozesse im Hintergrund starten oder über längere Zeiträume stabil offen halten möchtest, selbst wenn Deine SSH-Verbindung unterbrochen wird.

Gerade bei Diensten wie Qdrant, Ollama oder Trainingsprozessen kann es sehr hilfreich sein, wenn Du Deine Sitzung nicht verlierst, nur weil die Verbindung abbricht oder Du versehentlich das Terminal schließt.

tmux installieren

Die Installation dauert nur wenige Sekunden. Danach steht Dir tmux sofort zur Verfügung.

Warum tmux eine gute Idee ist

Die wichtigsten tmux-Kommandos für Einsteiger

tmux arbeitet mit sogenannten "Sessions", also abgeschlossenen Terminal-Umgebungen, die im Hintergrund weiterlaufen.

Besonderheiten beim Arbeiten mit macOS und iTerm2

Wenn Du von einem Mac aus arbeitest, ist iTerm2 (eine alternative Terminal-App für macOS) besonders empfehlenswert. In Kombination mit tmux bietet iTerm2 viele Vorteile:

Wenn Du von einem Mac aus per SSH auf Deinen Server zugreifst, lässt sich in den Einstellungen von iTerm2 die tmux-Integration aktivieren (unter Preferences → Profiles → Terminal den Haken bei Enable tmux integration setzen).

Zusammenfassung

tmux ist ein kleines, aber sehr mächtiges Werkzeug. Wenn Du häufiger mit Servern arbeitest oder KI-Modelle startest, trainierst oder überwachst, lohnt es sich, damit arbeiten. Du gewinnst Stabilität, Flexibilität und Komfort, gerade auch bei längeren Aufgaben, mehreren offenen Terminals oder unterbrochenen Verbindungen.