n8n AI Cost Optimization: Token Management and Model Routing

// Upstream filter node in n8n
const request = $input.first().json;
const text = request.message;
 
// Kill obvious spam patterns without LLM
if (/^(http|ftp):\/\//.test(text)) {
  return { classification: "url", handled: true };
}
 
if (/^\d{3}-\d{3}-\d{4}$/.test(text)) {
  return { classification: "phone", handled: true };
}
 
if (/@[a-z0-9.]+\.[a-z]{2,}$/.test(text)) {
  return { classification: "email", handled: true };
}
 
// Only send non-obvious cases to LLM
return {
  classification: "needs_llm",
  handled: false,
  text: text,
};

const request = $input.first().json;
const tokens = Math.ceil(request.content.length / 4); // Rough estimate
 
if (tokens < 50) {
  return {
    route: "cheap",
    model: "gpt-3.5-turbo",
    reason: "Very short input, doesn't need reasoning",
  };
}
 
if (tokens < 200) {
  return {
    route: "standard",
    model: "gpt-4-turbo",
    reason: "Moderate complexity",
  };
}
 
return {
  route: "expensive",
  model: "claude-3-opus",
  reason: "Complex analysis needed",
};

const request = $input.first().json;
const md5 = require("crypto").createHash("md5");
const hash = md5.update(request.query).digest("hex");
 
// Check cache
const cached = await n8n.itemCached(hash);
 
if (cached) {
  return {
    source: "cache",
    response: cached.response,
    cached_at: cached.timestamp,
  };
}
 
return {
  source: "new_request",
  hash: hash,
  query: request.query,
};

// Instead of prose, use structured instructions
const compressedPrompt = `You are a customer service AI for TechCorp.
 
RULES:
- Be polite, professional, simple language
- Max 100 words per response
- Escalate complex issues to humans
- Ask for customer name at start
- No pricing discussions without approval
 
PRODUCTS: {
  "A": "Analytics suite",
  "B": "Automation tool",
  "C": "CRM system",
  "D": "API platform"
}`;
 
// This is ~300 tokens instead of 1,200
return {
  compressed_tokens: 300,
  original_tokens: 1200,
  savings_percent: 75,
};

const request = $input.first().json;
const userType = request.userType; // "customer", "support", "admin"
 
// Base prompt - always sent (200 tokens)
const basePrompt = `You are a helpful AI assistant.`;
 
// Type-specific additions (injected only when needed)
const typeSpecificPrompts = {
  customer: "You help customers with products and billing.",
  support: "You help resolve technical issues.",
  admin: "You help manage accounts and settings.",
};
 
// Only inject relevant context
const finalPrompt =
  userType in typeSpecificPrompts
    ? basePrompt + typeSpecificPrompts[userType]
    : basePrompt;
 
return { prompt: finalPrompt };

// Don't do this - 500 tokens of examples
const bloatedExamples = `
Example 1: User says "I have an issue with Product A"
Response: Thank you for reaching out about Product A...
 
Example 2: User says "How much does Product B cost?"
Response: I appreciate your interest in Product B...
 
Example 3: User says "I need help with integration"
Response: I'd be happy to help with integration...
 
[... 10 more examples ...]
`;
 
// Do this instead - 150 tokens of strategic examples
const optimizedExamples = `
EXAMPLES:
Q: "I have an issue with Product A"
A: "I'm here to help. Can you describe the specific problem?"
 
Q: "How much does Product B cost?"
A: "I can't discuss pricing, but I can connect you with sales."
`;
 
return { examples: optimizedExamples };

const request = $input.first().json;
const text = request.input;
 
// Complexity scoring function
function scoreComplexity(text) {
  let score = 0;
 
  // Length signal
  const length = text.split(" ").length;
  if (length > 500) score += 3;
  else if (length > 200) score += 2;
  else if (length > 50) score += 1;
 
  // Reasoning signal - look for question patterns
  const reasoningPatterns = /why|how|analyze|compare|evaluate|impact/gi;
  score += (text.match(reasoningPatterns) || []).length;
 
  // Context signal - look for domain-specific terms
  const technicalTerms = /algorithm|architecture|integration|optimization/gi;
  score += (text.match(technicalTerms) || []).length * 0.5;
 
  return score;
}
 
const complexity = scoreComplexity(text);
 
// Route based on complexity
let model, cost;
if (complexity < 2) {
  model = "gpt-3.5-turbo";
  cost = 0.0005;
} else if (complexity < 5) {
  model = "gpt-4-turbo";
  cost = 0.01;
} else {
  model = "claude-3-opus";
  cost = 0.015;
}
 
return {
  model: model,
  complexity_score: complexity,
  estimated_cost: cost,
};

// n8n workflow: Trigger that accumulates requests
const batchWindow = 60000; // 60 seconds
const batchSize = 100; // Or until queue reaches 100
 
const queue = [];
const startTime = Date.now();
 
