# So baust du deinen eigenen KI-Automatisierungsserver mit n8n auf AWS: lokale Modelle, Remote-Modelle und ein echtes Business-Pipeline

*Veröffentlicht im TEN INVENT Blog · Februar 2026*

---

## Einführung

Stell dir folgendes Szenario vor: Ein Kunde schickt dir eine E-Mail mit einer Angebotsanfrage. Automatisch extrahiert die KI relevante Daten aus der E-Mail, klassifiziert die Anfrage, erstellt einen Angebotsentwurf basierend auf einer Vorlage, schickt ihn dem Manager über Slack zur Freigabe, und nach der Freigabe erstellt sie die Rechnung im Buchhaltungssystem und antwortet dem Kunden. Alles ohne manuelles Eingreifen.

Das ist keine Science Fiction — es ist ein Automatisierungspipeline, den du mit **n8n** bauen kannst, einem Open-Source-Workflow-Automatisierungstool, gehostet auf deinem eigenen AWS-Server, verbunden mit lokalen KI-Modellen (Ollama, LM Studio) und Remote-Modellen (OpenAI, Claude, Gemini).

In diesem Artikel zeige ich dir, wie du alles machst: von der Installation des Servers auf AWS über die Verbindung der KI-Modelle bis zum Aufbau einer echten Business-Pipeline.

---

## Was ist n8n und warum ist es wichtig?

### n8n in 30 Sekunden

