Jeremylongshore Claude Code Plugins Plus Skills Mistral Cost Tuning

Mistral AI Cost Tuning

Overview

Optimize Mistral AI costs through model selection, token management, caching, batch inference, and budget monitoring. Mistral offers the best price-performance in the market with models from $0.1/M tokens (Ministral/Small) to $0.5/M tokens (Large).

Prerequisites

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

Pricing Reference (as of 2025)

Always check docs.mistral.ai/deployment/laplateforme/pricing for current rates.

Instructions

Step 1: Cost Calculator

const PRICING: Record<string, { input: number; output: number }> = {
  'ministral-latest':      { input: 0.10, output: 0.10 },
  'mistral-small-latest':  { input: 0.10, output: 0.30 },
  'codestral-latest':      { input: 0.30, output: 0.90 },
  'mistral-large-latest':  { input: 0.50, output: 1.50 },
  'pixtral-large-latest':  { input: 2.00, output: 6.00 },
  'mistral-embed':         { input: 0.10, output: 0 },
};

function calculateCost(
  model: string,
  inputTokens: number,
  outputTokens: number,
  isBatch = false,
): number {
  const p = PRICING[model] ?? PRICING['mistral-small-latest'];
  const multiplier = isBatch ? 0.5 : 1.0;
  return ((inputTokens / 1e6) * p.input + (outputTokens / 1e6) * p.output) * multiplier;
}

// Example: 100K requests/month, avg 500 in + 200 out tokens
const monthlySmall = calculateCost('mistral-small-latest', 50_000_000, 20_000_000);
const monthlyLarge = calculateCost('mistral-large-latest', 50_000_000, 20_000_000);
console.log(`Small: $${monthlySmall.toFixed(2)}/month`);  // $11.00
console.log(`Large: $${monthlyLarge.toFixed(2)}/month`);  // $55.00

Step 2: Smart Model Router

type TaskComplexity = 'trivial' | 'simple' | 'moderate' | 'complex';

function selectModel(complexity: TaskComplexity): string {
  switch (complexity) {
    case 'trivial':  return 'ministral-latest';       // $0.10/M — yes/no, extract, format
    case 'simple':   return 'mistral-small-latest';   // $0.10/M — classify, summarize, Q&A
    case 'moderate': return 'codestral-latest';       // $0.30/M — code gen, moderate reasoning
    case 'complex':  return 'mistral-large-latest';   // $0.50/M — multi-step reasoning, analysis
  }
}

// Auto-detect complexity by prompt characteristics
function estimateComplexity(prompt: string): TaskComplexity {
  const tokens = Math.ceil(prompt.length / 4);
  if (tokens < 50) return 'trivial';
  if (tokens < 200) return 'simple';
  if (prompt.includes('code') || prompt.includes('analyze')) return 'moderate';
  return 'complex';
}

Step 3: Token Budget Manager

class BudgetManager {
  private dailyBudgetUsd: number;
  private monthlyBudgetUsd: number;
  private dailySpend = 0;
  private monthlySpend = 0;
  private lastResetDay = new Date().getDate();

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

  canAfford(model: string, estimatedInputTokens: number, estimatedOutputTokens: number): boolean {
    const cost = calculateCost(model, estimatedInputTokens, estimatedOutputTokens);
    this.maybeResetDaily();
    return this.dailySpend + cost <= this.dailyBudgetUsd
        && this.monthlySpend + cost <= this.monthlyBudgetUsd;
  }

  recordSpend(model: string, usage: { promptTokens: number; completionTokens: number }): void {
    const cost = calculateCost(model, usage.promptTokens, usage.completionTokens);
    this.dailySpend += cost;
    this.monthlySpend += cost;
    this.checkAlerts();
  }

  private checkAlerts(): void {
    const monthPct = (this.monthlySpend / this.monthlyBudgetUsd) * 100;
    if (monthPct > 90) console.error(`BUDGET CRITICAL: ${monthPct.toFixed(1)}% of monthly budget`);
    else if (monthPct > 80) console.warn(`Budget warning: ${monthPct.toFixed(1)}% of monthly budget`);
  }

  private maybeResetDaily(): void {
    const today = new Date().getDate();
    if (today !== this.lastResetDay) {
      this.dailySpend = 0;
      this.lastResetDay = today;
    }
  }

  report() {
    return {
      daily: { spent: this.dailySpend, budget: this.dailyBudgetUsd },
      monthly: { spent: this.monthlySpend, budget: this.monthlyBudgetUsd },
    };
  }
}

Step 4: Prompt Optimization

// Reduce tokens = reduce cost directly
function optimizeForCost(systemPrompt: string): string {
  // Remove filler words
  return systemPrompt
    .replace(/please\s+/gi, '')
    .replace(/I would like you to\s+/gi, '')
    .replace(/\s+/g, ' ')
    .trim();
}

// Before: "I would like you to please provide a comprehensive and detailed explanation of how REST APIs work." (~25 tokens)
// After: "Explain REST APIs concisely." (~6 tokens, 76% reduction)

// Set maxTokens to prevent runaway output
const response = await client.chat.complete({
  model: 'mistral-small-latest',
  messages,
  maxTokens: 200, // Cap output — prevents 4000-token essays
});

Step 5: Batch API for Bulk Workloads

// Batch API = 50% cost reduction for non-realtime processing
// Instead of 100K individual API calls at $11/month (small)
// Use batch: $5.50/month for the same work

// Supported endpoints:
// /v1/chat/completions, /v1/embeddings, /v1/fim/completions,
// /v1/moderations, /v1/ocr, /v1/classifications

// See mistral-webhooks-events for implementation details

Step 6: Usage Tracking SQL

CREATE TABLE mistral_usage (
  id SERIAL PRIMARY KEY,
  model VARCHAR(50) NOT NULL,
  input_tokens INTEGER NOT NULL,
  output_tokens INTEGER NOT NULL,
  cost_usd DECIMAL(10, 6) NOT NULL,
  is_batch BOOLEAN DEFAULT FALSE,
  endpoint VARCHAR(50),
  user_id VARCHAR(50),
  created_at TIMESTAMP DEFAULT NOW()
);

-- Daily cost report
SELECT
  DATE(created_at) AS day,
  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, 5 DESC;

-- Highest-cost users
SELECT user_id, SUM(cost_usd) AS cost, COUNT(*) AS requests
FROM mistral_usage
WHERE created_at >= DATE_TRUNC('month', NOW())
GROUP BY 1 ORDER BY 2 DESC LIMIT 10;

Cost Reduction Strategies

Error Handling

Resources

• Mistral Pricing
• Mistral Console
• Batch Inference

Output

• Cost calculator with current pricing
• Smart model router by task complexity
• Token budget manager with alerts
• Prompt optimization patterns
• Usage tracking SQL schema

Converted and distributed by TomeVault — claim your Tome and manage your conversions.