Files

ph34444 ec581f67da docs: AI support automation design spec and implementation plan

2026-03-16 15:41:38 +01:00

23 KiB

Raw Blame History

AI-gestützte IT-Support-Automatisierung Implementation Plan

For agentic workers: REQUIRED: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Ein produktives Hybrid-System bauen, das Freescout-Mails analysiert, KI-Vorschläge macht, Mensch-Approval einholt, und eine selbstlernende Wissensdatenbank aufbaut.

Architecture: 4-phasiger Ansatz:

Phase 1 (Setup): Docker Compose + Vector DB + Freescout Custom Fields
Phase 2 (Workflows): n8n Workflows A (Mail-Processing), B (Approval), C (KB-Update)
Phase 3 (Integration): End-to-End Testing + API Connections
Phase 4 (Production): Monitoring + Dokumentation + Go-Live

Tech Stack:

Orchestrierung: n8n (vorhanden, Docker)
Vector DB: Milvus (Docker)
KI: LiteLLM API (extern: http://llm.eks-ai.apps.asgard.eks-lnx.fft-it.de)
Mail-Source: Freescout API (extern: https://ekshelpdesk.fft-it.de)
Job-Execution: Baramundi Management Server API (extern)
Audit Trail: PostgreSQL (Docker)

Chunk 1: Infrastructure & Setup

Task 1.1: Vector Database in Docker Compose integrieren

Files:

Modify: compose.yaml
Create: .env.example (aktualisieren mit neuen Vars)
Step 1: compose.yaml lesen und Struktur verstehen

Schau dir die aktuelle Struktur an (Traefik, n8n).

Step 2: Milvus Service zu compose.yaml hinzufügen

  milvus:
    image: milvusdb/milvus:latest
    restart: always
    environment:
      COMMON_STORAGETYPE: local
      COMMON_LOG_LEVEL: info
    ports:
      - "127.0.0.1:19530:19530"
      - "127.0.0.1:9091:9091"
    volumes:
      - milvus_data:/var/lib/milvus
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]
      interval: 30s
      timeout: 10s
      retries: 5

  postgres:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_DB: n8n_kb
      POSTGRES_USER: kb_user
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    ports:
      - "127.0.0.1:5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U kb_user"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  traefik_data:
  n8n_data:
  milvus_data:
  postgres_data:

Step 3: .env mit neuen Variablen aktualisieren

# Existing
SSL_EMAIL=your-email@example.com
SUBDOMAIN=n8n
DOMAIN_NAME=example.com
GENERIC_TIMEZONE=Europe/Berlin

# New für KB
POSTGRES_PASSWORD=secure_password_change_me
MILVUS_API_URL=http://milvus:19530

Step 4: Services starten und healthcheck testen

docker-compose up -d milvus postgres
docker-compose logs -f milvus
# Expected: "Milvus is ready to serve"

curl http://127.0.0.1:9091/healthz
# Expected: 200 OK

Step 5: Commit

git add compose.yaml .env.example
git commit -m "infra: add Milvus vector DB and PostgreSQL for KB audit trail"

Task 1.2: PostgreSQL Audit Schema erstellen

Files:

Create: sql/01-audit-schema.sql
Step 1: Erstelle SQL Schema Datei

-- Audit Trail für KB Updates
CREATE TABLE knowledge_base_updates (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  ticket_id INTEGER NOT NULL,
  problem_text TEXT NOT NULL,
  kategorie VARCHAR(100),
  lösung TEXT,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  approved_at TIMESTAMP,
  executed_at TIMESTAMP,
  status VARCHAR(50) CHECK (status IN ('PENDING', 'APPROVED', 'REJECTED', 'EXECUTED')),
  freescout_note TEXT
);

CREATE INDEX idx_kbu_ticket ON knowledge_base_updates(ticket_id);
CREATE INDEX idx_kbu_status ON knowledge_base_updates(status);
CREATE INDEX idx_kbu_kategorie ON knowledge_base_updates(kategorie);

CREATE TABLE kb_feedback (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  kb_entry_id VARCHAR(255) NOT NULL,
  feedback VARCHAR(50) CHECK (feedback IN ('helpful', 'not_helpful')),
  reason TEXT,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_kbf_entry ON kb_feedback(kb_entry_id);

CREATE TABLE workflow_executions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  workflow_name VARCHAR(255),
  ticket_id INTEGER,
  status VARCHAR(50),
  error_message TEXT,
  execution_time_ms INTEGER,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_we_ticket ON workflow_executions(ticket_id);
CREATE INDEX idx_we_workflow ON workflow_executions(workflow_name);

Step 2: Initialisiere PostgreSQL mit Schema

docker-compose exec postgres psql -U kb_user -d n8n_kb < sql/01-audit-schema.sql
# Expected: CREATE TABLE, CREATE INDEX messages

Step 3: Teste Schema

docker-compose exec postgres psql -U kb_user -d n8n_kb -c "\dt"
# Expected: 3 tables angezeigt

Step 4: Commit

git add sql/01-audit-schema.sql
git commit -m "infra: PostgreSQL audit schema for KB tracking"

Task 1.3: Freescout Custom Fields erstellen (manuell)

Dokumentation: Freescout API Docs

Step 1: Freescout API Key vorbereiten

Erstelle .env Eintrag:

FREESCOUT_API_KEY=your_api_key_here
FREESCOUT_API_BASE=https://ekshelpdesk.fft-it.de/api/v1
FREESCOUT_MAILBOX_ID=1

Step 2: Test Freescout API Verbindung

curl -H "Authorization: Bearer $FREESCOUT_API_KEY" \
  https://ekshelpdesk.fft-it.de/api/v1/mailboxes/1
# Expected: Mailbox JSON angezeigt

Step 3: Erstelle Setup-Skript für Custom Fields

Datei: scripts/setup-freescout-fields.sh

#!/bin/bash

API_BASE="${FREESCOUT_API_BASE}"
API_KEY="${FREESCOUT_API_KEY}"
MAILBOX_ID="${FREESCOUT_MAILBOX_ID}"

echo "Creating Freescout Custom Fields..."

# Field 1: AI_SUGGESTION (Text für JSON)
curl -X POST "$API_BASE/mailboxes/$MAILBOX_ID/custom-fields" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "AI_SUGGESTION",
    "title": "KI-Vorschlag",
    "type": "text",
    "required": false
  }' && echo "✅ AI_SUGGESTION created"

# Field 2: AI_SUGGESTION_STATUS (Dropdown)
curl -X POST "$API_BASE/mailboxes/$MAILBOX_ID/custom-fields" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "AI_SUGGESTION_STATUS",
    "title": "KI-Status",
    "type": "select",
    "required": false,
    "options": ["PENDING", "APPROVED", "REJECTED", "EXECUTED"]
  }' && echo "✅ AI_SUGGESTION_STATUS created"

