RAG für medizinische Bücher


Unterkapitel:
- Debian und Cuda installieren
- Docker Engine installieren
- Docker Images, Container und Volumes erstellen
- OpenWebUI einrichten
- Anhang (marker-pdf, Vorgehen ohne compose)


Guten Tag.
Von der Installation eines einfachen RAG-Systems für medizinische Bücher habe ich ein genaues Protokoll geschrieben.
Retrieval-Augmented Generation (RAG) kombiniert das Abrufen von Informationen (Retrieval) aus internen Dokumenten mit der Textgenerierung (Generation) durch KI.
Wikipedia zu RAG
Es gibt auch RAG mit Nutzung externer Quellen.
Dieses RAG hier soll sich strikt auf lokale Buchtexte begrenzen.
Dieses RAG hier ist nicht für schutzbedürftige personenbezogene Daten vorgesehen.
Idee ist, medizinische Lehrbücher besser nutzen zu können.
Vorgesehen ist ein Nutzer und 5 bis 50 Bücher.
Fundstellen sollen kapitelgenau angegeben werden.
Was mir die KI erzählt nehme ich als Anregung und lese ggf. das Orginal.

Eine Nvidia-RTX Grafikkarte ist nötig, angeblich reicht eine RTX 2060, ich nutze eine RTX 3070.
Installiert wird am besten auf einer separaten Festplatte mit >100GB.
Es sollte klar sein, welche Taste beim Computerstart gedrückt werden muss für Boot-Auswahl (bei mir F11) und Bios-Menü (bei mir DEL).
Im Bios-Menü muss eingestellt sein, dass kein(!) secure-boot erfolgt, weil sonst angeblich CUDA nicht funktioniert.
Bei mir war secure-boot sowieso ausgeschaltet gewesen.
Mit secure-boot ist nicht gemeint die Einstellung, die TPM deaktiviert.
Die Deaktivierung von secure-boot war bei mir im Bios-UEFI-Menü arg versteckt.
Bei Unsicherheit ist es gut, mit genauer Bezeichnung des Mainboard ChatGPT oder oder die Mistral-KI oder die Google-KI zu fragen.
Die Vorgehensweise bei der Installation ist eher kleinschrittig, um Fehler besser eingrenzen zu können.
Ein falscher Buchstabe reicht ja schon für ein Scheitern.

Installiert wird als Betriebssystem Debian, bei mir ist es Version 13.4.
Dann werden installiert Nvidia-Driver und Nvidia-Cuda-Toolkit aus den Debian-Quellen.
Dann Docker-Ce und Nvidia-Container-Toolkit.
Dann aus dem Docker-Hub Open-WebUI (bei mir Version 0.8.10.), Ollama, Qdrant.
LLM für das Embedding ist z.B. mxbai-embed-largest,
LLM für Auswertung ist z.B. llama 3.1 8B.
Sprache der Wissenstexte ist Englisch, deutsche Texte übersetze ich z.B. mit Google Translate.
Wenn ich OCR und Umwandlung in das Markdown-Format brauche, verwende ich auf separatem System marker-pdf.

Viele Einzelschritte. Die ich reichlich für Irrwege nutzte.
Die allermeisten Terminalbefehle und Texte hat die KI gebastelt. Was funktioniert hat wurde protokolliert.
Ohne viele Nachfragen bei ChatGPT und Mistral-KI und der Google-Ki hätte ich es nicht geschafft.
Interessant war dabei auch, wie anders und auch eigenartig die Missverständnisse und Fehler beim Dialog mit KI sind.
In der Richtung sehe ich auch den besonderen Wert von RAG bei medizinischen Fragen. Mit den vom System genutzten Büchern neben mir.
Die Installation ist eigentlich ganz einfach. Wenn man eine klare Linie hat. Deshalb die Weitergabe des Protokolls.
Bei meiner Art der Nutzung (privat, lokal, ein Nutzer) sind alle Programme gratis und ohne Registrierung nutzbar.
Bei einer anderen Nutzung sind Lizenzbedingungen zu klären.
Alle Angaben sind natürlich ohne jede Gewähr, Haftung usw.