n8n (ausgesprochen „n-eight-n") ist eine Open-Source-Workflow-Automatisierungsplattform — denk an Zapier oder Make.com, aber mit drei großen Vorteilen:

- **Self-hosted** — läuft auf deinem Server, deine Daten verlassen nichts
- **Open-source** — kostenlos für die Community Edition, keine künstlichen Limits
- **KI-nativ** — hat dedizierte Nodes für KI-Agenten, Embeddings, Vector Stores und Chat-Modelle

### Warum Self-hosted auf AWS?

n8n bietet auch eine Cloud-Version (n8n Cloud, ab 20$/Monat), aber Self-Hosting auf AWS gibt dir:

- **Totale Kontrolle** über die Daten — essenziell für GDPR und sensible Geschäftsdaten
- **Geringe Kosten** — ein EC2 t3.small kostet ca. 15$/Monat (t3.micro ist ~7-10$, hat aber weniger RAM)
- **Flexibilität** — du kannst beliebig viele Ressourcen hinzufügen, interne Dienste verbinden
- **Uptime** — der Server ist immer online, Webhooks funktionieren 24/7

---

## Teil 1: Installation von n8n auf AWS EC2

### Was du brauchst

- Ein AWS-Konto (Free Tier reicht für den Einstieg)
- Eine Domain oder Subdomain (z.B. `automation.deinedomain.de`)
- Grundlegende Terminal-Kenntnisse

### Schritt 1: EC2-Instanz starten

1. Melde dich in der AWS-Konsole an und navigiere zu EC2.
2. Klicke auf **Launch Instance** und konfiguriere:
   - **Name**: `n8n-server`
   - **AMI**: Ubuntu 24.04 LTS
   - **Instanztyp**: `t3.small` (2 vCPU, 2GB RAM — Minimum für n8n mit KI)
   - **Key Pair**: Erstelle oder wähle ein SSH-Schlüsselpaar
   - **Security Group**: Erlaube Ports 22 (SSH), 80 (HTTP), 443 (HTTPS)
   - **Storage**: 20GB SSD (gp3)

3. Starte die Instanz und warte, bis sie läuft.

### Schritt 2: Elastic IP

Weise eine Elastic IP zu und verknüpfe sie mit deiner Instanz. Ohne diese ändert sich die öffentliche IP bei jedem Neustart.

1. EC2 → Elastic IPs → Allocate Elastic IP address
2. Wähle die zugewiesene IP → Actions → Associate Elastic IP address
3. Wähle deine EC2-Instanz

### Schritt 3: DNS konfigurieren

Bei deinem Domain-Registrar erstelle einen A-Record:

```
Typ: A
Name: automation (oder n8n, was du bevorzugst)
Wert: [Deine Elastic IP]
TTL: 300
```

### Schritt 4: Per SSH verbinden und Docker installieren

```bash
# SSH-Verbindung
ssh -i ~/n8n-key.pem ubuntu@DEINE_ELASTIC_IP

# System aktualisieren
sudo apt update && sudo apt upgrade -y

# Docker installieren
sudo apt install -y docker.io docker-compose
sudo systemctl enable --now docker

# Aktuellen Benutzer zur Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER
# Neu verbinden zum Übernehmen
exit
```

### Schritt 5: NGINX als Reverse Proxy installieren

```bash
sudo apt install -y nginx

# NGINX für n8n konfigurieren
sudo tee /etc/nginx/sites-available/n8n << 'EOF'
server {
    listen 80;
    server_name automation.deinedomain.de;

    location / {
        proxy_pass http://localhost:5678;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # WebSocket-Support (essenziell für n8n!)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
EOF

sudo ln -s /etc/nginx/sites-available/n8n /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx
```

### Schritt 6: SSL-Zertifikat mit Certbot installieren

```bash
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d automation.deinedomain.de
```

Certbot konfiguriert automatisch HTTPS und Redirect von HTTP.

### Schritt 7: n8n mit Docker Compose starten

Erstelle das Arbeitsverzeichnis und die Konfigurationsdateien:

```bash
mkdir ~/n8n && cd ~/n8n

# Verschlüsselungsschlüssel generieren (speichern!)
ENCRYPTION_KEY=$(openssl rand -base64 24)
echo "Dein Schlüssel: $ENCRYPTION_KEY"
```

Erstelle `docker-compose.yml`:

```yaml
services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: always
    ports:
      - "127.0.0.1:5678:5678"
    environment:
      - N8N_HOST=automation.deinedomain.de
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_URL=https://automation.deinedomain.de/
      - N8N_ENCRYPTION_KEY=DEIN_SCHLUESSEL_HIER
      - GENERIC_TIMEZONE=Europe/Berlin
      - N8N_RUNNERS_ENABLED=true
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:
```

Starte n8n:

```bash
docker-compose up -d
```

Rufe `https://automation.deinedomain.de` auf — du solltest den n8n-Setup-Bildschirm sehen. Erstelle das Admin-Konto und die Installation ist fertig.

---

## Teil 2: KI-Modelle verbinden

Hier wird es interessant. n8n unterstützt nativ mehrere Arten von KI-Modellen, und du kannst sie alle im selben Workflow nutzen.

### Remote-Modelle (Cloud) — am einfachsten zu verbinden

**OpenAI (GPT-4, GPT-4o)**

1. Gehe in n8n zu Settings → Credentials → Add Credential
2. Wähle „OpenAI API"
3. Gib den API-Key von [platform.openai.com](https://platform.openai.com) ein
4. Teste die Verbindung

Jetzt kannst du den **OpenAI Chat Model** Node in jedem Workflow nutzen.

**Anthropic (Claude)**

1. Add Credential → „Anthropic API"
2. Gib den API-Key von [console.anthropic.com](https://console.anthropic.com) ein
3. Verfügbar als **Anthropic Chat Model** in Workflows

**Google Gemini**

1. Add Credential → „Google Gemini"
2. Gib den API-Key von Google AI Studio ein
3. Verfügbar als Chat-Model-Node

**Wann Remote-Modelle nutzen:**
- Komplexe Reasoning-Aufgaben (Vertragsanalyse, lange Dokumentenerstellung)
- Wenn du die besten möglichen Ergebnisse brauchst
- Seltene Aufgaben, die dedizierte lokale Hardware nicht rechtfertigen

### Lokale Modelle — null Kosten pro Request

Für lokale Modelle ist **Ollama** die Hauptempfehlung — ein einfacher Runtime für lokale Modelle, perfekt integriert mit n8n.

**Variante A: Ollama auf demselben AWS-Server**

Wenn deine EC2-Instanz genug Speicher hat (mind. 4GB RAM für kleine Modelle), kannst du Ollama direkt auf dem Server laufen lassen:

```bash
# Ollama installieren
curl -fsSL https://ollama.ai/install.sh | sh

# Modell herunterladen
ollama pull qwen3:8b
ollama pull nomic-embed-text  # für Embeddings

# Ollama läuft auf localhost:11434
```

In n8n:
1. Add Credential → „Ollama API"
2. Base URL: `http://localhost:11434`
3. Fertig! Du kannst die **Ollama Chat Model** und **Ollama Embeddings** Nodes nutzen

**Variante B: LM Studio / Ollama auf deinem lokalen Rechner, für n8n exponiert**

Wenn du einen leistungsstarken PC zu Hause oder im Büro mit GPU hast, kannst du dort die Modelle laufen lassen und sie dem n8n-Server über das Internet exponieren.

Setup mit lokal exponiertem Ollama:

```bash
# Auf deinem lokalen Rechner
OLLAMA_HOST=0.0.0.0 ollama serve
```

Dann konfiguriere einen sicheren Tunnel (z.B. Cloudflare Tunnel, ngrok oder VPN) und gib in n8n die Tunnel-URL ein.

Setup mit LM Studio:
1. Starte in LM Studio den lokalen Server (Server-Tab)
2. LM Studio bedient eine OpenAI-kompatible API auf `localhost:1234`
3. Exponiere sie durch einen sicheren Tunnel
4. In n8n nutze das Credential „OpenAI API" mit deiner Tunnel-URL

**Variante C: Lokales Modell auf einem anderen dedizierten AWS-Server**

Für Produktion ist die robusteste Lösung ein separater EC2 mit GPU:

1. Starte einen EC2 mit GPU (z.B. `g4dn.xlarge` — NVIDIA T4, 16GB VRAM)
2. Installiere Ollama oder vLLM
3. Konfiguriere die Security Group, sodass nur die n8n-Server-IP Zugriff hat
4. Verbinde in n8n über private IP (wenn im selben VPC) oder HTTPS

**Wann lokale Modelle nutzen:**
- Verarbeitung sensibler Daten (Daten verlassen deine Infrastruktur nie)
- Hohe Request-Volumina (null Kosten pro Token)
- Wiederkehrende Aufgaben: Klassifizierung, Entitäts-Extraktion, kurze Zusammenfassungen
- Wenn du vollständige Unabhängigkeit von Cloud-Anbietern willst

### Hybride Strategie: Das Beste aus beiden Welten

Der pragmatischste Ansatz kombiniert beide Typen:

| Aufgabe | Modell | Warum |
|---------|--------|-------|
| E-Mail-Klassifizierung | Ollama (Qwen3-8B lokal) | Hohes Volumen, einfache Aufgabe, null Kosten |
| Angebotsentwurf | Claude/GPT-4 (remote) | Maximale Qualität für kundenorientierte Ausgaben |
| Datenextraktion aus PDF | Ollama (Qwen3-8B lokal) | Sensible Daten, nicht in die Cloud |
| Berichtszusammenfassung | Ollama (Qwen3-14B lokal) | Hohes Volumen, kosteneffektiv |
| Feedback-Sentimentanalyse | Ollama (Qwen3-8B lokal) | Einfache Aufgabe, lokal reicht |
| E-Mail-Antwort-Generierung | Claude (remote) | Ton und Qualität zählen |

---

## Teil 3: Eine echte Business-Pipeline — Automatische Angebotsanfrage-Verarbeitung

Lass uns einen konkreten Workflow bauen. Szenario: Dein Unternehmen erhält Angebotsanfragen per E-Mail. Du willst den Prozess von E-Mail-Eingang bis Angebotsversand so weit wie möglich automatisieren.

### Workflow-Architektur

```
[E-Mail erhalten]
    → [KI: Klassifizierung - ist es eine Angebotsanfrage?]
    → [KI: Datenextraktion (Kunde, angefragte Services, Budget)]
    → [Kundensuche im CRM]
    → [KI: Angebotsentwurf erstellen]
    → [Slack-Benachrichtigung zur Freigabe]
    → [Bei Freigabe: E-Mail an Kunden senden]
    → [Task im Projektmanagement erstellen]
    → [In Google Sheets loggen]
```

### Schritt-für-Schritt-Aufbau in n8n

**Node 1: E-Mail-Trigger**

Füge einen **Gmail Trigger** (oder IMAP Email Trigger) Node hinzu, der sich bei jeder neuen E-Mail an die Angebotsadresse aktiviert.

**Node 2: Klassifizierung mit lokaler KI**

Füge einen **AI Agent** Node hinzu, verbunden mit **Ollama Chat Model** (Qwen3-8B). System-Prompt:

```
Du bist ein Business-E-Mail-Klassifikator. Du erhältst den Inhalt einer E-Mail
und musst NUR mit einer dieser Kategorien antworten:
- ANGEBOTSANFRAGE
- ALLGEMEINE_ANFRAGE
- BESCHWERDE
- SPAM
- SONSTIGES

Antworte nur mit der Kategorie, nichts anderem.
```

**Node 3: Router (IF)**

Füge einen **IF** Node hinzu, der prüft, ob die Klassifizierung „ANGEBOTSANFRAGE" enthält. Wenn ja, weiter im Pipeline. Wenn nein, zu anderen Workflows routen.

**Node 4: Datenextraktion mit lokaler KI**

Weiterer **AI Agent** Node mit Ollama. System-Prompt:

```
Du bist ein Assistent zur Datenextraktion aus Business-E-Mails.
Extrahiere aus der erhaltenen E-Mail folgende Informationen im JSON-Format:

{
  "kundenname": "",
  "kunden_email": "",
  "kunden_firma": "",
  "angefragte_services": [],
  "erwaehntes_budget": "",
  "gewuenschter_termin": "",
  "zusatzdetails": ""
}

Wenn eine Information nicht verfügbar ist, lasse das Feld leer.
Antworte NUR mit dem JSON, ohne Zusatztext.
```

**Node 5: CRM-Suche**

Füge einen **HTTP Request** oder dedizierten Node (Airtable, HubSpot, Notion) hinzu, der den Kunden in deiner Datenbank sucht.

**Node 6: Angebotsentwurf mit Remote-KI**

Jetzt wechseln wir zu einem starken Modell. Füge einen **AI Agent** Node hinzu, verbunden mit **Claude** oder **GPT-4**. System-Prompt:

```
Du bist ein Vertriebsberater für TEN INVENT,
eine IT-Beratungs- und Softwareentwicklungsfirma.

Erstelle einen professionellen Angebotsentwurf basierend auf:
- Kundendaten: {{aus Node 4 extrahierte Daten}}
- Kundenhistorie: {{CRM-Daten aus Node 5}}
- Angefragte Services: {{aus Extraktion}}

Das Angebot muss:
- Professionell und warm im Ton sein
- Strukturiert mit: Einleitung, Beschreibung der vorgeschlagenen Services,
  geschätztem Zeitrahmen, ungefähren Kosten, Bedingungen
- In deutscher Sprache sein

Keine exakten Preise — lasse [PREIS ZU ERGÄNZEN]
wo der Manager entscheiden muss.
```

**Node 7: Slack-Benachrichtigung**

Füge einen **Slack** Node hinzu, der in einen dedizierten Kanal (z.B. `#neue-angebote`) schreibt:

```
🆕 Neue Angebotsanfrage!
Kunde: {{kundenname}} ({{kunden_firma}})
Services: {{angefragte_services}}
Entwurf: [Link zum Entwurf]

Reagiere mit ✅ zum Freigeben.
```

**Node 8: Warten auf Freigabe**

**Node 9: E-Mail-Versand** — Bei Freigabe sendet ein **Gmail** (Send Email) Node das Angebot an den Kunden.

**Node 10: Nachbearbeitung** — Parallele Nodes für Task in Notion/Trello/Asana, Zeile in Google Sheets, CRM-Update.

### Ergebnis

Ein Prozess, der 45 Minuten dauerte, reduziert sich auf 2 Minuten Prüfung und einen Klick zur Freigabe. Der Rest läuft automatisch.

---

## Weitere Business-Pipelines

Mit n8n und KI-Modellen sind die Möglichkeiten praktisch unbegrenzt:

**Social-Media-Monitoring:** Webhook von Plattformen → KI klassifiziert Sentiment → Alerts bei negativen Erwähnungen → Generierte Antwortvorschläge

**Kunden-Onboarding:** Formular ausgefüllt → KI extrahiert Anforderungen → Projektplan erstellen → Notion-Spaces anlegen → Personalisierte Willkommens-E-Mail

**Technischer Support Level 1:** E-Mail/Chat vom Kunden → KI klassifiziert Problem → Knowledge-Base-Suche (RAG) → Antwort generieren → Bei niedrigem Confidence an Menschen eskalieren

**Rechnungsverarbeitung:** E-Mail mit Rechnungsanhang → KI extrahiert Daten aus PDF → Validierung → Buchhaltung → Zahlungsfreigabe-Benachrichtigung

**Content-Marketing:** Redaktionsplan → KI generiert Artikelentwurf → Menschliches Review → Blog-Publikation → Social-Media-Verteilung → Engagement-Tracking

---

## Produktions-Tipps

### Sicherheit

- HTTPS zwingend (bereits mit Certbot konfiguriert)
- n8n-Authentifizierung mit starkem Passwort
- Security Group auf notwendige IPs beschränken
- Ollama nicht direkt dem Internet exponieren
- API-Keys in n8n Credentials speichern

### Backup

```bash
0 2 * * * docker exec n8n tar czf /tmp/n8n-backup.tar.gz /home/node/.n8n \
  && docker cp n8n:/tmp/n8n-backup.tar.gz ~/backups/n8n-$(date +%Y%m%d).tar.gz
```

### Kosten

Ein realistisches Setup für ein kleines Unternehmen:

| Komponente | Monatliche Kosten |
|------------|------------------:|
| EC2 t3.small (n8n) | ~15$ (t3.micro ist ~7-10$, hat aber weniger RAM) |
| Elastic IP | 0$ (kostenlos wenn zugewiesen) |
| Domain | ~1$ (amortisiert pro Monat) |
| OpenAI API (moderate Nutzung) | 5-20$ |
| Claude API (moderate Nutzung) | 5-15$ |
| **Gesamt** | **25-50$/Monat** |

Vergleich mit: einem Teilzeit-Mitarbeiter, der dieselben Aufgaben manuell erledigt = mehrere tausend Euro/Monat. Die ROI ist offensichtlich.

## Fazit

n8n auf AWS mit hybriden KI-Modellen (lokal + remote) bietet wahrscheinlich das beste Kosten-Nutzen-Verhältnis für Business-Automatisierung 2026. Du hast volle Datenkontrolle, vorhersehbare Kosten und Flexibilität.

Starte einfach: n8n installieren, ein Modell verbinden, einen Prozess automatisieren. Wenn du siehst, wie 10 Minuten manuelle Arbeit zu 10 Sekunden automatischer Ausführung werden, hörst du nicht mehr auf.

---

*Dieser Artikel ist Teil der technischen Publikationsreihe des TEN INVENT Blogs. Bei Fragen zur KI-Automatisierung in deinem Unternehmen [kontaktiere uns](/contact).*