Mémoire vectorielle pour agents IA : guide

Introduction

La fenêtre de contexte d'un LLM — même à 200k tokens — ne suffit pas comme mémoire agent. Elle est volatile, coûteuse en tokens et incapable de retrouver une information par son sens plutôt que par sa position. La mémoire vectorielle résout ce problème : elle convertit les informations en vecteurs numériques (embeddings) et les retrouve par similarité sémantique, pas par correspondance exacte de mots-clés. Ce guide explique le fonctionnement, compare les 4 outils principaux et vous montre comment implémenter une mémoire vectorielle dans un agent Python. Pour les concepts généraux de mémoire agent, consultez notre guide dédié.

Résumé rapide

Outil	Type	Coût	Cas d'usage idéal
Pinecone	Cloud managé	Gratuit < 100k vecteurs	Production cloud, zéro ops
Chroma	Local / cloud	Gratuit (open source)	Prototypage, dev local
Qdrant	Self-hosted / cloud	Gratuit (open source)	Production self-hosted, haute perf
Weaviate	Self-hosted / cloud	Gratuit (open source)	GraphQL natif, multimodal

Comment fonctionne la mémoire vectorielle

Le principe : embeddings + similarité

Un embedding est une représentation numérique d'un texte sous forme de vecteur (liste de nombres). Deux textes sémantiquement proches produisent des vecteurs proches dans l'espace vectoriel — même s'ils n'utilisent pas les mêmes mots.

"installer OpenClaw sur Ubuntu" → [0.12, -0.34, 0.56, ...]  (1536 dims)
"setup OpenClaw Linux"          → [0.11, -0.33, 0.55, ...]  (très proche)
"recette de gâteau au chocolat" → [-0.87, 0.21, -0.15, ...] (très éloigné)

La similarité cosine mesure l'angle entre deux vecteurs : 1.0 = identiques, 0.0 = sans rapport. C'est la métrique standard pour la recherche sémantique.

Le workflow store → retrieve

Store : le texte est converti en embedding via un modèle (OpenAI text-embedding-3-small, Cohere, Sentence-Transformers) et stocké dans la base vectorielle avec ses metadata
Retrieve : quand l'agent a besoin d'un souvenir, sa requête est convertie en embedding et comparée aux vecteurs stockés. Les K vecteurs les plus proches sont retournés

Ce mécanisme est au cœur du RAG (Retrieval-Augmented Generation), mais la mémoire vectorielle agent va plus loin : elle stocke aussi les faits appris, les préférences utilisateur et les résultats d'actions passées — pas seulement des documents statiques.

Les 3 niveaux de mémoire vectorielle

Court terme — en mémoire (in-memory)

Les vecteurs sont stockés dans une structure Python (liste, numpy array). Rapide mais volatile — tout est perdu quand le processus s'arrête.

Quand l'utiliser : cache de session, recherche dans un petit corpus (< 1000 documents) pendant une seule exécution.

Moyen terme — local persistant

Les vecteurs sont stockés sur disque (SQLite, fichier Parquet). Ils persistent entre les sessions mais restent sur une seule machine.

Quand l'utiliser : développement local, agents mono-utilisateur, prototypes.

Outil typique : Chroma en mode local (pip install chromadb, pas de serveur).

Long terme — cloud ou serveur dédié

Les vecteurs sont stockés dans un service managé ou un serveur self-hosted. Ils persistent, sont accessibles depuis n'importe quel client, et scalent à des millions de vecteurs.

Quand l'utiliser : production, multi-utilisateurs, volumes importants (> 100k vecteurs).

Outils typiques : Pinecone (cloud), Qdrant (self-hosted/cloud), Weaviate (self-hosted/cloud).

Comparatif des outils

Critère	Pinecone	Chroma	Qdrant	Weaviate
Déploiement	Cloud only	Local + cloud	Self-hosted + cloud	Self-hosted + cloud
Setup	5 min (SaaS)	`pip install`	Docker	Docker
Performance	Excellente	Bonne (< 1M)	Excellente (Rust)	Bonne
Tier gratuit	100k vecteurs	Illimité (local)	Illimité (self-hosted)	Illimité (self-hosted)
Coût production	~70 $/mois	Gratuit (local)	Gratuit (self-hosted)	Gratuit (self-hosted)
Metadata filtering	Avancé	Basique	Avancé (payload)	Avancé (GraphQL)
SDK Python	Officiel	Officiel	Officiel	Officiel
Particularité	Zero ops	Le plus simple	Le plus performant	Multimodal natif

Choisir la bonne solution

Votre agent est en production ?
├── NON → Prototype / dev local
│   └── Chroma (pip install, zéro config, gratuit)
│
└── OUI → Production
    ├── Vous voulez zéro infrastructure ?
    │   └── Pinecone (cloud managé, ~70 $/mois)
    │
    ├── Vous avez un serveur et voulez du self-hosted ?
    │   └── Qdrant (Docker, Rust, haute perf, gratuit)
    │
    └── Vous avez besoin de multimodal (texte + images) ?
        └── Weaviate (Docker, GraphQL natif)

Recommandation pragmatique : commencez avec Chroma en local, migrez vers Qdrant Cloud ou Pinecone quand vous passez en production. Les APIs sont suffisamment proches pour que la migration soit réalisable en quelques heures.

Implémenter une mémoire vectorielle simple

Exemple complet avec ChromaDB (le plus simple pour commencer) :

