🚀 Dein erstes AI & Automation Lab

Ziel: In ca. 60 Minuten baust du dir auf deinem Laptop ein eigenes AI-Chat-System und eine Automationsplattform — alles lokal, ohne Cloud, ohne Accounts.

Was du am Ende hast:

Ein lokales Large Language Model (LLM), das du im Browser befragen kannst
Eine Automationsplattform (n8n), die das LLM automatisiert nutzen kann
Grundverständnis für Docker, LLMs und Workflow-Automation

Teil 1 — Docker installieren (10 Min.)

Docker ist wie eine "App-Box": Du lädst fertige Software-Pakete (Container) herunter und startest sie, ohne irgendetwas kompliziert installieren zu müssen. Stell dir vor, du bekommst eine komplett eingerichtete virtuelle Maschine — aber viel kleiner und schneller.

Schritt 1: Terminal öffnen

Klicke unten in der Taskleiste auf das Terminal-Symbol oder drücke Ctrl + Alt + T.

Das Terminal ist deine "Kommandozeile". Hier tippst du Befehle ein, die der Computer direkt ausführt — ohne grafische Oberfläche. Das klingt erstmal ungewohnt, aber du wirst sehen: Für viele Aufgaben ist es schneller als Klicken.

Schritt 2: System aktualisieren

sudo apt update && sudo apt upgrade -y

Was passiert hier im Detail:

sudo — steht für "Super User Do". Damit sagst du dem System: "Führe den folgenden Befehl mit Administrator-Rechten aus." Du wirst nach deinem Passwort gefragt.
apt — der Paketmanager von Linux. Er verwaltet Software-Installation und Updates, ähnlich wie ein App Store, aber per Kommandozeile.
update — holt die neueste Liste aller verfügbaren Software-Pakete vom Server. Es installiert noch nichts, sondern schaut nur: "Was gibt es Neues?"
&& — verknüpft zwei Befehle. Der zweite wird nur ausgeführt, wenn der erste erfolgreich war.
upgrade -y — installiert tatsächlich alle verfügbaren Updates. Das -y steht für "yes" und überspringt die Rückfrage "Möchtest du wirklich aktualisieren?".

Schritt 3: Docker installieren

sudo apt install -y docker.io docker-compose

apt install — installiert neue Software-Pakete auf deinem System.
docker.io — das eigentliche Docker-Programm. Es ermöglicht dir, Container (isolierte Mini-Umgebungen) zu starten.
docker-compose — ein Zusatztool, mit dem du mehrere Container gleichzeitig in einer einzigen Datei definieren und starten kannst. Ohne Compose müsstest du jeden Container einzeln mit langen Befehlen starten.
-y — wieder "yes", damit du nicht manuell bestätigen musst.

Schritt 4: Docker ohne sudo nutzbar machen

sudo usermod -aG docker $USER

usermod — ein Befehl zum Ändern von Benutzer-Einstellungen.
-aG docker — fügt (-a = append/hinzufügen) deinen Benutzer zur Gruppe (-G = Group) namens docker hinzu. Gruppen sind wie Berechtigungs-Clubs: Wer in der Gruppe "docker" ist, darf Docker-Befehle ohne sudo ausführen.
$USER — eine Variable, die automatisch deinen aktuellen Benutzernamen enthält. Das System ersetzt $USER beim Ausführen durch deinen Namen (z.B. "praktikant").

⚠️ Wichtig: Danach einmal ab- und wieder anmelden (oder Laptop neu starten), damit die Änderung greift. Linux liest Gruppenrechte nur beim Login ein.

Schritt 5: Testen ob Docker läuft

docker run hello-world

docker run — der wichtigste Docker-Befehl. Er macht drei Dinge auf einmal: (1) Prüft ob das Image "hello-world" lokal vorhanden ist, (2) lädt es herunter falls nicht, (3) startet einen Container daraus.
hello-world — ein winziges Test-Image von Docker, das nur eine Erfolgsnachricht ausgibt. Perfekt zum Testen.

Wenn du eine Nachricht siehst, die mit "Hello from Docker!" beginnt — perfekt, Docker funktioniert!

Teil 2 — Alles starten mit Docker Compose (10 Min.)

Statt jeden Dienst einzeln zu starten, beschreiben wir alles in einer einzigen Datei. Docker Compose liest diese Datei und startet alle Services automatisch — mit den richtigen Einstellungen, Verbindungen und Abhängigkeiten.

Schritt 1: Projektordner anlegen

mkdir ~/ai-lab && cd ~/ai-lab

