@ai.ntellect/core 0.8.3 → 1.1.0

package/docs/modules/memoire/interface-imemory.md

@@ -0,0 +1,183 @@
+---
+description: >-
+  L'interface IMemory définit une abstraction pour stocker, rechercher et gérer
+  des entrées mémorielles
+---
+
+# Interface IMemory
+
+L'interface `IMemory` définit une abstraction pour **stocker, rechercher et gérer des entrées mémorielles** dans un environnement où un agent doit retenir des informations sur le long terme ou pour des sessions temporaires.
+
+Ce module suit une **approche modulaire et agnostique** du backend, permettant d’être implémenté avec différents moteurs de stockage :
+
+* **Stockage en mémoire** (`InMemoryAdapter`)
+* **Base de données** (`MeilisearchAdapter`, `RedisAdapter`, `PostgreSQLAdapter`)
+* **Stockage distribué** (`VectorDBAdapter`, `PineconeAdapter`)
+
+***
+
+### **Objectif de l'interface**
+
+L'interface `IMemory` doit permettre :
+
+* **Le stockage structuré et sécurisé d'informations** persistantes ou temporaires.
+* **Une récupération rapide** avec support des **requêtes sémantiques** (recherche par similarité).
+* **La gestion dynamique du cycle de vie des mémoires** (création, expiration, suppression).
+* **L’adaptabilité à différents backends**, grâce aux `IMemoryAdapter` interchangeables.
+
+***
+
+### **Définition de l’interface**
+
+```typescript
+/**
+ * Interface pour la gestion de la mémoire d'un agent
+ */
+export interface IMemory {
+  /**
+   * Initialise le service mémoire avec les configurations requises
+   * @returns {Promise<void>}
+   */
+  init(): Promise<void>;
+
+  /**
+   * Crée une nouvelle entrée mémoire.
+   * @param {MemoryInput} input - Données de la mémoire à enregistrer.
+   * @returns {Promise<MemoryEntry | undefined>} Retourne l’entrée créée, ou `undefined` en cas d’échec.
+   */
+  createMemory(input: MemoryInput): Promise<MemoryEntry | undefined>;
+
+  /**
+   * Récupère une entrée mémoire par son identifiant.
+   * @param {string} id - Identifiant unique de la mémoire.
+   * @param {string} roomId - Identifiant de la session ou du contexte.
+   * @returns {Promise<MemoryEntry | null>} Retourne l'entrée mémoire si trouvée, sinon `null`.
+   */
+  getMemoryById(id: string, roomId: string): Promise<MemoryEntry | null>;
+
+  /**
+   * Effectue une recherche d’entrées mémoire selon une requête textuelle.
+   * @param {string} query - Texte de la requête.
+   * @param {MemorySearchOptions} options - Options de recherche.
+   * @returns {Promise<MemoryEntry[]>} Retourne une liste d'entrées mémorielles correspondantes.
+   */
+  searchMemory(
+    query: string,
+    options: MemorySearchOptions
+  ): Promise<MemoryEntry[]>;
+
+  /**
+   * Récupère toutes les mémoires associées à un `roomId`.
+   * @param {string} roomId - Identifiant de la session.
+   * @returns {Promise<MemoryEntry[]>} Liste des entrées mémorielles.
+   */
+  getAllMemories(roomId: string): Promise<MemoryEntry[]>;
+
+  /**
+   * Supprime une entrée mémoire spécifique.
+   * @param {string} id - Identifiant de la mémoire.
+   * @param {string} roomId - Identifiant de la session.
+   * @returns {Promise<void>}
+   */
+  deleteMemoryById(id: string, roomId: string): Promise<void>;
+
+  /**
+   * Supprime toutes les entrées mémorielles d'un `roomId`.
+   * @param {string} roomId - Identifiant de la session.
+   * @returns {Promise<void>}
+   */
+  clearMemories(roomId: string): Promise<void>;
+}
+```
+
+***
+
+### **Interfaces associées**
+
+#### **1. `MemoryInput` : Données pour une nouvelle entrée mémoire**
+
+Lorsqu’une nouvelle mémoire est créée, elle doit suivre une structure bien définie.
+
+```typescript
+/**
+ * Données nécessaires pour créer une mémoire
+ */
+export interface MemoryInput {
+  /** Identifiant unique de la mémoire (optionnel, généré si absent) */
+  id?: string;
+  /** Contenu textuel de la mémoire */
+  data: string;
+  /** Identifiant de la session ou du contexte */
+  roomId: string;
+  /** (Optionnel) Vecteur d’embedding pour recherche sémantique */
+  embedding?: number[];
+  /** Date d’expiration (TTL) */
+  expiresAt?: Date;
+}
+```
+
+#### **2. `MemoryEntry` : Représentation d’une mémoire stockée**
+
+Une mémoire active stockée doit être représentée sous cette forme.
+
+```typescript
+/**
+ * Représentation d'une mémoire stockée
+ */
+export interface MemoryEntry extends MemoryInput {
+  /** Identifiant unique attribué à la mémoire */
+  id: string;
+  /** Date de création de la mémoire */
+  createdAt: Date;
+}
+```
+
+#### **3. `MemorySearchOptions` : Options de recherche avancées**
+
+La recherche mémoire peut inclure des critères supplémentaires pour affiner les résultats.
+
+```typescript
+/**
+ * Options de recherche pour requêtes mémoire
+ */
+export interface MemorySearchOptions {
+  /** Identifiant du contexte de recherche */
+  roomId: string;
+  /** Nombre maximal de résultats */
+  limit?: number;
+  /** Score minimal de similarité si une recherche sémantique est utilisée */
+  minSimilarity?: number;
+}
+```
+
+***
+
+### **Pourquoi cette interface ?**
+
+L’interface `IMemory` permet une **gestion optimisée et évolutive** des données mémoire :
+
+1. **Abstraction complète du moteur de stockage**
+   * Permet d’implémenter `IMemory` avec **n’importe quel backend** (`Redis`, `PostgreSQL`, `VectorDB`, etc.).
+   * Découple la **logique métier** de la **logique de persistance**.
+2. **Support des recherches sémantiques**
+   * Les données peuvent être indexées sous forme de **vecteurs** (`embedding`).
+   * Permet des recherches avancées **par similarité** et non uniquement par mots-clés.
+3. **Modèle flexible et dynamique**
+   * Gestion **multi-sessions (`roomId`)** pour segmenter la mémoire selon les contextes.
+   * Prise en charge d’un **TTL** (`expiresAt`) pour éviter l’accumulation inutile de données.
+4. **Extensibilité via des adaptateurs (`IMemoryAdapter`)**
+   * Compatible avec **des moteurs de stockage externes** (`Meilisearch`, `Pinecone`, etc.).
+   * Possibilité d’intégrer **plusieurs sources de mémoire** (ex: mémoire immédiate + historique long-terme).
+
+***
+
+### **Cas d’usage**
+
+L’interface `IMemory` peut être utilisée dans plusieurs scénarios :
+
+| **Cas d'usage**                   | **Exemple**                                                      |
+| --------------------------------- | ---------------------------------------------------------------- |
+| Stockage d’historique utilisateur | Mémorisation des interactions d’un chatbot avec un utilisateur.  |
+| Recherche sémantique              | Trouver des documents ou réponses similaires à une requête.      |
+| Maintien du contexte              | Conserver un état conversationnel pour un agent autonome.        |
+| Mémoire dynamique                 | Stocker temporairement des informations utiles dans un `roomId`. |

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.