RAG-kosten optimaliseren

Kostenstructuur van RAG

Een RAG-systeem maakt kosten op twee momenten.

Indexeringskosten (eenmalig plus incrementeel):

• Embedding van alle document-chunks.
• Opslag in een vectordatabase.

Query-kosten (per gebruikersvraag):

• Embedding van de gebruikersvraag.
• Optioneel: LLM-aanroepen voor query-expansie en reranking.
• LLM-aanroep voor het genereren van het antwoord.

Bij een actief systeem domineren de query-kosten. De embedding-aanroep per query is relatief goedkoop. De LLM-aanroep voor generatie is verreweg de grootste post.

Semantische caching

De meest effectieve kostenreductie is herhalende vragen uit de cache beantwoorden in plaats van de volledige pipeline draaien.

class CostOptimizedRAG {
  private cache: SemanticCache;
  private cacheHits = 0;
  private cacheMisses = 0;

  async query(question: string): Promise<string> {
    const embedding = await this.embedWithCost(question);
    const cached = await this.cache.get(question, embedding);

    if (cached) {
      this.cacheHits++;
      return cached;
    }

    this.cacheMisses++;
    const answer = await this.fullRAGPipeline(question, embedding);
    this.cache.set(question, embedding, answer, 7200);
    return answer;
  }

  get cacheHitRate(): number {
    const total = this.cacheHits + this.cacheMisses;
    return total > 0 ? this.cacheHits / total : 0;
  }
}

Een cache-hit-rate van 30 tot 50 procent is realistisch voor systemen met herhalende vragen. Dat kan de kosten ongeveer halveren.

Tiered model-selectie

Gebruik goedkopere modellen voor eenvoudige queries en duurdere modellen alleen waar dat echt nodig is.

async function tieredQuery(question: string, context: string): Promise<string> {
  const complexity = await classifyQuestionComplexity(question);

  const modelConfig = {
    simple: { model: "claude-haiku-4-5", max_tokens: 512 },
    medium: { model: "claude-haiku-4-5", max_tokens: 1024 },
    complex: { model: "claude-opus-4-7", max_tokens: 2048 },
  }[complexity];

  const response = await anthropic.messages.create({
    ...modelConfig,
    system: RAG_SYSTEM_PROMPT,
    messages: [{ role: "user", content: `Context:
${context}

Vraag: ${question}` }],
  });
  return response.content[0].type === "text" ? response.content[0].text : "";
}

async function classifyQuestionComplexity(question: string): Promise<"simple" | "medium" | "complex"> {
  if (question.length < 50 && !question.includes("vergelijk") && !question.includes("analyseer")) {
    return "simple";
  }
  if (question.includes("vergelijk") || question.includes("voor- en nadelen") || question.includes("wanneer")) {
    return "complex";
  }
  return "medium";
}

Op prijspeil juni 2026 is Claude Haiku 4.5 (ongeveer $1,00 input en $5,00 output per 1M tokens) circa vijf keer goedkoper dan Claude Opus 4.7 (ongeveer $5,00 input en $25,00 output per 1M tokens). In de praktijk kan een meerderheid van de queries prima door Haiku worden afgehandeld, dus reserveer Opus voor de complexe gevallen.

Embedding-kosten reduceren

async function batchEmbedWithDeduplication(texts: string[]): Promise<Map<string, number[]>> {
  const unique = new Set(texts);
  const toEmbed = Array.from(unique);

  const embeddings = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: toEmbed,
  });

  const embeddingMap = new Map<string, number[]>();
  toEmbed.forEach((text, i) => {
    embeddingMap.set(text, embeddings.data[i].embedding);
  });

  return embeddingMap;
}

Gebruik text-embedding-3-small ($0,02 per 1M tokens) in plaats van text-embedding-3-large ($0,13 per 1M tokens) als het kwaliteitsverschil voor jouw data acceptabel is. Dat scheelt ongeveer 85 procent in embedding-kosten. Toets dit met je RAGAS-scores voordat je het in productie zet. Met de batch-API liggen beide tarieven nog eens de helft lager.

Context-lengte reduceren

Minder tokens betekent lagere kosten. Stuur alleen de meest relevante chunks mee en kap de lengte af.

function buildMinimalContext(
  docs: { content: string; score: number }[],
  question: string,
  maxTokens = 2000
): string {
  const sorted = [...docs].sort((a, b) => b.score - a.score).slice(0, 3);

  const parts = sorted.map(doc => {
    const words = doc.content.split(/\s+/);
    const maxWords = Math.floor(maxTokens / 3 / 1.3);
    return words.slice(0, maxWords).join(" ");
  });

  return parts.join("

");
}

Kostenmonitoring

Houd per query bij wat je verbruikt, zodat je optimalisaties kunt onderbouwen met cijfers.

const COSTS = {
  "text-embedding-3-small": 0.02 / 1_000_000,
  "text-embedding-3-large": 0.13 / 1_000_000,
  "claude-haiku-4-5-input": 1.0 / 1_000_000,
  "claude-haiku-4-5-output": 5.0 / 1_000_000,
  "claude-opus-4-7-input": 5.0 / 1_000_000,
  "claude-opus-4-7-output": 25.0 / 1_000_000,
};

function estimateQueryCost(
  questionTokens: number,
  contextTokens: number,
  responseTokens: number,
  model: string
): number {
  const embeddingCost = questionTokens * COSTS["text-embedding-3-small"];
  const inputCost = (questionTokens + contextTokens) * COSTS[`${model}-input`];
  const outputCost = responseTokens * COSTS[`${model}-output`];
  return embeddingCost + inputCost + outputCost;
}

De getallen hierboven zijn een momentopname (juni 2026). Werk de tarieven bij vanuit de officiele prijspagina van je provider, zodat je monitoring blijft kloppen.