# Field 3: PROCESSED_BY_AI (Boolean)
curl -X POST "$API_BASE/mailboxes/$MAILBOX_ID/custom-fields" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "PROCESSED_BY_AI",
    "title": "Von KI verarbeitet",
    "type": "checkbox",
    "required": false
  }' && echo "✅ PROCESSED_BY_AI created"

echo "✅ All custom fields created!"

Step 4: Führe Setup Skript aus

bash scripts/setup-freescout-fields.sh
# Expected: 3x ✅ created

Step 5: Commit

git add scripts/setup-freescout-fields.sh
git commit -m "scripts: setup Freescout custom fields"

Chunk 2: n8n Workflows Setup & Workflow A (Mail Processing)

Task 2.1: n8n Credentials & Collections vorbereiten

Files:

Create: n8n-workflows/00-SETUP.md
Create: n8n-workflows/workflow-a-mail-processing.json
Step 1: Verstehe n8n Workflow Export Format

n8n Workflows werden als JSON exportiert. Struktur:

{
  "name": "Workflow Name",
  "nodes": [...],
  "connections": {...},
  "active": true
}

Step 2: Erstelle Setup-Dokumentation

Datei: n8n-workflows/00-SETUP.md

# n8n Workflows Setup

## Benötigte Credentials

1. **Freescout API:**
   - Type: HTTP Request (Generic Credentials)
   - Base URL: https://ekshelpdesk.fft-it.de/api/v1
   - Auth: Bearer Token (von .env FREESCOUT_API_KEY)

