Feuille de route

Objectif : Construire un Hub de Connecteurs alimenté par l’IA — Autonome (assistant de portail), Copilote (intégré au système hôte), Hub (orchestration centrale inter-systèmes). Principes : Agnostique des fournisseurs (pas de verrouillage propriétaire), abstraction minimale, orienté protocole, orienté connecteur (l’intégration est la valeur fondamentale).

​

Vision du Produit

Standalone   → Votre propre assistant IA (Portal)
Copilot      → IA intégrée dans un système hôte (iframe / widget / embed)
Hub          → Orchestration centrale inter-systèmes (Portal / API)

​

Versions Livrées

​

v0.1 (2026-02-22) — MVP: ReAct + DAG Planner

• ReActAgent avec outils (calculatrice, python_exec, web_search)
• DAG Planner (LLM génère des graphes de dépendances)
• Portal UI avec streaming + KaTeX

​

v0.2 (2026-02-24) — Multi-Model + Memory

• Retry / rate limiting / usage tracking
• Native function calling (no JSON-only parsing)
• Multi-model support (fast + main LLM)
• Memory: WindowMemory, SummaryMemory
• FastAPI backend with SSE streaming

​

v0.3 (2026-02-25) — Web Tools + MCP

• Web tools (web_search, web_fetch) via Jina/Tavily/Brave
• File operations tool
• MCP client (standard tool integration)
• Tool auto-discovery + categories
• DAG visualization with click-to-scroll
• Code exec in Docker (--network=none)

​

v0.4 (2026-02-25) — Conversations multi-tours + Agents

• Conversations multi-tours (DbMemory)
• Interface de repliement des étapes d’outils
• Outils de requête HTTP + exécution shell
• Gestion des agents (créer, configurer, publier)
• Authentification JWT
• Mode d’exécution par agent + contrôle de température

​

v0.5 (2026-02-28) — Full RAG + Grounded Gen

• Pipeline RAG complet (embedding + vector store + FTS + RRF + reranker)
• Génération ancrée (citations, détection de conflits, scores de confiance)
• Gestion des documents de la base de connaissances (CRUD, recherche, retry, migration de schéma)
• ContextGuard + messages épinglés (gestionnaire de budget de tokens)
• Persistance DbMemory + LLM Compact
• DAG Re-Planning (jusqu’à 3 rounds)

​

v0.6 (2026-03-01) — Plateforme de connecteurs

• CRUD de connecteur: créer, lire, mettre à jour, supprimer
• ConnectorToolAdapter: convertit Connecteur → BaseTool
• Identifiants par utilisateur: chiffrement AES-GCM
• Portail de confirmation: approbation des opérations d’écriture
• Journalisation d’audit: tous les appels d’outils enregistrés
• Disjoncteur: dégradation progressive en cas de défaillance
• Outils utilitaires: email_send, json_transform, template_render, text_utils
• Options d’intégration: Jina, OpenAI, fournisseurs personnalisés

​

v0.7 (2026-03-06) — Plateforme d’administration + Multi-locataire

• Plateforme d’administration : gestion des utilisateurs, basculement des rôles, réinitialisation de mot de passe, activation/désactivation de compte
• Inscription sur invitation uniquement : trois modes (ouvert/invitation/désactivé) + CRUD de code d’invitation
• Gestion du stockage : utilisation disque par utilisateur, effacement, nettoyage des orphelins
• Modération des conversations : liste d’administration/suppression de tous
• Déconnexion forcée par utilisateur : révocation de tous les jetons
• Tableau de bord de santé API : statistiques système, métriques des connecteurs
• Assistant de configuration initiale : création guidée du compte administrateur
• Centre personnel : instructions globales par utilisateur, préférence de langue
• Authentification JWT : authentification SSE basée sur jetons, propriété de conversation
• Serveurs MCP globaux : provisionnés par l’administrateur, chargés dans toutes les sessions
• Compatibilité rétroactive : migration automatique registration_enabled → registration_mode

​

v0.7.x (2026-03-07 to 2026-03-12) — Stabilité + Polissage