mkdir — steht für "make directory" und erstellt einen neuen Ordner.
~/ai-lab — die Tilde ~ ist eine Abkürzung für dein Home-Verzeichnis (z.B. /home/praktikant). Der Ordner heißt also ai-lab und liegt direkt in deinem Benutzerordner.
cd — steht für "change directory" und wechselt in den angegebenen Ordner. Danach bist du "drin" und alle weiteren Befehle beziehen sich auf diesen Ordner.

Schritt 2: Docker-Compose-Datei erstellen

nano docker-compose.yml

nano — ein einfacher Texteditor im Terminal. Er öffnet sich direkt im selben Fenster. Bedienung: Tippen zum Schreiben, Ctrl + O zum Speichern, Ctrl + X zum Schließen.
docker-compose.yml — der Dateiname, den Docker Compose automatisch sucht. .yml (auch .yaml) ist ein Dateiformat für strukturierte Konfigurationen — ähnlich wie eine Einkaufsliste mit Einrückungen statt Klammern.

Füge folgenden Inhalt ein (mit Rechtsklick → Einfügen):

services:
# "services" ist der Hauptblock — hier werden alle Container definiert,
# die zusammen gestartet werden sollen.
# (Hinweis: "version:" wird seit Docker Compose v2 nicht mehr benötigt.)

  # =====================================================
  # OLLAMA — Das KI-Gehirn: führt das LLM lokal aus
  # =====================================================
  ollama:
    image: ollama/ollama
    # Welches Docker-Image benutzt wird. Docker lädt es automatisch
    # von Docker Hub herunter (wie ein App Store für Container).
    container_name: ollama
    # Ein fester Name für den Container, damit wir ihn leicht
    # finden und ansprechen können (z.B. in anderen Containern).
    ports:
      - "11434:11434"
    # Port-Weiterleitung: Der Container lauscht intern auf Port 11434.
    # Wir leiten ihn auf den gleichen Port deines Laptops weiter.
    # Format: "Laptop-Port:Container-Port"
    # Du könntest also auch "9999:11434" schreiben — dann wäre
    # Ollama auf deinem Laptop unter Port 9999 erreichbar.
    volumes:
      - ollama_data:/root/.ollama
    # Ein Volume ist wie ein USB-Stick für den Container:
    # Daten bleiben erhalten, auch wenn der Container neu gestartet wird.
    # Hier werden die heruntergeladenen KI-Modelle gespeichert.
    # Ohne Volume wären die Modelle nach jedem Neustart weg!
    restart: unless-stopped
    # Startet den Container automatisch neu, falls er abstürzt —
    # außer du stoppst ihn bewusst mit "docker-compose down".

  # =====================================================
  # OPEN WEBUI — Die Chat-Oberfläche (sieht aus wie ChatGPT)
  # =====================================================
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    # Dieses Image kommt von GitHub Container Registry (ghcr.io)
    # statt Docker Hub — einfach ein anderer "App Store".
    # ":main" bedeutet: die neueste Version vom Hauptzweig.
    container_name: open-webui
    ports:
      - "3000:8080"
    # Der Container läuft intern auf Port 8080, aber wir leiten
    # auf Port 3000 weiter. Im Browser also: localhost:3000
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    # Eine Umgebungsvariable — wie eine Einstellung für den Container.
    # Hier sagen wir Open WebUI, wo es Ollama findet.
    # "ollama" funktioniert als Hostname, weil Docker Compose
    # alle Services automatisch in ein gemeinsames Netzwerk steckt.
    # Die Container können sich gegenseitig über ihre Service-Namen
    # ansprechen — als wären es Computernamen im selben Netzwerk.
    depends_on:
      - ollama
    # Startreihenfolge: Open WebUI erst starten, nachdem
    # der Ollama-Container gestartet wurde.
    volumes:
      - webui_data:/app/backend/data
    restart: unless-stopped

  # =====================================================
  # N8N — Automationsplattform: Workflows per Drag & Drop
  # =====================================================
  n8n:
    image: docker.n8n.io/n8nio/n8n
    # Das offizielle n8n-Image aus der eigenen n8n-Registry.
    # n8n hat seine Images von Docker Hub auf eine eigene
    # Registry (docker.n8n.io) umgezogen — das ist die
    # aktuelle und empfohlene Quelle.
    container_name: n8n
    ports:
      - "5678:5678"
    # n8n läuft auf Port 5678 — das ist der Standard-Port.
    volumes:
      - n8n_data:/home/node/.n8n
    # Hier speichert n8n deine erstellten Workflows,
    # Zugangsdaten (Credentials) und Ausführungsprotokolle.
    environment:
      - N8N_DEFAULT_LOCALE=de
      # Setzt die Sprache der n8n-Oberfläche auf Deutsch.
      # n8n ist nicht zu 100% übersetzt — manche Texte
      # bleiben auf Englisch, aber die wichtigsten Menüs
      # und Beschreibungen sind auf Deutsch.
      - GENERIC_TIMEZONE=Europe/Berlin
      # Setzt die Zeitzone. Wichtig für zeitgesteuerte
      # Workflows (z.B. "Jeden Morgen um 9 Uhr ausführen"),
      # damit die richtige Uhrzeit verwendet wird.
      - N8N_SECURE_COOKIE=false
      # Deaktiviert HTTPS-Pflicht für Cookies. Nötig, weil wir
      # lokal über http:// (nicht https://) arbeiten.
      # In einer Produktivumgebung sollte das auf true stehen
      # und HTTPS konfiguriert sein.
      - N8N_RUNNERS_ENABLED=true
      # Aktiviert den neuen Task-Runner von n8n. Dieser führt
      # JavaScript/Python-Code in Nodes sicher in einem
      # separaten Prozess aus — sicherer und stabiler als
      # die alte Methode.
    restart: unless-stopped

