// Kostengünstige Routing-Entscheidung
const routingPrompt = `Klassifizieren Sie diese eingehende Anfrage in eine dieser Kategorien:
- EINFACH: Grundlegende Datenextraktion, Formatierung
- STANDARD: Mehrschrittverarbeitung, moderates Reasoning
- KOMPLEX: Tiefe Analyse, kreative Generierung, Coding

Anfrage: {{$json.input}}

Antworten Sie nur mit: EINFACH, STANDARD oder KOMPLEX`;

// Kosten: ~0,00009 € pro Klassifizierung
// Einsparungen: 0,009-0,09 € pro Anfrage durch Vermeidung von Überdimensionierung

{
  "name": "KI-Modell-Router",
  "nodes": [
    {
      "parameters": {
        "model": "gpt-4o-mini",
        "options": {
          "temperature": 0.1,
          "maxTokens": 50
        },
        "prompt": "=Klassifizieren Sie die Anfrage-Komplexität:\n{{$json.input}}\n\nAntwort: EINFACH|STANDARD|KOMPLEX"
      },
      "type": "n8n-nodes-base.openAi",
      "typeVersion": 1.6
    },
    {
      "parameters": {
        "rules": {
          "rules": [
            {
              "value": "EINFACH",
              "output": 0
            },
            {
              "value": "STANDARD",
              "output": 1
            },
            {
              "value": "KOMPLEX",
              "output": 2
            }
          ]
        }
      },
      "type": "n8n-nodes-base.switch",
      "typeVersion": 1
    }
  ]
}

// Ineffizient: 1000 separate API-Aufrufe
for (const item of items) {
  const result = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{ role: "user", content: item.prompt }]
  });
}

// Effizient: 100 Elemente pro Batch verarbeiten
const batches = chunk(items, 100);
for (const batch of batches) {
  const combinedPrompt = batch.map((item, i) => 
    `[Element ${i + 1}] ${item.prompt}`
  ).join('\n\n---\n\n');
  
  const result = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{ 
      role: "user", 
      content: `Verarbeiten Sie diese ${batch.length} Elemente:\n\n${combinedPrompt}` 
    }]
  });
  
  // Ergebnisse parsen und verteilen
  const responses = parseBatchResponse(result.choices[0].message.content);
}

{
  "name": "Batch-Prozessor",
  "nodes": [
    {
      "parameters": {
        "batchSize": 100,
        "options": {}
      },
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 3
    },
    {
      "parameters": {
        "jsCode": "// Batch-Elemente zu einem einzigen Prompt kombinieren\nconst combined = items.map((item, i) => \n  `[${i + 1}] ${item.json.content}`\n).join('\\n\\n---\\n\\n');\n\nreturn [{\n  json: {\n    batchPrompt: combined,\n    itemCount: items.length,\n    originalItems: items\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2
    }
  ]
}

// Cache vor API-Aufruf prüfen
const similarRequests = await vectorDB.similaritySearch({
  query: currentRequest,
  threshold: 0.95, // Hoher Ähnlichkeitsschwellenwert
  limit: 1
});

if (similarRequests.length > 0) {
  // Cache-Treffer: Gespeicherte Antwort zurückgeben
  return similarRequests[0].response;
}

// Cache-Fehlschlag: API aufrufen und Ergebnis speichern
const response = await callLLM(currentRequest);
await vectorDB.store({
  request: currentRequest,
  response: response,
  embedding: await generateEmbedding(currentRequest)
});

{
  "name": "Smart-Cache-Schicht",
  "nodes": [
    {
      "parameters": {
        "operation": "search",
        "indexName": "llm-request-cache",
        "options": {
          "k": 1,
          "minSimilarity": 0.95
        },
        "query": "={{ $json.input }}"
      },
      "type": "n8n-nodes-base.pinecone",
      "typeVersion": 1
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "={{ $json.results.length }}",
            "type": {
              "value": "gt",
              "version": 1
            },
            "rightValue": "0"
          }
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2
    }
  ]
}

{
  "name": "Smart-Trigger-Filter",
  "nodes": [
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "={{ $json.payload.priority }}",
            "type": {
              "value": "in",
              "version": 1
            },
            "rightValue": "hoch,kritisch"
          }
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2
    }
  ]
}

# MEMORY.md - Optimierte Struktur

## Kritischer Kontext (Immer beibehalten)
- Benutzereinstellungen und Kernkonfigurationen
- Aktive Projektdefinitionen
- Sicherheitsanmeldedaten (gehasht)

## Arbeitsgedächtnis (Zusammengefasst)
- Kürzliche Konversationshistorie (letzte 10 Austausche)
- Aktueller Aufgabenkontext
- Ausstehende Aufgaben

