Skip to main content

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 0 — Benutzer einrichten (5 Min.)

Bevor es losgeht, legen wir einen eigenen Benutzer an, mit dem du die gesamte Installation durchführst. Melde dich dazu zunächst als Root oder mit einem bestehenden Administrator-Account an.

Schritt 1: Benutzer "praktikant" anlegen

sudo adduser praktikant
    adduser — erstellt einen neuen Benutzer auf dem System. Du wirst nach einem Passwort und optional nach Zusatzinfos (Name etc.) gefragt. Die Zusatzinfos kannst du mit Enter überspringen.

    Schritt 2: Sudo-Rechte vergeben

    sudo usermod -aG sudo praktikant
      usermod -aG sudo — fügt den Benutzer praktikant zur Gruppe sudo hinzu. Damit darf er Befehle mit Administrator-Rechten (sudo) ausführen.

      Schritt 3: Zum neuen Benutzer wechseln

      su - praktikant
        su - — steht für "switch user". Das - sorgt dafür, dass die komplette Login-Umgebung des neuen Benutzers geladen wird (Home-Verzeichnis, Pfade etc.). Du wirst nach dem Passwort von praktikant gefragt.

        Ab jetzt arbeitest du als Benutzer praktikant weiter.

        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 und curl installieren

        sudo apt update && sudo apt upgrade -y
sudo apt install -y curl ca-certificates

        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?". curl — ein Kommandozeilen-Tool zum Herunterladen von Dateien aus dem Internet. Wir brauchen es im nächsten Schritt, um Dockers GPG-Schlüssel und Installationsskripte herunterzuladen. ca-certificates — stellt sicher, dass dein System HTTPS-Verbindungen korrekt verifizieren kann.

          Schritt 3: Docker über das offizielle Repository installieren

          Wir installieren Docker nicht über apt install docker.io, sondern über das offizielle Docker-Repository. So bekommst du die aktuellste Version — inklusive des modernen docker compose (ohne Bindestrich).

          3a: Dockers GPG-Schlüssel hinzufügen

          sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo tee /etc/apt/keyrings/docker.asc > /dev/null
