// Cost-optimized routing decision
const routingPrompt = `Classify this incoming request into one of these categories:
- SIMPLE: Basic data extraction, formatting
- STANDARD: Multi-step processing, moderate reasoning
- COMPLEX: Deep analysis, creative generation, coding

Request: {{$json.input}}

Respond with only: SIMPLE, STANDARD, or COMPLEX`;

// Cost: ~$0.0001 per classification
// Saves: $0.01-$0.10 per request by avoiding over-provisioning

{
  "name": "AI Model Router",
  "nodes": [
    {
      "parameters": {
        "model": "gpt-4o-mini",
        "options": {
          "temperature": 0.1,
          "maxTokens": 50
        },
        "prompt": "=Classify request complexity:\n{{$json.input}}\n\nResponse: SIMPLE|STANDARD|COMPLEX"
      },
      "type": "n8n-nodes-base.openAi",
      "typeVersion": 1.6
    },
    {
      "parameters": {
        "rules": {
          "rules": [
            {
              "value": "SIMPLE",
              "output": 0
            },
            {
              "value": "STANDARD",
              "output": 1
            },
            {
              "value": "COMPLEX",
              "output": 2
            }
          ]
        }
      },
      "type": "n8n-nodes-base.switch",
      "typeVersion": 1
    }
  ]
}

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

// Efficient: Process 100 items per batch
const batches = chunk(items, 100);
for (const batch of batches) {
  const combinedPrompt = batch.map((item, i) => 
    `[Item ${i + 1}] ${item.prompt}`
  ).join('\n\n---\n\n');
  
  const result = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{ 
      role: "user", 
      content: `Process these ${batch.length} items:\n\n${combinedPrompt}` 
    }]
  });
  
  // Parse and distribute results
  const responses = parseBatchResponse(result.choices[0].message.content);
}

{
  "name": "Batch Processor",
  "nodes": [
    {
      "parameters": {
        "batchSize": 100,
        "options": {}
      },
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 3
    },
    {
      "parameters": {
        "jsCode": "// Combine batch items into single prompt\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
    }
  ]
}

// Check cache before API call
const similarRequests = await vectorDB.similaritySearch({
  query: currentRequest,
  threshold: 0.95, // High similarity threshold
  limit: 1
});

if (similarRequests.length > 0) {
  // Cache hit: Return cached response
  return similarRequests[0].response;
}

// Cache miss: Call API and store result
const response = await callLLM(currentRequest);
await vectorDB.store({
  request: currentRequest,
  response: response,
  embedding: await generateEmbedding(currentRequest)
});

{
  "name": "Smart Cache Layer",
  "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": "high,critical"
          }
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2
    }
  ]
}

# MEMORY.md - Optimized Structure

## Critical Context (Always Retained)
- User preferences and core settings
- Active project definitions
- Security credentials (hashed)

## Working Memory (Summarized)
- Recent conversation history (last 10 exchanges)
- Current task context
- Pending action items

## Archived Memory (Vector Store)
- Historical conversations (summarized weekly)
- Completed projects (key outcomes only)
- Learned patterns and preferences

## Expiration Policy
- Working memory: 30 days
- Archived items: 90 days
- System logs: 7 days

// Pre-process context to minimize token usage
function optimizeContext(memory, maxTokens = 4000) {
  // Priority ranking for context retention
  const priority = [
    ...memory.critical,
    ...memory.working.slice(0, 5),
    ...summarizeOldMemory(memory.archived)
  ];
  
  // Truncate while preserving structure
  return truncateWithStructure(priority, maxTokens);
}

// Typical savings: 40-60% reduction in context tokens

# gateway.config.yaml
channels:
  # High-cost: Full AI capabilities
  email:
    model: gpt-4o
    memory: full
    reasoning: high
    
  # Medium-cost: Balanced capabilities
  slack:
    model: claude-3-5-sonnet
    memory: working
    reasoning: medium
    
  # Low-cost: Essential only
  telegram:
    model: gpt-4o-mini
    memory: minimal
    reasoning: low
    
  # Event-driven: Reactive only
  webhook:
    model: none  # Pre-filtered responses
    memory: none
    reasoning: none

// Use appropriate session targets for workload type
// Isolated sessions: Ideal for independent, one-off tasks
openclaw agent --message "Quick analysis" --session isolated

// Current session: Share context for related tasks
openclaw agent --message "Continue previous task" --session current

// Named sessions: Persistent context for ongoing projects
openclaw agent --message "Update project status" --session project:alpha

# Start Ollama with optimized models
ollama pull llama3.1:8b
ollama pull mistral:7b-instruct

# Configure OpenClaw to use local models
openclaw config set model.default.local llama3.1:8b
openclaw config set model.routing.threshold 0.85

async function routeToOptimalModel(request, complexity) {
  // Route simple requests to local models
  if (complexity === 'SIMPLE') {
    return await ollama.generate({
      model: 'llama3.1:8b',
      prompt: request
    });
  }
  
  // Route medium complexity with fallback
  if (complexity === 'STANDARD') {
    try {
      return await ollama.generate({
        model: 'mistral:7b-instruct',
        prompt: request
      });
    } catch {
      // Fallback to API on local model failure
      return await openai.chat.completions.create({
        model: 'gpt-4o-mini',
        messages: [{ role: 'user', content: request }]
      });
    }
  }
  
  // High complexity: Use best available API model
  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  # Scale based on workload
      
  n8n-main:
    image: n8nio/n8n:latest
    environment:
      - N8N_MODE=main
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - QUEUE_BULL_REDIS_HOST=redis

// Auto-scaling based on queue depth
const queueMetrics = await getQueueMetrics();

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

-- Optimize for workflow execution patterns
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';

-- Partition execution tables for large deployments
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);