2. **LiteLLM API:**
   - Type: HTTP Request
   - Base URL: http://llm.eks-ai.apps.asgard.eks-lnx.fft-it.de
   - No auth needed (lokal)

3. **PostgreSQL:**
   - Host: postgres (Docker)
   - Port: 5432
   - Database: n8n_kb
   - User: kb_user
   - Password: (von .env POSTGRES_PASSWORD)

4. **Milvus:**
   - Host: milvus
   - Port: 19530
   - No auth

## Workflow Import

Importiere folgende Workflows in n8n:
1. workflow-a-mail-processing.json
2. workflow-b-approval-execution.json
3. workflow-c-kb-update.json

Schalte sie in dieser Reihenfolge an:
1. Workflow A (Mail Processing) – hauptziel
2. Workflow B (Approval) – triggered bei Field-Änderung
3. Workflow C (KB Update) – triggered nach Workflow B

Step 3: Commit Setup Dokumentation

git add n8n-workflows/00-SETUP.md
git commit -m "docs: n8n setup and credential configuration"

Task 2.2: Workflow A – Mail Processing (Polling + KI-Analyse)

Files:

Create: n8n-workflows/workflow-a-mail-processing.json

Logik:

Trigger: Cron (alle 5 Min)
Freescout API: neue Tickets fetchen
Für jedes Ticket: Vector DB Query + LLM Call
Speichere Vorschlag in Freescout

Step 1: Workflow-Struktur in n8n UI bauen

Node 1: Cron Trigger

Cron: */5 * * * * (alle 5 Min)

Node 2: Freescoot API – Get Conversations

Method: GET
URL: https://ekshelpdesk.fft-it.de/api/v1/mailboxes/1/conversations?status=active
Auth: Bearer Token
Params: status=active&limit=20&processed_by_ai=false

Node 3: Loop through Conversations

Use: Loop node über Array aus Node 2

Node 4: Extract Conversation Details

Use: Set node um Subject, Body zu extrahieren

{
  ticket_id: item.id,
  subject: item.subject,
  body: item.threads[0].body,
  customer_email: item.customer.email
}

Node 5: Vector DB Query (Milvus)

Python node um ähnliche KB-Einträge zu finden

from pymilvus import Collection

# Connect to Milvus
collection = Collection("knowledge_base")

# Search for similar problems
results = collection.search(
  data=[embedding_vector],  # zu erzeugen via LLM
  anns_field="embedding",
  param={
    "metric_type": "L2",
    "params": {"nprobe": 10}
  },
  limit=3,
  output_fields=["problem_text", "kategorie", "lösung"]
)

return results

Node 6: LLM Call (LiteLLM)

HTTP Request zu LiteLLM
Method: POST
URL: http://llm.eks-ai.apps.asgard.eks-lnx.fft-it.de/v1/chat/completions
Body:

{
  "model": "available-model",
  "messages": [
    {
      "role": "system",
      "content": "Du bist IT-Support-Assistent..."
    },
    {
      "role": "user",
      "content": "Ticket: [subject]\n[body]\n\nÄhnliche Lösungen aus KB: [top 3 results]"
    }
  ],
  "temperature": 0.3
}

Node 7: Parse LLM Response

Extract JSON aus response

{
  kategorie: json.kategorie,
  lösung_typ: json.lösung_typ,
  vertrauen: json.vertrauen,
  antwort_text: json.antwort_text,
  begründung: json.begründung
}

Node 8: Save to Freescout (Custom Fields)