# =====================================================
# VOLUMES — Persistente Speicherbereiche
# =====================================================
volumes:
  ollama_data:
  webui_data:
  n8n_data:
# Hier werden die Volumes "registriert". Docker erstellt dafür
# automatisch Speicherbereiche auf deiner Festplatte.
# Solange du diese Volumes nicht löschst, bleiben alle deine
# Modelle, Chat-Verläufe und Workflows erhalten — auch wenn
# du die Container stoppst und neu startest.

Speichern mit Ctrl + O, Enter, dann schließen mit Ctrl + X.

Schritt 3: Alles starten

docker-compose up -d

docker-compose up — liest die docker-compose.yml im aktuellen Ordner, lädt alle nötigen Images herunter und startet die Container.
-d — steht für "detached" (losgelöst). Die Container laufen im Hintergrund, sodass du das Terminal weiter nutzen kannst. Ohne -d würden die Logs direkt im Terminal angezeigt und du könntest nichts anderes mehr tippen.

Docker lädt jetzt die Container herunter. Das dauert beim ersten Mal einige Minuten — hol dir einen Kaffee ☕

Schritt 4: Prüfen ob alles läuft

docker ps

docker ps — zeigt alle aktuell laufenden Container an. ps steht für "process status". Du siehst eine Tabelle mit Container-Namen, Status, Ports und Laufzeit.

Du solltest drei Container sehen: ollama, open-webui und n8n.

Teil 3 — Dein erstes LLM laden und chatten (10 Min.)

Schritt 1: Ein KI-Modell herunterladen

docker exec ollama ollama pull phi3:mini

docker exec — führt einen Befehl innerhalb eines laufenden Containers aus, ohne ihn neu zu starten. Stell dir vor, du rufst in die Box hinein: "Hey, mach mal das!"
ollama (erster) — der Name des Containers, in dem der Befehl ausgeführt werden soll.
ollama pull phi3:mini (zweiter Teil) — der Befehl, der im Container läuft. ollama pull lädt ein KI-Modell herunter, ähnlich wie apt install Software installiert.
phi3:mini — das Modell "Phi-3" von Microsoft in der kleinen Variante (ca. 2 GB). Es ist schnell genug für ältere Laptops und trotzdem erstaunlich schlau.

Hintergrund: Ein LLM (Large Language Model) ist das Herzstück hinter ChatGPT & Co. Es ist eine riesige Datei mit "gelerntem Wissen", die Text versteht und Text erzeugt. Du lädst dir hier eines direkt auf deinen Laptop — kein Internet nötig zum Chatten, keine Daten verlassen deinen Rechner.

Schritt 2: Chat-Oberfläche öffnen

Öffne im Browser: http://localhost:3000

Was ist localhost? Das ist die Adresse deines eigenen Computers. localhost:3000 bedeutet: "Verbinde dich mit dem Dienst auf meinem eigenen Rechner, der auf Port 3000 lauscht." Dort wartet Open WebUI.

Erstelle einen lokalen Account (bleibt alles nur auf deinem Rechner)
Wähle oben das Modell phi3:mini aus
Stell eine Frage!

💡 Probier mal diese Prompts:

Erkläre mir Docker in 3 Sätzen, als wäre ich 10 Jahre alt.
Was ist der Unterschied zwischen einer VM und einem Container?
Schreibe mir ein kurzes Python-Skript, das "Hallo Welt" ausgibt.

🎉 Glückwunsch! Du hast gerade dein eigenes, privates ChatGPT aufgebaut.

