LLM-toepassingen in productie (RAG + vectordatabase + caching) · Les

Caching integreren in een RAG-pipeline

Implementeer cachinglagen in uw RAG-applicatie om eerder gegenereerde antwoorden of opgehaalde contexten op te slaan en terug te halen.

Les 3 van 411 stappen

Caching integreren in een RAG-pipeline is een gratis LLM-toepassingen in productie (RAG + vectordatabase + caching)-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject LLM-toepassingen in productie (RAG + vectordatabase + caching). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus LLM-toepassingen in productie (RAG + vectordatabase + caching) bevat in totaal 4 lessen.

Introductie tot RAG-caching

Welkom bij de laatste les over caching! We hebben geleerd waarom caching essentieel is en verschillende strategieën verkend.

Nu gaan we praktisch aan de slag. In deze les richten we ons op het rechtstreeks integreren van caching in je RAG-pijplijn om de prestaties te verbeteren en kosten te verlagen.

Waar cache je in RAG?

In een RAG-pijplijn zijn er twee belangrijke punten waarop caching aanzienlijke voordelen biedt:

Ophaalstap: De documenten cachen die door je vectordatabase zijn opgehaald.
Generatiestap: Het uiteindelijke antwoord cachen dat door het Large Language Model (LLM) is gegenereerd.

Elk punt pakt andere knelpunten aan.

Opgehaalde context cachen

Wanneer een gebruiker een vraag stelt, bevraagt je RAG-systeem eerst een vectordatabase om relevante documenten (de ‘context’) te vinden.

Als dezelfde vraag (of een zeer vergelijkbare vraag) opnieuw wordt gesteld, waarom zou je de vectordatabase dan opnieuw bevragen? Door de opgehaalde documenten te cachen, kun je aanzienlijk tijd en middelen besparen.

Sleutel: De zoekopdracht van de gebruiker (of de embedding ervan).
Waarde: Lijst met opgehaalde documenten/stukken.

LLM-antwoorden cachen

Na het ophalen van de context stuurt je RAG-systeem de zoekopdracht van de gebruiker en de context naar een LLM om een definitief antwoord te genereren.

LLM-aanroepen zijn vaak het duurste en traagste onderdeel. Het cachen van het uiteindelijk gegenereerde antwoord voor een bepaalde combinatie van zoekopdracht en context is zeer effectief.

Sleutel: Tupel van (zoekopdracht van gebruiker, opgehaalde context).
Waarde: Door de LLM gegenereerd antwoord.

Eenvoudige cache in het geheugen

Voor de demonstratie gebruiken we een eenvoudig Python-dict als cache in het geheugen. In praktijksituaties zou je speciale cachingbibliotheken of externe services zoals Redis gebruiken.

Het basisidee is:

Controleer of er een resultaat voor de huidige invoer in de cache staat.
Zo ja (cachetreffer), geef het resultaat uit de cache onmiddellijk terug.
Zo nee (cachemisser), bereken het resultaat, sla het op in de cache en geef het vervolgens terug.

Python: LLM-aanroepen cachen

Hier zie je een eenvoudig Python-voorbeeld dat laat zien hoe je resultaten van een gesimuleerde LLM-aanroep kunt cachen. Let erop dat de ‘werkelijke LLM-aanroep’ slechts één keer plaatsvindt voor dezelfde invoer.

import time

# Simulate an expensive LLM call
def mock_llm_call(prompt, context):
    print(f"DEBUG: Making actual LLM call for: '{prompt}'")
    time.sleep(1) # Simulate network delay
    return f"Response to '{prompt}' with context: {context}"

# Simple in-memory cache
llm_cache = {}

def get_llm_response_cached(prompt, context):
    cache_key = (prompt, context) # Use a tuple as the key
    if cache_key in llm_cache:
        print("DEBUG: Cache hit!")
        return llm_cache[cache_key]
    else:
        print("DEBUG: Cache miss. Calling LLM...")
        response = mock_llm_call(prompt, context)
        llm_cache[cache_key] = response
        return response

# Main execution
if __name__ == "__main__":
    print("--- First call ---")
    response1 = get_llm_response_cached(
        "What is RAG?", 
        "RAG combines retrieval with generation."
    )
    print(f"Result 1: {response1}\n")

    print("--- Second call (same query/context) ---")
    response2 = get_llm_response_cached(
        "What is RAG?", 
        "RAG combines retrieval with generation."
    )
    print(f"Result 2: {response2}\n")

    print("--- Third call (different query) ---")
    response3 = get_llm_response_cached(
        "How does RAG work?", 
        "RAG uses a retriever and a generator."
    )
    print(f"Result 3: {response3}\n")