## Archivierter Speicher (Vektorspeicher)
- Historische Konversationen (wöchentlich zusammengefasst)
- Abgeschlossene Projekte (nur wichtige Ergebnisse)
- Gelernte Muster und Präferenzen

## Ablaufrichtlinie
- Arbeitsgedächtnis: 30 Tage
- Archivierte Elemente: 90 Tage
- Systemprotokolle: 7 Tage

// Kontext vorverarbeiten, um Token-Verbrauch zu minimieren
function optimizeContext(memory, maxTokens = 4000) {
  // Prioritätsrangfolge für Kontextbeibehaltung
  const priority = [
    ...memory.critical,
    ...memory.working.slice(0, 5),
    ...summarizeOldMemory(memory.archived)
  ];
  
  // Kürzen bei gleichzeitiger Beibehaltung der Struktur
  return truncateWithStructure(priority, maxTokens);
}

// Typische Einsparungen: 40-60% Reduktion der Context-Tokens

# gateway.config.yaml
channels:
  # Hochkosten: Volle KI-Fähigkeiten
  email:
    model: gpt-4o
    memory: full
    reasoning: high
    
  # Mittelkosten: Ausgewogene Fähigkeiten
  slack:
    model: claude-3-5-sonnet
    memory: working
    reasoning: medium
    
  # Niedrige Kosten: Nur Essentials
  telegram:
    model: gpt-4o-mini
    memory: minimal
    reasoning: low
    
  # Event-gesteuert: Nur reaktiv
  webhook:
    model: none  # Vorab gefilterte Antworten
    memory: none
    reasoning: none

// Passende Session-Ziele für Workload-Typ verwenden
// Isolierte Sessions: Ideal für unabhängige, einmalige Aufgaben
openclaw agent --message "Schnelle Analyse" --session isolated

// Aktuelle Session: Kontext für verwandte Aufgaben teilen
openclaw agent --message "Vorherige Aufgabe fortsetzen" --session current

// Benannte Sessions: Persistenter Kontext für laufende Projekte
openclaw agent --message "Projektstatus aktualisieren" --session project:alpha

# Ollama mit optimierten Modellen starten
ollama pull llama3.1:8b
ollama pull mistral:7b-instruct

# OpenClaw für lokale Modelle konfigurieren
openclaw config set model.default.local llama3.1:8b
openclaw config set model.routing.threshold 0.85

async function routeToOptimalModel(request, complexity) {
  // Einfache Anfragen an lokale Modelle weiterleiten
  if (complexity === 'EINFACH') {
    return await ollama.generate({
      model: 'llama3.1:8b',
      prompt: request
    });
  }
  
  // Mittlere Komplexität mit Fallback weiterleiten
  if (complexity === 'STANDARD') {
    try {
      return await ollama.generate({
        model: 'mistral:7b-instruct',
        prompt: request
      });
    } catch {
      // Fallback auf API bei Fehler des lokalen Modells
      return await openai.chat.completions.create({
        model: 'gpt-4o-mini',
        messages: [{ role: 'user', content: request }]
      });
    }
  }
  
  // Hohe Komplexität: Bestes verfügbares API-Modell verwenden
  return await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: request }]
  });
}

version: '3.8'
services:
  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
      
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: n8n
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data
      
  n8n-webhook:
    image: n8nio/n8n:latest
    environment:
      - N8N_MODE=webhook
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - QUEUE_BULL_REDIS_HOST=redis
    deploy:
      replicas: 2
      
  n8n-worker:
    image: n8nio/n8n:latest
    environment:
      - N8N_MODE=worker
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - QUEUE_BULL_REDIS_HOST=redis
    deploy:
      replicas: 5  # Basierend auf Workload skalieren
      
  n8n-main:
    image: n8nio/n8n:latest
    environment:
      - N8N_MODE=main
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - QUEUE_BULL_REDIS_HOST=redis

// Automatische Skalierung basierend auf Queue-Tiefe
const queueMetrics = await getQueueMetrics();

if (queueMetrics.waiting > 1000) {
  await scaleWorkers('+2');
} else if (queueMetrics.waiting < 100 && workers > 2) {
  await scaleWorkers('-1');
}

-- Optimieren für Workflow-Ausführungsmuster
ALTER SYSTEM SET shared_buffers = '4GB';
ALTER SYSTEM SET effective_cache_size = '12GB';
ALTER SYSTEM SET maintenance_work_mem = '1GB';
ALTER SYSTEM SET work_mem = '256MB';

-- Ausführungstabellen für große Bereitstellungen partitionieren
CREATE TABLE execution_entity_partitioned (
    id SERIAL,
    workflow_id VARCHAR(36),
    finished BOOLEAN,
    started_at TIMESTAMP,
    stopped_at TIMESTAMP,
    data JSONB
) PARTITION BY RANGE (started_at);

