Mistral Cost Tuning

Mistral AI Cost Tuning

Overview

Optimize Mistral AI costs through smart model selection, token management, and usage monitoring.

Prerequisites

• Access to Mistral AI console
• Understanding of current usage patterns
• Database for usage tracking (optional)
• Alerting system configured (optional)

Pricing Overview

Note: Prices subject to change. Check console.mistral.ai for current pricing.

Instructions

Step 1: Cost Estimation Calculator

interface TokenUsage {
  inputTokens: number;
  outputTokens: number;
}

interface CostEstimate {
  model: string;
  inputCost: number;
  outputCost: number;
  totalCost: number;
  currency: string;
}

const PRICING = {
  'mistral-small-latest': { input: 0.20, output: 0.60 },
  'mistral-large-latest': { input: 2.00, output: 6.00 },
  'mistral-embed': { input: 0.10, output: 0 },
} as const;

function estimateCost(model: keyof typeof PRICING, usage: TokenUsage): CostEstimate {
  const prices = PRICING[model];
  const inputCost = (usage.inputTokens / 1_000_000) * prices.input;
  const outputCost = (usage.outputTokens / 1_000_000) * prices.output;

  return {
    model,
    inputCost,
    outputCost,
    totalCost: inputCost + outputCost,
    currency: 'USD',
  };
}

// Usage
const cost = estimateCost('mistral-small-latest', {
  inputTokens: 500_000,
  outputTokens: 200_000,
});
console.log(`Estimated cost: $${cost.totalCost.toFixed(4)}`);
// Estimated cost: $0.2200

Step 2: Model Selection by Task

type TaskType = 'simple' | 'moderate' | 'complex' | 'embedding';

interface ModelRecommendation {
  model: string;
  reason: string;
  estimatedCostPer1000Requests: number;  # 1000ms = 1 second
}

function recommendModel(
  taskType: TaskType,
  avgInputTokens: number,
  avgOutputTokens: number
): ModelRecommendation {
  switch (taskType) {
    case 'simple':
      // Classification, extraction, simple Q&A
      return {
        model: 'mistral-small-latest',
        reason: 'Fast and cost-effective for simple tasks',
        estimatedCostPer1000Requests:
          (avgInputTokens * 0.20 + avgOutputTokens * 0.60) / 1000,  # 1 second in ms
      };

    case 'moderate':
      // Summarization, translation, basic coding
      return {
        model: 'mistral-small-latest',
        reason: 'Good balance of capability and cost',
        estimatedCostPer1000Requests:
          (avgInputTokens * 0.20 + avgOutputTokens * 0.60) / 1000,  # 1 second in ms
      };

    case 'complex':
      // Complex reasoning, code generation, analysis
      return {
        model: 'mistral-large-latest',
        reason: 'Required for complex tasks',
        estimatedCostPer1000Requests:
          (avgInputTokens * 2.00 + avgOutputTokens * 6.00) / 1000,  # 1 second in ms
      };

    case 'embedding':
      return {
        model: 'mistral-embed',
        reason: 'Specialized for embeddings',
        estimatedCostPer1000Requests: (avgInputTokens * 0.10) / 1000,  # 1 second in ms
      };
  }
}

// Usage
const rec = recommendModel('simple', 500, 200);  # 200: HTTP 500 Internal Server Error
console.log(`Recommended: ${rec.model} - $${rec.estimatedCostPer1000Requests.toFixed(4)}/1000 req`);  # 1 second in ms

Step 3: Token Budget Management

class TokenBudgetManager {
  private dailyBudget: number;
  private monthlyBudget: number;
  private dailyUsage: Map<string, number> = new Map();
  private monthlyUsage = 0;

  constructor(dailyBudget: number, monthlyBudget: number) {
    this.dailyBudget = dailyBudget;
    this.monthlyBudget = monthlyBudget;
  }

  recordUsage(model: string, tokens: number): void {
    const today = new Date().toISOString().split('T')[0];
    const key = `${today}:${model}`;

    const current = this.dailyUsage.get(key) || 0;
    this.dailyUsage.set(key, current + tokens);
    this.monthlyUsage += tokens;

    this.checkBudgetAlerts();
  }

  canMakeRequest(model: string, estimatedTokens: number): boolean {
    const today = new Date().toISOString().split('T')[0];
    const key = `${today}:${model}`;
    const todayUsage = this.dailyUsage.get(key) || 0;

    return (
      todayUsage + estimatedTokens <= this.dailyBudget &&
      this.monthlyUsage + estimatedTokens <= this.monthlyBudget
    );
  }

  private checkBudgetAlerts(): void {
    if (this.monthlyUsage > this.monthlyBudget * 0.8) {
      console.warn(`Budget alert: ${((this.monthlyUsage / this.monthlyBudget) * 100).toFixed(1)}% of monthly budget used`);
    }
  }

