@ai.ntellect/core 1.0.0 → 1.1.0

package/docs/modules/memoire/les-adaptateurs/README.md

@@ -0,0 +1,209 @@
+---
+description: >-
+  Un adaptateur mémoire est un composant permettant de gérer la persistance et
+  la récupération des données de l'agent en fonction du moteur sous-jacent.
+---
+
+# Les adaptateurs
+
+### **Qu’est-ce qu’un adaptateur mémoire ?**
+
+Un **adaptateur mémoire** est un composant permettant de gérer la **persistance et la récupération** des données de l'agent en fonction du moteur sous-jacent.
+
+Il sert d'interface entre le système et le stockage, en encapsulant les spécificités d’un moteur (base de données, cache, indexation…).
+
+Grâce aux adaptateurs, **le système peut changer de moteur de stockage sans modifier son code**.
+
+***
+
+### **Fonctionnement des adaptateurs mémoire**
+
+Tous les adaptateurs doivent implémenter une interface commune **`IMemoryAdapter`**, garantissant une API standardisée.
+
+#### **Méthodes essentielles d’un adaptateur**
+
+| Méthode                                                                        | Description                                  |
+| ------------------------------------------------------------------------------ | -------------------------------------------- |
+| `init(roomId: string)`                                                         | Initialise le stockage pour une salle donnée |
+| `createMemory(input: CreateMemoryInput)`                                       | Stocke une nouvelle mémoire                  |
+| `getMemoryById(id: string, roomId: string)`                                    | Récupère une mémoire spécifique              |
+| `getMemoryByIndex(query: string, options: { roomId: string; limit?: number })` | Recherche des mémoires par indexation        |
+| `getAllMemories(roomId: string)`                                               | Récupère toutes les mémoires d’une salle     |
+| `clearMemoryById(id: string, roomId: string)`                                  | Supprime une mémoire spécifique              |
+| `clearAllMemories()`                                                           | Vide toutes les mémoires                     |
+
+Ainsi, un adaptateur peut être **changé ou ajouté dynamiquement**, sans modifier l'agent.
+
+***
+
+### **Adaptateurs intégrés (par défaut)**
+
+Le framework propose **plusieurs adaptateurs intégrés** :
+
+| Adaptateur             | Type de stockage     | Cas d’usage                     |
+| ---------------------- | -------------------- | ------------------------------- |
+| **InMemoryAdapter**    | RAM (non persistant) | Cache rapide, temporaire        |
+| **MeilisearchAdapter** | Moteur de recherche  | Recherche avancée et indexation |
+| **RedisAdapter**       | Stockage clé-valeur  | Cache persistant avec TTL       |
+
+***
+
+### **Créer un nouvel adaptateur : Exemple avec SQLite**
+
+Si on veut utiliser **SQLite** comme moteur de stockage mémoire, on doit créer un nouvel adaptateur.
+
+#### **1. Installer la dépendance**
+
+On utilise [BetterSQLite3](https://github.com/WiseLibs/better-sqlite3) pour des accès rapides et synchrones.
+
+```sh
+npm install better-sqlite3
+```
+
+#### **2. Implémenter l’adaptateur**
+
+On crée un fichier `BetterSQLiteAdapter.ts` qui respecte l’interface `IMemoryAdapter`.
+
+```typescript
+import Database from "better-sqlite3";
+import { IMemoryAdapter } from "../interfaces";
+import { BaseMemoryType, CreateMemoryInput } from "../types";
+
+/**
+ * @module BetterSQLiteAdapter
+ * @description Adaptateur SQLite pour le stockage persistant des mémoires.
+ */
+export class BetterSQLiteAdapter implements IMemoryAdapter {
+  private db: Database.Database;
+
+  /**
+   * Initialise l'adaptateur avec une base SQLite.
+   * @param {string} dbPath - Chemin vers le fichier SQLite
+   */
+  constructor(dbPath: string = "./memory.db") {
+    this.db = new Database(dbPath);
+    this.initSchema();
+  }
+
+  /**
+   * Initialise la table SQLite si elle n'existe pas
+   */
+  private initSchema(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        roomId TEXT,
+        data TEXT,
+        createdAt TEXT
+      )
+    `);
+  }
+
+  /**
+   * Initialise le stockage pour une salle spécifique (non nécessaire pour SQLite).
+   */
+  async init(_roomId: string): Promise<void> {
+    return;
+  }
+
+  /**
+   * Stocke une nouvelle mémoire dans la base SQLite.
+   * @param {CreateMemoryInput} input - Données de la mémoire
+   * @returns {Promise<BaseMemoryType>} - Mémoire créée
+   */
+  async createMemory(input: CreateMemoryInput): Promise<BaseMemoryType> {
+    const memory: BaseMemoryType = {
+      id: input.id || crypto.randomUUID(),
+      data: input.data,
+      roomId: input.roomId,
+      createdAt: new Date(),
+    };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (id, roomId, data, createdAt)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(memory.id, memory.roomId, memory.data, memory.createdAt.toISOString());
+
+    return memory;
+  }
+
+  /**
+   * Récupère une mémoire par ID et salle.
+   * @param {string} id - Identifiant de la mémoire
+   * @param {string} roomId - Identifiant de la salle
+   * @returns {Promise<BaseMemoryType | null>} - Mémoire trouvée ou null
+   */
+  async getMemoryById(id: string, roomId: string): Promise<BaseMemoryType | null> {
+    const stmt = this.db.prepare(`
+      SELECT * FROM memories WHERE id = ? AND roomId = ?
+    `);
+    const row = stmt.get(id, roomId);
+    return row ? { ...row, createdAt: new Date(row.createdAt) } : null;
+  }
+
+  /**
+   * Recherche des mémoires contenant un mot-clé.
+   */
+  async getMemoryByIndex(query: string, options: { roomId: string; limit?: number }): Promise<BaseMemoryType[]> {
+    const stmt = this.db.prepare(`
+      SELECT * FROM memories WHERE roomId = ? AND data LIKE ? LIMIT ?
+    `);
+    return stmt.all(options.roomId, `%${query}%`, options.limit || 10);
+  }
+
+  /**
+   * Récupère toutes les mémoires d'une salle.
+   */
+  async getAllMemories(roomId: string): Promise<BaseMemoryType[]> {
+    const stmt = this.db.prepare(`
+      SELECT * FROM memories WHERE roomId = ?
+    `);
+    return stmt.all(roomId);
+  }
+
+  /**
+   * Supprime une mémoire spécifique.
+   */
+  async clearMemoryById(id: string, roomId: string): Promise<void> {
+    const stmt = this.db.prepare(`
+      DELETE FROM memories WHERE id = ? AND roomId = ?
+    `);
+    stmt.run(id, roomId);
+  }
+
+  /**
+   * Supprime toutes les mémoires.
+   */
+  async clearAllMemories(): Promise<void> {
+    this.db.exec(`DELETE FROM memories`);
+  }
+}
+```
+
+***
+
+### **Intégrer le nouvel adaptateur**
+
+Une fois le nouvel adaptateur implémenté, on peut l’intégrer dans l’agent :
+
+```typescript
+import { BetterSQLiteAdapter } from "./BetterSQLiteAdapter";
+import { Memory } from "../modules/memory";
+
+// Initialisation avec SQLite
+const memoryAdapter = new BetterSQLiteAdapter("./agent-memory.db");
+const memoryModule = new Memory(memoryAdapter);
+
+async function run() {
+  await memoryModule.createMemory({
+    data: "Ceci est un test",
+    roomId: "chat-session-1",
+  });
+
+  const memories = await memoryModule.getAllMemories("chat-session-1");
+  console.log("Mémoires récupérées :", memories);
+}
+
+run();
+```

package/docs/modules/memoire/les-adaptateurs/inmemoryadapter.md

@@ -0,0 +1,110 @@
+---
+description: >-
+  InMemoryAdapter est l'implémentation la plus simple d'un adaptateur mémoire.
+  Il stocke les données en RAM.
+---
+
+# InMemoryAdapter
+
+`InMemoryAdapter` est une implémentation simple et efficace de l’interface **IMemoryAdapter**. Il repose sur une structure **Map** pour stocker des entrées mémoire **en RAM** et ne conserve aucune donnée une fois le processus arrêté.
+
+Ce type d’adaptateur est particulièrement adapté aux cas où la mémoire doit être temporaire, avec un accès très rapide, sans nécessiter de persistance durable.
+
+***
+
+### **Spécificités techniques de l’InMemoryAdapter**
+
+#### **Stockage en mémoire via une Map**
+
+L’adaptateur utilise une **Map TypeScript**, qui associe un `roomId` à une liste de mémoires. Contrairement à une base de données, les opérations de lecture et d’écriture sont exécutées en **temps constant O(1)** pour l’insertion et l’accès direct par clé.
+
+```typescript
+private storage: Map<string, BaseMemoryType[]> = new Map();
+```
+
+Chaque **room** représente une instance de mémoire séparée. Cela permet d’isoler les données par contexte, tout en bénéficiant d’une récupération rapide.
+
+***
+
+#### **Initialisation et création dynamique des rooms**
+
+Lorsqu’un système accède à la mémoire pour la première fois, une **vérification est effectuée** afin de s’assurer que le `roomId` existe bien dans la **Map**. Si ce n’est pas le cas, un espace de stockage est créé dynamiquement.
+
+```typescript
+async init(roomId: string): Promise<void> {
+  if (!this.storage.has(roomId)) {
+    this.storage.set(roomId, []);
+  }
+}
+```
+
+Ce mécanisme permet une allocation **à la demande**, évitant tout stockage inutile en mémoire.
+
+***
+
+#### **Optimisation des recherches**
+
+`InMemoryAdapter` ne permet pas d’indexation avancée comme une base de données. La recherche est effectuée **par filtrage séquentiel** dans la liste des mémoires associées à une room.
+
+```typescript
+async getMemoryByIndex(query: string, options: { roomId: string; limit?: number })
+  : Promise<BaseMemoryType[]> {
+  const memories = this.storage.get(options.roomId) || [];
+  return memories.filter((m) => m.data.includes(query)).slice(0, options.limit || 10);
+}
+```
+
+Ce type de recherche est suffisant pour un usage **temporaire ou de prototypage**, mais il devient inefficace sur **de grands volumes de données**.
+
+***
+
+#### **Effacement ciblé et suppression totale**
+
+`InMemoryAdapter` permet de supprimer des entrées individuelles ou de réinitialiser l’ensemble des données en **effaçant directement les références stockées**.
+
+**Suppression d’une mémoire spécifique**
+
+```typescript
+async clearMemoryById(id: string, roomId: string): Promise<void> {
+  const memories = this.storage.get(roomId) || [];
+  this.storage.set(roomId, memories.filter((m) => m.id !== id));
+}
+```
+
+**Réinitialisation complète de toutes les rooms**
+
+```typescript
+async clearAllMemories(): Promise<void> {
+  this.storage.clear();
+}
+```
+
+Ces opérations sont **instantanées**, mais elles **ne permettent pas d’annulation** (contrairement à une base de données transactionnelle).
+
+***
+
+### **Limitations et considérations**
+
+#### **Absence de persistance**
+
+`InMemoryAdapter` est **volatile** : les données disparaissent dès l’arrêt du processus. Pour des systèmes nécessitant un historique persistant, un adaptateur basé sur un stockage externe (comme **Redis**, **SQLite**, ou **Meilisearch**) est recommandé.
+
+#### **Consommation mémoire**
+
+Le stockage en **RAM** signifie que la quantité de mémoire disponible limite la capacité de stockage. **Une accumulation non contrôlée peut entraîner des fuites mémoire et un crash de l’application**.
+
+#### **Performances sur de gros volumes**
+
+Les accès directs via `roomId` sont rapides, mais la **recherche textuelle est inefficace** sur de grands ensembles de données, car elle repose sur une **parcours linéaire**.
+
+***
+
+### **Cas d’usage**&#x20;
+
+`InMemoryAdapter` est une solution pertinente pour :
+
+* **Stockage temporaire d’interactions utilisateur** dans des agents conversationnels.
+* **Tests et prototypage rapide** sans configurer de base de données.
+* **Cache léger** pour éviter des appels répétés à des services externes.
+
+Pour une application en production ou nécessitant des recherches complexes, une alternative **persistance** est nécessaire.&#x20;

package/docs/modules/memoire/les-adaptateurs/meilisearchadapter.md

@@ -0,0 +1,147 @@
+---
+description: >-
+  L'adaptateur Meilisearch est conçu pour offrir une indexation rapide et une
+  recherche avancée sur les données en mémoire.
+---
+
+# MeiliSearchAdapter
+
+`MeilisearchAdapter` intègre Meilisearch comme moteur de stockage et de recherche pour la mémoire des systèmes. 
+
+Ce type d’adaptateur est particulièrement adapté aux cas où un système doit retrouver rapidement des informations contextuelles à partir d’une **grande quantité de données**.
+
+***
+
+### **Spécificités techniques du MeilisearchAdapter**
+
+#### **Stockage sous forme d’index dans Meilisearch**
+
+L’adaptateur crée un index distinct pour chaque `roomId`. Un index est l’équivalent d’une **collection de documents** dans une base NoSQL, permettant une **recherche optimisée**.
+
+```typescript
+private async initializeStorage(roomId: string): Promise<void> {
+  try {
+    await this.makeRequest(`/indexes/${roomId}`);
+  } catch {
+    await this.makeRequest("/indexes", {
+      method: "POST",
+      body: JSON.stringify({ uid: roomId, primaryKey: "id" }),
+    });
+  }
+}
+```
+
+Si l’index n’existe pas encore, il est automatiquement créé, évitant toute configuration manuelle.
+
+***
+
+#### **Indexation et recherche avancée**
+
+Meilisearch permet des **requêtes de recherche floues** avec un **scoring** de pertinence. Les résultats sont classés en fonction de leur **similarité avec la requête**, ce qui est idéal pour une mémoire adaptative.
+
+**Indexation d’une nouvelle mémoire**
+
+```typescript
+async createMemory(input: CreateMemoryInput & { embedding?: number[] }): Promise<BaseMemoryType | undefined> {
+  await this.initializeStorage(input.roomId);
+
+  const existingMemory = await this.search(input.data, input.roomId, { limit: 1 });
+  if (existingMemory.length > 0) {
+    return existingMemory[0].document;
+  }
+
+  const memory: BaseMemoryType = {
+    id: input.id || crypto.randomUUID(),
+    data: input.data,
+    embedding: input.embedding,
+    roomId: input.roomId,
+    createdAt: new Date(),
+  };
+
+  await this.addDocuments([memory], input.roomId);
+  return memory;
+}
+```
+
+Chaque mémoire ajoutée est immédiatement indexée et accessible via **une recherche contextuelle rapide**.
+
+***
+
+#### **Optimisation de la recherche et scoring de pertinence**
+
+Contrairement à une recherche brute basée sur une correspondance exacte, Meilisearch évalue **le degré de similarité** des documents avec la requête. Cela permet d’améliorer la compréhension contextuelle du système.
+
+```typescript
+private async search(query: string, roomId: string, options?: { limit?: number; threshold?: number }): Promise<SearchResult[]> {
+  const searchResults = await this.makeRequest(`/indexes/${roomId}/search`, {
+    method: "POST",
+    body: JSON.stringify({
+      q: query,
+      limit: options?.limit || 10,
+    }),
+  });
+
+  if (!searchResults.hits) return [];
+
+  return searchResults.hits.map((hit: any) => ({
+    document: {
+      id: hit.id,
+      data: hit.data,
+      embedding: hit.embedding,
+      roomId: hit.roomId,
+      createdAt: hit.createdAt,
+    },
+    score: hit._score || 0,
+  }));
+}
+```
+
+Les résultats retournés sont **triés par pertinence**, avec un score de similarité permettant d'ajuster dynamiquement les réponses du système.
+
+***
+
+#### **Suppression et nettoyage d’index**
+
+L’adaptateur permet d’effacer **sélectivement** une mémoire spécifique ou **de supprimer un index complet**, ce qui est utile lorsque la mémoire devient obsolète ou que l’on veut réinitialiser un contexte.
+
+**Suppression d’une mémoire spécifique**
+
+```typescript
+async clearMemoryById(id: string, roomId: string): Promise<void> {
+  await this.makeRequest(`/indexes/${roomId}/documents/${id}`, { method: "DELETE" });
+}
+```
+
+**Suppression de toutes les mémoires d’un index**
+
+```typescript
+private async deleteStorage(roomId: string): Promise<void> {
+  await this.makeRequest(`/indexes/${roomId}`, { method: "DELETE" });
+}
+```
+
+***
+
+### **Limitations et considérations**
+
+#### **Dépendance à un service externe**
+
+Meilisearch nécessite une instance serveur active. Un système exécuté localement doit donc **se connecter à une base distante** ou à **une instance en auto-hébergement**.
+
+#### **Latence réseau**
+
+Les performances dépendent de la latence du serveur Meilisearch. Pour des besoins de faible latence, une solution comme **Redis** peut être plus adaptée.
+
+#### **Consommation mémoire et stockage**
+
+Les index doivent être **nettoyés régulièrement**, en particulier si l’agent génère un **grand volume de données**.
+
+***
+
+### **Cas d’usage**&#x20;
+
+**`MeilisearchAdapter`** est idéal pour :
+
+* **La recherche avancée en langage naturel** dans les logs de l’agent.
+* **L’historisation et la récupération d’interactions** sur le long terme.
+* **La gestion d’une base de connaissances structurée** pour un agent conversationnel.

package/docs/modules/memoire/les-adaptateurs/redisadapter.md

@@ -0,0 +1,212 @@
+---
+description: >-
+  L’adaptateur Redis utilise une base de données clé-valeur en mémoire, idéale
+  pour des stockages rapides et temporaires.
+---
+
+# RedisAdapter
+
+`RedisAdapter` intègre **Redis** comme moteur de stockage pour la mémoire des systèmes. 
+
+Redis permet un **accès instantané** aux données grâce à un modèle **clé-valeur**, tout en offrant des fonctionnalités avancées comme **la persistance**, **le TTL (Time-To-Live)** et **la réplication distribuée**.
+
+Ce type d’adaptateur est particulièrement adapté aux agents qui nécessitent **des accès ultra-rapides** et une **gestion fine du cycle de vie des mémoires**.
+
+***
+
+### **Spécificités techniques du RedisAdapter**
+
+#### **Stockage sous forme de clés structurées**
+
+Chaque mémoire est stockée dans Redis avec une clé formée comme suit :
+
+```plaintext
+<memory_prefix>:<room_id>:<memory_id>
+```
+
+Cela permet de **segmenter les mémoires** par `roomId` et d’éviter les collisions.
+
+Exemple de stockage d’une mémoire :
+
+```typescript
+const key = `${this.cachePrefix}${memory.roomId}:${memory.id}`;
+await this.redis.set(key, JSON.stringify(memory), { EX: this.cacheTTL });
+```
+
+L’option `{ EX: this.cacheTTL }` définit **une expiration automatique** après un temps défini, évitant ainsi l’accumulation de données obsolètes.
+
+***
+
+#### **Initialisation et connexion au serveur Redis**
+
+L’adaptateur doit établir une connexion avec un serveur Redis, qui peut être **local, distant ou géré via un service cloud**.
+
+```typescript
+constructor(
+  private readonly redisUrl: string,
+  options: { cachePrefix?: string; cacheTTL?: number }
+) {
+  this.cachePrefix = options.cachePrefix || "memory:";
+  this.cacheTTL = options.cacheTTL || 3600;
+  this.redis = createClient({ url: redisUrl });
+}
+```
+
+* `cachePrefix` permet de **différencier plusieurs types de données** stockées dans Redis.
+* `cacheTTL` définit **le temps de rétention** des mémoires (en secondes).
+
+**Avantage :** Un système utilisant Redis peut fonctionner sans base de données persistante, en exploitant uniquement la mémoire vive du serveur.
+
+***
+
+#### **Création et récupération des mémoires**
+
+**Stockage d’une nouvelle mémoire**
+
+Chaque entrée est **convertie en JSON** et stockée sous une clé unique dans Redis.
+
+```typescript
+async createMemory(input: CreateMemoryInput & { embedding?: number[] }): Promise<BaseMemoryType | undefined> {
+  const memory: BaseMemoryType = {
+    id: input.id || crypto.randomUUID(),
+    data: input.data,
+    embedding: input.embedding,
+    roomId: input.roomId,
+    createdAt: new Date(),
+  };
+
+  const key = `${this.cachePrefix}${memory.roomId}:${memory.id}`;
+  await this.redis.set(key, JSON.stringify(memory), { EX: this.cacheTTL });
+
+  return memory;
+}
+```
+
+💡 **Optimisation :** Redis étant une base en RAM, **éviter de stocker des objets volumineux** pour limiter l’impact sur la mémoire.
+
+***
+
+**Récupération d’une mémoire**
+
+Les entrées sont récupérées en **temps constant** grâce à l’accès clé-valeur.
+
+```typescript
+async getMemoryById(id: string, roomId: string): Promise<BaseMemoryType | null> {
+  const key = `${this.cachePrefix}${roomId}:${id}`;
+  const data = await this.redis.get(key);
+  return data ? JSON.parse(data) : null;
+}
+```
+
+**Temps d’accès :** \~ **1 ms**, bien plus rapide qu’une base de données traditionnelle.
+
+***
+
+#### **Recherche et indexation dans Redis**
+
+Redis ne supporte pas nativement **les recherches full-text**, mais il est possible de **simuler une indexation** en utilisant **les clés et SCAN MATCH**.
+
+```typescript
+async getMemoryByIndex(query: string, options: { roomId: string; limit?: number }): Promise<BaseMemoryType[]> {
+  const pattern = `${this.cachePrefix}${options.roomId}:*`;
+  const keys = await this.redis.keys(pattern);
+
+  const memories = await Promise.all(
+    keys.map(async (key) => {
+      const data = await this.redis.get(key);
+      return data ? JSON.parse(data) : null;
+    })
+  );
+
+  return memories.filter(Boolean).slice(0, options.limit || 10);
+}
+```
+
+**Limite :** Redis ne propose pas de scoring de pertinence comme Meilisearch. Les recherches sont basées sur **des correspondances exactes** ou **un filtrage par clé**.
+
+***
+
+#### **Suppression et nettoyage de la mémoire**
+
+Redis permet une suppression instantanée d’une mémoire spécifique ou d’un ensemble de mémoires.
+
+**Suppression d’une mémoire individuelle**
+
+```typescript
+async clearMemoryById(id: string, roomId: string): Promise<void> {
+  const key = `${this.cachePrefix}${roomId}:${id}`;
+  await this.redis.del(key);
+}
+```
+
+**Suppression de toutes les mémoires d’un agent**
+
+```typescript
+async clearAllMemories(): Promise<void> {
+  const keys = await this.redis.keys(`${this.cachePrefix}*`);
+  if (keys.length > 0) {
+    await this.redis.del(keys);
+  }
+}
+```
+
+**Attention :** Cette opération peut être coûteuse si le volume de données est important.
+
+***
+
+### **Limitations et considérations**
+
+#### **Dépendance à un service en mémoire volatile**
+
+Redis fonctionne en **RAM**, ce qui signifie que **sans mécanisme de persistance activé**, les mémoires stockées peuvent être **perdues en cas de redémarrage**. Par défaut, Redis offre **deux modes de persistance** :
+
+* **RDB (Redis Database Snapshot)** : Sauvegarde périodique en dur.
+* **AOF (Append-Only File)** : Journalisation des opérations pour rejouer l’état en cas de crash.\
+  Si la mémoire de l’agent doit être **persistante sur le long terme**, il est recommandé d’associer Redis avec **une base durable** comme PostgreSQL ou Meilisearch.
+
+#### **Latence ultra-faible mais dépendance au réseau**
+
+Redis est **extrêmement rapide** (accès en **O(1)**), mais cette rapidité dépend de **l’emplacement du serveur**.
+
+* Un **Redis local** offre **des performances optimales**.
+* Un **Redis distant** introduit une **latence liée au réseau**.\
+  Si l’agent est déployé dans un environnement distribué, il est préférable d’**héberger Redis proche de l’instance exécutant l’agent**.
+
+#### **Consommation mémoire et TTL obligatoire**
+
+Redis stocke **tout en RAM**, ce qui peut poser un problème si un système génère un **grand volume de données**.
+
+⚠ **Sans expiration (TTL), les mémoires s’accumulent et saturent Redis**.
+
+Il est **recommandé de fixer une politique d’expiration** (exemple : **stockage des mémoires pour X heures**).
+
+Exemple de gestion du TTL :
+
+```typescript
+await this.redis.set(key, JSON.stringify(memory), { EX: 3600 }); // Expire après 1h
+```
+
+Si l’agent doit **conserver son historique sur le long terme**, une solution **persistante (Meilisearch, SQL, stockage objet)** est plus adaptée.
+
+#### **Absence de moteur de recherche avancé**
+
+Redis **ne supporte pas nativement les recherches full-text ou vectorielles**.
+
+* Pour **des recherches sémantiques**, il est préférable d’utiliser **Meilisearch**.
+* Pour **des recherches par similarité**, Redis **peut stocker des embeddings**, mais un moteur spécialisé comme **FAISS ou Weaviate** est plus efficace.
+
+#### **Non adapté aux grosses bases historiques**
+
+Si le système doit **retrouver des informations sur plusieurs mois/années**, Redis n’est pas une solution idéale.\
+**Recommandation** : Utiliser Redis pour **le stockage temporaire** et exporter les anciennes données vers une **base durable** (Meilisearch/PostgreSQL).
+
+***
+
+### **Cas d’usage adaptés**
+
+**`RedisAdapter`** est particulièrement utile pour :&#x20;
+
+* **Le caching des réponses d’un agent** pour réduire les appels aux LLMs.
+* **Les sessions temporaires**, où l’état mémoire doit expirer après une période définie.
+* **Les interactions en temps réel**, nécessitant des accès ultra-rapides.
+* **Le stockage intermédiaire** avant synchronisation avec une base plus durable.