async function processBatch() {
  if (queue.length === 0) return;
 
  // Group similar requests
  const grouped = {};
  for (const item of queue) {
    const type = item.type;
    if (!grouped[type]) grouped[type] = [];
    grouped[type].push(item);
  }
 
  // Process each group with single LLM call
  for (const [type, items] of Object.entries(grouped)) {
    const combined = items.map((i) => `- ${i.text}`).join("\n");
 
    const prompt = `Classify these items:\n${combined}`;
 
    // Single API call for multiple items
    const response = await callLLM(prompt);
 
    // Distribute results back
    return {
      processed: items.length,
      cost_per_item: "1/100th of regular",
    };
  }
}

const requests = $input.all().json;
 
// Create deduplication map
const seen = new Map();
const deduped = [];
 
for (const req of requests) {
  const key = req.text; // or use hash for large text
 
  if (!seen.has(key)) {
    seen.set(key, []);
    deduped.push(req);
  }
 
  // Track which original indices map to this deduped item
  seen.get(key).push(req.index);
}
 
return {
  original_count: requests.length,
  deduplicated_count: deduped.length,
  duplicates_removed: requests.length - deduped.length,
  efficiency_gain: `${Math.round(((requests.length - deduped.length) / requests.length) * 100)}%`,
};

// Track cost per request type
const costLog = {
  timestamp: new Date().toISOString(),
  request_type: $input.first().json.type,
  model_used: $input.first().json.model,
  input_tokens: $input.first().json.usage.prompt_tokens,
  output_tokens: $input.first().json.usage.completion_tokens,
  total_tokens: $input.first().json.usage.total_tokens,
  cost_usd:
    ($input.first().json.usage.prompt_tokens * 0.0005 +
      $input.first().json.usage.completion_tokens * 0.0015) /
    1000,
};
 
// Store in cost tracking system (database, Airtable, etc)
return costLog;

// Daily cost summary
const costs = $input.all().json; // Load all cost logs
 
const summary = {
  total_cost: costs.reduce((sum, c) => sum + c.cost_usd, 0),
  by_type: {},
  by_model: {},
  expensive_requests: costs
    .sort((a, b) => b.cost_usd - a.cost_usd)
    .slice(0, 10),
};
 
for (const cost of costs) {
  if (!summary.by_type[cost.request_type])
    summary.by_type[cost.request_type] = 0;
  summary.by_type[cost.request_type] += cost.cost_usd;
 
  if (!summary.by_model[cost.model_used]) summary.by_model[cost.model_used] = 0;
  summary.by_model[cost.model_used] += cost.cost_usd;
}
 
return summary;

const costLog = $input.first().json;
const dailyBudget = 100; // $100/day
const hourlyBudget = dailyBudget / 24;
 
// Get today's spend so far
const todaysCosts = await getTodaysCosts(); // Query your cost DB
const todaySpend = todaysCosts.reduce((sum, c) => sum + c.cost_usd, 0);
const projectedDaily = (todaySpend / hoursElapsedToday) * 24;
 
// Get this hour's spend
const thisHoursCosts = await getLastHoursCosts();
const thisHourSpend = thisHoursCosts.reduce((sum, c) => sum + c.cost_usd, 0);
 
// Throttle if necessary
const shouldThrottle = thisHourSpend > hourlyBudget * 1.5;
 
return {
  current_spend: todaySpend,
  projected_daily: projectedDaily,
  budget_status: projectedDaily > dailyBudget ? "OVER" : "OK",
  throttle_enabled: shouldThrottle,
  recommendation: shouldThrottle
    ? "Reduce request rate by 50%"
    : "Normal operation",
};

// Before optimization
const beforeOptimization = {
  daily_requests: 50000,
  avg_tokens_per_request: 2500,
  total_daily_tokens: 50000 * 2500,
  daily_cost: (50000 * 2500 * 0.001) / 1000, // Assuming $0.001 per 1K tokens
  monthly_cost: ((50000 * 2500 * 0.001) / 1000) * 30,
};
 
// After optimization
const afterOptimization = {
  // Upstream filtering kills 40% of requests
  requests_reaching_llm: 50000 * 0.6,
  // Prompt optimization saves 60% of system prompt tokens
  tokens_per_request: 2500 * 0.4,
  // Model tiering saves 30% on average
  effective_rate: 0.001 * 0.7,
 
  total_daily_tokens: 50000 * 0.6 * (2500 * 0.4),
  daily_cost: (50000 * 0.6 * (2500 * 0.4) * 0.0007) / 1000,
  monthly_cost: ((50000 * 0.6 * (2500 * 0.4) * 0.0007) / 1000) * 30,
};
 
return {
  before_daily: beforeOptimization.daily_cost.toFixed(2),
  after_daily: afterOptimization.daily_cost.toFixed(2),
  monthly_savings: (
    beforeOptimization.monthly_cost - afterOptimization.monthly_cost
  ).toFixed(2),
  reduction_percent: (
    ((beforeOptimization.monthly_cost - afterOptimization.monthly_cost) /
      beforeOptimization.monthly_cost) *
    100
  ).toFixed(1),
};