HTTP Request
Method: PUT
URL: https://ekshelpdesk.fft-it.de/api/v1/conversations/{ticket_id}
Body:

{
  "custom_fields": {
    "AI_SUGGESTION": "{{$node[\"Parse LLM Response\"].json}}",
    "AI_SUGGESTION_STATUS": "PENDING",
    "PROCESSED_BY_AI": true
  }
}

Step 2: Exportiere Workflow als JSON

In n8n: Menu → Export → Full Workflow JSON Speichere als n8n-workflows/workflow-a-mail-processing.json

Step 3: Teste Workflow manuell
Starte Workflow manuell (Test-Button)
Check Freescout UI: neue Custom Fields angezeigt?
Check n8n Logs auf Fehler
Step 4: Aktiviere Cron Trigger

Schalte Workflow an. Sollte jetzt alle 5 Min laufen.

Step 5: Commit

git add n8n-workflows/workflow-a-mail-processing.json
git commit -m "feat: workflow A – mail processing and KI analysis"

Chunk 3: Workflow B & C (Approval + KB Update)

Task 3.1: Workflow B – Approval & Execution

Files:

Create: n8n-workflows/workflow-b-approval-execution.json

Logik:

Trigger: Webhook oder Polling (wenn AI_SUGGESTION_STATUS geändert)
Validiere: APPROVED oder REJECTED
Wenn APPROVED: Branching
- Baramundi Job? → Baramundi API Call
- Automatische Antwort? → Email senden
Trigger Workflow C

Step 1: Baue Trigger Node

Option A: Webhook Trigger (empfohlen)

Freescout muss Webhook supportieren
Trigger bei Field-Änderung

Option B: Polling via HTTP

Alle 2 Min abfragen: welche Conversations haben AI_SUGGESTION_STATUS = APPROVED
Fallback wenn Webhook nicht verfügbar

Für MVP: Option B (Polling)

Step 2: Baue Approval Check Node

HTTP Request zu Freescout:

GET /api/v1/conversations?custom_field_AI_SUGGESTION_STATUS=APPROVED&processed_approval=false

Step 3: Baue Branching Logic

Für jedes approved Ticket:

Parse AI_SUGGESTION
Check: ist lösung_typ == "BARAMUNDI_JOB" oder "AUTOMATISCHE_ANTWORT"?
Step 4: Baramundi Job Node

Wenn Baramundi:

POST /api/jobs (Baramundi Management Server)
{
  "name": "{{$node[...].json.baramundi_job.name}}",
  "parameter": {...}
}

Step 5: Email/Reply Node

Wenn Automatische Antwort:

POST /api/v1/conversations/{id}/threads
{
  "from": "support@company.com",
  "to": "{{customer_email}}",
  "subject": "Re: {{subject}}",
  "body": "{{antwort_text}}"
}

Step 6: Mark as Executed

Nach Success: Update Custom Field

PUT /api/v1/conversations/{id}
{
  "custom_fields": {
    "AI_SUGGESTION_STATUS": "EXECUTED"
  }
}

Step 7: Trigger Workflow C

Webhook Call zu Workflow C:

POST http://n8n:5678/webhook/kb-update
{
  "ticket_id": "...",
  "status": "EXECUTED"
}

Step 8: Exportiere & Teste

# Export Workflow B
# In n8n: Menu → Export

git add n8n-workflows/workflow-b-approval-execution.json
git commit -m "feat: workflow B – approval gate and execution"

Task 3.2: Workflow C – Knowledge Base Update

Files:

Create: n8n-workflows/workflow-c-kb-update.json

Logik:

Trigger: Webhook von Workflow B
Hole Lösungs-Details
Generiere Embedding (LLM)
Speichere in Milvus
Update Häufigkeit bestehender Einträge
Log in PostgreSQL

Step 1: Webhook Trigger Node

POST http://n8n:5678/webhook/kb-update

Payload:

{
  "ticket_id": "123",
  "problem_text": "...",
  "kategorie": "Hardware",
  "lösung": "Drucker-Treiber neu installiert"
}

Step 2: Embedding Generation Node

LLM Call für Embedding:

POST http://llm.eks-ai.apps.asgard.eks-lnx.fft-it.de/v1/embeddings
{
  "model": "available",
  "input": "Hardware: {{kategorie}} + {{problem_text}}"
}

Step 3: Milvus Insert Node

Python Node:

from pymilvus import Collection
import json

collection = Collection("knowledge_base")

entity = {
  "id": uuid4(),
  "problem_text": "{{problem_text}}",
  "kategorie": "{{kategorie}}",
  "lösung": "{{lösung}}",
  "häufigkeit": 1,
  "embedding": embedding_vector,
  "timestamp": datetime.now(),
  "freescout_ticket_id": ticket_id
}

collection.insert([entity])
collection.flush()

return {"status": "inserted"}

Step 4: Update Häufigkeit (Optional)

Suche ähnliche KB-Einträge und erhöhe deren Häufigkeit:

results = collection.search(
  data=[embedding_vector],
  limit=5,
  threshold=0.85
)

for result in results:
  # Update entry
  collection.delete(id=result.id)
  result.häufigkeit += 1
  collection.insert([result])

Step 5: PostgreSQL Audit Log Node

PostgreSQL Node:

INSERT INTO knowledge_base_updates
  (ticket_id, problem_text, kategorie, lösung, status, created_at, approved_at, executed_at)
VALUES
  ('{{ticket_id}}', '{{problem_text}}', '{{kategorie}}', '{{lösung}}', 'EXECUTED', NOW(), NOW(), NOW())

Step 6: Error Handling

Wenn einer der Steps fehlschlägt:

Log Error in PostgreSQL
Notify Admin (optional Email)
STOP (nicht crashen)
Step 7: Exportiere & Teste

git add n8n-workflows/workflow-c-kb-update.json
git commit -m "feat: workflow C – knowledge base auto-update"

Chunk 4: Integration, Testing & Production

Task 4.1: End-to-End Testing

Files:

Create: tests/e2e-test-scenario.md
Create: tests/curl-test-collection.sh
Step 1: Schreibe E2E Test Szenario

# E2E Test: Full Workflow

## Setup
- Milvus läuft
- PostgreSQL läuft
- n8n läuft
- Freescout erreichbar
- LiteLLM erreichbar

## Test Steps

1. **Create Test Ticket in Freescout**
   - Subject: "Drucker funktioniert nicht"
   - Body: "Jeder Druck-Befehl wird abgelehnt. Fehlercode 5."
   - Customer: test@example.com

2. **Warte 5 Min** (Workflow A Cycle)
   - Check n8n Logs: Mail verarbeitet?
   - Check Freescout: Custom Field AI_SUGGESTION gefüllt?

3. **Approve Vorschlag**
   - Freescout: AI_SUGGESTION_STATUS = APPROVED

4. **Warte 2 Min** (Workflow B Cycle)
   - Check n8n: Job ausgelöst oder Email gesendet?
   - Check Baramundi: Job erstellt?

5. **Warte 1 Min** (Workflow C Cycle)
   - Check PostgreSQL: INSERT in knowledge_base_updates?
   - Check Milvus: KB-Eintrag erstellt?

6. **Vector DB Search Test**
   - Query Milvus mit ähnlichem Problem
   - Sollte neuen Eintrag finden mit hoher Similarity

Step 2: Schreibe Test Curl Commands

tests/curl-test-collection.sh:

#!/bin/bash

echo "=== E2E Test Collection ==="

# 1. Check Milvus Health
echo "✓ Testing Milvus..."
curl http://127.0.0.1:9091/healthz

# 2. Check PostgreSQL
echo "✓ Testing PostgreSQL..."
docker-compose exec postgres psql -U kb_user -d n8n_kb -c "SELECT COUNT(*) FROM knowledge_base_updates;"