Debian und Cuda installieren


Meine Debian-ISO-Datei war debian-13.4.0-amd64-DVD-1.iso
Die Debian-Seite mit Download.
Mit dem Hilfsprogramm Rufus kommt unter Windows die ISO-Datei auf einen USB-Stick.
Hier ein Link zu Rufus: Rufus-Download bei Chip
Bei der Debian-Installation kann man eigentlich nichts wirklich falsch machen.
Ausser: Auf der falschen Festplatte installieren!
Es kann deshalb sinnvoll sein, zur Sicherheit bei allen anderen Festplatten das Stromkabel zu entfernen.
Beim Computerstart zum Installieren die Taste für Bootauswahl gedrückt halten, den USB-Stick als Quelle wählen.
Im Zweifelsfall ist immer die voreingestellte Auswahl zu nehmen.
Die Frage ob man fehlende Firmware laden wolle verneinen.
Passwort für WLAN eingeben.
Rechnername bestätigen.
Domain beliebig eingeben.
Root-Passwort leer lassen.
Name eingeben.
Nutzername bestätigen.
Ein sehr kurzes Nutzerpasswort eingeben - es muss sehr oft (!) eingegeben werden.
Geführt ganze Festplatte wählen.
Die Festplatte für Debian wählen. Name sd? aufschreiben.
Anfänger-Optionen bestätigen.
Partionierung bestätigen.
Geschrieben sd? prüfen, wenn richtig bestätigen.
Die Frage nach Spiegelserver bejahen.
Land D bestätigen.
Debian-Quelle bestätigen.
Proxy leer lassen.
Starten bestätigen.
Software Vorschläge bestätigen.
Jetzt ist Debian fertig installiert und gestartet.

Setze Einstellungen(Zahnrad) > Energie > Automatische Bereitschaft nein.
Setze Einstellungen > System > Softwareaktualisierungen manuell.
Vor manuellen Debian-Updates (also nicht jetzt) mache ich ggf. ein Backup der Festplatte mit Clonezilla.

Nun werden installiert die zu Debian-Repos gehörende Ausführung von nvidia-driver
und von nvidia-cuda-toolkit, das ist bei späterer Kernel-Aktualisierung viel stabiler
als die Verwendung der von nvidia direkt angebotenen Treiber/Toolkits.
Die Debian-CUDA-Pakete bieten höhere Stabilität, unterstützen aber ggf. nicht die neuesten NVIDIA-GPUs.
Und sie unterstützen nicht neue Versionen von Pytorch/marker-pdf.
Erstmal kommen Vorarbeiten.
Im Folgenden werden alle Terminalbefehle im blauen Rahmen und alle Dateitexte im roten Rahmen zum Kopieren mit Copy-Button angeboten.

Hier der erste Terminalbefehl. Er öffnet eine vorhandene Konfigurationsdatei im Editor nano.
Einfügen erfolgt im Terminal und auch sonst in Linux am besten mit Rechtsklick und dann Klick auf Einfügen.
Dann mit der Pfeiltaste nach rechts, damit die Markierung verschwindet.
Der Editor nano hat ungewohnte Befehle. Cursorsteuerung mit den Pfeiltasten. Einfügen mit Rechtsklick und Klick auf Einfügen. Speichern mit STRG o.

sudo nano /etc/apt/sources.list


Gehe mit den Pfeiltasten mit dem Cursor hinter "non-free-firmware" ans Zeilenende.
Gib ein Leerzeichen ein. Gib dann mit Rechtsklick und Klick auf Einfügen den kopierten Text contrib non-free ein.
Mache das für alle sechs Vorkommen von "non-free-firmware".

contrib non-free


Dann wird gespeichert mit STRG o, der Dateinamen wird bestätigt mit ENTER, geschlossen wird mit STRG x
Der nächste Terminalbefehl:

sudo apt update


Jetzt kommen zwei Terminalbefehle zur Reinigung von alten nvidia und cuda Programmen (ob nötig lasse ich offen).

sudo apt purge -y 'nvidia-*' 'cuda-*' || true


sudo apt autoremove -y