• Gestion des codes d’invitation
• Quotas par utilisateur (application 429)
• Journalisation d’audit structurée
• Filtrage des mots sensibles
• Historique de connexion administrateur
• Navigateur de fichiers administrateur
• Vues administrateur améliorées (champs model_name, tools, kb_ids)
• Déploiement Docker Compose (image unique, volumes nommés)
• Détection automatique OAuth depuis window.location
• Support de la réflexion étendue / raisonnement (LLM_REASONING_EFFORT, LLM_REASONING_BUDGET_TOKENS) pour OpenAI série o, Gemini 2.5+, Claude
• Activation/désactivation par outil administrateur (outils désactivés exclus du chat à l’exécution)
• Gestion des serveurs MCP déplacée vers la page Connecteurs
• Support de base de données double : SQLite (par défaut zéro-config) + PostgreSQL (production) ; Docker Compose provisionne automatiquement PostgreSQL
• Page de documentation de configuration des modèles avec configuration de la réflexion étendue par fournisseur
• Protocole SSE v2 : streaming de réponse en temps réel avec champs delta_reasoning, usage, et événements done/suggestions/title/end séparés ; taille du pool SQLite 5 -> 20
• Expansion AI Builder : 7 nouveaux outils de construction (GetSettings, TestConnection, ImportOpenAPI pour connecteurs ; ListConnectors, AddConnector, RemoveConnector, SetModel pour agents), drapeau is_builder sur agents, actualisation automatique du prompt du constructeur, garde SSRF
• Frontend SSE v2 : curseur pulsant avec points animés, snapshots de re-planification DAG sous forme de cartes réductibles, mise en page DAG découplée des états d’étapes
• Page de documentation du concept AI Builder avec guides de construction de connecteurs et d’agents
• Système d’organisation : CRUD complet avec adhésion basée sur les rôles (propriétaire/administrateur/membre), interface de gestion administrateur
• Visibilité des ressources à trois niveaux (personnel/org/global) pour agents, connecteurs, bases de connaissances, serveurs MCP
• API Publier/dépublier pour tous les types de ressources ; délégation de propriétaire pour agents publiés
• Point de terminaison administrateur set-visibility (remplace clone-to-global) ; assistant de requête build_visibility_filter() unifié
• Connecteurs de base de données (Phase 1-3) : accès SQL direct à PG/MySQL/Oracle/SQL Server + BD héritées chinoises ; introspection de schéma, annotation IA, exécution de requête en lecture seule, identifiants chiffrés, 3 outils par connecteur (list_tables, describe_table, query)
• Centre d’évaluation : benchmarking quantitatif de la qualité des agents — CRUD d’ensemble de test (invite + comportement attendu + assertions), exécutions d’éval (exécution parallèle + évaluateur LLM + résultats par cas réussi/échoué/latence/jetons), visionneuse de résultats avec interrogation automatique ; migration r8t0v2x4z567
• Trois rôles de modèle (Général/Rapide/Raisonnement) avec isolation de configuration env par niveau ; le modèle rapide n’hérite plus des paramètres du modèle principal
• Classe de données StepOutput remplaçant les résultats d’étapes en chaîne simple pour les données structurées et le passage d’artefacts
• Cache d’outils pour l’exécution DAG — appels d’outils identiques mis en cache par exécution avec verrouillage asynchrone de prévention de ruée (DAG_TOOL_CACHE)
• Vérification LLM par étape avec 1 nouvelle tentative en cas d’échec (DAG_STEP_VERIFICATION)
• Routage automatique : LLM rapide classe les requêtes comme ReAct ou DAG ; point de terminaison /api/auto ; bascule de mode 3 voies frontend (AUTO_ROUTING)
• Organisation de plateforme + Abonnements aux ressources : Org de plateforme intégré rejoint automatiquement tous les utilisateurs ; API Marché pour s’abonner aux ressources partagées ; tableau d’abonnements aux ressources ; partage de ressources basé sur org remplaçant la visibilité globale
• Découverte automatique d’agent et liaison de sous-agent : drapeau discoverable sur agents ; liste blanche sub_agent_ids ; CallAgentTool pour déléguer des tâches aux agents spécialistes
• Identifiants du serveur MCP + Remplacement par utilisateur : tableau mcp_server_credentials ; point de terminaison PUT /api/mcp-servers/{id}/my-credentials ; drapeau allow_fallback pour le comportement de secours des identifiants
• Bascule connecteur/KB : POST /api/connectors/{id}/toggle et POST /api/knowledge-bases/{id}/toggle pour suspendre/reprendre les ressources
• Conversations KB autonomes : champ kb_ids sur conversations pour le chat KB direct sans liaison d’agent