Teil 4 — Dein erster Automations-Workflow in n8n (20 Min.)

Jetzt verbinden wir das LLM mit einer Automation. n8n ist eine visuelle Plattform, in der du per Drag & Drop "Nodes" (Bausteine) zu einem Workflow verbindest — wie eine Kette, durch die Daten fließen.

Schritt 1: n8n öffnen

Öffne im Browser: http://localhost:5678

Beim ersten Mal: Erstelle einen lokalen Account (nur auf deinem Rechner).

Die Oberfläche sollte größtenteils auf Deutsch sein — dank der Einstellung N8N_DEFAULT_LOCALE=de in unserer Compose-Datei. Einige Texte sind möglicherweise noch auf Englisch, wenn sie noch nicht übersetzt wurden.

Schritt 2: Neuen Workflow erstellen

Klicke auf "Neuen Workflow erstellen" (bzw. "Create new workflow").

Schritt 3: Workflow zusammenbauen

Wir bauen einen Mini-Workflow: Du schickst einen Text rein → das LLM fasst ihn zusammen.

Node 1: Trigger (manuell)

Klicke auf das + in der Mitte
Suche "Manueller Trigger" (bzw. "Manual Trigger") → auswählen (Damit kannst du den Workflow per Knopfdruck starten)

Was ist ein Trigger? Jeder Workflow braucht einen Auslöser — das Ereignis, das die Kette startet. Ein "Manueller Trigger" heißt: Du drückst selbst auf "Test". Andere Trigger könnten sein: "Jeden Morgen um 9 Uhr" oder "Wenn eine neue E-Mail kommt".

Node 2: Text vorbereiten

Klicke auf das + rechts vom Trigger
Suche "Felder bearbeiten" (bzw. "Edit Fields") unter "Datentransformation" → auswählen
Klicke auf "Feld hinzufügen" → "String"
Name: prompt
Value — kopiere diesen Text rein:

Fasse den folgenden Text in 2 Sätzen zusammen: Künstliche Intelligenz verändert die Arbeitswelt grundlegend. Besonders in der Pharmaindustrie werden Prozesse automatisiert, die früher Stunden gedauert haben. Von der Dokumentenprüfung bis zur Datenanalyse helfen KI-Systeme dabei, schneller und genauer zu arbeiten. Gleichzeitig entstehen neue Berufsbilder rund um Prompt Engineering und KI-Integration.

Was macht "Felder bearbeiten"? Dieser Node erzeugt ein Datenpaket mit einem Feld namens "prompt", das den Text enthält. Stell dir vor, du steckst einen Brief in einen Umschlag und beschriftest ihn — der nächste Node weiß dann, wo er den Text findet.

Node 3: LLM aufrufen

Klicke auf das + rechts
Suche "HTTP-Anfrage" (bzw. "HTTP Request") → auswählen
Konfiguriere:
- Methode: POST
- URL: http://ollama:11434/api/generate
- Send Body aktivieren
- Body-Inhaltstyp: JSON
- Im Feld JSON folgendes eintragen

{
  "model": "phi3:mini",
  "prompt": "{{ $json.prompt }}",
  "stream": false
}

Was passiert hier?

HTTP-Anfrage — so kommunizieren Programme miteinander übers Netzwerk. Du schickst eine Anfrage ("Request") an Ollama.

POST — die HTTP-Methode. POST heißt: "Ich schicke dir Daten und will eine Antwort." (GET wäre: "Gib mir etwas.")

http://ollama:11434/api/generate — die Adresse der Ollama-API. Wir nutzen ollama statt localhost, weil die Container sich untereinander über ihre Service-Namen ansprechen (das Docker-Compose-Netzwerk macht es möglich).

{{ $json.prompt }} — das ist n8n-Syntax: "Nimm den Wert aus dem Feld prompt vom vorherigen Node." Die doppelten geschwungenen Klammern {{ }} sagen n8n: "Das hier ist kein normaler Text, sondern ein Verweis auf Daten."

stream: false — normalerweise schickt Ollama die Antwort Wort für Wort (Streaming). Wir wollen aber die komplette Antwort auf einmal, deshalb false.

Node 4: Ergebnis anzeigen

Das Ergebnis kommt im Feld response der HTTP-Antwort zurück. Du kannst es direkt im Ausgabe-Panel von n8n sehen — klicke einfach auf den letzten Node nach dem Ausführen.

Schritt 4: Workflow ausführen!

Klicke oben auf "Workflow testen" (bzw. "Test Workflow") → der Workflow läuft durch alle Nodes.

Im letzten Node siehst du die Zusammenfassung, die das LLM generiert hat.