Jetzt kommt ein Terminalbefehl, der eine Blacklist für nouveau mit dem Nano-Editor erstellt (ob nötig lasse ich offen).

sudo nano /etc/modprobe.d/blacklist-nouveau.conf


Jetzt kommt Text der dazu in nano als Inhalt einzufügen ist:

blacklist nouveau
options nouveau modeset=0


Wieder speichern mit STRG o, bestätigen mit ENTER, schliessen mit STRG x.

Weiterer Terminalbefehl:

sudo update-initramfs -u


Jetzt Header erneuern

sudo apt install linux-headers-$(uname -r)


Jetzt die eigentliche Installation

sudo apt install nvidia-driver nvidia-cuda-toolkit


Den Hinweis auf den wegen momentanem TreiberKonflikt nach Ende der Installation nötigen Neustart mit Klick auf OK bestätigen.
Weiterer Terminalbefehl noch vor dem Neustart:

sudo apt update


Weiterer Terminalbefehl zum Neustart:

sudo reboot



Wenn nach dem Herunterfahren der Neustart beginnt ggf. die Bootmenütaste drücken.
Der Neustart klappt ohne Probleme
Jetzt kommt die Prüfung, ob CUDA korrekt installiert ist.

nvidia-smi


Wenn hier die GPU benannt ist, ist alles OK.

nvcc --version


Wenn hier die CUDA-Treiber-Version - aktuell 12.4. - angegeben ist, ist alles OK.
Anmerkungen:
Die recht alte CUDA-Version 12.4. des Debian-Repos kann angeblich bei RTX 5090 manchmal Probleme machen.
Und sie funktioniert auch nicht mit dem aktuellen marker-pdf (was man aber nicht unbedingt braucht).
Insbesondere hat CUDA 13.2 direkt von Nvidia (und nicht aus den Debian-Repos) bei mir zwar gut funktioniert,
hat beim Update Debian 13.3. auf 13.4 aber mein ganzes System kaputt gemacht.
Protokoll zur Installation von CUDA 13.3 direkt von Nvidia siehe unten im Anhang.
Fertig.
Hier habe ich die Festplatte gesichert mit Clonezilla.

Docker Engine installieren


Verwendet wird die proprietäre Docker-CE Engine und nicht die Docker-Engine aus den Debian-Repos.
Angeblich würde die Nutzung der Debian-Repos bei KI-Anwendungen Probleme machen.
Hier der Link zur offiziellen Docker Anleitung.
Vorbereitend wird jetzt das System von alten Docker Resten gereinigt:

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-doc podman-docker containerd runc | cut -f1)


Im Folgenden wird in mehreren Schritten Docker's official GPG key hinzugefügt:

sudo apt update


sudo apt install ca-certificates curl


sudo install -m 0755 -d /etc/apt/keyrings


sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc


sudo chmod a+r /etc/apt/keyrings/docker.asc



Der Schritt hier wird bezeichnet als Add the repository to Apt sources (als 1 Block ins Terminal kopieren)

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF


sudo apt update


Jetzt kommt die eigentliche Docker Installation:

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin



Es wird geprüft ob Docker gestartet ist:

sudo systemctl status docker


Wenn der erfolgte Start angezeigt wird, muss die Anzeige mit STRG c geschlossen werden.
Nur (!) wenn nicht gestartet: Manueller Docker-Start:

sudo systemctl start docker


Jetzt ein Probelauf von Docker:

sudo docker run hello-world




Docker soll ohne sudo laufen. Offizielle Anleitung dazu

sudo groupadd docker


sudo usermod -aG docker $USER


Neustart oder/und

newgrp docker


Test:

docker run hello-world



Um Docker-ce unter Debian 13.4 die Nutzung der Nvidia-GPU zu ermöglichen ist Nvidia Container Toolkit nötig.
Hierfür den GPG-Schlüssel herunterladen und speichern:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg


Repository-Konfiguration erstellen:

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list


Paketliste aktualisieren:

sudo apt-get update


Damit Docker Zugriff auf die GPU erhält, wird das NVIDIA Container Toolkit installiert und konfiguriert.
Jetzt die eigentliche Installation des Nvidia Container Toolkit:

sudo apt-get install -y nvidia-container-toolkit


Konfigurieren:

sudo nvidia-ctk runtime configure --runtime=docker


Docker-Daemon neu starten:

sudo systemctl restart docker


Prüfen ob Docker die GPU sieht:

sudo docker run --rm --gpus all nvidia/cuda:12.0.0-base-ubuntu22.04 nvidia-smi


Man muss eine Tabelle mit der GPU sehen. Docker ist fertig.
Hier habe ich die Festplatte gesichert mit Clonezilla.

Docker Images, Container und Volumes erstellen für die
RAG-Oberfläche (OpenWebUI), RAG-System(Ollama), RAG-Datenbank(Qdrant)


Hier verwende ich ein Script, das mir bis auf eine kleine Abweichung dankenswerter Weise ChatGPT erstellte.
Unterverzeichnis rag erstellen:

mkdir rag


In rag wechseln.

cd rag


Das System ist für lokale Nutzung ausgelegt. Alle Docker-Dienste sind an 127.0.0.1 gebunden, um Zugriff aus dem Netzwerk zu verhindern.
Achtung bei eventuellem Editieren von docker-compose.yml: korrekte Einrückungen sind nötig.

Mit dem Editor nano in diesem Verzeichnis die Datei docker-compose.yml erstellen:

nano docker-compose.yml


Inhalt der Datei docker-compose.yml

services: ollama: image: ollama/ollama:latest container_name: ollama restart: unless-stopped ports: - "127.0.0.1:11434:11434" volumes: - ollama:/root/.ollama deploy: resources: reservations: devices: - driver: nvidia count: all capabilities: [gpu] open-webui: image: ghcr.io/open-webui/open-webui:cuda container_name: open-webui restart: unless-stopped ports: - "127.0.0.1:3000:8080" volumes: - open-webui:/app/backend/data environment: - OLLAMA_BASE_URL=http://ollama:11434 - QDRANT_URL=http://qdrant:6333 depends_on: - ollama - qdrant deploy: resources: reservations: devices: - driver: nvidia count: all capabilities: [gpu] qdrant: image: qdrant/qdrant:latest container_name: qdrant restart: unless-stopped ports: - "127.0.0.1:6333:6333" volumes: - qdrant_data:/qdrant/storage volumes: ollama: open-webui: qdrant_data:


Den Inhalt im nano-Editor einfügen mit Rechtsklick und Klick auf Einfügen.
Falls formale Probleme mit dem Inhalt im roten Rahmen auftreten gibt es die reine Text-Datei: Inhalt von docker-compose
Dann in nano speichern mit STRG o , Dateiname bestätigen mit ENTER, Verlassen mit STRG x
Dann die Compose-Datei ausführen mit:

docker compose up -d


Achtung. Der Download der Images von etwa 8 GB aus dem Docker-Hub dauert lange, dann werden aus Images Container und Volumes erstellt.
Wenn aus technischem Grund der Download abbrechen sollte einfach docker compose up -d neu starten

Alternativ zur Verwendung der Datei docker-compose.yml ist auch dasselbe Ziel mit vielen einzelnen Terminalbefehlen erreichbar.
Das ist umständlicher und wird primär nicht empfohlen. Es macht aber Debugging leichter und kommt sinnvoll zum Einsatz,
wenn nach Änderungen docker-compose.yml nicht funktionieren sollte. Es wird im Anhang gezeigt.

Als Test (am Besten mit Rechtsklick/neues-Fenster) die Oberfläche von OpenWebUI öffnen in Firefox: localhost:3000
Bitte jetzt noch keine Eingaben machen.
Fertig.

Open-WebUI einrichten und die ersten LLM und Wissenstexte laden


Die Angaben im Folgenden beziehen sich auf die am 20.3.2026 aktuelle Version 0.8.10 von OpenWebUI
Jetzt(!) in Firefox in OpenWebUI die Aufforderung zum Loslegen anklicken.
Lokal anmelden mit Name, Emailadresse, Passwort.
Die Angaben bleiben lokal, sie können beliebig gemacht werden, müssen nicht echt sein, müssen nur erinnert werden.