​

Versions Planifiées

​

v0.8 — Configuration déclarative des connecteurs + Divulgation progressive

• Connecteurs de base de données : accès SQL direct (PostgreSQL, MySQL, Oracle) (livré en v0.7.x — Phase 1-3)
• RBAC : contrôle d’accès aux connecteurs par utilisateur/rôle (livré en v0.7.x — système org + visibilité à trois niveaux)
• Chiffrement des identifiants de connecteur + remplacement par utilisateur : table connector_credentials, chiffrement Fernet via CREDENTIAL_ENCRYPTION_KEY, drapeau allow_fallback, points de terminaison GET/PUT/DELETE /my-credentials, résolution des identifiants par utilisateur lors du chargement des outils de chat
• Interface d’examen de publication : Système d’examen de publication au niveau de l’organisation — bascule d’examen par organisation, ReviewsSheet avec flux d’approbation/rejet, badges de statut sur les cartes de ressources, avis d’examen dans la boîte de dialogue de publication, renvoi pour les ressources rejetées
• Divulgation progressive des connecteurs (Phase 1-2) : un seul ConnectorMetaTool remplace les outils par action ; le message système reçoit uniquement des stubs légers (nom + description d’une ligne, ~30 tokens/connecteur vs ~250 tokens/action) ; l’agent appelle discover(connector) pour charger le schéma d’action complet à la demande — le schéma ne se charge que lorsque le modèle sélectionne un connecteur, maintenant le préfixe du message stable pour la mise en cache. Reflète le modèle interne defer_loading: true de Claude Code. Sous-commande execute ; drapeau de fonctionnalité pour la rétrocompatibilité.
• Système de compétences d’agent + Instructions compactes : Chargement à la demande des compétences pour les instructions d’agent — modèle Skill (nom, contenu/SOP, scripts optionnels) attaché aux agents ; référencé dans le message système par nom uniquement (~10 tokens/compétence) ; l’agent appelle read_skill(name) pour charger le contenu complet à la demande. Réduit le coût en tokens d’instruction par conversation d’environ 80 % tout en permettant des bibliothèques SOP plus riches. Homologue de la divulgation progressive de ConnectorMetaTool appliquée au niveau des instructions. Active la différenciation de l’histoire « instructions + outils + compétences ». Ajoute également le champ compact_instructions au modèle Agent — liste de priorités de compression par agent injectée dans ContextGuard lors de la compression (par exemple, « préserver les ID et montants des commandes, supprimer les réponses API brutes »), remplaçant l’invite générique statique actuelle. Inspiré par le modèle Compact Instructions de Claude Code.
• Configuration de connecteur YAML/JSON : la plateforme génère automatiquement le serveur MCP
• Import/export de connecteur : partager des modèles de connecteur
• Fork de connecteur : cloner et personnaliser les connecteurs existants
• Connecteurs de base de données Phase 4 : pilotes d’entreprise — Oracle (oracledb), SQL Server (aioodbc), 达梦 DM8 (aioodbc + DM ODBC), 南大通用 GBase (aioodbc + GBase ODBC)
• Notification push de message : Actions de notification Lark, WeCom, Slack, Email
• Système de modèle de flux de travail : Éditeur de flux de travail visuel pour concevoir et exécuter des blueprints d’automatisation multi-étapes — modèles ORM Workflow / WorkflowRun, CRUD complet + API d’exécution SSE, import/export, WorkflowEngine avec exécution topologique et 12 types de nœuds (Start, End, LLM, ConditionBranch, QuestionClassifier, Agent, KnowledgeRetrieval, Connector, HTTPRequest, VariableAssign, TemplateTransform, CodeExecution), éditeur visuel React Flow v12 avec palette glisser-déposer et panneau de configuration de nœud, sécurité d’exécution basée sur subprocess
• Audit opérationnel : journalisation détaillée de qui a fait quoi — onglet d’audit du journal d’examen administrateur ajouté (piste d’examen de publication par organisation/ressource)
• Annotations de schéma sémantique : étendre les champs de schéma de connecteur avec les drapeaux semantic_tag, description et pii ; annotations affichées dans les descriptions d’outils LLM pour que l’agent comprenne l’intention du champ sans deviner à partir des noms de colonnes