  getUsageReport(): { daily: Record<string, number>; monthly: number } {
    return {
      daily: Object.fromEntries(this.dailyUsage),
      monthly: this.monthlyUsage,
    };
  }
}

Step 4: Prompt Optimization

// Optimize prompts to reduce token usage
function optimizePrompt(prompt: string): string {
  return prompt
    .replace(/\s+/g, ' ')           // Remove extra whitespace
    .replace(/\n\s*\n/g, '\n')      // Remove blank lines
    .trim();
}

// Use system prompts efficiently
const EFFICIENT_SYSTEM_PROMPT = `
You are a helpful assistant. Be concise. Answer in 1-2 sentences when possible.
`.trim();

// Compare token counts
function countTokensEstimate(text: string): number {
  // Rough estimate: 1 token ≈ 4 characters
  return Math.ceil(text.length / 4);
}

// Example: Reduce prompt size
const originalPrompt = `
  I would like you to help me with the following task.
  Please provide a comprehensive and detailed explanation
  of how to implement a REST API in Node.js.
`;

const optimizedPrompt = `Explain implementing a REST API in Node.js. Be concise.`;

console.log(`Original: ~${countTokensEstimate(originalPrompt)} tokens`);
console.log(`Optimized: ~${countTokensEstimate(optimizedPrompt)} tokens`);
// Original: ~47 tokens
// Optimized: ~13 tokens (72% reduction)

Step 5: Caching for Cost Reduction

import crypto from 'crypto';
import { LRUCache } from 'lru-cache';

const responseCache = new LRUCache<string, { response: string; cost: number }>({
  max: 10000,  # 10000: 10 seconds in ms
  ttl: 24 * 60 * 60 * 1000, // 24 hours  # 1000: 1 second in ms
});

interface CachedResult {
  response: string;
  cached: boolean;
  cost: number;
  savedCost: number;
}

async function costAwareChat(
  client: Mistral,
  messages: any[],
  model: string
): Promise<CachedResult> {
  const cacheKey = crypto
    .createHash('sha256')
    .update(JSON.stringify({ messages, model }))
    .digest('hex');

  const cached = responseCache.get(cacheKey);
  if (cached) {
    return {
      response: cached.response,
      cached: true,
      cost: 0,
      savedCost: cached.cost,
    };
  }

  const response = await client.chat.complete({ model, messages });
  const content = response.choices?.[0]?.message?.content ?? '';

  const cost = estimateCost(model as any, {
    inputTokens: response.usage?.promptTokens || 0,
    outputTokens: response.usage?.completionTokens || 0,
  }).totalCost;

  responseCache.set(cacheKey, { response: content, cost });

  return {
    response: content,
    cached: false,
    cost,
    savedCost: 0,
  };
}

Step 6: Usage Dashboard Query

-- Track usage in your database
CREATE TABLE mistral_usage (
  id SERIAL PRIMARY KEY,
  model VARCHAR(50),
  input_tokens INTEGER,
  output_tokens INTEGER,
  cost_usd DECIMAL(10, 6),
  user_id VARCHAR(50),
  created_at TIMESTAMP DEFAULT NOW()
);

-- Daily cost report
SELECT
  DATE(created_at) as date,
  model,
  SUM(input_tokens) as total_input,
  SUM(output_tokens) as total_output,
  SUM(cost_usd) as total_cost
FROM mistral_usage
WHERE created_at >= NOW() - INTERVAL '30 days'
GROUP BY 1, 2
ORDER BY 1 DESC, 3 DESC;

-- User cost breakdown
SELECT
  user_id,
  SUM(cost_usd) as total_cost,
  COUNT(*) as request_count
FROM mistral_usage
WHERE created_at >= DATE_TRUNC('month', NOW())
GROUP BY 1
ORDER BY 2 DESC
LIMIT 10;

Output

• Optimized model selection
• Token budget management
• Usage monitoring implemented
• Cost reduction strategies applied

Cost Reduction Strategies

Error Handling

Examples

Quick Cost Check

// Estimate monthly cost
const monthlyRequests = 100_000;
const avgInputTokens = 500;  # HTTP 500 Internal Server Error
const avgOutputTokens = 200;  # HTTP 200 OK

const smallCost = estimateCost('mistral-small-latest', {
  inputTokens: avgInputTokens * monthlyRequests,
  outputTokens: avgOutputTokens * monthlyRequests,
});

const largeCost = estimateCost('mistral-large-latest', {
  inputTokens: avgInputTokens * monthlyRequests,
  outputTokens: avgOutputTokens * monthlyRequests,
});

console.log(`Small model: $${smallCost.totalCost.toFixed(2)}/month`);
console.log(`Large model: $${largeCost.totalCost.toFixed(2)}/month`);
// Small model: $22.00/month
// Large model: $220.00/month

Resources

• Mistral AI Pricing
• Mistral AI Console

Next Steps

For architecture patterns, see mistral-reference-architecture.