🚀 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):

version: "3.8"
# Version des Docker-Compose-Dateiformats. 3.8 ist ein moderner Standard.

services:
# Hier werden alle Container definiert, die zusammen gestartet werden sollen.

  # --- Das KI-Gehirn: Ollama 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.
    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"
    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.
    restart: unless-stopped
    # Startet den Container automatisch neu, falls er abstürzt —
    # außer du stoppst ihn bewusst mit docker-compose down.

  # --- 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".
    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 in ein gemeinsames Netzwerk steckt.
    depends_on:
      - ollama
    # Startet Open WebUI erst, nachdem Ollama läuft.
    volumes:
      - webui_data:/app/backend/data
    restart: unless-stopped

  # --- Die Automationsplattform: Workflows per Drag & Drop ---
  n8n:
    image: n8nio/n8n
    container_name: n8n
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    # Hier speichert n8n deine erstellten Workflows.
    environment:
      - N8N_SECURE_COOKIE=false
    # Deaktiviert HTTPS-Pflicht für Cookies. Nötig, weil wir
    # lokal über http:// (nicht https://) arbeiten.
    restart: unless-stopped

volumes:
  ollama_data:
  webui_data:
  n8n_data:
# Hier werden die Volumes "registriert". Docker erstellt dafür
# automatisch Speicherbereiche auf deiner Festplatte.

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

~~Das~~

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-33" ~~Mini~~von ~~ist~~Microsoft ~~klein~~in der kleinen Variante (ca. 2 GB),. ~~schnell,~~Es ist schnell genug für ältere Laptops und ~~läuft~~trotzdem ~~auch~~erstaunlich ~~auf~~schlau. ~~älteren Laptops.~~

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).

Schritt 2: Neuen Workflow erstellen

Klicke auf "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 "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 "Manual 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 "Edit Fields" (unter "Data Transformation") → auswählen
Klicke auf "Add Field" → "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 Edit Fields? 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 Request" → auswählen
Konfiguriere:
- Method: POST
- URL: http://ollama:11434/api/generate
- Body Content Type: JSON
- Body Parameters → Add Parameter:
  - Name: model → Value: phi3:mini
  - Name: prompt → Value: {{ $json.prompt }}
  - Name: stream → Value: false (⚠️ als Boolean, nicht als String — Toggle nutzen)

Was passiert hier?

HTTP Request — 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. {{ $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 Output-Panel von n8n ~~sehen.~~sehen — klicke einfach auf den letzten Node nach dem Ausführen.

Schritt 4: Workflow ausführen!

Klicke oben auf "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 "If"-Node hinzu, der prüft ob der Text länger als 100 Zeichen ist
Wenn ja → Zusammenfassung durch LLM
Wenn nein → direkt ausgeben

Tipp: Der If-Node findet sich unter "Flow". Bedingung: {{ $json.prompt.length }} → "is greater than" → 100

Challenge 3: Eigenes System-Prompt

Ändere den Prompt im Edit-Fields-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 ~~installierte~~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-Request 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!)~~localhost — die Container sprechen sich über ihre Namen an).

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.