RAGPerf: An End-to-End Benchmarking Framework for Retrieval-Augmented Generation Systems

Dit artikel introduceert RAGPerf, een open-source end-to-end benchmarkingframework dat modulaire RAG-pipelines analyseert door de prestaties en nauwkeurigheid van componenten zoals embedding, indexering en generatie te meten onder diverse realistische werklasten.

De kern

Stel je voor dat je een superintelligente robot hebt (een LLM of "Large Language Model") die alles weet over de wereld, maar die robot zijn geheugen is vastgezet in de tijd. Hij weet niet wat er gisteren is gebeurd, hij kent je eigen bedrijf niet, en hij kan geen geheimen van je familie onthullen.

Om deze robot nuttig te maken, geven we hem een bijbel van notities (een externe kennisbank) waar hij in kan kijken voordat hij antwoordt. Dit noemen we RAG (Retrieval-Augmented Generation). Het is alsof je de robot een bril geeft waarmee hij snel in een enorme bibliotheek kan bladeren om het juiste antwoord te vinden voordat hij praat.

Maar hier zit het probleem: Het bouwen van zo'n systeem is als het bouwen van een raceauto. Je hebt een motor (de robot), een navigatiesysteem (het zoeken in de bibliotheek), en een chauffeur (de robot die het antwoord formuleert). Als je auto te traag is, of als de chauffeur te lang zoekt in de bibliotheek, is je raceauto waardeloos.

De onderzoekers van deze paper hebben RAGPerf bedacht. Wat is dat? Het is een proefcircuit en een diagnose-app voor deze robotsystemen.

Hier is hoe RAGPerf werkt, vertaald naar alledaagse taal:

1. Het Proefcircuit (De Werklast Generator)

Stel je voor dat je een nieuwe supermarkt wilt testen. Je kunt niet alleen wachten tot er klanten komen. Je moet zelf een scenario creëren: "Laat 100 mensen tegelijk binnenvallen, laat 50 mensen nieuwe producten toevoegen aan de schappen, en laat 10 mensen oude producten weghalen."

RAGPerf doet precies dit voor robots. Het simuleert een drukke werkdag:

• Het laat duizenden vragen tegelijk binnenkomen.
• Het voegt nieuwe documenten toe (zoals een verslag van gisteren).
• Het verwijdert oude, verouderde informatie.
• Het doet dit met verschillende soorten "spullen": tekst, PDF's, audio-opnames en zelfs video's.

2. De Diagnose-app (Het Profileren)

Wanneer je raceauto op het circuit rijdt, wil je weten: Waar zit de rem vast? Is de motor te heet? Is de band te dun?

RAGPerf is die slimme diagnose-app. Het kijkt niet alleen naar of het antwoord goed is, maar hoe het systeem het antwoord vindt. Het meet:

• Snelheid: Hoe lang duurt het voordat de robot antwoordt?
• Geheugen: Hoeveel geheugen (RAM) en rekenkracht (GPU) gebruikt hij?
• Bottlenecks: Is het de robot die traag is, of is het de bibliotheek waar hij in zoekt?

3. De Bouwvakkers (De Modulele Opbouw)

Een RAG-systeem is als een fabriek met verschillende stations:

1. Inpakken: Het omzetten van documenten naar een taal die de robot begrijpt (Embedding).
2. Archiveren: Het opslaan in een slimme database (Indexing).
3. Zoeken: Het vinden van de juiste pagina's (Retrieval).
4. Sorteren: Het kiezen van de allerbeste pagina's (Reranking).
5. Schrijven: Het robotantwoord genereren (Generation).

RAGPerf laat je elk van deze stations apart testen. Je kunt zeggen: "Wat gebeurt er als ik een langzamere robot gebruik maar een snellere bibliotheek?" of "Wat als ik PDF's gebruik in plaats van tekst?" Het helpt je de perfecte balans te vinden tussen snelheid, kosten en kwaliteit.

Waarom is dit belangrijk?

Vroeger keken ontwikkelaars alleen naar het eindresultaat: "Kreeg de robot het juiste antwoord?"
Maar als de robot 10 seconden over dat antwoord doet, is het nutteloos voor een klant die direct antwoord wil. Of als het systeem 500 euro aan elektriciteit kost per vraag, is het te duur.

