Cachingstrategieën in het geheugen en extern
Vergelijk verschillende cachingbenaderingen, waaronder eenvoudige caches in het geheugen en robuuste externe oplossingen zoals Redis.
Cachingstrategieën in het geheugen en extern is een gratis LLM-toepassingen in productie (RAG + vectordatabase + caching)-les op CoddyKit. Dit is les 2 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 cachingstrategieën
Caching is essentieel om LLM-toepassingen sneller en kostenefficiënter te maken. Maar niet alle caches zijn hetzelfde!
In deze les bespreken we twee belangrijke strategieën: caching in het geheugen en externe caching. Elke strategie heeft unieke voordelen en nadelen, afhankelijk van de behoeften van je toepassing.
Caching in het geheugen: de basis
Caching in het geheugen betekent dat je gegevens rechtstreeks opslaat in het Random Access Memory (RAM) van je toepassing. Zie het als een tijdelijk notitieblok dat je app bij de hand houdt.
- Snelheid: Gegevens ophalen uit RAM gaat bijzonder snel.
- Eenvoud: Vaak eenvoudig in te stellen met ingebouwde taalfuncties, zoals woordenboeken of hashmaps.
- Geen externe afhankelijkheden: Je app hoeft geen verbinding te maken met een andere service.
Eenvoudige cache in het geheugen (Python)
Hier zie je een eenvoudig Python-voorbeeld waarin een woordenboek wordt gebruikt om een cache in het geheugen voor LLM-antwoorden na te bootsen. Let erop dat volgende verzoeken voor dezelfde prompt de cache gebruiken.
cache = {}
def get_llm_response(prompt):
if prompt in cache:
print("Cache hit!")
return cache[prompt]
else:
print("Cache miss, calling LLM...")
# Simulate a slow LLM call
response = f"LLM response for: {prompt}"
cache[prompt] = response
return response
if __name__ == "__main__":
print(get_llm_response("What is RAG?"))
print(get_llm_response("What is RAG?"))
print(get_llm_response("Tell me a joke."))
print(get_llm_response("Tell me a joke."))Beperkingen van caches in het geheugen
Hoewel ze snel en eenvoudig zijn, hebben caches in het geheugen belangrijke nadelen voor LLM-toepassingen in productie:
- Vl vluchtige gegevens: Alle gegevens in de cache gaan verloren als je toepassing opnieuw wordt gestart of crasht.
- Beperkte schaalbaarheid: Elke instantie van je toepassing heeft een eigen, afzonderlijke cache. Als je meerdere servers gebruikt, delen die geen gegevens, waardoor werk dubbel wordt uitgevoerd.
- Geheugengebruik: Grote caches kunnen veel RAM verbruiken en zo mogelijk de algehele prestaties van je toepassing beïnvloeden.
Externe caching introduceren
Om de beperkingen van caches in het geheugen te overwinnen, gebruiken we externe cachingoplossingen. Deze slaan gegevens buiten je toepassing op, meestal op een speciale server of in een speciale service.
Daardoor kunnen meerdere instanties van je toepassing dezelfde gegevens in de cache openen en delen. Dat maakt deze oplossing ideaal voor schaalbare, gedistribueerde systemen.
Redis: een populaire externe cache
Redis (Remote Dictionary Server) is een populaire opensourcegegevensopslag in het geheugen. Redis wordt veel gebruikt als cache, database en berichtenmakelaar vanwege de hoge prestaties en veelzijdige gegevensstructuren.
Het is een uitstekende keuze voor externe caching in LLM-toepassingen, omdat het bijzonder snel is en ontworpen is voor toegang via een netwerk.
Voordelen van externe caching
Externe caches zoals Redis bieden verschillende belangrijke voordelen:
- Gedistribueerd: Meerdere instanties van een toepassing kunnen één consistente cache delen.
- Persistent: Gegevens kunnen zo worden geconfigureerd dat ze op schijf worden opgeslagen en behouden blijven na het opnieuw starten van de toepassing of cacheserver.
- Schaalbaar: De cache kan onafhankelijk van je toepassing worden opgeschaald en grote hoeveelheden gegevens en verzoeken verwerken.
- Uitgebreide functies: Redis biedt geavanceerde functies, zoals Time-To-Live (TTL) voor het automatisch verlopen van cache-items en verschillende gegevensstructuren.
Redis gebruiken voor LLM-caching (Python)
Zo kun je vanuit Python communiceren met Redis met behulp van de bibliotheek redis-py. Deze code gaat ervan uit dat er lokaal een Redis-server draait op localhost:6379.
Het voorbeeld laat zien hoe je een sleutel instelt met een vervaltijd (TTL) en deze vervolgens ophaalt.
import redis
import json
# Connect to Redis. Ensure a Redis server is running!
# e.g., on Docker: docker run --name my-redis -p 6379:6379 -d redis
try:
r = redis.Redis(host='localhost', port=6379, db=0)
r.ping() # Check connection
print("Connected to Redis successfully!")
except redis.exceptions.ConnectionError as e:
print(f"Could not connect to Redis: {e}")
print("Please ensure a Redis server is running on localhost:6379")
r = None # Set r to None if connection fails
def get_llm_response_from_redis(prompt):
if r is None:
return {"error": "Redis not connected, cannot cache."}
cache_key = f"llm_response:{prompt}"
cached_data = r.get(cache_key)
if cached_data:
print("Redis Cache hit!")
return json.loads(cached_data.decode('utf-8'))
else:
print("Redis Cache miss, calling LLM...")
# Simulate LLM call and create a response structure
response_data = {"text": f"LLM response for: {prompt}", "source": "LLM"}
# Cache the response for 3600 seconds (1 hour)
r.setex(cache_key, 3600, json.dumps(response_data))
return response_data
if __name__ == "__main__":
print(get_llm_response_from_redis("What is the capital of France?"))
print(get_llm_response_from_redis("What is the capital of France?"))
print(get_llm_response_from_redis("Who invented the light bulb?"))
print(get_llm_response_from_redis("Who invented the light bulb?"))De juiste cachingstrategie kiezen
Je keuze voor een cachingstrategie hangt af van de vereisten van je toepassing:
- Gebruik caches in het geheugen als:
Je toepassing als één instantie draait, gegevensverlies bij opnieuw starten acceptabel is of je zeer kleine, tijdelijke gegevensverzamelingen cacht. - Gebruik externe caches (bijvoorbeeld Redis) als:
Je gedistribueerde caching over meerdere instanties van je toepassing nodig hebt, het bewaren van gegevens cruciaal is, je gegevensverzameling groot is of je geavanceerde cachingfuncties en schaalbaarheid nodig hebt.
Voor de meeste LLM-toepassingen in productie is externe caching de robuuste keuze.
Kennistoets over cachingstrategieën
Test je begrip van cachingstrategieën!
Samenvatting: cache je kennis
We hebben de twee belangrijkste cachingstrategieën voor LLM-toepassingen verkend:
- Caches in het geheugen zijn snel en eenvoudig, maar beperkt tot één instantie van een toepassing en verliezen hun gegevens bij opnieuw starten.
- Externe caches zoals Redis bieden persistentie, gedeeld gebruik tussen systemen en onafhankelijke schaalbaarheid. Daardoor zijn ze ideaal voor robuuste LLM-systemen in productie.
De juiste strategie hangt af van de schaal van je toepassing, je behoeften op het gebied van gegevenspersistentie en de operationele complexiteit.
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
Veelgestelde vragen
Is de les “Cachingstrategieën in het geheugen en extern” gratis?
Ja — de volledige tekst van “Cachingstrategieën in het geheugen en extern” 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 “Cachingstrategieën in het geheugen en extern”?
Vergelijk verschillende cachingbenaderingen, waaronder eenvoudige caches in het geheugen en robuuste externe oplossingen zoals Redis. 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 2 van 4.
Hoe lang duurt de les “Cachingstrategieën in het geheugen en extern”?
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