# 3. Check Freescout API
echo "✓ Testing Freescout API..."
curl -H "Authorization: Bearer $FREESCOUT_API_KEY" \
  https://ekshelpdesk.fft-it.de/api/v1/mailboxes/1/conversations?limit=5

# 4. Check LiteLLM
echo "✓ Testing LiteLLM..."
curl -X POST http://llm.eks-ai.apps.asgard.eks-lnx.fft-it.de/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "any",
    "messages": [{"role": "user", "content": "test"}]
  }'

echo "=== All tests passed ==="

Step 3: Führe Tests aus

bash tests/curl-test-collection.sh
# Expected: ✓ All tests passed

Step 4: Erstelle echtes Test-Ticket in Freescout

Manuell oder via Freescout UI:

Subject: "Drucker funktioniert nicht"
Body: "Fehlercode 5 beim Drucken"

Überwache:

n8n Logs
Freescout Custom Fields
PostgreSQL
Step 5: Commit

git add tests/
git commit -m "test: E2E test scenarios and curl collection"

Task 4.2: Monitoring & Logging Setup

Files:

Create: docker-compose.override.yml (für Logging)
Create: docs/MONITORING.md
Step 1: Füge n8n Logging zu Compose hinzu

docker-compose.override.yml:

services:
  n8n:
    environment:
      - N8N_LOG_LEVEL=debug
      - N8N_LOG_OUTPUT=stdout
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "10"

Step 2: Erstelle Monitoring Dokumentation

docs/MONITORING.md:

# Monitoring & Debugging

## Key Metrics

1. **Mail Processing Rate**
   - N8N Logs: "processed X conversations"
   - PostgreSQL: `SELECT COUNT(*) FROM workflow_executions WHERE workflow_name='workflow-a'`

2. **Approval Rate**
   - PostgreSQL: `SELECT status, COUNT(*) FROM knowledge_base_updates GROUP BY status`
   - Expected: Meiste APPROVED

3. **KB Growth**
   - Milvus: `SELECT COUNT(*) FROM knowledge_base` (via Python)
   - Expected: +1 pro appropierten Ticket

4. **Error Rate**
   - PostgreSQL: `SELECT * FROM workflow_executions WHERE status='ERROR'`
   - Expected: < 5%

## Troubleshooting

### Workflow A läuft nicht
- Check: Cron trigger aktiv?
- Check: n8n credentials valid?
- Check: Freescout API erreichbar?

### Workflow B triggert nicht
- Check: AI_SUGGESTION_STATUS im Freescout updatet?
- Check: Polling Interval (2 Min)?

### Workflow C speichert nicht in KB
- Check: Milvus läuft?
- Check: Embedding generiert?

## Logs

```bash
# n8n Logs
docker-compose logs -f n8n

# PostgreSQL
docker-compose exec postgres psql -U kb_user -d n8n_kb -c "SELECT * FROM workflow_executions LIMIT 10;"

# Milvus
docker-compose logs -f milvus


- [ ] **Step 3: Commit**

```bash
git add docker-compose.override.yml docs/MONITORING.md
git commit -m "infra: logging and monitoring setup"

Task 4.3: Production Dokumentation & Go-Live Checklist

Files:

Create: docs/DEPLOYMENT.md
Create: docs/GO-LIVE-CHECKLIST.md
Step 1: Schreibe Deployment Guide

docs/DEPLOYMENT.md:

# Deployment Guide

## Prerequisites

- Docker & Docker Compose installed
- Freescout API Key
- Baramundi API Access
- PostgreSQL Backup Strategy

## Deployment Steps

1. Clone Repository
2. Setup .env (siehe .env.example)
3. Run Docker Services: `docker-compose up -d`
4. Run DB Schema: `sql/01-audit-schema.sql`
5. Setup Freescout Custom Fields: `bash scripts/setup-freescout-fields.sh`
6. Import n8n Workflows (manual via n8n UI)
7. Run E2E Tests: `bash tests/curl-test-collection.sh`
8. Enable Workflows (schalte alle 3 Workflows an)