​

v0.9 — Observabilité + Durcissement de la production

• Divulgation progressive des connecteurs (Phase 3-4) : interface ConnectorExecutor unifiée (API/DB/MCP derrière une seule abstraction) ; validation des paramètres d’action avec jsonschema ; découverte et exécution agnostiques du protocole
• Couche de trace d’agent (Observabilité++) : Hiérarchie run/trace/thread au niveau de l’application pour le débogage des agents — chaque conversation → Trace, chaque appel LLM / appel d’outil / étape DAG → Span avec entrée/sortie/tokens/timing. Visionneuse de trace frontend avec chronologie et charges utiles d’appels LLM extensibles. Cela va au-delà d’OTel (niveau infrastructure) pour fournir un débogage de boucle d’agent exploitable pour les développeurs et les clients d’entreprise. Export OpenTelemetry comme option de récepteur de données. Modélisé d’après les concepts run/trace/thread de LangSmith — le modèle validé par l’industrie pour l’observabilité des agents.
• Tableau de bord des métriques : latence, taux de succès, utilisation des tokens, analytique des appels de connecteurs — par agent, par utilisateur, par org
• Disjoncteur : backoff exponentiel, détection de défaillance
• Système de hooks d’agent : Une couche d’application déterministe qui s’exécute en dehors de la boucle LLM — les hooks s’exécutent automatiquement sur les événements d’outil et ne peuvent pas être contournés par les instructions de l’agent. Trois points de hook : PreToolUse (valider / bloquer avant l’exécution), PostToolUse (effets secondaires après l’exécution), SessionStart (injecter du contexte dynamique). Hooks intégrés : écriture automatique de ConnectorCallLog à chaque appel de connecteur (actuellement manuel) ; blocage des opérations d’écriture quand l’org est en mode lecture seule ; troncature automatique des résultats de requête DB surdimensionnés avant qu’ils n’atteignent l’agent ; limitation du débit par fréquence d’appel de connecteur. Hooks définis par l’utilisateur : configuration YAML par agent (champ hooks:) déclarant des commandes shell ou des callables Python déclenchés sur les événements d’outil correspondants — même modèle que les hooks de Claude Code. Principe de conception clé : les hooks sont pour la logique “doit toujours se produire” qui ne devrait jamais dépendre du LLM se souvenant de le faire. Les instructions disent « enregistrer tous les appels » ; les hooks les enregistrent réellement. Les instructions disent « ne pas écrire en mode lecture seule » ; les hooks le bloquent réellement.
• Espace de travail d’agent (Déchargement de sortie d’outil + Transfert) : Quand les réponses MCP / connecteur / DB dépassent un seuil (par défaut : 8K caractères), enregistrement automatique de la sortie complète dans un fichier d’espace de travail par conversation (workspace://tool_result_xxx.txt) et retour d’un aperçu tronqué + URI de fichier à l’agent. Trois nouveaux outils intégrés : read_workspace_file(path, start_line, end_line) pour l’accès sélectif, list_workspace_files() pour la découverte, et write_handoff(summary) pour les transitions de contexte — l’agent écrit une note HANDOFF structurée (progression, ce qui a fonctionné, ce qui a échoué, prochaine étape) avant la compression de contexte ou le changement de session ; l’instance d’agent suivante la lit au lieu de dépendre de la qualité du résumé de l’algorithme de compression. Reflète les modèles d’espace de travail + transfert de Claude Code. Prévient la dilution de l’attention sur les grands ensembles de résultats et élimine la perte de données silencieuse due à la troncature. Changement minimal : étendre truncate_tool_output() dans MCPToolAdapter et ConnectorToolAdapter pour écrire dans le stockage d’espace de travail.
• Durcissement du sandbox : améliorations v2 de l’isolation de l’exécution du code
• Tests de performance : benchmarks de charge concurrente
• Mise en pool des connexions MCP : la génération de sous-processus STDIO par requête ne s’adapte pas — 100 utilisateurs concurrents = 100 sous-processus par serveur MCP. Mettre en pool les connexions STDIO avec isolation d’env par utilisateur (clé par (server_id, env_hash)) ; les transports SSE/HTTP partagent les sessions httpx.AsyncClient. Objectif : démarrage à chaud sub-100ms pour STDIO en pool, connexions O(1) HTTP par serveur MCP quel que soit le nombre d’utilisateurs
• Tâches planifiées + Agents déclenchés par événement (Boucle) : déclencheurs de tâches de fond de type cron ; tables DB scheduled_jobs + job_runs ; intégration APScheduler ; API CRUD de tâche + UI d’historique de tâche ; notification de résultat via connecteurs de push de message. La portée couvre à la fois les modèles déclenchés par le temps (cron) et déclenchés par événement (webhook entrant) — un agent s’exécutant de manière asynchrone en arrière-plan EST le cas d’usage du sous-agent asynchrone pour le mode Hub.
• Générateur de schéma DB avancé : agent de gestion de schéma piloté par IA pour les bases de données à grande échelle — annotation stratégique de table (basée sur motif, informée par exécution SQL), gestion de visibilité en masse par préfixe de domaine, annotation itérative multi-tour pour les déploiements de 1K–7K+ tables ; complète le travail d’annotation par lot existant avec sélectivité et raisonnement de contexte métier

​

v1.0 — Connecteur Hot-Plug + Intégrable

• Divulgation Progressive des Connecteurs (Phase 5) : Sélection d’Outils Guidée par Sémantique (extraction d’entités à partir de la requête → recherche dans le Registre d’Ontologie → réduction de l’ensemble de connecteurs ; réduction de 90%+ des jetons pour les déploiements de 50+ connecteurs) ; Mode d’échelle pour les connecteurs batch/ETL ; Interface universelle de style CLI connecteur <nom> <action> <params>
• Alignement d’Entités Inter-Connecteurs (Registre d’Ontologie) : définir les types d’entités partagées (Client, Commande, Actif) avec mappages de champs entre connecteurs ; DAGPlanner résout automatiquement les clés JOIN inter-systèmes ; active les requêtes inter-connecteurs (par ex., « clients dans Salesforce qui ont commandé dans Shopify ») sans noms de champs codés en dur
• Connecteurs hot-plug : télécharger la spécification OpenAPI, l’IA génère la configuration, actif en 5 minutes (pas de redémarrage)
• Marketplace de connecteurs : modèles partagés par la communauté
• Widget intégrable : <script src="fim-one.js"> injecté dans la page hôte
• Injection de contexte de page : le widget lit le contexte de la page hôte (ID actuel, URL, sélecteurs DOM)
• Déclencheurs avancés : événements entrants par webhook ; améliorations des tâches planifiées (multi-fuseau horaire, sensibilité au calendrier)
• Exécution par lot : traiter 1000+ éléments via DAG
• Sécurité d’entreprise : liste blanche IP, chiffrement au repos, SSO
• Éditeur KB Avancé : Agent en mode Builder pour les utilisateurs avancés gérant de grandes bases de connaissances — ingestion d’URL en masse, détection des doublons, analyse des lacunes, gestion du cycle de vie des documents ; étend le chat IA KB existant avec une boucle d’outils ReAct

​

Fonctionnalités figées (Livrées, Maintenance uniquement)

​

À considérer (Reporté indéfiniment)

​

Comment les versions s’alignent avec les modes

​

Allocation des ressources (v0.8–v1.0)

​

Jalons pilotés par les métriques

​

Questions ouvertes / À définir

• Modération de la marketplace : Comment valider les connecteurs communautaires ? (v1.0)
• Économie des tokens : Comment tarifier les scénarios multi-utilisateurs, multi-agents ? (v1.0)
• Désactivation de la télémétrie : Comment respecter les préférences de confidentialité ? (v0.8)
• Versioning des connecteurs : Comment gérer les changements cassants dans les API des connecteurs ? (v0.8)
• Limitation de débit : Par connecteur, par utilisateur ou global ? (v0.8)