RAGPerf helpt ontwikkelaars om:

• Fouten te vinden: "Ah, onze PDF's worden te langzaam verwerkt!"
• Kosten te besparen: "We kunnen een kleinere robot gebruiken als we de zoekmethode verbeteren."
• Betrouwbaarheid te garanderen: "Zorgt het systeem dat het antwoord gebaseerd is op de feiten, of verzint de robot dingen?"

De Conclusie

Kortom, RAGPerf is de "testbaan" die ervoor zorgt dat jouw slimme AI-assistent niet alleen slim is, maar ook snel, goedkoop en betrouwbaar werkt in de echte wereld. Het maakt het mogelijk om te experimenteren zonder je hele systeem te laten crashen, zodat je de perfecte machine kunt bouwen voor jouw specifieke behoeften.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "RAGPerf: An End-to-End Benchmarking Framework for Retrieval-Augmented Generation Systems", vertaald en samengevat in het Nederlands.

1. Het Probleem

De opkomst van Large Language Models (LLMs) heeft de AI-landschap gerevolutioneerd, maar hun toepassing in domeinspecifieke scenario's (zoals juridisch, medisch of financieel) vereist vaak toegang tot externe kennisbases. Retrieval-Augmented Generation (RAG) lost dit op door externe kennis aan de generatie toe te voegen.

Echter, het optimaliseren en evalueren van RAG-systemen in productie is complex en tijdrovend vanwege:

• Complexiteit van de stack: Een RAG-pijplijn bestaat uit meerdere onderdelen (embedding, indexering, retrieval, reranking, generatie) die sterk met elkaar interageren.
• Gebrek aan end-to-end benchmarks: Bestaande benchmarks (zoals BEIR, RAGBench, AutoRAG) focussen voornamelijk op semantische kwaliteit (bijv. hallucinatiepercentages) of evalueren slechts losse componenten (zoals alleen vector databases). Ze missen inzicht in systeemprestaties (latentie, doorvoer, hardware-gebruik) en resource-contentie in een geïntegreerde omgeving.
• Moeilijkheid bij configuratie: Het is voor ontwikkelaars lastig om de optimale configuratie te kiezen voor verschillende datasets, embedding-modellen en vector databases zonder een gestructureerde, reproduceerbare testomgeving.

2. Methodologie: RAGPerf Framework

RAGPerf is een modulair, end-to-end benchmarking framework ontworpen om het volledige gedrag van RAG-pijplijnen te karakteriseren. Het framework is opgebouwd uit de volgende kerncomponenten:

• Modulaire Architectuur: De RAG-werkstroom wordt ontkoppeld in vijf losse modules: Embedding, Indexering, Retrieval, Reranking en Generatie. Elke module heeft een gestandaardiseerde interface (YAML-configuratie), waardoor gebruikers componenten (zoals verschillende vector databases of LLMs) eenvoudig kunnen uitwisselen.
• Workload Generator: Om realistische scenario's te simuleren, genereert RAGPerf een mix van operaties:
  • Query: Leesoperaties voor retrieval en generatie.
  • Insert/Update/Remove: Schrijfbewerkingen om de dynamiek van kennisbases na te bootsen.
  • Dynamische Ground Truth: Voor update-operaties gebruikt RAGPerf een LLM-generatiemodule om synthetische updates en bijbehorende vragen/antwoorden te creëren, zodat de nauwkeurigheid van de geüpdatete kennis kan worden gemeten.
  • Toegangspatronen: Ondersteuning voor Uniforme en Zipfian-verdelingen (hotspots) om verschillende toegangsgedragingen te simuleren.
• Ondersteunde Componenten:
  • Vector Databases: LanceDB, Milvus, Qdrant, Chroma, Elasticsearch.
  • Modellen: Ondersteuning voor diverse embedding-modellen, rerankers en generatiemodellen (o.a. Qwen, Llama, DeepSeek) en multimodale inputs (tekst, PDF, code, audio).
  • Profiling: Een onafhankelijke monitor verzamelt fijnmazige metrics (CPU/GPU-gebruik, geheugenfootprint, I/O-throughput) zonder de RAG-pijplijn te verstoren.