-- Create monthly partitions
CREATE TABLE execution_entity_2026_04 
    PARTITION OF execution_entity_partitioned
    FOR VALUES FROM ('2026-04-01') TO ('2026-05-01');

// Use indexes for common query patterns
// Index on workflow_id and started_at for execution queries
CREATE INDEX CONCURRENTLY idx_execution_workflow_time 
ON execution_entity(workflow_id, started_at DESC);

// Partial index for active executions
CREATE INDEX CONCURRENTLY idx_execution_active 
ON execution_entity(id) 
WHERE finished = false;

// Token bucket algorithm for API protection
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;
    }
    
    // Wait for token availability
    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;
  }
}

// Usage
const openaiLimiter = new RateLimiter(100, 200); // 100 req/s burst to 200

// n8n execution hook for cost 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
      }
    });
  }
};

// Aggregate daily costs
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]);
}

# Custom metrics endpoint
- name: n8n_cost_total
  help: Total AI API costs per workflow
  type: counter
  labels: [workflow_id, model]

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

- name: n8n_cache_hit_ratio
  help: Cache hit ratio for LLM requests
  type: gauge
  labels: [cache_type]

// Essential metrics for optimization decisions
const dashboardMetrics = {
  // Cost efficiency
  costPerExecution: totalCost / totalExecutions,
  costPerTask: totalCost / totalTasksCompleted,
  modelCostDistribution: breakdownByModel,
  
  // Performance
  avgExecutionTime: totalDuration / totalExecutions,
  p95ExecutionTime: percentile(executionTimes, 95),
  errorRate: failedExecutions / totalExecutions,
  
  // Resource utilization
  queueDepth: currentQueueSize,
  workerUtilization: activeWorkers / totalWorkers,
  apiQuotaUsage: usedQuota / totalQuota
};

# Cost anomaly detection
- 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: "AI API costs doubled compared to yesterday"

- 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: "Execution failure rate above 10%"

// Instead of free-form response requiring parsing
const unstructuredPrompt = `Extract the meeting details from this text: ${text}`;
// Response: "The meeting is scheduled for tomorrow at 2pm in Conference Room A"
// Requires: Additional parsing step

// Use structured output
const structuredPrompt = `Extract meeting details from this text: ${text}

Respond ONLY in this JSON format:
{
  "date": "YYYY-MM-DD",
  "time": "HH:MM",
  "location": "string",
  "attendees": ["string"]
}`;
// Response: {"date": "2026-04-22", "time": "14:00", ...}
// Saves: Parsing step, reduced error handling, consistent format

// Instead of single expensive call
const complexPrompt = `Analyze this financial report and provide:
1. Revenue trends
2. Expense breakdown
3. Cash flow analysis
4. Risk assessment
5. Recommendations

Report: ${report}`;
// Cost: ~$0.10-0.20, Quality: Variable

// Break into structured steps
const steps = [
  { prompt: `Extract revenue data: ${report}`, cost: 0.02 },
  { prompt: `Extract expense data: ${report}`, cost: 0.02 },
  { prompt: `Calculate cash flow from: ${revenue} ${expenses}`, cost: 0.01 },
  { prompt: `Identify risks in: ${extractedData}`, cost: 0.03 },
  { prompt: `Generate recommendations based on: ${analysis}`, cost: 0.04 }
];
// Total cost: ~$0.12, Quality: Higher (specialized each step)

// Remove redundant whitespace and formatting
function compressText(text) {
  return text
    .replace(/\s+/g, ' ')           // Collapse whitespace
    .replace(/\n{3,}/g, '\n\n')      // Limit newlines
    .replace(/\[\s+/g, '[')          // Normalize brackets
    .replace(/\s+\]/g, ']')
    .trim();
}

// Abbreviate common patterns
const abbreviations = {
  'artificial intelligence': 'AI',
  'machine learning': 'ML',
  'natural language processing': 'NLP',
  'customer relationship management': '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;
}

// Typical savings: 20-40% token reduction

// Instead of including full documents
function extractRelevantContext(fullDocument, query) {
  // Use embedding similarity to find relevant sections
  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 most relevant
  
  return relevantSections.map(s => s.content).join('\n\n');
}

// Check rules before expensive AI call
function preFilterRequest(request) {
  // Simple pattern matching for common responses
  const rules = [
    {
      pattern: /^(hi|hello|hey)\b/i,
      response: "Hello! How can I assist you today?"
    },
    {
      pattern: /^(thank|thanks)\b/i,
      response: "You're welcome! Is there anything else I can help with?"
    },
    {
      pattern: /(business hours|open hours)/i,
      response: "Our business hours are Monday-Friday, 9AM-6PM EST."
    }
  ];
  
  for (const rule of rules) {
    if (rule.pattern.test(request)) {
      return { matched: true, response: rule.response };
    }
  }
  
  return { matched: false };
}

// Usage
const filter = preFilterRequest(userMessage);
if (filter.matched) {
  return filter.response; // Cost: $0
}
// Continue to AI model... // Cost: $0.01-0.10