Asynchronous Verified Semantic Caching for Tiered LLM Architectures

Het paper introduceert Krites, een asynchroon cachingbeleid dat een LLM-rechter gebruikt om statische antwoorden te verifiëren en dynamisch te promoten, waardoor de dekking van goedkope, vooraf gecureerde antwoorden aanzienlijk wordt vergroot zonder de latentie op het kritieke pad te beïnvloeden.

De kern

Stel je voor dat je een zeer slimme, maar dure en trage robot hebt die vragen beantwoordt. Dit is een Groot Taalmodel (LLM), zoals die achter AI-assistenten zit. Elke keer als iemand een vraag stelt, moet deze robot hard nadenken, wat veel geld kost en tijd kost.

Om dit sneller en goedkoper te maken, gebruiken bedrijven een cache (een soort slimme notitieblok). Als iemand een vraag stelt die eerder is gesteld, kijken ze eerst in hun notitieblok. Als het antwoord daar al staat, hoeft de robot niet te werken. Dat is snel en goedkoop.

Maar er is een probleem: mensen vragen dingen op duizenden verschillende manieren.

• Vraag A: "Kan mijn hond honing eten?"
• Vraag B: "Is het veilig voor een hond om honing te krijgen?"

Voor een computer zijn dit twee heel verschillende zinnen. Een traditioneel notitieblok kijkt alleen of de woorden exact hetzelfde zijn of heel erg op elkaar lijken. Als ze niet voldoende op elkaar lijken, denkt de computer: "Nee, dit is nieuw," en laat hij de dure robot aan het werk. Hierdoor gaat er veel geld en tijd verloren aan vragen die eigenlijk al beantwoord zijn.

Het probleem: De "Grijze Zone"

De huidige systemen hebben een strenge regel: "Alleen als de vragen 95% op elkaar lijken, mag je het oude antwoord gebruiken."

• Als je de regel strenger maakt (bijv. 99%), mis je veel kansen om geld te besparen.
• Als je de regel losser maakt (bijv. 80%), geef je soms het verkeerde antwoord (bijvoorbeeld: "Kan mijn hond honing?" vs "Kan mijn hond vergif eten?" – dat lijkt op elkaar, maar het antwoord is totaal anders).

Dit is de grijze zone: vragen die op elkaar lijken, maar waar de computer niet zeker van is of het antwoord mag worden gedeeld.

De oplossing: Krites (De "Asynchrone Keurmeester")

De auteurs van dit papier hebben Krites bedacht. Het is een slimme manier om die grijze zone veilig te gebruiken zonder de snelheid te vertragen.

Stel je Krites voor als een super-snel restaurant met twee niveaus:

1. De Snelle Kassa (De Kritische Weg):
   Als een klant binnenkomt, kijkt de kassamedewerker direct in het standaard notitieblok.

   • Is de vraag exact hetzelfde? -> Direct antwoord. (Snel!)
   • Is de vraag heel anders? -> Naar de chef-kok (de dure robot). (Snel, want de beslissing is direct genomen).
   • Belangrijk: De klant wacht nooit op de chef-kok voor een beslissing. De kassa doet haar werk zoals altijd.

2. De Achtertuin (De Asynchrone Verificatie):
   Wat gebeurt er als de kassamedewerker twijfelt? De vraag lijkt op een oude vraag, maar niet helemaal genoeg om het oude antwoord te geven.

   • In het oude systeem zou de klant nu naar de chef-kok worden gestuurd.
   • Bij Krites zegt de kassamedewerker: "Ik geef je het antwoord van de chef-kok (omdat ik niet mag wachten), maar ik stuur een stille melding naar een Keurmeester in de achtertuin."