-- Monatliche Partitionen erstellen
CREATE TABLE execution_entity_2026_04 
    PARTITION OF execution_entity_partitioned
    FOR VALUES FROM ('2026-04-01') TO ('2026-05-01');

// Indizes für häufige Abfragemuster verwenden
// Index auf workflow_id und started_at für Ausführungsabfragen
CREATE INDEX CONCURRENTLY idx_execution_workflow_time 
ON execution_entity(workflow_id, started_at DESC);

// Teiler Index für aktive Ausführungen
CREATE INDEX CONCURRENTLY idx_execution_active 
ON execution_entity(id) 
WHERE finished = false;

// Token-Bucket-Algorithmus zum API-Schutz
class RateLimiter {
  constructor(tokensPerSecond, bucketSize) {
    this.tokens = bucketSize;
    this.lastRefill = Date.now();
    this.tokensPerSecond = tokensPerSecond;
    this.bucketSize = bucketSize;
  }
  
  async acquire() {
    this.refill();
    if (this.tokens >= 1) {
      this.tokens--;
      return true;
    }
    
    // Warten auf Token-Verfügbarkeit
    const waitTime = Math.ceil((1 - this.tokens) * 1000 / this.tokensPerSecond);
    await sleep(waitTime);
    return this.acquire();
  }
  
  refill() {
    const now = Date.now();
    const elapsed = (now - this.lastRefill) / 1000;
    this.tokens = Math.min(
      this.bucketSize,
      this.tokens + elapsed * this.tokensPerSecond
    );
    this.lastRefill = now;
  }
}

// Verwendung
const openaiLimiter = new RateLimiter(100, 200); // 100 Anfragen/s, Burst bis 200

// n8n-Ausführungshook für Kosten-Tracking
const costTracker = {
  async beforeExecute(workflowId, executionId) {
    await trackMetric('execution.start', {
      workflowId,
      executionId,
      timestamp: Date.now()
    });
  },
  
  async afterExecute(workflowId, executionId, result, costs) {
    await trackMetric('execution.complete', {
      workflowId,
      executionId,
      duration: Date.now() - result.startTime,
      costs: {
        aiTokens: costs.tokens || 0,
        aiCost: costs.estimatedCost || 0,
        computeTime: costs.computeMs || 0
      }
    });
  }
};

// Tägliche Kosten aggregieren
async function getDailyCostReport(date) {
  return await db.query(`
    SELECT 
      workflow_id,
      SUM(ai_cost) as total_cost,
      SUM(ai_tokens) as total_tokens,
      COUNT(*) as execution_count,
      AVG(duration) as avg_duration
    FROM execution_metrics
    WHERE DATE(timestamp) = $1
    GROUP BY workflow_id
    ORDER BY total_cost DESC
  `, [date]);
}

# Benutzerdefinierter Metriken-Endpunkt
- name: n8n_cost_total
  help: Gesamte KI-API-Kosten pro Workflow
  type: counter
  labels: [workflow_id, model]

- name: n8n_execution_duration
  help: Workflow-Ausführungsdauer
  type: histogram
  labels: [workflow_id]
  buckets: [0.1, 0.5, 1, 2, 5, 10, 30, 60]

- name: n8n_cache_hit_ratio
  help: Cache-Trefferrate für LLM-Anfragen
  type: gauge
  labels: [cache_type]

// Wesentliche Metriken für Optimierungsentscheidungen
const dashboardMetrics = {
  // Kosteneffizienz
  costPerExecution: totalCost / totalExecutions,
  costPerTask: totalCost / totalTasksCompleted,
  modelCostDistribution: breakdownByModel,
  
  // Leistung
  avgExecutionTime: totalDuration / totalExecutions,
  p95ExecutionTime: percentile(executionTimes, 95),
  errorRate: failedExecutions / totalExecutions,
  
  // Ressourcennutzung
  queueDepth: currentQueueSize,
  workerUtilization: activeWorkers / totalWorkers,
  apiQuotaUsage: usedQuota / totalQuota
};

# Kostenanomalie-Erkennung
- alert: HighCostAnomaly
  expr: |
    (
      sum(rate(n8n_cost_total[1h])) 
      / 
      sum(rate(n8n_cost_total[1h] offset 1d))
    ) > 2
  for: 15m
  labels:
    severity: warning
  annotations:
    summary: "KI-API-Kosten verdoppelt im Vergleich zu gestern"

- alert: ExecutionFailureRate
  expr: |
    (
      sum(rate(n8n_execution_failed_total[5m]))
      /
      sum(rate(n8n_execution_total[5m]))
    ) > 0.1
  for: 5m
  labels:
    severity: critical
  annotations:
    summary: "Ausführungsfehlerrate über 10%"

