Memory — Short-Term / Long-Term / Hybride

La mémoire donne continuité, personnalisation et traçabilité aux systèmes LLM. Short-Term = fenêtre de contexte ; Long-Term = souvenirs persistants ; Hybride = orchestration des deux.

Résumé incrémental Index vectoriel (RAG) Profil & préférences TTL, consentement, RLS Token Efficiency

Support

Fenêtre de contexte du modèle (ex. 8k/32k/200k tokens).
Tout ce qui sort de la fenêtre est « oublié » naturellement.

Techniques principales

Buffer brut : n derniers tours (simple, mais coûteux en tokens).
Buffer résumé : résumer périodiquement (facts, décisions, TODO).
Sélection dynamique : ne garder que les passages pertinents (similarité sémantique, règles).

Paramétrages recommandés

Contexte LLM	Buffer brut	Résumé	Compression
≤ 8k	4–6 tours	toutes les 4–6 itérations	agressive (≈50–70%)
32k	8–12 tours	toutes les 6–10	modérée (≈30–50%)
≥ 100k	12–20 tours	toutes les 10–15	faible (≈20–30%)

Prompts de résumé (extraits)

Résume les tours récents en 5 puces :
                                - Décisions prises
                                - Faits vérifiables (avec dates)
                                - Actions en cours / TODO
                                - Risques / blocages
                                - Préférences explicites de l'utilisateur

Format : JSON compact ({"facts":[],"decisions":[],"todo":[]}) pour réutilisation.

# Résumé STM toutes les 8 interactions (ex.)
                    if turns % 8 == 0:
                    summary = llm.summarize(dialogue_tail, style="facts+decisions+actions")
                    stm_summary.append({"t": now(), "summary": summary})

Stockage persistant

Vecteurs + RAG : échanges « importants » → encodés → index vectoriel.
Graphes (Neo4j/RDF) : entités & relations (Guillaume → fondateur → Ideo-Lab).
Journaux : événements horodatés + résumés hebdo/mensuels.

Bénéfice : continuité multi-sessions, personnalisation profonde.

Métadonnées & schéma

{
                            "user_id":"u123", "type":"preference|project|fact",
                            "text":"Préfère FR, travaille sur 'IA Matrix'",
                            "tags":["lang:fr","project:matrix"], "confidence":0.82,
                            "updated_at":"2025-09-09T10:00Z", "ttl":"90d", "hash":"sha256:..."
                            }

Filtres par user_id, type, tags, date, permissions (RLS).

Rétention & cycle de vie

Catégorie	TTL	Action à l’expiration
Préférences	365 j	Revalidation puis reset
Projets	180 j	Archivage → résumé mensuel
Facts temporaires	90 j	Suppression

Combinaison : STM = historique immédiat ; LTM = souvenirs distants. Ex. « Comme je te l’ai dit hier… » ⇒ STM + LTM se complètent.

Score de rappel (fusion)

# score mémoire (0..1)
                            score = 0.55*similarity + 0.25*recency + 0.10*authority + 0.10*role_boost
                            # role_boost : user > assistant > system (selon cas d'usage)
                            # recency = exp(-Δt / τ), τ typ. 7–30 jours

Budget contexte

Typique : 1/3 STM, 1/3 LTM, 1/3 génération.
Éviter la redondance : clusteriser les souvenirs proches & n’en garder qu’1.

KPIs

Coherence Score (0..1) : continuité de la réponse vs historique.
Recall mémoire : % souvenirs corrects rappelés.
Token Efficiency = tokens utiles / tokens totaux.
CSAT / NPS (ressenti continuité).

A/B & diff-tests

Datasets multi-sessions (Q→ souvenirs attendus).
Comparer variantes : STM-only vs Hybride ; différents top-k.
Tests d’oubli (expiration) & d’accès croisés (RLS).

Observabilité

Histogrammes scores (sim/recency), P95 latence.
Alertes : fuite mémoire, rappel incorrect, dépassement budget.

# Recall mémoire@10 (ex.)
                    ok = 0
                    for s in scenarios:
                    r = chat_with_memory(s).ask("Rappelle mon projet ?")
                    ok += int("IA Matrix" in r.text)
                    recall_at_10 = ok / len(scenarios)

# Exemple hybride (LangChain-like, très condensé)
                        class MemoryMgr:
                        def __init__(self, llm, vecdb, user_id):
                        self.llm, self.db, self.uid = llm, vecdb, user_id
                        self.tail, self.summ = [], []         # STM
                        self.ttl_days = 90

                        def add_turn(self, role, text):
                        self.tail.append({"t": now(), "role": role, "text": text})
                        # Fenêtre glissante
                        while tokens(self.tail) > 1800: self.tail.pop(0)
                        # Résumé incrémental
                        if tokens(self.tail) > 1200:
                        s = self.llm.summarize(self.tail, style="facts|decisions|todo")
                        self.summ.append({"t": now(), "summary": s})
                        self.tail = [{"t": now(), "role":"system", "text": f"Résumé: {s}"}]

                        def persist_if_important(self, turn):
                        if is_fact(turn.text) or is_preference(turn.text):
                        vec = embed(turn.text)
                        meta = {"user_id": self.uid, "text": turn.text, "updated_at": now(),
                        "ttl": f"{self.ttl_days}d", "hash": sha256(turn.text)}
                        self.db.upsert(vec, meta, id=meta["hash"])

                        def recall(self, query, k=8):
                        qv = embed(query)
                        res = self.db.search(qv, k=k, filter={"user_id": self.uid})
                        # score = α*sim + β*recency + γ*role_boost
                        for r in res:
                        r.score = 0.6*r.sim + 0.3*recency(r.updated_at) + 0.1*role_boost(r)
                        return sorted(res, key=lambda x:x.score, reverse=True)

                        def build_context(self, query):
                        ltm = self.recall(query)[:8]
                        ctx = compress(self.tail + self.summ + ltm, budget_tokens=3000)
                        return ctx

                        # Boucle
                        mm = MemoryMgr(llm, vecdb, user_id="u123")
                        mm.add_turn("user", "Je bosse sur le projet IA Matrix.")
                        mm.persist_if_important(mm.tail[-1])
                        ctx = mm.build_context("Statut du projet ?")
                        answer = llm.generate(prompt_with(ctx, "Statut du projet ?"))

LangChain (raccourci)

from langchain.memory import ConversationSummaryBufferMemory
                            mem = ConversationSummaryBufferMemory(llm=llm, max_token_limit=2000)
                            # retriever = ContextualCompressionRetriever(base_retriever, compressor=LLMChainFilter(llm))

Schéma de décision (Mermaid)

flowchart TD A[New turn] --> B{Tokens > seuil ?} B -- oui --> C[Résumé incrémental] B -- non --> D[Append à STM] A --> E{Fait/Préférence ?} E -- oui --> F[Vector DB Upsert] E -- non --> G[No-op]

Memory — Short-Term / Long-Term / Hybride

Mémoire court terme (STM)

Mémoire long terme (LTM)

Mémoire hybride

Stratégies clés

Qualité & Évaluation

Recette d’implémentation (Python)

Sécurité & Conformité

Cas d’usage & Exemples