Cache de reponses LLM

Un appel a GPT-4 coute entre 0.01 et 0.10 dollar et prend 1 a 10 secondes. Si 100 utilisateurs posent la meme question ("Comment installer Python ?"), ca fait 100 appels inutiles. La solution : mettre les reponses en cache. La premiere fois, tu appelles le LLM et tu stockes la reponse. Les fois suivantes, tu renvoies la reponse stockee sans appeler le LLM.

C'est exactement comme un cache navigateur : la premiere visite charge la page depuis le serveur, les suivantes utilisent la copie locale.

Le point cle : la cle du cache. Deux questions identiques doivent donner la meme cle. Mais "Comment installer Python?" et "comment installer python ?" sont-elles identiques ? Pour un cache efficace, il faut normaliser la question (minuscules, sans espaces superflus).

Tu vas creer une classe LLMCache avec :

__init__(self) : initialise un dictionnaire vide pour le cache et un compteur de hits/misses.

_normaliser(self, question) : normalise la question en minuscules et en supprimant les espaces en debut et fin.

consulter(self, question, fonction_llm) : verifie si la question normalisee est dans le cache. Si oui, incremente le compteur de hits et renvoie {"source": "cache", "reponse": reponse}. Si non, appelle fonction_llm(question), stocke le resultat, incremente le compteur de misses, et renvoie {"source": "llm", "reponse": reponse}.

stats(self) : renvoie {"hits": n, "misses": n, "taille": n} avec le nombre de hits, misses et d'entrees dans le cache.

Exemple :

cache = LLMCache()
def fake_llm(q): return f"Reponse a {q}"
cache.consulter("Bonjour", fake_llm) renvoie {"source": "llm", "reponse": "Reponse a Bonjour"}
cache.consulter("bonjour", fake_llm) renvoie {"source": "cache", "reponse": "Reponse a Bonjour"}

Tests (4/5)

Premier appel va au LLM

c = LLMCache()
def llm(q): return 'R:' + q
r = c.consulter('Bonjour', llm)
assert r['source'] == 'llm'
assert r['reponse'] == 'R:Bonjour'

Deuxieme appel vient du cache

c = LLMCache()
compteur = {'n': 0}
def llm(q):
    compteur['n'] += 1
    return 'R'
c.consulter('Test', llm)
c.consulter('test', llm)
assert compteur['n'] == 1, 'Le LLM ne doit etre appele qu une fois pour la meme question'

Normalisation des questions

c = LLMCache()
def llm(q): return 'OK'
c.consulter('  Hello  ', llm)
r = c.consulter('hello', llm)
assert r['source'] == 'cache'

Stats correctes

c = LLMCache()
def llm(q): return 'R'
c.consulter('A', llm)
c.consulter('B', llm)
c.consulter('a', llm)
s = c.stats()
assert s == {'hits': 1, 'misses': 2, 'taille': 2}

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

class LLMCache:
    def __init__(self):
        self.cache = {}
        self.hits = 0
        self.misses = 0

    def _normaliser(self, question):
        return question.strip().lower()

    def consulter(self, question, fonction_llm):
        cle = self._normaliser(question)
        if cle in self.cache:
            self.hits += 1
            return {"source": "cache", "reponse": self.cache[cle]}
        reponse = fonction_llm(question)
        self.cache[cle] = reponse
        self.misses += 1
        return {"source": "llm", "reponse": reponse}

    def stats(self):
        return {"hits": self.hits, "misses": self.misses, "taille": len(self.cache)}

← Rate limiter pour API Evaluer une reponse LLM →

solution.py

Bravo!

Cache de reponses LLM

Tests (4/5)

Indices (3 disponibles)

Solution officielle