Modelle von Ollama holen für Auswertung und Embedding, hier wurde genommen llama3.1:8b und mxbai-embed-large:latest
Links unten im Eck auf den orange Punkt mit den Initialen klicken
In der Auswahl links Admin-Bereich anklicken
In der Auswahl in der Leiste oben auf Einstellungen klicken
In der Auswahl Links auf Modelle klicken
Rechts oben auf das kleine Feld Verwalten klicken
Bei Bedarf auf den klein geschriebenen Link rechts "hier klicken" klicken, es öffnet sich ein neuer Tab mit der Modellauswahl von Ollama.
Im Firefox-Tab "Admin-Bereich" bei dem grauen Text "Modell Tag eingeben .. " ein Modell eingeben, z.B. :

llama3.1:8b


Rechts neben dieser Eingabe auf den Download-Pfeil klicken, den Download abwarten, der Fortschritt wird mit einem Balken angezeigt.
Wenn Laden fertig ist nochmal Verwalten anklicken
Jetzt nochmal bei dem grauen Text "Modell Tag eingeben .. " ein Modell eingeben, z.B.:

mxbai-embed-large:latest


Und auf den Download-Pfeil klicken

Wenn Laden fertig ist:
Einstellen, dass mxbai-embed-large:latest zum Embedding verwendet wird:
Auf Admin-Bereich>Einstellungen>Dokumente gehen,
Wichtig: Bei Embedding-Modell-Engine in der Auswahl rechts anstelle von "Standard .." "Ollama" auswählen.
Bei dem grauen Text "Embedding Modell festlegen" eingeben mxbai-embed-large:latest
Rechts unten auf Speichern klicken.

Den Arbeitsbereich konfigurieren:
In der Ecke links oben auf "OI" klicken
Links auf Arbeitsbereich klicken
Rechts oben auf +Neues Modell klicken
Den grossen Text Modellname überschreiben z.B. mit MeineFrage
"Wählen Sie ein Basismodell" anklicken und llama3.1:8b wählen
Den grauen Text "Fügen Sie eine kurze Beschreibung .." beliebig überschreiben, z.B. Auswertung
Bei Bedarf ein Bild eingeben mit Klick auf den schwarzen Punkt im grossen OI-Feld
Unter System-Prompt eingeben: Use provided context only
Unten Speichern & Erstellen anklicken
Klick links unten auf orangen Punkt. Dann Klick auf Einstellungen>Allgemein.
Bei System-Prompt Use provided context only eintragen und speichern.
Einstellungen schliessen mit Klick auf Kreuz rechts oben.

Wissen hinzufügen
Oben auf "Wissen" klicken
Rechts auf + Neues Wissen klicken
Den grauen Text Benennen Sie Ihren Wissensspeicher überschreiben, bei mir Merck
Den grauen Text Beschreiben Sie Ihren Wissensspeicher .. beliebig überschreiben, bei mir Auswertung
Klick rechts unten auf Wissen erstellen
Klick rechts oben auf +
Bei mir klicken auf Ordner hochladen, alternativ auf Datei hochladen
Bei mir wähle ich den Ordner aus, in dem ich die pdf-Dateien für die englisch-sprachigen Kapitel des Merck-Manual-of-Diagnosis-and-Therapy habe
Anmerkung: Bisher habe ich noch kein gutes zweisprachiges Embedding Modell för Deutsch und Englisch zum Laufen gebracht.
Ich nehme deshalb zum Embedding nur Texte in englischer Sprache. Deutsche Texte übersetze ich vorher mit Google-Translate.
Klick rechts oben auf Hochladen
Firefox fragt nochmal nach, auch hier Klick auf Hochladen
Fortschritt und Erfolg werden angezeigt. Abwarten. Bei laufendem Embedding nicht (!) gleichzeitig Abfragen machen.
Klick Arbeitsbereich
Klick auf das Bild für meinen Arbeitsbereich
Klick auf Wissensspeicher auswählen
Klick bei mir auf auf Merck
Klick auf Speichern & Aktualisieren
Zum Zerlegen einer grossen PDF-Datei nehme ich z.B. Pdf Sam und/oder Pdf24
Vorbereitung der Wissenstexte bleibt hier ansonsten unbesprochen.
Genauso die Feinabstimmung der Systemeinstellungen.