🎉 Du hast gerade deine erste KI-Automation gebaut!

Teil 5 — Bonus-Challenges (wenn noch Zeit ist)

Challenge 1: Anderes Modell testen

docker exec ollama ollama pull llama3.2:1b

llama3.2:1b — Metas "Llama 3.2" Modell mit 1 Milliarde Parametern. Kleiner als Phi-3, aber interessant zum Vergleichen: Verschiedene Modelle haben unterschiedliche Stärken.

Vergleiche die Antworten von Phi-3 und Llama 3.2 auf die gleiche Frage in Open WebUI. Wechsle dazu oben in der Chat-Oberfläche einfach das Modell.

Challenge 2: n8n-Workflow erweitern

Füge vor dem LLM einen "Wenn"-Node (bzw. "If") hinzu, der prüft ob der Text länger als 100 Zeichen ist
Wenn ja → Zusammenfassung durch LLM
Wenn nein → direkt ausgeben

Tipp: Der Wenn-Node findet sich unter "Ablaufsteuerung" (bzw. "Flow"). Bedingung: {{ $json.prompt.length }} → "ist größer als" → 100

Challenge 3: Eigenes System-Prompt

Ändere den Prompt im "Felder bearbeiten"-Node zu:

Du bist ein Experte für die Pharmaindustrie. Erkläre das folgende Thema einfach und verständlich: Was ist ein ERP-System?

Was ist ein System-Prompt? Das ist die "Rollenbeschreibung" für das LLM. Du sagst ihm damit, wer es sein soll und wie es antworten soll — bevor es die eigentliche Frage bekommt. In Unternehmen werden System-Prompts genutzt, um KI-Assistenten auf bestimmte Aufgaben zu spezialisieren.

🧠 Was du gelernt hast

Thema	Was du gemacht hast
Docker	Container gestartet, Docker Compose genutzt, Services verwaltet
LLM	Ein KI-Modell lokal geladen und im Chat genutzt
Automation	Einen n8n-Workflow gebaut, der ein LLM automatisiert aufruft
API-Grundlagen	Einen HTTP POST Request an eine REST-API geschickt
Linux-Basics	Terminal-Befehle, Paketmanager, Dateien erstellen, Benutzerrechte

🔧 Nützliche Befehle zum Nachschlagen

Befehl	Was er tut
`docker ps`	Zeigt laufende Container (ps = process status)
`docker ps -a`	Zeigt alle Container, auch gestoppte
`docker-compose up -d`	Startet alle Services im Hintergrund
`docker-compose down`	Stoppt alle Services und entfernt die Container
`docker-compose logs -f`	Zeigt Live-Logs aller Container (-f = follow, folgt neuen Einträgen)
`docker-compose logs -f ollama`	Zeigt Live-Logs nur von Ollama
`docker exec ollama ollama list`	Zeigt alle installierten KI-Modelle
`docker exec ollama ollama pull <modell>`	Lädt ein neues Modell herunter
`docker exec ollama ollama rm <modell>`	Löscht ein Modell (spart Speicherplatz)
`docker stats`	Zeigt CPU- und RAM-Verbrauch aller Container live

❓ Troubleshooting

Open WebUI zeigt kein Modell an? → Warte 1–2 Minuten, Ollama braucht Zeit zum Starten. Dann Seite neu laden.

n8n HTTP-Anfrage schlägt fehl? → Prüfe ob stream wirklich auf false steht (als Boolean, nicht als Text). → Prüfe die URL: http://ollama:11434/api/generate (nicht localhost — die Container sprechen sich über ihre Namen an).

n8n ist nicht auf Deutsch? → Prüfe in der Compose-Datei ob N8N_DEFAULT_LOCALE=de korrekt gesetzt ist. Danach Container neu starten: docker-compose down && docker-compose up -d. Manche Texte bleiben auf Englisch — die deutsche Übersetzung deckt nicht 100% der Oberfläche ab.

Docker-Befehle brauchen sudo? → Du hast dich nach usermod nicht neu angemeldet. Einmal ausloggen und wieder einloggen.

"Permission denied" bei docker-compose? → Prüfe mit groups ob "docker" in deiner Gruppenliste auftaucht. Falls nicht: Schritt 4 aus Teil 1 wiederholen und neu anmelden.

Laptop wird langsam? → Modelle brauchen RAM. Phi-3 Mini braucht ca. 3–4 GB. Schließe andere Programme. → Mit docker stats kannst du sehen, welcher Container wie viel Ressourcen verbraucht.

Container startet nicht? → docker-compose logs -f <containername> zeigt dir die Fehlermeldung des Containers.