sudo chmod a+r /etc/apt/keyrings/docker.asc
            GPG-Schlüssel — damit prüft dein System, dass die Docker-Pakete wirklich von Docker stammen und nicht manipuliert wurden. Das ist eine Sicherheitsmaßnahme. curl -fsSL — lädt die Datei herunter. -f = Fehler bei HTTP-Fehlern, -s = leise (keine Fortschrittsanzeige), -S = zeigt Fehler trotzdem an, -L = folgt Weiterleitungen. tee — schreibt die heruntergeladene Datei an den angegebenen Ort und gibt sie gleichzeitig aus (die Ausgabe leiten wir mit > /dev/null ins Nichts).

            3b: Docker-Repository hinzufügen

            echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
              Dieser Befehl fügt die Docker-Paketquelle zu deinem System hinzu. Ab jetzt weiß apt, wo es Docker-Pakete finden kann. $(dpkg --print-architecture) — erkennt automatisch, ob dein System amd64 oder arm64 nutzt. $(. /etc/os-release && echo "$VERSION_CODENAME") — erkennt automatisch deine Ubuntu-Version (z.B. noble für 24.04).

              3c: Docker installieren

              sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
                docker-ce — Docker Community Edition, das eigentliche Docker-Programm. docker-ce-cli — die Kommandozeilen-Tools für Docker. containerd.io — die Container-Laufzeitumgebung, die Docker im Hintergrund nutzt. docker-buildx-plugin — erweiterte Build-Funktionen für Docker-Images. docker-compose-plugin — das aktuelle Docker Compose als Plugin. Damit nutzt du docker compose (ohne Bindestrich) statt des veralteten docker-compose. Es ist schneller, besser integriert und wird aktiv weiterentwickelt.

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

                  Damit die Änderung sofort wirkt, ohne dich ab- und wieder anmelden zu müssen:

                  newgrp docker
                    newgrp docker — startet eine neue Shell-Sitzung, in der die Gruppe docker bereits aktiv ist. So kannst du direkt weiterarbeiten, ohne dich ausloggen zu müssen. Alternativ kannst du dich auch einfach ab- und wieder anmelden — Linux liest Gruppenrechte normalerweise 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!

                      Docker Compose Version prüfen:

                      docker compose version

                      Du solltest eine aktuelle Version sehen (z.B. v2.x.x).

                      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:
      - 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.
      - WEBHOOK_URL=http://ip-des-containers:5678/
    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.

                      1. Erstelle einen lokalen Account (bleibt alles nur auf deinem Rechner)
                      2. Wähle oben das Modell phi3:mini aus
                      3. 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 n8n-Oberfläche ist auf Englisch — n8n unterstützt offiziell nur Englisch. In dieser Anleitung verwenden wir daher durchgehend die englischen Bezeichnungen.

                      Schritt 2: Ollama als Credential einrichten

                      Bevor wir einen Workflow bauen, sagen wir n8n einmal, wo unser Ollama-Server läuft. Das muss nur einmal gemacht werden — danach können alle Workflows darauf zugreifen.

                      Was sind Credentials? Das sind gespeicherte Zugangsdaten, mit denen n8n sich bei externen Diensten anmeldet. Bei Ollama brauchen wir kein Passwort oder API-Key — nur die Adresse, unter der Ollama erreichbar ist. Wir nutzen ollama statt localhost, weil sich die Docker-Container über ihre Service-Namen ansprechen (das Docker-Compose-Netzwerk macht das möglich).

                      Schritt 3: Neuen Workflow erstellen

                      Klicke oben rechts auf "Create new workflow".

                      Schritt 4: Workflow zusammenbauen

                      Wir bauen einen Chat-Workflow: Du schreibst eine Nachricht → das LLM antwortet dir — direkt in n8n als Chat-Oberfläche.

                      Node 1: Chat Trigger

                      1. Klicke auf das + in der Mitte
                      2. Suche "Chat Trigger" → auswählen

                      Die Standardeinstellungen kannst du so lassen. Der Chat Trigger öffnet ein Chat-Fenster direkt in n8n, über das du mit dem LLM sprechen kannst.

                      Was ist ein Chat Trigger? Jeder Workflow braucht einen Auslöser — das Ereignis, das die Kette startet. Der "Chat Trigger" startet den Workflow jedes Mal, wenn du eine Nachricht im Chat-Fenster abschickst. Du bekommst eine richtige Chat-Oberfläche, ähnlich wie bei ChatGPT.

                      Node 2: AI Agent

                      1. Klicke auf das + rechts vom Chat Trigger
                      2. Suche "AI Agent" → auswählen

                      Die Standardeinstellungen passen für unseren Zweck. Optional kannst du im Feld System Message eine Rollenbeschreibung eintragen, z.B.:

                      Du bist ein hilfreicher Assistent. Antworte immer auf Deutsch.

                      Was ist ein AI Agent? Der AI Agent ist n8n's zentraler Baustein für KI-Workflows. Er nimmt die Nachricht vom Chat Trigger entgegen, leitet sie an das Sprachmodell weiter und gibt die Antwort zurück. Ein Agent kann auch "nachdenken" und Werkzeuge (Tools) nutzen — z.B. im Internet suchen oder Berechnungen durchführen. Für den Anfang nutzen wir ihn ohne Tools als reinen Chat-Assistenten.

                      Node 3: Ollama Chat Model (Sub-Node)

                      Jetzt verbinden wir den AI Agent mit unserem lokalen LLM:

                      1. Klicke auf den AI Agent Node, um ihn zu öffnen
                      2. Du siehst unten am Node einen Connector-Punkt mit der Beschriftung "Model" — klicke auf das + daneben
                      3. Suche "Ollama Chat Model" → auswählen
                      4. Im Feld Credential to connect with wähle die Ollama-Credential aus, die du in Schritt 2 erstellt hast
                      5. Im Feld Model trage ein: phi3:mini

                      Was ist ein Sub-Node? n8n unterscheidet zwischen normalen Nodes (die in der Kette liegen) und Sub-Nodes (die an einen anderen Node "angedockt" werden). Der Ollama Chat Model ist ein Sub-Node — er wird nicht in den Datenfluss eingereiht, sondern an den AI Agent angehängt, um ihm zu sagen: "Nutze dieses Sprachmodell." Das ist wie ein Werkzeug, das du dem Agenten in die Hand gibst.

                      Schritt 5: Workflow testen!

                      1. Klicke oben auf "Chat" (das Sprechblasen-Symbol) — es öffnet sich ein Chat-Fenster
                      2. Schreibe eine Nachricht, z.B.: Erkläre mir Docker in 3 Sätzen, als wäre ich 10 Jahre alt.
                      3. Warte kurz — das LLM denkt lokal auf deinem Rechner nach
                      4. Die Antwort erscheint direkt im Chat!

                      💡 Probier diese Fragen im Chat:

                      • Was ist der Unterschied zwischen einer VM und einem Container?
                      • Schreibe mir ein kurzes Python-Skript, das "Hallo Welt" ausgibt.
                      • Was sind die wichtigsten Vorteile von Workflow-Automation?

                      🎉 Du hast gerade deine erste KI-Automation gebaut — mit einer richtigen Chat-Oberfläche!

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

                      Challenge 1: Anderes Modell testen

                      docker exec ollama ollama pull phi4-mini
                      • phi4-mini — Microsofts "Phi-4 Mini" mit 3,8 Milliarden Parametern. Gleiche Größe wie Phi-3, aber deutlich bessere Antwortqualität: Der direkte Nachfolger mit verbessertem Reasoning und Sprachverständnis.

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

                      Challenge 2: n8n-Workflow erweitern

                      • Ändere das Modell im Ollama Chat Model Sub-Node auf Phi-4 Mini
                      • Teste die gleichen Fragen erneut und vergleiche die Antworten mit Phi-3
                      • Probiere verschiedene System Messages aus, z.B.:
                      Du bist ein Experte für die Pharmaindustrie. Erkläre alles einfach und verständlich.

                      Challenge 3: Eigenes System-Prompt

                      Ändere die System Message im AI Agent 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 als Chat-Assistenten nutzt
                      AI Agent Einen AI Agent mit Ollama Chat Model und Chat Trigger konfiguriert
                      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 Chat zeigt keine Antwort / AI Agent schlägt fehl? → Prüfe ob die Ollama-Credential korrekt eingerichtet ist: Base URL muss http://ollama:11434 sein (nicht localhost — die Container sprechen sich über ihre Namen an). → Prüfe ob das Modell phi3:mini im Ollama Chat Model Node korrekt eingetragen ist. → Prüfe ob das Modell heruntergeladen wurde: docker exec ollama ollama list

                      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.

                      Back to top