goblin-agents 0.1.5 → 0.1.11

package/README.md

@@ -4,6 +4,15 @@
 
 Le module `goblin-agents` fournit une infrastructure complète pour intégrer des agents d'intelligence artificielle (IA) dans l'écosystème Xcraft. Il permet de créer, configurer et interagir avec différents modèles de langage (LLM) via des fournisseurs comme Ollama et OpenAI. Ce module est conçu pour faciliter l'utilisation d'agents IA dans diverses applications, en offrant des fonctionnalités avancées comme la gestion de conversations, l'analyse de documents PDF, et l'utilisation d'outils externes.
 
+## Sommaire
+
+- [Structure du module](#structure-du-module)
+- [Fonctionnement global](#fonctionnement-global)
+- [Exemples d'utilisation](#exemples-dutilisation)
+- [Interactions avec d'autres modules](#interactions-avec-dautres-modules)
+- [Configuration avancée](#configuration-avancée)
+- [Détails des sources](#détails-des-sources)
+
 ## Structure du module
 
 - **AiAgent** : Acteur principal qui encapsule un agent IA et ses fonctionnalités
@@ -19,6 +28,7 @@ Le module `goblin-agents` permet de créer et gérer des agents IA qui peuvent i
 Les agents peuvent maintenir plusieurs contextes de conversation simultanément, ce qui permet d'avoir des conversations distinctes avec différents utilisateurs ou sur différents sujets. Chaque contexte conserve son propre historique de messages, ce qui permet à l'agent de maintenir la cohérence dans ses réponses.
 
 Le module prend en charge diverses fonctionnalités avancées :
+
 - Génération de texte à partir de prompts
 - Conversations interactives avec historique
 - Extraction de texte à partir d'images de documents PDF
@@ -36,11 +46,11 @@ Les agents peuvent être configurés avec une grande variété d'options qui inf
 const {AiAgent} = require('goblin-agents/lib/llm/aiAgent.js');
 
 // Dans une méthode d'un acteur Elf
-async initAgents() {  
+async initAgents() {
   const feedId = await this.newQuestFeed();
 
   // Création d'un agent avec Ollama (local)
-  const ollamaAgentId = SmartId.from('aiAgent', 'ollama-mistral-assistant');
+  const ollamaAgentId = 'aiAgent@ollama-mistral-assistant';
   const agent = await new AiAgent(this).create(ollamaAgentId, feedId, {
     name: 'Assistant Personnel',
     role: 'assistant',
@@ -55,8 +65,8 @@ async initAgents() {
   });
 
   // Création d'un agent avec OpenAI (cloud)
-  const openAiAgentId = SmartId.from('aiAgent', 'gpt-4o-assistant');
-  const agent = await new AiAgent(this).create(openAiAgentId, feedId, {
+  const openAiAgentId = 'aiAgent@gpt-4o-assistant';
+  const cloudAgent = await new AiAgent(this).create(openAiAgentId, feedId, {
     name: 'Assistant Personnel',
     role: 'assistant',
     provider: 'open-ai',
@@ -67,20 +77,20 @@ async initAgents() {
     },
     usability: 'stable'
   });
+}
 ```
 
 ### Conversation avec un agent
 
 ```javascript
-
 // Dans une méthode d'un acteur Elf
 async askAgent(desktopId, agentId, contextId, question, saveExchange = false) {
   const feedId = await this.newQuestFeed();
-  
+
   // Instancie l'agent approprié par ex. 'aiAgent@gpt-4o-assistant'
   const agent = await new AiAgent(this).create(agentId, feedId);
- 
-  // Continue la conversation sur ce contexte par ex. 'story-xyz' et 
+
+  // Continue la conversation sur ce contexte par ex. 'story-xyz' et
   // obtient une réponse à la question de l'utilisateur
   const response = await agent.chat(contextId, question, desktopId);
 
@@ -92,40 +102,13 @@ async askAgent(desktopId, agentId, contextId, question, saveExchange = false) {
 }
 ```
 
-### Résumer et "squasher" un contexte
-
-```javascript
-
-// Dans une méthode d'un acteur Elf
-async resumeAndSquashContexte(agentId, contextId) {
-  const feedId = await this.newQuestFeed();
-  
-  // Instancie l'agent approprié par ex. 'aiAgent@gpt-4o-assistant'
-  const agent = await new AiAgent(this).create(agentId, feedId);
-
-  // Demande un résumé des échanges
-  const resumePrompt = "Résume l'essentiel de nos échanges en utilisant l'historique des messages";
-  const resumedContent = await agent.resumeExchange(resumePrompt, contextId);
-
-  // Reset la mémoire contextuel et persiste le changement
-  await agent.reset(contextId, true);
-
-  // Ajoute un nouvel historique d'échange a partir du résumé 
-  await agent.set(contextId, [{role: 'assistant', content: resumedContent}]);
-
-  // Sauve ce nouvel état
-  await agent.save();
-}
-```
-
 ### Utilisation d'outils externes
 
 ```javascript
-
 // Dans une méthode d'un acteur Elf
 async addWeatherToolSupportToAgent(agentId) {
   const feedId = await this.newQuestFeed();
-  
+
   // Instancie l'agent approprié par ex. 'aiAgent@gpt-4o-assistant'
   const agent = await new AiAgent(this).create(agentId, feedId);
 
@@ -154,25 +137,17 @@ async addWeatherToolSupportToAgent(agentId) {
       }
     ]
   });
-}
-
-
-// L'agent pourra maintenant utiliser l'outil weather.getWeather
-const question = "Quel temps fait-il à Paris aujourd'hui?";
-const response = await agent.chat(contextId, question, desktopId);
 
+  // L'agent pourra maintenant utiliser l'outil weather.getWeather
+  const question = "Quel temps fait-il à Paris aujourd'hui?";
+  const response = await agent.chat(contextId, question, desktopId);
+}
 ```
 
 ### Génération d'embeddings pour la recherche sémantique
 
 ```javascript
-
 // Dans une méthode d'un acteur Elf
-// {
-//  'indexContent@article-1', 'Contenu à indexer'
-//  'indexContent@article-2', 'Un autre contenu à indexer'
-// }
-//
 async updateKnowledgeBase(articles) {
   const feedId = await this.newQuestFeed();
 
@@ -189,9 +164,9 @@ async updateKnowledgeBase(articles) {
   // Générer des embeddings pour plusieurs textes en une seule requête
   const vectorsBatch = await agent.embedInBatch(texts);
 
-  // Upsert les articles dans un archetype IndexedContent 
+  // Upsert les articles dans un archetype IndexedContent
   for(const articleId of articleIds) {
-    // Récupère les vecteurs correspondant au texte dans le lot 
+    // Récupère les vecteurs correspondant au texte dans le lot
     // et le texte original
     const index = articleIds.indexOf(articleId);
     const vectors = vectorsBatch[index];
@@ -216,66 +191,40 @@ async updateKnowledgeBase(articles) {
     );
   }
 }
-
-// Dans une méthode d'un acteur Elf
-async queryKnowledgeBase(question = "Comment fonctionne l'apprentissage par renforcement?") {
-  const feedId = await this.newQuestFeed();
-
-  // Instancie l'agent approprié pour faire un embedding
-  // par ex. 'aiAgent@default-embedder'
-  const agent = await new AiAgent(this).create(agentId, feedId);
-
-  // Générer un embedding pour un texte, par ex. pour une recherche
-  // Convertit la question texte en vecteurs
-  const vectors = await agent.embed(question);
-
-  // Effectue une recherche par similitude dans cryo
-  // Utilise un Archetype "IndexedContent"
-  // Limite la recherche au contenu indexé en français
-  // avec un scope 'knowledge-base'
-  // les 100 premier résultats les plus pertinents
-  const results = await this.cryo.searchDistance2(
-    IndexedContentLogic.db,
-    vectors,
-    ['fr'],
-    ['knowledge-base'],
-    100
-  );
-
-  // Itère sur les données et retourne les résultats
-  // a l'appelant
-  return Array.from(results);
-}
 ```
 
 ## Interactions avec d'autres modules
 
 Le module `goblin-agents` interagit avec plusieurs autres composants de l'écosystème Xcraft :
 
-- **xcraft-core-goblin** : Fournit l'infrastructure Elf pour la création d'acteurs
-- **xcraft-core-stones** : Utilisé pour la définition des types de données
-- **xcraft-core-utils** : Utilisé pour les appels API REST et la gestion des verrous
+- **[xcraft-core-goblin]** : Fournit l'infrastructure Elf pour la création d'acteurs
+- **[xcraft-core-stones]** : Utilisé pour la définition des types de données
+- **[xcraft-core-utils]** : Utilisé pour les appels API REST et la gestion des verrous
+- **[xcraft-core-etc]** : Utilisé pour la gestion de la configuration du module
 
 Le module peut également interagir avec d'autres services Goblin via le système d'appels d'outils, permettant aux agents d'effectuer des actions concrètes dans l'application.
 
 ## Configuration avancée
 
-- **version** : Version des agents (par défaut: 2)
-- **defaultProfile** : Profil par défaut des agents (par défaut: null)
-- **defaultSettings** : Paramètres par défaut (par défaut: null)
-- **profiles** : Profils pour remplacer les paramètres (par défaut: {})
-- **settings** : Paramètres par nom (par défaut: {})
+| Option          | Description                           | Type   | Valeur par défaut |
+| --------------- | ------------------------------------- | ------ | ----------------- |
+| version         | Version des agents                    | Number | 2                 |
+| defaultProfile  | Profil par défaut des agents          | String | null              |
+| defaultSettings | Paramètres par défaut                 | Object | null              |
+| profiles        | Profils pour remplacer les paramètres | Object | {}                |
+| settings        | Paramètres par nom                    | Object | {}                |
 
 ## Détails des sources
 
 ### `aiAgent.js`
 
-Ce fichier est le point d'entrée du module, exportant les commandes Xcraft pour l'acteur AiAgent. Il importe l'acteur et sa logique depuis le fichier principal et les expose au système Xcraft.
+Ce fichier est le point d'entrée du module, exportant les commandes Xcraft pour l'acteur AiAgent. Il importe l'acteur et sa logique depuis le fichier principal et les expose au système Xcraft via `Elf.birth()`.
 
 ### `config.js`
 
 Ce fichier définit la configuration du module, permettant de spécifier :
 
+- La version des agents (`version`)
 - Le profil par défaut des agents (`defaultProfile`)
 - Les paramètres par défaut (`defaultSettings`)
 - Les profils pour remplacer les paramètres (`profiles`)
@@ -294,38 +243,161 @@ Ce fichier contient la définition complète de l'acteur AiAgent, avec :
 - **AiAgentLogic** : Logique métier de l'agent (mutations d'état)
 - **AiAgent** : Classe principale de l'acteur avec les méthodes d'interaction
 
-L'acteur AiAgent offre de nombreuses méthodes pour interagir avec les modèles de langage, gérer les conversations, et utiliser des outils externes. Il prend en charge différentes configurations et options pour personnaliser le comportement des modèles.
+#### État et modèle de données
+
+L'état d'un agent IA est défini par la classe `AiAgentShape` qui contient les propriétés suivantes :
+
+- `id` : Identifiant unique de l'agent
+- `version` : Version de l'agent
+- `name` : Nom de l'agent
+- `role` : Rôle de l'agent (assistant, etc.)
+- `prompt` : Prompt par défaut utilisé pour définir le comportement de l'agent
+- `provider` : Fournisseur LLM ('ollama' ou 'open-ai')
+- `model` : Modèle de langage utilisé
+- `host` : URL du serveur LLM
+- `headers` : En-têtes HTTP pour les requêtes API
+- `messages` : Historique des messages par contexte
+- `options` : Options de configuration du modèle (voir OptionsShape)
+- `format` : Format de sortie attendu
+- `tools` : Outils externes disponibles pour l'agent
+- `toolServiceId` : Identifiant du service d'outils
+- `usability` : État d'utilisabilité ('disabled', 'experimental', 'stable', 'deprecated')
+- `meta` : Métadonnées de l'agent
+
+La classe `OptionsShape` définit de nombreuses options de configuration pour les modèles LLM, incluant des paramètres comme la température, la taille du contexte, les pénalités de répétition, et les options d'optimisation mémoire.
+
+#### Cycle de vie de l'acteur
+
+L'acteur AiAgent suit le cycle de vie standard des acteurs Elf Archetype :
+
+1. **Création** : Via la méthode `create()` qui initialise l'agent avec un ID et un état
+2. **Configuration** : Via `patch()` pour modifier les paramètres ou `upgrade()` pour les mises à jour de version
+3. **Utilisation** : Via les méthodes de conversation et de génération
+4. **Persistance** : Via `save()` pour sauvegarder l'état
+5. **Suppression** : Via `trash()` pour marquer comme supprimé ou `delete()` pour suppression définitive
+
+#### Méthodes publiques
 
-Les options de configuration sont particulièrement riches et permettent d'ajuster finement le comportement des modèles, notamment :
-- Gestion de la mémoire (NUMA, VRAM)
-- Taille du contexte et traitement par lots
-- Paramètres de génération (température, top_k, top_p)
-- Pénalités pour éviter les répétitions
-- Algorithmes adaptatifs comme Mirostat
+**`create(id, desktopId, agentState)`** - Crée un nouvel agent avec l'ID et l'état spécifiés. Persiste automatiquement l'agent après création.
+
+**`patch(agentState)`** - Met à jour l'état de l'agent avec les propriétés fournies et persiste les changements.
+
+**`upgrade(version, agentState)`** - Met à niveau l'agent vers une nouvelle version avec l'état spécifié, uniquement si la version est supérieure à la version actuelle.
+
+**`gen(prompt)`** - Génère du texte à partir d'un prompt en utilisant le modèle configuré de l'agent.
+
+**`reset(contextId, save)`** - Réinitialise l'historique des messages pour un contexte spécifique. Si aucun contextId n'est fourni, réinitialise tous les contextes.
+
+**`readPDFpages(pdfPath)`** - Extrait le texte des pages d'un document PDF en utilisant l'OCR via un modèle multimodal.
+
+**`embed(rawText)`** - Génère un embedding vectoriel pour un texte donné, retourné sous forme de littéral SQL hexadécimal.
+
+**`embedInBatch(rawTexts)`** - Génère des embeddings vectoriels pour plusieurs textes en une seule requête, optimisé pour les traitements par lots.
+
+**`set(contextId, messages)`** - Définit directement l'historique des messages pour un contexte spécifique.
+
+**`chat(contextId, question, userDesktopId, sessionId)`** - Engage une conversation avec l'agent dans un contexte spécifique. Gère automatiquement l'historique et les appels d'outils.
+
+**`ask(contextId, question, questionId)`** - Pose une question à l'agent avec streaming de la réponse (uniquement pour Ollama). Émet des événements pour chaque partie de la réponse.
+
+**`resumeExchange(resumePrompt, contextId)`** - Reprend un échange existant avec un nouveau prompt système, en utilisant l'historique du contexte comme base.
+
+**`react(reactPrompt, contextId, question)`** - Utilise le paradigme ReAct (Reasoning and Acting) pour permettre à l'agent de raisonner et d'agir de manière autonome.
+
+**`callAgent(contextId, agentId, action, feedId)`** - Appelle un autre agent pour effectuer une action spécifique dans le cadre d'une orchestration multi-agents.
+
+**`addAssistantMessage(contextId, message)`** - Ajoute un message de l'assistant à l'historique d'un contexte spécifique.
+
+**`change(path, newValue)`** - Modifie une propriété spécifique de l'état de l'agent avec gestion automatique des types pour certains paramètres.
+
+**`getUserChatContextHistory(contextId, filterTool)`** - Récupère l'historique des messages pour un contexte spécifique avec option de filtrage des messages d'outils.
+
+**`getBaseSettings()`** - Retourne les paramètres de base de l'agent (provider, host, headers, model).
+
+**`getUsability()`** - Retourne l'état d'utilisabilité de l'agent.
+
+**`trash()`** - Marque l'agent comme supprimé en changeant son statut meta à 'trashed'.
+
+**`save()`** - Persiste l'état actuel de l'agent sur le disque.
 
 ### `lib/llm/providers.js`
 
-Ce fichier définit les classes pour interagir avec différents fournisseurs de LLM :
+Ce fichier définit l'architecture des fournisseurs de LLM avec une classe abstraite `LLMProvider` et ses implémentations concrètes :
+
+#### LLMProvider (classe abstraite)
+
+Définit l'interface commune que tous les fournisseurs doivent implémenter :
+
+- `chat()` : Conversation avec le modèle
+- `gen()` : Génération de texte
+- `embed()` : Génération d'embeddings
+- `embedInBatch()` : Génération d'embeddings par lots
 
-- **LLMProvider** : Classe abstraite définissant l'interface commune
-- **OllamaProvider** : Implémentation pour le fournisseur Ollama (local)
-- **OpenAIProvider** : Implémentation pour OpenAI et services compatibles
+#### OllamaProvider
 
-Ces classes encapsulent les détails d'implémentation spécifiques à chaque fournisseur, offrant une interface unifiée pour le reste du module. Elles gèrent les différences dans les formats de requête et de réponse, permettant à l'acteur AiAgent de fonctionner de manière transparente avec différents fournisseurs.
+Implémentation pour le fournisseur Ollama (serveur local) :
+
+- Utilise la bibliothèque `ollama` pour communiquer avec le serveur
+- Gère le streaming pour les conversations en temps réel
+- Implémente un sémaphore pour limiter les requêtes d'embedding simultanées (max 4)
+- Supporte tous les formats de sortie JSON structurés
+
+#### OpenAIProvider
+
+Implémentation pour OpenAI et services compatibles (OpenRouter, etc.) :
+
+- Utilise `RestAPI` de xcraft-core-utils pour les appels HTTP
+- Adapte les formats de requête entre Ollama et OpenAI
+- Gère les schémas JSON pour les réponses structurées
+- Supporte les en-têtes d'authentification personnalisés
 
 ### `lib/llm/utils.js`
 
-Ce fichier contient diverses fonctions utilitaires pour :
+Ce fichier contient un ensemble complet d'utilitaires pour le traitement de texte et de documents :
+
+#### Traitement de documents PDF
+
+**`getPDFImages(pdfPath)`** - Convertit les pages d'un PDF en images base64 pour l'OCR avec des options optimisées pour la qualité du texte.
+
+**`OCR_SYSTEM_PROMPT`** - Prompt système spécialisé pour guider les modèles multimodaux dans l'extraction de texte à partir d'images.
+
+#### Traitement de texte et HTML
+
+**`cleanHtmlContent(html)`** - Nettoie le contenu HTML en supprimant les balises et en normalisant les espaces.
+
+**`simplifyHtml(html)`** - Simplifie le HTML en gardant uniquement les éléments sûrs via sanitize-html.
+
+**`extractTitlesAndContent(html)`** - Extrait intelligemment les titres et le contenu d'un document HTML en préservant la structure.
+
+**`html2chunks(html, chunkSize, chunkOverlap)`** - Découpe un document HTML en chunks en utilisant RecursiveCharacterTextSplitter de LangChain.
+
+#### Gestion des tokens et découpage
+
+**`estimateTokenCount(text)`** - Estime le nombre de tokens d'un texte (approximation basée sur les mots × 1.33).
+
+**`splitLongText(text, maxLength, baseId)`** - Découpe un texte long en segments de taille maximale en préservant les mots entiers.
+
+**`sliceText(text, chunkSize)`** - Découpe un texte en chunks en respectant les limites de phrases.
+
+**`groupSentences(text, maxSize)`** - Groupe les phrases en chunks de taille optimale pour les modèles de langage.
+
+#### Traitement par lots et optimisation
+
+**`chunkArray(array, size)`** - Divise un tableau en sous-tableaux de taille spécifiée pour le traitement par lots.
+
+**`embedChunksInBatch(agent, allChunks, batchSize)`** - Traite les embeddings par lots en associant chaque embedding à son contenu d'origine.
+
+**`buildPromptFromArticlesMulti(initialQuestion, questionsWithArticles, maxTotalTokens)`** - Construit des prompts optimisés à partir de multiples articles en respectant les limites de tokens.
+
+#### Utilitaires de conversion
 
-- Extraction de texte à partir d'images PDF (`getPDFImages`)
-- Nettoyage et simplification de contenu HTML (`cleanHtmlContent`, `simplifyHtml`)
-- Découpage de texte en segments gérables (`splitLongText`, `html2chunks`)
-- Estimation du nombre de tokens (`estimateTokenCount`)
-- Construction de prompts à partir d'articles (`buildPromptFromArticles`)
-- Traitement par lots des embeddings (`embedChunksInBatch`, `chunkArray`)
+**`vectorToSqlLiteral(vec)`** - Convertit un vecteur Float32Array en littéral SQL hexadécimal pour le stockage en base de données.
 
-Ces utilitaires sont essentiels pour préparer les données avant de les envoyer aux modèles de langage et pour traiter les résultats. Ils permettent notamment de gérer les contraintes de taille de contexte des modèles en découpant intelligemment les textes longs.
+Ces utilitaires sont essentiels pour préparer les données avant de les envoyer aux modèles de langage et pour traiter les résultats. Ils permettent notamment de gérer les contraintes de taille de contexte des modèles en découpant intelligemment les textes longs tout en préservant la cohérence sémantique.
 
-Le module inclut également des fonctionnalités spécifiques pour l'OCR (reconnaissance optique de caractères) avec un prompt système dédié (`OCR_SYSTEM_PROMPT`) qui guide les modèles multimodaux dans l'extraction de texte à partir d'images.
+_Cette documentation a été mise à jour automatiquement._
 
-*Ce document est une mise à jour de la documentation précédente.*
+[xcraft-core-goblin]: https://github.com/Xcraft-Inc/xcraft-core-goblin
+[xcraft-core-stones]: https://github.com/Xcraft-Inc/xcraft-core-stones
+[xcraft-core-utils]: https://github.com/Xcraft-Inc/xcraft-core-utils
+[xcraft-core-etc]: https://github.com/Xcraft-Inc/xcraft-core-etc

package/lib/llm/providers.js

@@ -151,7 +151,11 @@ class OpenAIProvider extends LLMProvider {
     const chat = await this.#openAI._post(query, chatRequest);
     const {choices} = chat;
     if (chat.error) {
-      const err = new Error(chat.error.message);
+      const err = new Error(
+        chat.error?.metadata
+          ? JSON.stringify(chat.error?.metadata)
+          : chat.error.message
+      );
       err.code = chat.error.code;
       throw err;
     }

package/lib/llm/utils.js

@@ -77,7 +77,7 @@ const splitLongText = (text, maxLength, baseId) => {
   return segments;
 };
 
-const html2chunks = async (html, chunkSize = 1000, chunkOverlap = 0) => {
+const html2chunks = async (html, chunkSize = 300, chunkOverlap = 0) => {
   const textSplitter = RecursiveCharacterTextSplitter.fromLanguage('html', {
     chunkSize,
     chunkOverlap,
@@ -223,58 +223,46 @@ function groupSentences(text, maxSize) {
   return chunks;
 }
 
-const buildPromptFromArticles = (articles, question, maxTokens) => {
-  let context = '[CONTEXT]\n\n';
-  let currentTokenCount = estimateTokenCount(context);
-
-  articles.forEach((article) => {
-    const {kind, title, link, locale} = article;
-    const articleContext = `# ${kind}: ${title} #\nLien: ${link}\n Langue: ${locale}\n`;
-
-    context += articleContext;
-
-    if (article.segments && article.segments.length > 0) {
-      context += '## Segments pertinents: ##\n';
-      article.segments
-        .sort((a, b) => b.score - a.score) // Trier par pertinence
-        .forEach((s, i) => {
-          let segmentContext = `  ${i + 1}. ${s.segment} (Pertinence: ${
-            s.score
-          })\n`;
-          currentTokenCount += estimateTokenCount(segmentContext);
-
-          if (currentTokenCount > maxTokens) {
-            return;
-          }
-
-          context += segmentContext;
-
-          // Ajouter du contexte avant et après le segment
-          const beforeContext = article.content.substring(
-            Math.max(0, s.start - 50),
-            s.start
-          );
-          const afterContext = article.content.substring(
-            s.end,
-            Math.min(article.content.length, s.end + 50)
-          );
-
-          const additionalContext = `### Contexte avant: ###\n${beforeContext}\n### Contexte après: ###\n${afterContext}\n`;
-          currentTokenCount += estimateTokenCount(additionalContext);
+function buildPromptFromArticlesMulti(
+  initialQuestion,
+  questionsWithArticles,
+  maxTotalTokens
+) {
+  let prompt = '[CONTEXT]\n\n';
+  let currentTokenCount = estimateTokenCount(prompt);
+
+  const buffer = 16000; // Réserve de tokens pour l'instruction + réponse
+  const maxTokensPerQuestion = Math.floor(
+    (maxTotalTokens - buffer) / questionsWithArticles.length
+  );
+
+  for (const {articles} of questionsWithArticles) {
+    let section = '';
+    let sectionTokenCount = estimateTokenCount(section);
+    for (const article of articles) {
+      const {title, sourceId, description} = article;
+      const articleBlock = `\n# ${title} \n## Lien: ${sourceId}\n\n${description}\n`;
+      const tokensForArticle = estimateTokenCount(articleBlock);
+
+      if (sectionTokenCount + tokensForArticle > maxTokensPerQuestion) {
+        break;
+      }
 
-          if (currentTokenCount > maxTokens) {
-            return;
-          }
+      section += articleBlock;
+      sectionTokenCount += tokensForArticle;
+    }
 
-          context += additionalContext;
-        });
+    if (currentTokenCount + sectionTokenCount > maxTotalTokens - buffer) {
+      break;
     }
-  });
 
-  const questionContext = '[QUESTION]\n\n' + question;
-  context += questionContext;
-  return context.trim();
-};
+    prompt += section;
+    currentTokenCount += sectionTokenCount;
+  }
+  const questionContext = '[QUESTION]\n\n' + initialQuestion;
+  prompt += questionContext;
+  return prompt.trim();
+}
 
 /**
  * Split an array into smaller chunks of a given size.
@@ -301,7 +289,7 @@ function chunkArray(array, size) {
  * @returns {Promise<object>} A map of embeddings structured as:
  *    { [contentId]: { [key]: { chunk, embedding } } }
  */
-async function embedChunksInBatch(agent, allChunks, batchSize = 500) {
+async function embedChunksInBatch(agent, allChunks, batchSize = 50) {
   const embeddingsByContent = {};
 
   for (let start = 0; start < allChunks.length; start += batchSize) {
@@ -340,5 +328,5 @@ module.exports = {
   getPDFImages,
   sliceText,
   groupSentences,
-  buildPromptFromArticles,
+  buildPromptFromArticlesMulti,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goblin-agents",
-  "version": "0.1.5",
+  "version": "0.1.11",
   "description": "AI Agents framework",
   "author": "Samuel Loup",
   "license": "MIT",