Auteur : Antigravity (IA Assistant Système)
Date d'émission : 08 Octobre 2026
Localisation de référence : Guadeloupe (UTC-4)
Contexte opérationnel : Écosystème autonome Raphaël (C:\ASSISTANT_IA)
Verdict Global : FAISABILITÉ TECHNIQUE À 100% (Immédiate, Mature et Éprouvée).
L'interfaçage de n'importe quel nouveau modèle d'IA (DeepSeek-V3/R1, Claude 3.5/3.7/Sonnet, Gemini 2.5/3.8, Qwen 2.5, Llama 3.3) avec l'ensemble des scripts existants de Raphaël sans réentraînement est totalement réalisable dès aujourd'hui.
Cette approche repose sur le standard ouvert Model Context Protocol (MCP) et la convergence industrielle vers JSON Schema Draft 7 / 2020-12 pour le Function Calling in-context.
tool_calls).tools, Anthropic input_schema, Gemini function_declarations) est une opération mathématiquement déterministe de moins de 100 lignes de code Python.C:\ASSISTANT_IA\ugc-studio\mcp_server.py) et d'un proxy de conversion de requêtes (C:\ASSISTANT_IA\BRIDGE_MOTEUR_SECOURS\claude-code-proxy\server.py). Il ne manque qu'un Registre Canonique unifié pour fédérer l'ensemble des scripts de C:\ASSISTANT_IA\tools\.Le Model Context Protocol (MCP) est un protocole ouvert basé sur JSON-RPC 2.0 fonctionnant soit en transport local (stdio via flux d'entrées/sorties standard), soit en transport distant (SSE - Server-Sent Events over HTTP).
flowchart LR
A["Agent Hôte<br/>(Claude Code, Antigravity, DeepSeek)"] -- "JSON-RPC (stdio/SSE)" --> B["Serveur MCP Universel<br/>(jarvis_mcp_server.py)"]
B -- "Exécution Locale" --> C["Scripts Raphaël<br/>(tools/chasse_orchestrateur.py)"]
B -- "Exécution Locale" --> D["Scripts Raphaël<br/>(tools/juge_produit.py)"]
B -- "Exécution Locale" --> E["Scripts Raphaël<br/>(tools/generer_rapport.py)"]
tools/list : Renvoie la liste déclarative des outils disponibles, avec leurs noms, descriptions et arguments formatés en JSON Schema.tools/call : Reçoit le nom de l'outil et les arguments JSON validés, exécute le script sous-jacent, et retourne le résultat textuel ou binaire (type: text|image).resources/list & resources/read : Expose des documents passifs (ex: logs, Tracker Google Sheet, fiches produits) sans consommer d'appels de fonction actifs.prompts/list : Expose des modèles de prompts et SOPs paramétrables.Le format OpenAI est la référence de facto adoptée par plus de 90% des fournisseurs d'API et serveurs d'inférence (DeepSeek, Mistral, Groq, Together AI, vLLM, Ollama) :
{
"type": "function",
"function": {
"name": "lancer_chasse_produit",
"description": "Lance le pipeline de recherche de produits gagnants...",
"parameters": {
"type": "object",
"properties": {
"mots_cles": {"type": "string", "description": "Niche ciblée"},
"nombre_max": {"type": "integer", "default": 5}
},
"required": ["mots_cles"]
}
}
}
Utilise un objet direct input_schema (identique au sous-objet parameters d'OpenAI) :
{
"name": "lancer_chasse_produit",
"description": "Lance le pipeline...",
"input_schema": {
"type": "object",
"properties": { ... },
"required": [ ... ]
}
}
Utilise function_declarations avec des types scalaires en majuscules (OBJECT, STRING, INTEGER) :
{
"function_declarations": [{
"name": "lancer_chasse_produit",
"description": "Lance le pipeline...",
"parameters": {
"type": "OBJECT",
"properties": { ... },
"required": [ ... ]
}
}]
}
L'infrastructure actuelle de Raphaël présente une grande puissance fonctionnelle, mais un découplage hétérogène des outils selon les moteurs :
| Moteur Actuel | Mode d'Accès aux Scripts | Standard Utilisé | Niveau de Découplage |
|---|---|---|---|
Antigravity CLI (agy.exe) |
Outils MCP natifs (mcp/playwright) + Exécution Shell powershell |
MCP stdio + Shell Direct | Élevé |
Claude Code CLI (claude.exe) |
Commandes CLI directes via Bash/Powershell | Shell Direct + Invocation de scripts | Modéré |
Jarvis Live Voice (server.py) |
JARVIS_MISSION_TOOLS codés en dur dans Gemini Live API |
Gemini Function Declarations | Faible (Lié au code du serveur) |
| UGC Studio | mcp_server.py opérationnel (375 lignes) |
MCP JSON-RPC 2.0 stdio | Très Élevé (Prêt à l'emploi) |
| Claude-Code-Proxy (Secours) | Passerelle LiteLLM vers OpenRouter / Gemini | Translation Anthropic ↔ OpenAI | Élevé |
Actuellement, pour qu'un modèle comprenne un script comme tools/generer_rapport_produit_jarvis.py ou tools/chasse_orchestrateur.py, il faut soit lui donner un accès terminal libre (avec le risque d'erreurs de syntaxe CLI), soit coder manuellement la déclaration dans server.py.
La Couche Universelle résout définitivement ce problème en centralisant la définition des outils.
La solution proposée s'appelle le Jarvis Universal Tool Layer (JUTL). Elle s'articule autour de 4 modules indépendants :
flowchart TD
subgraph S["1. Scripts Existants (tools/*.py)"]
S1["chasse_orchestrateur.py"]
S2["juge_produit_orchestrateur.py"]
S3["generer_rapport_produit_jarvis.py"]
S4["telegram_reliable.py"]
end
subgraph R["2. Registre Canonique (registry.py)"]
R1["Décorateurs @jarvis_tool<br/>ou Fiches Métadonnées Pydantic"]
end
subgraph A["3. Adaptateur Multimodal & Multi-LLM (bridge.py)"]
A1["Export MCP (JSON-RPC stdio/SSE)"]
A2["Export OpenAI / DeepSeek (tools)"]
A3["Export Anthropic (input_schema)"]
A4["Export Google Gemini (function_declarations)"]
end
subgraph M["4. Modèles d'Inférence (Zero Fine-Tuning)"]
M1["DeepSeek-V3 / R1"]
M2["Claude 3.5 / Sonnet"]
M3["Gemini 2.5 / 3.8"]
M4["Modèles Locaux (Qwen 2.5 / Llama 3.3)"]
end
S --> R
R --> A
A --> M
M -- "tool_call (JSON)" --> A
A -- "Exécution sécurisée" --> S
tools/registry.py)Chaque outil existant est déclaré au moyen d'un décorateur ou d'un modèle Pydantic standard.
Exemple d'implémentation concrète :
from pydantic import BaseModel, Field
from typing import Optional, List, Callable
import inspect
class ToolDefinition(BaseModel):
name: str
description: str
parameters: dict # JSON Schema standard
handler: Callable
REGISTRY: dict[str, ToolDefinition] = {}
def jarvis_tool(name: str, description: str, args_model: type[BaseModel]):
def decorator(func: Callable):
REGISTRY[name] = ToolDefinition(
name=name,
description=description,
parameters=args_model.model_json_schema(),
handler=func
)
return func
return decorator
À partir du JSON Schema stocké dans le registre, le traducteur produit instantanément le format requis par le modèle sollicité :
{ "name": tool.name, "description": tool.description, "inputSchema": tool.parameters }{ "type": "function", "function": { "name": tool.name, "description": tool.description, "parameters": tool.parameters } }{ "name": tool.name, "description": tool.description, "input_schema": tool.parameters }string -> STRING, object -> OBJECT, array -> ARRAY).jarvis_mcp_server.py)Un serveur unique qui expose l'ensemble des scripts de Raphaël via le protocole MCP stdio.
* Compatible nativement avec :
* Claude Desktop & Claude Code (claude mcp add ...)
* Google Antigravity (~/.gemini/antigravity-cli/mcp/...)
* Cursor, Windsurf, Open WebUI.
Si Raphaël possède 40 outils, injecter les 40 schémas à chaque requête consomme environ 6 000 à 10 000 tokens et peut diluer l'attention du modèle.
Deux mécanismes éprouvés sont intégrés :
1. Regroupement par Pôles (Namespaces) :
* pole_chasse : minea_scan, sourcing_image, juger_produit.
* pole_studio : extraire_ads, rendre_video, generer_visuel.
* pole_reporting : generer_rapport_produit, stats_rejets, lire_tracker.
2. Meta-Tool Discovery (Mode Lazy) :
* Le modèle reçoit uniquement un outil de découverte : rechercher_outils(besoin: str).
* Le moteur filtre et injecte dynamiquement les 3 outils les plus pertinents pour le tour suivant.
| Modèle Testé | Précision Function Calling (BFCL) | Dialecte Compatible | Comportement & Prise en Charge |
|---|---|---|---|
| Claude 3.5 / 3.7 / Sonnet | 96.8% | Native Anthropic / MCP | Référence absolue. Respect strict des types, chaînage multi-outils parfait. |
| Gemini 2.5 / 3.8 Flash | 94.2% | Native Gemini / Live API | Extrêmement rapide, parfait pour Jarvis Live Voice temps réel (<1.2s de latence). |
| DeepSeek-V3 | 93.5% | Standard OpenAI | Excellent élève. Respecte parfaitement les schémas JSON avec un coût divisé par 10. |
| DeepSeek-R1 | 88.5% | OpenAI / Structured ReAct | Modèle de raisonnement pur. Nécessite de préserver les balises <think> avant le tool_call. |
| Qwen 2.5 (72B) / Llama 3.3 | 91.0% | Standard OpenAI (via vLLM/Ollama) | Totalement autonome en local ou sur serveur dédié HP. |
shell=True).cp1252, provoquant des erreurs lors des échanges JSON contenant des accents.sys.stdout.reconfigure(encoding='utf-8') et sys.stderr.reconfigure(encoding='utf-8') dans tous les bridges./ et \ sur Windows.pathlib.Path pour normaliser tous les chemins absolus (C:/ASSISTANT_IA -> C:\ASSISTANT_IA).gantt
title Déploiement de la Couche Universelle des Outils (JUTL)
dateFormat YYYY-MM-DD
section Phase 1 : Cœur
Création du Registre Canonique (registry.py) :p1, 2026-10-09, 1d
Enregistrement des 10 scripts prioritaires :p2, after p1, 1d
section Phase 2 : Protocoles
Serveur MCP Général (jarvis_mcp_server.py) :p3, after p2, 1d
Pont d'Inférence OpenAI/DeepSeek (bridge.py) :p4, after p3, 1d
section Phase 3 : Intégration
Connexion à Jarvis Live Voice (server.py) :p5, after p4, 1d
Test de validation croisée (DeepSeek + Claude + Gemini):p6, after p5, 1d
C:\ASSISTANT_IA\tools\registry.py et wrap des scripts prioritaires (generer_rapport_produit_jarvis.py, juge_produit_orchestrateur.py, chasse_orchestrateur.py, telegram_reliable.py).C:\ASSISTANT_IA\tools\jarvis_mcp_server.py permettant à Claude Code, Antigravity et Cursor de consommer ces outils immédiatement sans taper de commande shell.server.py pour que la voie vocale et le mode mission bénéficient du catalogue sans code en dur.La création d'une couche universelle de définition d'outils est non seulement faisable, mais représente l'évolution naturelle et stratégique pour l'écosystème de Raphaël. Elle supprime toute adhérence à un modèle d'IA particulier, protège l'investissement déjà réalisé dans les scripts Python existants, et permet de basculer instantanément sur n'importe quelle nouvelle IA de pointe (ex: DeepSeek ou les futurs modèles 2027) par simple injection de contexte à l'inférence.