"""
Mémoire vectorielle minimale pour un agent IA.
Utilise ChromaDB (local) + embeddings OpenAI.
"""

import chromadb
from openai import OpenAI
from uuid import uuid4
from datetime import datetime

# --- Setup ---
chroma = chromadb.PersistentClient(path="./agent_memory_db")
collection = chroma.get_or_create_collection(
    name="agent_memory",
    metadata={"hnsw:space": "cosine"}  # similarité cosine
)
openai_client = OpenAI()

def embed(text: str) -> list[float]:
    """Convertir un texte en embedding."""
    response = openai_client.embeddings.create(
        input=text,
        model="text-embedding-3-small"
    )
    return response.data[0].embedding

# --- Store : mémoriser un fait ---
def remember(text: str, category: str = "general"):
    collection.add(
        ids=[str(uuid4())],
        embeddings=[embed(text)],
        documents=[text],
        metadatas=[{
            "category": category,
            "timestamp": datetime.now().isoformat()
        }]
    )

# --- Retrieve : retrouver des souvenirs ---
def recall(query: str, n_results: int = 3) -> list[dict]:
    results = collection.query(
        query_embeddings=[embed(query)],
        n_results=n_results,
        include=["documents", "metadatas", "distances"]
    )
    return [
        {
            "text": doc,
            "category": meta["category"],
            "similarity": 1 - dist  # Chroma retourne la distance, pas la similarité
        }
        for doc, meta, dist in zip(
            results["documents"][0],
            results["metadatas"][0],
            results["distances"][0]
        )
    ]

# --- Usage dans un agent ---
# L'agent apprend des faits
remember("L'utilisateur travaille sur un projet e-commerce.", "context")
remember("Le stack technique est Python + FastAPI + PostgreSQL.", "context")
remember("L'utilisateur préfère les réponses courtes et structurées.", "preference")

# L'agent récupère les souvenirs pertinents
memories = recall("quel framework recommander pour son projet")
for m in memories:
    print(f"[{m['similarity']:.2f}] ({m['category']}) {m['text']}")
# [0.87] (context) Le stack technique est Python + FastAPI + PostgreSQL.
# [0.82] (context) L'utilisateur travaille sur un projet e-commerce.

Ce code est directement intégrable dans la boucle d'un agent OpenClaw (comme skill) ou dans un nœud LangGraph.

Bonnes pratiques

Choisissez le bon modèle d'embedding. text-embedding-3-small (OpenAI, 1536 dims) offre le meilleur rapport qualité/coût. Pour du multilingue, multilingual-e5-large (open source) est excellent. Le modèle d'embedding détermine la qualité de la recherche — c'est le choix le plus impactant.

Découpez vos documents (chunking). Un embedding représente un seul concept. Un document de 5 pages doit être découpé en chunks de 200 à 500 tokens pour que la recherche soit précise. Chevauchement de 50 tokens entre chunks pour éviter de couper les idées.

Stockez toujours le texte original en metadata. L'embedding seul ne permet pas de reconstruire le texte. Conservez le texte source dans les metadata pour l'injecter dans le prompt de l'agent.

Gérez la fraîcheur. Ajoutez un timestamp à chaque vecteur. Un souvenir de 6 mois peut être obsolète. Implémentez un score de fraîcheur : relevance = similarity * decay(age).

Estimez vos coûts. Embedding : ~0,02 $ pour 1M de tokens avec OpenAI. Stockage Chroma : gratuit (local). Stockage Pinecone : gratuit < 100k, puis ~0,33 $/100k vecteurs/mois. Pour un agent avec 10k souvenirs, le coût est négligeable.

Testez la pertinence du retrieval. Créez un jeu de test : 20 requêtes avec les résultats attendus. Mesurez le recall@K (% de bons résultats dans les K premiers). Un recall@5 > 80% est un bon objectif.

Questions fréquentes

Quelle est la différence entre mémoire vectorielle et RAG ?

Le RAG (Retrieval-Augmented Generation) est un pattern qui utilise la mémoire vectorielle pour enrichir le prompt d'un LLM avec des documents pertinents. La mémoire vectorielle est le mécanisme de stockage/récupération ; le RAG est la façon de l'utiliser dans un pipeline de génération.

Faut-il un GPU pour les embeddings ?

Non pour les modèles cloud (OpenAI, Cohere) — l'API gère tout. Pour les modèles locaux (Sentence-Transformers), un GPU accélère significativement (10-50x), mais le CPU fonctionne pour les petits volumes.

Combien de vecteurs peut-on stocker gratuitement ?

Chroma : illimité en local (limité par votre disque). Pinecone : 100k vecteurs. Qdrant Cloud : 1M de vecteurs (tier gratuit). Pour le développement, Chroma en local est la solution la plus simple.

Peut-on mélanger des vecteurs de modèles différents ?

Non. Un index ne peut contenir que des vecteurs de même dimension et du même modèle d'embedding. Mélanger des vecteurs de modèles différents produit des résultats de similarité incohérents. Si vous changez de modèle, réindexez tout.

La mémoire vectorielle remplace-t-elle la fenêtre de contexte ?

Non, elle la complète. La fenêtre de contexte reste nécessaire pour la conversation en cours et le raisonnement immédiat. La mémoire vectorielle sert à récupérer des informations pertinentes depuis un store persistant et à les injecter dans la fenêtre de contexte.