3. De Keurmeester (De LLM-Judge):
   Deze Keurmeester is een andere, zeer slimme AI die niet in de weg staat van de klant. Hij kijkt rustig naar de twee vragen in de achtertuin: "Is het antwoord voor 'Kan mijn hond honing?' ook goed voor 'Is het veilig voor een hond om honing te krijgen?'?"

   • Als de Keurmeester zegt: "Ja, dat is hetzelfde!", dan schrijft hij dit nieuwe antwoord in het notitieblok van de kassa, direct onder de nieuwe vraag.
   • De volgende keer dat iemand die vraag stelt, ziet de kassamedewerker het nieuwe antwoord en geeft het direct. De dure chef-kok hoeft niet meer te werken.

Waarom is dit geweldig?

• Geen vertraging: De klant hoeft nooit te wachten op de Keurmeester. De snelheid blijft hetzelfde als het oude systeem.
• Meer besparing: Het systeem leert van zijn twijfels. Vroeger werden twijfelachtige vragen als "nieuw" behandeld en duur betaald. Nu worden ze na een korte check in de achtertuin toch als "oud" herkend.
• Veiligheid: Omdat de Keurmeester heel streng is (hij kijkt naar de betekenis, niet alleen naar de woorden), geven ze geen verkeerde antwoorden. Ze vangen de "grijze zone" veilig op.

Het resultaat

In tests hebben ze laten zien dat Krites het aantal keren dat ze een bestaand, veilig antwoord kunnen geven, met wel 3 tot 4 keer kunnen verhogen. Ze besparen enorm veel geld en tijd, zonder dat de gebruiker merkt dat er iets anders gebeurt.

Kortom: Krites is als een slimme conciërge die niet wacht tot de manager (de dure robot) een beslissing neemt, maar die achteraf een expert laat checken of een snelle beslissing wel klopte. Als dat zo is, past hij de regels aan voor de volgende keer. Zo wordt alles sneller, goedkoper en slimmer.

Technische samenvatting

Titel: Asynchrone Geverifieerde Semantische Caching voor Gelaagde LLM-Architecturen

1. Het Probleem

Grote Taalmodellen (LLMs) zijn essentieel geworden voor zoekopdrachten, assistenten en agentische workflows. De inzet ervan wordt beperkt door een drietal systemische uitdagingen: kosten, latentie en kwaliteit.

• Huidige aanpak: Productiesystemen gebruiken vaak een gelaagde (tiered) architectuur met een statische cache (offline, handmatig gecureerde antwoorden) en een dynamische cache (online gegenereerd).
• De beperking: Beide lagen worden doorgaans beheerd door één enkele gelijkwaardigheidsthesold (similarity threshold) op basis van vector-embeddings.
  • Een conservatieve drempel mist veilige hergebruiksmogelijkheden (lage hit-rate).
  • Een agressieve drempel riskeert het leveren van semantisch onjuiste antwoorden (hoge foutkans).
• De "Grijze Zone": Er bestaat een overlap in de verdeling van gelijkwaardigheid tussen correcte en incorrecte hits. Paraphrases kunnen onder een conservatieve drempel vallen, terwijl ze semantisch identiek zijn. Bestaande systemen kunnen deze "grijze zone" niet veilig exploiteren zonder de latentie of betrouwbaarheid te schaden.

2. Methodologie: Krites

Het paper introduceert Krites, een nieuw caching-beleid dat de statische en dynamische lagen koppelt via een asynchrone verificatielus.

• Kernprincipe: Krites verandert niets aan het kritieke pad (serving path). Het gedraagt zich exact als een standaard beleid met statische drempels voor de gebruiker.