Die erste Abfrage
Klick auf Arbeitsbereich
Klick auf - bei mir - "MeineFrage"
Die Beispielfrage - Welche Krankheiten machen Gelbsucht - gibt eine schlechte Antwort
Die Beispielfrage - Give diseases with icterus - gibt eine gute Antwort
Antworten sind begrenzt auf die Wissenstexte. Genutzte Kapitel werden angegeben.


Guten Erfolg beim Testen und Weiterbauen!
21.3.2026 Peter G.
Sende Mail

Anhang


Protokoll: marker-pdf auf einem separaten Debian-System mit Cuda 13.3 und Pytorch

Für die Funktion eines RAG-Systems ist wichtig die auch formal gute Qualität der Wissenstexte.
marker-pdf wandelt PDF-Dateien oder HTML-Dateien ordentlich in Markdown-Dateien um.
Unter Berücksichtigung des Layout und ggf. OCR.
Markdown-Dateien sind reine Text-Dateien und sind für die anderen Programme besonders gut zu verstehen.
Ein separates System für marker-pdf auf einer kleinen (80 GB reicht) separaten Festplatte, wo Debian nicht aktualisiert wird, ist sinnvoll,
weil einerseits marker-pdf eine aktuelle Cuda-Version braucht und andererseits eine aktuelle Cuda-Version leicht mit einer Aktualisierung von Debian kollidiert.

Debian installieren wie oben beschrieben inklusive "Jetzt Header erneuern" sudo apt install linux-headers-$(uname -r)
Nicht mehr (!) durchzuführen ist "Jetzt die eigentliche Installation ....".
Stattdessen weiter wie folgt:
Nvidia-Anleitung zur Installation CUDA 13.x auf Debian
Cuda Toolkit installieren:

wget https://developer.download.nvidia.com/compute/cuda/13.2.0/local_installers/cuda-repo-debian13-13-2-local_13.2.0-595.45.04-1_amd64.deb


sudo dpkg -i cuda-repo-debian13-13-2-local_13.2.0-595.45.04-1_amd64.deb


Die Terminalausgabe bietet zum Schluss eine Befehlszeile mit Schlüssel an.:
Der Vorschlag den die Terminalausgabe bei mir machte ist im pink Rahmen.
Wenn der Text im pink Rahmen nicht exakt der Terminalausgabe entspricht, muss der Vorschlag der Terminalausgabe genommen werden.

sudo cp /var/cuda-repo-debian13-13-2-local/cuda-BB4A7807-keyring.gpg /usr/share/keyrings/


sudo apt-get update


sudo apt-get -y install cuda-toolkit-13-2


Nvidia Driver installieren:
Es wird angeboten anscheinend alternativ nvidia-open und cuda-drivers, ich nehme hier den proprietären Treiber:
Eine Anleitung zum Umschalten zwischen den beiden Treibern wird in der Nvidia-Anleitung angeboten.

sudo apt-get install -y cuda-drivers


Neustart:

sudo reboot


Prüfung:

nvidia-smi


Virtuelle Umgebung erstellen:

sudo apt install python3.13-venv


python3 -m venv mein-env


Virtuelle Umgebung aktivieren (den Befehl braucht man immer wieder):

source mein-env/bin/activate


Jetzt Pytorch installieren, lange Downloads, lange Installation:

pip3 install torch torchvision


Jetzt marker-pdf installieren, lange Downloads:

pip3 install marker-pdf[full] surya-ocr


Ausgabeverzeichnis erstellen:

mkdir test-out


Jetzt eine Datei test.pdf ins aktuelle Verzeichnis kopieren. Dann Testlauf mit:

marker_single test.pdf --output_dir test-out


marker_single ist für eine Datei, marker ist für ein Verzeichnis.
Bei mir funktionierte marker_single, aber nicht marker.
Als Problemlösung machte ich eine Batch-Datei marker.sh:
marker.sh in Nano öffnen:

nano marker.sh


Der Inhalt von marker.sh:

#!/bin/bash # marker_single auf alle pdf-Dateien in pdf-in anwenden mit dem ziel test-out for f in pdf-in/*; do echo "Bearbeite mit marker_single $f ..." # Hier den eigentlichen Befehl einfuegen, zum Beispiel: marker_single "$f" --output_dir test-out done echo "Fertig!"


Einfügen in Nano mit Rechtsklick/Einfügen.
Speichern STRG o Bestätigen ENTER Schliessen STRG x

Das Eingabeverzeichnis erstellen:

mkdir pdf-in


marker.sh ausführbar machen:

chmod +x marker.sh


Mehrere zu bearbeitende pdf-Dateien sollten für einen Test in das Verzeichnis pdf-in kopiert werden.
Dann Testlauf der Batch-Datei:

./marker.sh


In test-out kommt jede Markdown-Datei in ein eigenes Unterverzeichnis.
Ich brauche sie aber alle zusammen.
Hier eine Batch-Datei, die alle md-Dateien aus test-out einsammelt nach md-out.

mkdir md-out


Nano öffnen:

nano md-nach-md-out.sh


Der Text:

#!/bin/bash # Befehl, der ausgefuehrt werden soll, cp *.md /home/peter/md-out COMMAND="cp *.md /home/peter/md-out" # Schleife ueber alle direkten Unterverzeichnisse for dir in test-out/*/ ; do if [ -d "$dir" ]; then echo "--- Bearbeite Verzeichnis: $dir ---" (cd "$dir" && $COMMAND) fi done


Einfügen in Nano mit Rechtsklick/Einfügen.
EDITIEREN in Nano, "peter" ersetzen durch eigenes Verzeichnis.
Speichern STRG o Bestätigen ENTER Schliessen STRG x
Ausführbar machen:

chmod +x md-nach-md-out.sh


Testen:

./md-nach-md-out.sh


Terminalbefehle anstelle docker-compose.yml

Hier wird als Alternative zum Einsatz von docker-compose.yml das Vorgehen mit Terminalbefehlen gezeigt.
Es ist weniger komfortabel, ist aber besser verständlich und besser zum Debugging geeignet.

Ein Netzwerk für mehrere Container wird erstellt (compose macht das automatisch).

docker network create rag-net


Volumes werden erstellt.

docker volume create ollama


docker volume create open-webui


docker volume create qdrant_data


Als erstes (Reihenfolge ist wichtig) wird der qdrant-Container gestartet und ggf. das Image geladen

docker run -d --name qdrant --network rag-net --restart unless-stopped -p 127.0.0.1:6333:6333 -v qdrant_data:/qdrant/storage qdrant/qdrant:latest


Als zweites wird der ollama-Container mit gpu-Zugriff gestartet und ggf. das Image geladen.

docker run -d --name ollama --network rag-net --restart unless-stopped --gpus all -p 127.0.0.1:11434:11434 -v ollama:/root/.ollama ollama/ollama:latest


Als drittes wird nach 10 Sekunden Pause (!) der open-webui-Container mit gpu-Zugriff und Environment gestartet und ggf. das Image geladen.

docker run -d --name open-webui --network rag-net --restart unless-stopped --gpus all -p 127.0.0.1:3000:8080 -v open-webui:/app/backend/data -e OLLAMA_BASE_URL=http://ollama:11434 -e QDRANT_URL=http://qdrant:6333 ghcr.io/open-webui/open-webui:cuda


Fertig !

Hier noch einige Terminalbefehle nur (!) für den Debugging-Fall und deshalb ohne Copy-Rahmen:
Logs einsehen:
docker logs -f open-webui
docker logs -f ollama
docker logs -f qdrant
Verbindung testen:
docker exec -it open-webui curl http://ollama:11434
docker exec -it open-webui curl http://qdrant:6333
GPU prüfen:
docker exec -it ollama nvidia-smi
Container Stoppen und Entfernen:
docker stop open-webui ollama qdrant
docker rm open-webui ollama qdrant
Netzwerk der Container entfernen:
docker network rm rag-net