## Monitoring

See docs/MONITORING.md

## Rollback

1. Deaktiviere alle n8n Workflows
2. Lösche PostgreSQL Daten (optional)
3. Setze KB zurück (optional)

Step 2: Go-Live Checklist

docs/GO-LIVE-CHECKLIST.md:

# Go-Live Checklist

## 1 Week Before

- [ ] E2E Tests durchgeführt (alle ✓)
- [ ] Staging Environment getestet
- [ ] Team Training abgeschlossen
- [ ] Backup-Strategie definiert

## Go-Live Day

- [ ] Alle Docker Services laufen
- [ ] All n8n Workflows aktiv
- [ ] Monitoring Dashboard aktiv
- [ ] Backup vor Go-Live

## Während Launch

- [ ] Monitor n8n Logs
- [ ] Monitor Freescout
- [ ] Monitor Baramundi Job Queue
- [ ] Alert System aktiv

## Nach 24h

- [ ] KI-Vorschläge angezeigt?
- [ ] Approvals funktionieren?
- [ ] Jobs werden ausgelöst?
- [ ] KB wächst?

## Nach 1 Woche

- [ ] Statistiken: Wie viele Mails verarbeitet?
- [ ] Wie viele Approvals?
- [ ] Wie viele Baramundi Jobs?
- [ ] Feedback vom Team sammeln

Step 3: Commit

git add docs/DEPLOYMENT.md docs/GO-LIVE-CHECKLIST.md
git commit -m "docs: deployment and go-live documentation"

Task 4.4: Final Testing & Acceptance

Step 1: Führe alle E2E Tests durch

bash tests/curl-test-collection.sh

Step 2: Teste mit echtem Ticket (Staging)

Erstelle Test-Ticket in Freescout:

Subject: "Test: Drucker funktioniert nicht"
Body: "Fehlercode 5"

Überwache 15 Min:

Mail analysiert?
KI-Vorschlag angezeigt?
Approve Vorschlag
Job ausgelöst oder Email gesendet?
KB aktualisiert?
Step 3: Dokumentiere Ergebnisse

Wenn alles ✓: Go-Live bereit!

Step 4: Final Commit

git add .
git commit -m "feat: AI-support-automation MVP complete and tested"

Summary

✅ Phase 1: Milvus + PostgreSQL + Freescout Custom Fields
✅ Phase 2: Workflow A (Mail Processing) + Workflow B (Approval) + Workflow C (KB Update)
✅ Phase 3: E2E Testing + Monitoring
✅ Phase 4: Production Ready

Status: Bereit für Implementation via superpowers:subagent-driven-development oder superpowers:executing-plans

Next Steps

🚀 Sollen wir starten?

Wenn ja: Nutze superpowers:executing-plans um den Plan zu implementieren
Wenn nein: Änderungen an Plan vornehmen

23 KiB Raw Blame History Unescape Escape

AI-gestützte IT-Support-Automatisierung Implementation Plan

Chunk 1: Infrastructure & Setup

Task 1.1: Vector Database in Docker Compose integrieren

Task 1.2: PostgreSQL Audit Schema erstellen

Task 1.3: Freescout Custom Fields erstellen (manuell)

Chunk 2: n8n Workflows Setup & Workflow A (Mail Processing)

Task 2.1: n8n Credentials & Collections vorbereiten

Task 2.2: Workflow A – Mail Processing (Polling + KI-Analyse)

Chunk 3: Workflow B & C (Approval + KB Update)

Task 3.1: Workflow B – Approval & Execution

Task 3.2: Workflow C – Knowledge Base Update

Chunk 4: Integration, Testing & Production

Task 4.1: End-to-End Testing

Task 4.2: Monitoring & Logging Setup

Task 4.3: Production Dokumentation & Go-Live Checklist

Task 4.4: Final Testing & Acceptance

Summary

Next Steps

23 KiB

Raw Blame History