// Statt freier Antwortform, die Parsing erfordert
const unstructuredPrompt = `Extrahieren Sie die Meeting-Details aus diesem Text: ${text}`;
// Antwort: "Das Meeting ist für morgen um 14 Uhr in Konferenzraum A geplant"
// Erfordert: Zusätzlichen Parsing-Schritt

// Strukturierte Ausgabe verwenden
const structuredPrompt = `Extrahieren Sie Meeting-Details aus diesem Text: ${text}

Antworten Sie NUR in diesem JSON-Format:
{
  "datum": "JJJJ-MM-TT",
  "zeit": "HH:MM",
  "ort": "string",
  "teilnehmer": ["string"]
}`;
// Antwort: {"datum": "2026-04-22", "zeit": "14:00", ...}
// Spart: Parsing-Schritt, reduzierte Fehlerbehandlung, konsistentes Format

// Statt eines einzelnen teuren Aufrufs
const complexPrompt = `Analysieren Sie diesen Finanzbericht und liefern Sie:
1. Umsatztrends
2. Aufschlüsselung der Ausgaben
3. Cashflow-Analyse
4. Risikobewertung
5. Empfehlungen

Bericht: ${report}`;
// Kosten: ~0,09-0,18 €, Qualität: Variabel

// In strukturierte Schritte unterteilen
const steps = [
  { prompt: `Umsatzdaten extrahieren: ${report}`, cost: 0.018 },
  { prompt: `Ausgabendaten extrahieren: ${report}`, cost: 0.018 },
  { prompt: `Cashflow berechnen aus: ${revenue} ${expenses}`, cost: 0.009 },
  { prompt: `Risiken in ${extractedData} identifizieren`, cost: 0.027 },
  { prompt: `Empfehlungen basierend auf ${analysis} generieren`, cost: 0.036 }
];
// Gesamtkosten: ~0,11 €, Qualität: Höher (jeder Schritt spezialisiert)

// Redundante Leerzeichen und Formatierung entfernen
function compressText(text) {
  return text
    .replace(/\s+/g, ' ')           // Leerzeichen zusammenfassen
    .replace(/\n{3,}/g, '\n\n')      // Neue Zeilen begrenzen
    .replace(/\[\s+/g, '[')          // Klammern normalisieren
    .replace(/\s+\]/g, ']')
    .trim();
}

// Häufige Muster abkürzen
const abbreviations = {
  'Künstliche Intelligenz': 'KI',
  'Maschinelles Lernen': 'ML',
  'Natürliche Sprachverarbeitung': 'NLP',
  'Kundenbeziehungsmanagement': 'CRM'
};

function abbreviateText(text) {
  let result = text;
  for (const [full, abbr] of Object.entries(abbreviations)) {
    result = result.replace(new RegExp(full, 'gi'), abbr);
  }
  return result;
}

// Typische Einsparungen: 20-40% Token-Reduktion

// Statt vollständiger Dokumente
function extractRelevantContext(fullDocument, query) {
  // Einbettungsähnlichkeit verwenden, um relevante Abschnitte zu finden
  const sections = chunkDocument(fullDocument);
  const queryEmbedding = embed(query);
  
  const relevantSections = sections
    .map(section => ({
      ...section,
      similarity: cosineSimilarity(queryEmbedding, section.embedding)
    }))
    .filter(s => s.similarity > 0.7)
    .sort((a, b) => b.similarity - a.similarity)
    .slice(0, 3); // Top 3 relevanteste
  
  return relevantSections.map(s => s.content).join('\n\n');
}

// Regeln vor teurem KI-Aufruf prüfen
function preFilterRequest(request) {
  // Einfache Pattern-Matching für häufige Antworten
  const rules = [
    {
      pattern: /^(hallo|hi|hey)\b/i,
      response: "Hallo! Wie kann ich Ihnen heute helfen?"
    },
    {
      pattern: /^(danke|vielen dank)\b/i,
      response: "Gern geschehen! Kann ich Ihnen noch bei etwas anderem helfen?"
    },
    {
      pattern: /(öffnungszeiten|geschäftszeiten)/i,
      response: "Unsere Geschäftszeiten sind Montag bis Freitag, 9-18 Uhr MEZ."
    }
  ];
  
  for (const rule of rules) {
    if (rule.pattern.test(request)) {
      return { matched: true, response: rule.response };
    }
  }
  
  return { matched: false };
}

// Verwendung
const filter = preFilterRequest(userMessage);
if (filter.matched) {
  return filter.response; // Kosten: 0 €
}
// Weiter zu KI-Modell... // Kosten: 0,009-0,09 €