• Metingen:
  • Prestatiemetrics: End-to-end doorvoer, latentie, hardware-gebruik.
  • Kwaliteitsmetrics: Context recall, query-accuraatheid en feitelijke consistentie (geïntegreerd met het Ragas-framework).

3. Belangrijkste Bijdragen

1. Eerste End-to-End Systeembenchmark: RAGPerf is het eerste framework dat zowel de semantische kwaliteit als de systeemprestaties van een volledig geïntegreerde RAG-pijplijn evalueert, inclusief de interacties tussen componenten.
2. Realistische Dynamische Workloads: In tegenstelling tot statische benchmarks, ondersteunt RAGPerf continue updates (insert/update/delete) met geautomatiseerde validatie, wat essentieel is voor het begrijpen van prestatiedegrade door indexheropbouw en tijdelijke indices.
3. Fijnmazige Resource Profiling: Het framework biedt inzicht in waar de knelpunten liggen (bijv. CPU-bound retrieval vs. GPU-bound generatie) en hoe resource-contentie (bijv. GPU-geheugen tussen embedding en generatie) de prestaties beïnvloedt.
4. Open Source en Uitbreidbaar: De code is beschikbaar op GitHub en is ontworpen om eenvoudig nieuwe componenten en datasets toe te voegen.

4. Resultaten en Evaluatie

De auteurs hebben RAGPerf uitgebreid getest met diverse datasets (Wikipedia, ArXiv, GitHub-code, audio) en configuraties. De belangrijkste bevindingen zijn:

• Prestatieknelpunten:
  • Bij tekst-pijplijnen is de generatiestap (LLM) de dominante bottleneck (75-91% van de latentie), waardoor de keuze van de vector database minder impact heeft op de totale end-to-end latentie.
  • Bij multimodale pijplijnen (PDF/afbeeldingen) is formatconversie (bijv. OCR) en reranking vaak de grootste kostenpost.
• Resource Gebruik:
  • GPU-geheugen is de primaire hardware-beperking; het beperkt de batchgrootte en bepaalt of grote modellen volledig kunnen worden geladen.
  • Host-geheugen is kritiek voor vector-indexering. Onvoldoende RAM dwingt disk-based indexing af, wat de doorvoer drastisch verlaagt (tot 15% van het maximum).
  • CPU-gebruik piekt tijdens retrieval en indexbouw, maar is tijdens generatie laag.
• Impact van Updates:
  • Het gebruik van een tijdelijke "flat index" voor updates maakt nieuwe data direct zoekbaar (verbeterde recall), maar verhoogt de latentie naarmate de index groeit.
  • Schuine update-verdelingen (Zipfian) leiden tot lagere latentie-overhead dan uniforme updates omdat minder unieke entries in de tijdelijke index hoeven te worden bijgehouden.
• Configuratie Trade-offs:
  • Het vergroten van de batchgrootte verbetert de doorvoer tot een bepaald punt, maar grotere batches kunnen het GPU-geheugen voor KV-cache vullen, wat de latentie weer doet stijgen.
  • GPU-versnelde indices (zoals GPU_CAGRA) bieden slechts marginale prestatiewinsten ten opzichte van hun hoge geheugenvraag, waardoor het vaak beter is om GPU-geheugen te reserveren voor de LLM-generatie.
• Overhead: RAGPerf introduceert verwaarloosbare overhead (<0.26% CPU-gebruik en <0.11% extra latentie), wat het geschikt maakt voor productie-achtige evaluaties.

5. Betekenis en Conclusie

RAGPerf vult een cruciale lacune in het RAG-ecosysteem door ontwikkelaars en onderzoekers een instrument te bieden om data-gedreven beslissingen te nemen over systeemconfiguratie. Het stelt organisaties in staat om:

• De juiste balans te vinden tussen systeem-efficiëntie en outputkwaliteit.
• Knelpunten te identificeren voordat een systeem in productie gaat.
• De impact van hardware-beperkingen (CPU, RAM, GPU) op de RAG-prestaties te kwantificeren.

Door de modulariteit en de ondersteuning voor realistische, dynamische werklasten, maakt RAGPerf de ontwikkeling van robuuste en schaalbare RAG-toepassingen voor complexe domeinen mogelijk.