• Het Mechanisme:

  1. Grey-Zone Detectie: Wanneer een verzoek de statische cache mist, maar de dichtstbijzijnde statische neighbor in een "grijze zone" valt (d.w.z. de gelijkenis ligt tussen een lagere drempel $\sigma_{min}$ en de statische drempel $\tau_{static}$), wordt er geen directe afwijzing gegeven.
  2. Asynchrone Verificatie: In plaats van de gebruiker te laten wachten, wordt er een achtergrondtaak gepland. Een gespecialiseerde LLM-judge (een tweede LLM) controleert of het gecureerde statische antwoord acceptabel is voor de nieuwe prompt.
  3. Auxiliary Overwrite (Promotie): Als de judge het antwoord goedkeurt, wordt het statische antwoord asynchroon in de dynamische cache geschreven (een "overwrite" of "upsert") onder de nieuwe sleutel.
  4. Resultaat: De dynamische cache fungeert nu als een mutabele pointer-laag over de statische antwoorden. Volgende keren dat dezelfde vraag (of een parafrase) wordt gesteld, wordt het hoogwaardige statische antwoord direct uit de dynamische cache opgehaald, zonder dat de LLM-judge opnieuw hoeft te worden aangeroepen.

• Scheiding van Taken:

  • Serving Path: Blijft ongewijzigd (geen extra latentie voor de huidige gebruiker).
  • Verification Path: Loopt volledig asynchroon op een achtergrondpool van workers.

3. Belangrijkste Bijdragen

1. Decoupling van Serving en Verificatie: Krites lost het fundamentele compromis op tussen latentie en precisie door verificatie uit het kritieke pad te halen.
2. Dynamische Promotie van Statische Antwoorden: Het introduceert een mechanisme om gecureerde, offline geverifieerde antwoorden veilig te "promoveren" naar de dynamische cache, waardoor de bereik van de statische cache groeit zonder de kwaliteit te verlagen.
3. Architectuur voor Gelaagde Systemen: Het biedt een praktische oplossing voor bestaande productie-architecturen (statisch + dynamisch) zonder de bestaande drempellogica te moeten herschrijven.

4. Resultaten

De auteurs hebben Krites geëvalueerd via trace-gedreven simulaties op twee benchmarks (SemCacheLMArena voor conversatie en SemCacheSearchQueries voor zoekopdrachten), vergeleken met een geoptimaliseerde statische drempel-baseline (GPTCache-stijl).

• Toename in Statische Origin Hits: Krites verhoogt het percentage verzoeken dat wordt bediend met gecureerde statische antwoorden (directe hits + geverifieerde promoties) aanzienlijk:
  • +136% voor conversational workloads (SemCacheLMArena).
  • +290% voor zoekopdrachten (SemCacheSearchQueries).
• Latentie en Fouten:
  • De kritieke pad-latentie blijft ongewijzigd (geen vertraging voor de gebruiker).
  • De foutenratio blijft gelijk aan die van de baseline, omdat de initiële beslissing nog steeds op de veilige statische drempel is gebaseerd.
• Validatie van de Judge: Een test met een echte LLM-judge (Claude Opus 4.5) toonde een overeenstemming van 99/100 met menselijke labels in de grijze zone, wat aantoont dat de verificatie in de praktijk haalbaar is.

5. Betekenis en Impact

• Kostenefficiëntie: Door meer verzoeken te bedienen met goedkope, offline gecureerde antwoorden in plaats van dure online LLM-inferenties, dalen de operationele kosten aanzienlijk.
• Betrouwbaarheid en Veiligheid: In kritieke domeinen (zoals medische assistenten of zakelijke zoekopdrachten) is het leveren van een offline geverifieerd "gouden" antwoord superieur aan een online gegenereerd antwoord. Krites maakt het veilig mogelijk om deze "gouden" antwoorden breder in te zetten, zelfs bij variaties in de vraagstelling.
• Schaalbaarheid: Het systeem schaalbaar door de verificatie-aspecten uit te besteden aan achtergrondworkers, waardoor het geen bottleneck vormt voor de interactieve ervaring.

Conclusie: Krites biedt een elegante systemische oplossing die de beperkingen van statische drempels in semantische caching omzeilt. Het maximaliseert het hergebruik van hoogwaardige, gecureerde inhoud zonder de snelheid of veiligheid van de huidige gebruikerssessies te compromitteren.