De uitvoer van de cache begrijpen

Voer de code uit en bekijk de uitvoer:

Bij de eerste aanroep zie je "DEBUG: Making actual LLM call...".
Bij de tweede aanroep met identieke invoer zie je "DEBUG: Cache hit!" en vindt er geen werkelijke LLM-aanroep plaats. Dit bespaart tijd en kosten!
Bij de derde aanroep met andere invoer is er sprake van een cachemisser en wordt er opnieuw een LLM-aanroep uitgevoerd.

Dit laat het basismechanisme voor het cachen van LLM-antwoorden zien.

Cache integreren in het ophalen

Je kunt een vergelijkbaar cachepatroon toepassen op de ophaalstap. Controleer voordat je je vectordatabase bevraagt of de query van de gebruiker (of de embedding ervan) al eerder is gebruikt.

Als er een resultaat in de cache staat (de lijst met relevante documenten), sla je de zoekopdracht in de vectordatabase over en ga je rechtstreeks door naar de aanroep van het LLM met de context uit de cache.

Hierdoor wordt je vectordatabase minder belast en verloopt het ophalen sneller.

Cache-invalidering en TTL

Hoewel caching krachtig is, kunnen gegevens in de cache verouderd raken. Voor dynamische informatie heb je een strategie nodig om de cache te wissen of bij te werken.

Time-To-Live (TTL): Verwijder items automatisch na een bepaalde periode.
Minst recent gebruikt (LRU): Verwijder de oudste items wanneer de cache vol is.
Gebeurtenisgestuurd: Invalideer items in de cache wanneer de brongegevens veranderen.

Welke strategie het meest geschikt is, hangt af van de eisen die je aan de actualiteit van je gegevens stelt.

Controle van cache-integratie

Je hebt geleerd hoe je caching op verschillende punten in een RAG-verwerkingspijplijn integreert. Test nu je begrip!

Beantwoord dit in de interactieve les

Samenvatting: caching in RAG

Goed gedaan! In deze les hebben we theorie in de praktijk gebracht.

We hebben belangrijke integratiepunten voor caching in een RAG-verwerkingspijplijn geïdentificeerd: ophalen en genereren.
We hebben onderzocht hoe het cachen van opgehaalde contexten en LLM-antwoorden de prestaties aanzienlijk kan verbeteren en operationele kosten kan verlagen.
Je hebt een praktisch Python-voorbeeld gezien van de implementatie van een eenvoudige cache in het geheugen voor LLM-aanroepen.
We hebben kort strategieën voor cache-invalidering besproken, zoals TTL.

Je bent nu klaar om caching te gaan integreren in je eigen RAG-toepassingen!

Gratis beginnen

Leer LLM-toepassingen in productie (RAG + vectordatabase + caching) met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Caching integreren in een RAG-pipeline” gratis?

Ja — de volledige tekst van “Caching integreren in een RAG-pipeline” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus LLM-toepassingen in productie (RAG + vectordatabase + caching) wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus LLM-toepassingen in productie (RAG + vectordatabase + caching) bevat in totaal 4 lessen.

Wat leer ik in “Caching integreren in een RAG-pipeline”?

Implementeer cachinglagen in uw RAG-applicatie om eerder gegenereerde antwoorden of opgehaalde contexten op te slaan en terug te halen. Je oefent met LLM-toepassingen in productie (RAG + vectordatabase + caching) door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met LLM-toepassingen in productie (RAG + vectordatabase + caching) te beginnen?

Ervaring vooraf is niet nodig. LLM-toepassingen in productie (RAG + vectordatabase + caching) op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Caching integreren in een RAG-pipeline”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over LLM-toepassingen in productie (RAG + vectordatabase + caching)?

Ja. Elke les over LLM-toepassingen in productie (RAG + vectordatabase + caching) bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Het belang van caching van LLM-aanroepen
Cachingstrategieën in het geheugen en extern
Caching integreren in een RAG-pipeline
Semantische caching voor LLM-apps

← Terug naar LLM-toepassingen in productie (RAG + vectordatabase + caching)