diff --git a/MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Agentic-0-init_agent.ipynb b/MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Agentic-0-init_agent.ipynb index a64a86debe..20f834f2d7 100644 --- a/MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Agentic-0-init_agent.ipynb +++ b/MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Agentic-0-init_agent.ipynb @@ -3,19 +3,47 @@ { "cell_type": "code", "execution_count": 1, + "id": "38899698", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-19T23:44:45.582655Z", + "iopub.status.busy": "2026-09-19T23:44:45.582462Z", + "iopub.status.idle": "2026-09-19T23:44:45.592333Z", + "shell.execute_reply": "2026-09-19T23:44:45.591740Z" + }, + "papermill": { + "duration": 0.019989, + "end_time": "2026-09-19T23:44:45.593969", + "exception": false, + "start_time": "2026-09-19T23:44:45.573980", + "status": "completed" + }, + "tags": [ + "injected-parameters" + ] + }, + "outputs": [], + "source": [ + "# Parameters\n", + "BATCH_MODE = \"true\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "34e4559f", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:08.404916Z", - "iopub.status.busy": "2026-09-15T05:29:08.404340Z", - "iopub.status.idle": "2026-09-15T05:29:08.411557Z", - "shell.execute_reply": "2026-09-15T05:29:08.410039Z" + "iopub.execute_input": "2026-09-19T23:44:45.607644Z", + "iopub.status.busy": "2026-09-19T23:44:45.607455Z", + "iopub.status.idle": "2026-09-19T23:44:45.610933Z", + "shell.execute_reply": "2026-09-19T23:44:45.610444Z" }, "papermill": { - "duration": 0.024223, - "end_time": "2026-09-15T05:29:08.412930+00:00", + "duration": 0.011179, + "end_time": "2026-09-19T23:44:45.611993", "exception": false, - "start_time": "2026-09-15T05:29:08.388707+00:00", + "start_time": "2026-09-19T23:44:45.600814", "status": "completed" }, "tags": [] @@ -31,10 +59,10 @@ "id": "6196daf0", "metadata": { "papermill": { - "duration": 0.018215, - "end_time": "2026-09-15T05:29:08.450710+00:00", + "duration": 0.005838, + "end_time": "2026-09-19T23:44:45.628328", "exception": false, - "start_time": "2026-09-15T05:29:08.432495+00:00", + "start_time": "2026-09-19T23:44:45.622490", "status": "completed" }, "tags": [] @@ -45,9 +73,9 @@ "\n", "[Retour au README](../README.md) | [Suivant : Informal Agent](./Argument_Analysis_Agentic-1-informal_agent.ipynb)\n", "\n", - "Dans ce notebook, nous configurons l'infrastructure complete d'un syst\u00e8me multi-agents d'analyse rhetorique utilisant Semantic Kernel. Plusieurs agents specialises (ProjectManager, InformalAnalysis, PropositionalLogic) vont collaborer pour analyser un texte sous diff\u00e9rents angles, depuis l'identification informelle des arguments jusqu'a la verification formelle en logique propositionnelle via TweetyProject.\n", + "Dans ce notebook, nous configurons l'infrastructure complete d'un système multi-agents d'analyse rhetorique utilisant Semantic Kernel. Plusieurs agents specialises (ProjectManager, InformalAnalysis, PropositionalLogic) vont collaborer pour analyser un texte sous différents angles, depuis l'identification informelle des arguments jusqu'a la verification formelle en logique propositionnelle via TweetyProject.\n", "\n", - "**Objectif :** Analyser un texte sous diff\u00e9rents angles (informel et formel simple via logique propositionnelle) en observant la collaboration des agents via la modification d'un etat partage. Utiliser une orchestration basee sur la designation explicite de l'agent suivant via l'etat.\n", + "**Objectif :** Analyser un texte sous différents angles (informel et formel simple via logique propositionnelle) en observant la collaboration des agents via la modification d'un etat partage. Utiliser une orchestration basee sur la designation explicite de l'agent suivant via l'etat.\n", "\n", "**Structure :**\n", "1. Configuration Initiale & Dependances (Python, LLM)\n", @@ -56,9 +84,9 @@ "4. Agent: Project Manager (Definitions)\n", "5. Agent: Informal Analysis (Definitions)\n", "6. Agent: Propositional Logic (Definitions)\n", - "7. Orchestration de la Conversation (Definitions des Strat\u00e9gies)\n", - "8. Ex\u00e9cution de la Conversation Collaborative (Instanciation et Lancement)\n", - "9. Conclusion & Prochaines \u00c9tapes\n", + "7. Orchestration de la Conversation (Definitions des Stratégies)\n", + "8. Exécution de la Conversation Collaborative (Instanciation et Lancement)\n", + "9. Conclusion & Prochaines Étapes\n", "\n", "*(Version 2 : Correction bugs designation/affichage agent, validation type logique, nettoyage code et amelioration documentation)*" ] @@ -68,40 +96,40 @@ "id": "80571e1e", "metadata": { "papermill": { - "duration": 0.017217, - "end_time": "2026-09-15T05:29:08.481847+00:00", + "duration": 0.009578, + "end_time": "2026-09-19T23:44:45.643624", "exception": false, - "start_time": "2026-09-15T05:29:08.464630+00:00", + "start_time": "2026-09-19T23:44:45.634046", "status": "completed" }, "tags": [] }, "source": [ - "## 1. Configuration Initiale et D\u00e9pendances (Python, LLM)\n", + "## 1. Configuration Initiale et Dépendances (Python, LLM)\n", "\n", "Cette cellule unique regroupe :\n", - "* L'installation et la v\u00e9rification des d\u00e9pendances Python n\u00e9cessaires (`semantic-kernel`, `jpype1`, `python-dotenv`, `pandas`, `requests`).\n", + "* L'installation et la vérification des dépendances Python nécessaires (`semantic-kernel`, `jpype1`, `python-dotenv`, `pandas`, `requests`).\n", "* La configuration du logging global.\n", - "* Le chargement de la configuration du LLM (OpenAI ou Azure OpenAI) depuis le fichier `.env`. **Assurez-vous d'avoir un fichier `.env` \u00e0 la racine avec vos cl\u00e9s API et identifiants de mod\u00e8le.**\n", - "* La d\u00e9finition du texte source (`raw_text_input`) qui sera analys\u00e9 par les agents." + "* Le chargement de la configuration du LLM (OpenAI ou Azure OpenAI) depuis le fichier `.env`. **Assurez-vous d'avoir un fichier `.env` à la racine avec vos clés API et identifiants de modèle.**\n", + "* La définition du texte source (`raw_text_input`) qui sera analysé par les agents." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "a3661e07", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:08.511886Z", - "iopub.status.busy": "2026-09-15T05:29:08.511268Z", - "iopub.status.idle": "2026-09-15T05:29:13.715497Z", - "shell.execute_reply": "2026-09-15T05:29:13.712916Z" + "iopub.execute_input": "2026-09-19T23:44:45.656830Z", + "iopub.status.busy": "2026-09-19T23:44:45.656647Z", + "iopub.status.idle": "2026-09-19T23:44:49.770931Z", + "shell.execute_reply": "2026-09-19T23:44:49.770129Z" }, "papermill": { - "duration": 5.219732, - "end_time": "2026-09-15T05:29:13.716878+00:00", + "duration": 4.122513, + "end_time": "2026-09-19T23:44:49.772428", "exception": false, - "start_time": "2026-09-15T05:29:08.497146+00:00", + "start_time": "2026-09-19T23:44:45.649915", "status": "completed" }, "tags": [] @@ -174,42 +202,42 @@ "id": "pmpm31xh56", "metadata": { "papermill": { - "duration": 0.018013, - "end_time": "2026-09-15T05:29:13.753503+00:00", + "duration": 0.010566, + "end_time": "2026-09-19T23:44:49.792312", "exception": false, - "start_time": "2026-09-15T05:29:13.735490+00:00", + "start_time": "2026-09-19T23:44:49.781746", "status": "completed" }, "tags": [] }, "source": [ - "## V\u00e9rification de compatibilit\u00e9 des packages Python\n", + "## Vérification de compatibilité des packages Python\n", "\n", - "Avant de commencer, nous devons nous assurer que les packages `semantic-kernel` et `openai` sont compatibles entre eux. Cette cellule d\u00e9tecte automatiquement les conflits de version et installe les versions compatibles si n\u00e9cessaire.\n", + "Avant de commencer, nous devons nous assurer que les packages `semantic-kernel` et `openai` sont compatibles entre eux. Cette cellule détecte automatiquement les conflits de version et installe les versions compatibles si nécessaire.\n", "\n", - "**Probl\u00e8me fr\u00e9quent** : Les versions r\u00e9centes d'`openai` (2.0+) peuvent causer des erreurs d'import avec `semantic-kernel` \u00e0 cause de changements dans l'API (`omit`, `ChatCompletionMessageToolCall`).\n", + "**Problème fréquent** : Les versions récentes d'`openai` (2.0+) peuvent causer des erreurs d'import avec `semantic-kernel` à cause de changements dans l'API (`omit`, `ChatCompletionMessageToolCall`).\n", "\n", - "**Solution automatique** : Si un conflit est d\u00e9tect\u00e9, le script installera automatiquement une version compatible d'`openai` (>= 1.50.0, < 1.99.0).\n", + "**Solution automatique** : Si un conflit est détecté, le script installera automatiquement une version compatible d'`openai` (>= 1.50.0, < 1.99.0).\n", "\n", - "> **Important** : Si la cellule d\u00e9tecte un probl\u00e8me et r\u00e9installe les packages, vous devrez **red\u00e9marrer le noyau** (Kernel \u2192 Restart) avant de continuer." + "> **Important** : Si la cellule détecte un problème et réinstalle les packages, vous devrez **redémarrer le noyau** (Kernel → Restart) avant de continuer." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "dd1eb173", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:13.795076Z", - "iopub.status.busy": "2026-09-15T05:29:13.794311Z", - "iopub.status.idle": "2026-09-15T05:29:14.815752Z", - "shell.execute_reply": "2026-09-15T05:29:14.814435Z" + "iopub.execute_input": "2026-09-19T23:44:49.813550Z", + "iopub.status.busy": "2026-09-19T23:44:49.813281Z", + "iopub.status.idle": "2026-09-19T23:44:50.459836Z", + "shell.execute_reply": "2026-09-19T23:44:50.459242Z" }, "papermill": { - "duration": 1.043692, - "end_time": "2026-09-15T05:29:14.816770+00:00", + "duration": 0.661239, + "end_time": "2026-09-19T23:44:50.460635", "exception": false, - "start_time": "2026-09-15T05:29:13.773078+00:00", + "start_time": "2026-09-19T23:44:49.799396", "status": "completed" }, "tags": [] @@ -219,77 +247,77 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:13 [INFO] [Orchestration.Setup] --- V\u00e9rification des d\u00e9pendances ---\n" + "01:44:49 [INFO] [Orchestration.Setup] --- Vérification des dépendances ---\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:13 [INFO] [Orchestration.Setup] \u2714\ufe0f D\u00e9pendance 'jpype' trouv\u00e9e.\n" + "01:44:49 [INFO] [Orchestration.Setup] ✔️ Dépendance 'jpype' trouvée.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:13 [INFO] [Orchestration.Setup] \u2714\ufe0f D\u00e9pendance 'semantic_kernel' trouv\u00e9e.\n" + "01:44:49 [INFO] [Orchestration.Setup] ✔️ Dépendance 'semantic_kernel' trouvée.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:13 [INFO] [Orchestration.Setup] \u2714\ufe0f D\u00e9pendance 'dotenv' trouv\u00e9e.\n" + "01:44:49 [INFO] [Orchestration.Setup] ✔️ Dépendance 'dotenv' trouvée.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:14 [INFO] [Orchestration.Setup] \u2714\ufe0f D\u00e9pendance 'pandas' trouv\u00e9e.\n" + "01:44:50 [INFO] [Orchestration.Setup] ✔️ Dépendance 'pandas' trouvée.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:14 [INFO] [Orchestration.Setup] \u2714\ufe0f D\u00e9pendance 'requests' trouv\u00e9e.\n" + "01:44:50 [INFO] [Orchestration.Setup] ✔️ Dépendance 'requests' trouvée.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:14 [INFO] [Orchestration.Setup] \n", - "\u2705 D\u00e9pendances principales v\u00e9rifi\u00e9es.\n" + "01:44:50 [INFO] [Orchestration.Setup] \n", + "✅ Dépendances principales vérifiées.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:14 [INFO] [Orchestration.Setup] --- Chargement Configuration LLM ---\n" + "01:44:50 [INFO] [Orchestration.Setup] --- Chargement Configuration LLM ---\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:14 [INFO] [Orchestration.Setup] \u2705 Configuration OpenAI standard d\u00e9tect\u00e9e (Mod\u00e8le: gpt-5-mini). Org ID: Non fourni.\n" + "01:44:50 [INFO] [Orchestration.Setup] ✅ Configuration OpenAI standard détectée (Modèle: gpt-5.2). Org ID: Non fourni.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:14 [INFO] [Orchestration.Setup] --- Fin Configuration Initiale ---\n" + "01:44:50 [INFO] [Orchestration.Setup] --- Fin Configuration Initiale ---\n" ] } ], "source": [ - "# %% CELLULE [1] MODIFI\u00c9E (ID 25d83fde) - Configuration Initiale et D\u00e9pendances (Python, LLM)\n", - "# Regroupe d\u00e9pendances, config LLM. *** raw_text_input a \u00e9t\u00e9 SUPPRIM\u00c9 ***\n", + "# %% CELLULE [1] MODIFIÉE (ID 25d83fde) - Configuration Initiale et Dépendances (Python, LLM)\n", + "# Regroupe dépendances, config LLM. *** raw_text_input a été SUPPRIMÉ ***\n", "\n", "# Filtre les avertissements transitifs de l'import chain (tqdm auto-detect IProgress not found -> path leak).\n", "# Sans ce filtre, l'import de semantic_kernel / ipywidgets / jpype peut declencher un tqdm.auto warning\n", @@ -298,7 +326,7 @@ "warnings.filterwarnings('ignore', message=r'.*IProgress not found.*')\n", "warnings.filterwarnings('ignore', category=DeprecationWarning)\n", "\n", - "# Les d\u00e9pendances (semantic-kernel, python-dotenv, ipywidgets, jpype1, requests, tqdm, pandas)\n", + "# Les dépendances (semantic-kernel, python-dotenv, ipywidgets, jpype1, requests, tqdm, pandas)\n", "# doivent etre pre-provisionnees dans l'environnement (cf dependencies in requirements.txt).\n", "# L'installation pip inconditionnelle (`%pip install --upgrade ...`) a ete retiree car elle injectait\n", "# un path leak machine (`Requirement already satisfied: ... in C:\\ProgramData\\miniconda3\\Lib\\site-packages`)\n", @@ -315,87 +343,87 @@ "import logging\n", "\n", "# --- Configuration du Logging Global ---\n", - "# Format am\u00e9lior\u00e9 incluant le nom du logger pour mieux tracer\n", + "# Format amélioré incluant le nom du logger pour mieux tracer\n", "logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] [%(name)s] %(message)s', datefmt='%H:%M:%S')\n", "logging.getLogger(\"httpx\").setLevel(logging.WARNING)\n", "logging.getLogger(\"semantic_kernel.connectors.ai\").setLevel(logging.WARNING)\n", "logging.getLogger(\"semantic_kernel.kernel\").setLevel(logging.WARNING)\n", "logging.getLogger(\"semantic_kernel.functions\").setLevel(logging.WARNING)\n", - "# Garder INFO pour les agents et l'orchestration pour suivre le d\u00e9roulement\n", + "# Garder INFO pour les agents et l'orchestration pour suivre le déroulement\n", "logging.getLogger(\"semantic_kernel.agents\").setLevel(logging.INFO)\n", "logging.getLogger(\"Orchestration\").setLevel(logging.INFO)\n", - "# Configurer les loggers sp\u00e9cifiques utilis\u00e9s plus loin si n\u00e9cessaire\n", - "# (Ex: logging.getLogger(\"Orchestration.AgentPM\").setLevel(logging.DEBUG) pour plus de d\u00e9tails sur un agent)\n", + "# Configurer les loggers spécifiques utilisés plus loin si nécessaire\n", + "# (Ex: logging.getLogger(\"Orchestration.AgentPM\").setLevel(logging.DEBUG) pour plus de détails sur un agent)\n", "\n", "logger = logging.getLogger(\"Orchestration.Setup\") # Logger pour cette cellule\n", "\n", - "# --- V\u00e9rification et Installation D\u00e9pendances ---\n", + "# --- Vérification et Installation Dépendances ---\n", "def check_and_install(package_import_name: str, package_install_name: str):\n", - " \"\"\"V\u00e9rifie si un package est importable, sinon tente de l'installer.\"\"\"\n", + " \"\"\"Vérifie si un package est importable, sinon tente de l'installer.\"\"\"\n", " try:\n", " importlib.import_module(package_import_name)\n", - " logger.info(f\"\u2714\ufe0f D\u00e9pendance '{package_import_name}' trouv\u00e9e.\")\n", + " logger.info(f\"✔️ Dépendance '{package_import_name}' trouvée.\")\n", " return True\n", " except ImportError:\n", - " logger.warning(f\"\u26a0\ufe0f D\u00e9pendance '{package_import_name}' manquante (package: {package_install_name}). Tentative d'installation...\")\n", + " logger.warning(f\"⚠️ Dépendance '{package_import_name}' manquante (package: {package_install_name}). Tentative d'installation...\")\n", " try:\n", - " # Utilisation de -q pour une sortie moins verbeuse, --disable-pip-version-check pour \u00e9viter les warnings\n", + " # Utilisation de -q pour une sortie moins verbeuse, --disable-pip-version-check pour éviter les warnings\n", " subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"--disable-pip-version-check\", package_install_name])\n", - " logger.info(f\"\u2705 {package_install_name} install\u00e9 avec succ\u00e8s.\")\n", - " # Recharger les modules ou invalider les caches peut \u00eatre n\u00e9cessaire dans certains environnements\n", + " logger.info(f\"✅ {package_install_name} installé avec succès.\")\n", + " # Recharger les modules ou invalider les caches peut être nécessaire dans certains environnements\n", " importlib.invalidate_caches()\n", " importlib.import_module(package_import_name) # Re-tester l'import\n", - " logger.info(f\"\u2714\ufe0f {package_import_name} trouv\u00e9 apr\u00e8s installation.\")\n", + " logger.info(f\"✔️ {package_import_name} trouvé après installation.\")\n", " return True\n", " except Exception as e:\n", - " logger.error(f\"\u274c \u00c9chec de l'installation/import de {package_install_name}: {e}\")\n", - " logger.warning(\"\u203c\ufe0f Un red\u00e9marrage du noyau (Kernel -> Restart Kernel) peut \u00eatre n\u00e9cessaire si l'import \u00e9choue toujours.\")\n", + " logger.error(f\"❌ Échec de l'installation/import de {package_install_name}: {e}\")\n", + " logger.warning(\"‼️ Un redémarrage du noyau (Kernel -> Restart Kernel) peut être nécessaire si l'import échoue toujours.\")\n", " return False\n", "\n", - "logger.info(\"--- V\u00e9rification des d\u00e9pendances ---\")\n", + "logger.info(\"--- Vérification des dépendances ---\")\n", "deps_ok = True\n", "deps_list = [\n", " (\"jpype\", \"jpype1\"),\n", " (\"semantic_kernel\", \"semantic-kernel\"),\n", " (\"dotenv\", \"python-dotenv\"),\n", - " (\"pandas\", \"pandas\"), # N\u00e9cessaire pour InformalAnalysisPlugin\n", - " (\"requests\", \"requests\") # N\u00e9cessaire pour InformalAnalysisPlugin (t\u00e9l\u00e9chargement CSV)\n", + " (\"pandas\", \"pandas\"), # Nécessaire pour InformalAnalysisPlugin\n", + " (\"requests\", \"requests\") # Nécessaire pour InformalAnalysisPlugin (téléchargement CSV)\n", "]\n", "for import_name, install_name in deps_list:\n", " if not check_and_install(import_name, install_name):\n", " deps_ok = False\n", "\n", "if not deps_ok:\n", - " logger.critical(\"\\n\u274c Des d\u00e9pendances cl\u00e9s sont manquantes ou n'ont pu \u00eatre import\u00e9es apr\u00e8s installation. Veuillez v\u00e9rifier les erreurs et red\u00e9marrer le noyau si n\u00e9cessaire avant de continuer.\")\n", - " # Optionnel: Lever une exception pour arr\u00eater l'ex\u00e9cution\n", - " # raise RuntimeError(\"D\u00e9pendances manquantes ou n\u00e9cessitant un red\u00e9marrage du noyau.\")\n", + " logger.critical(\"\\n❌ Des dépendances clés sont manquantes ou n'ont pu être importées après installation. Veuillez vérifier les erreurs et redémarrer le noyau si nécessaire avant de continuer.\")\n", + " # Optionnel: Lever une exception pour arrêter l'exécution\n", + " # raise RuntimeError(\"Dépendances manquantes ou nécessitant un redémarrage du noyau.\")\n", "else:\n", - " logger.info(\"\\n\u2705 D\u00e9pendances principales v\u00e9rifi\u00e9es.\")\n", + " logger.info(\"\\n✅ Dépendances principales vérifiées.\")\n", "\n", "# --- Chargement config LLM depuis .env ---\n", "logger.info(\"--- Chargement Configuration LLM ---\")\n", - "load_dotenv(override=True) # `override=True` pour recharger si n\u00e9cessaire\n", + "load_dotenv(override=True) # `override=True` pour recharger si nécessaire\n", "\n", "api_key = os.getenv(\"OPENAI_API_KEY\")\n", "model_id = os.getenv(\"OPENAI_CHAT_MODEL_ID\")\n", - "endpoint = os.getenv(\"OPENAI_ENDPOINT\") # Endpoint sp\u00e9cifique Azure\n", + "endpoint = os.getenv(\"OPENAI_ENDPOINT\") # Endpoint spécifique Azure\n", "org_id = os.getenv(\"OPENAI_ORG_ID\") # Optionnel pour OpenAI standard\n", - "use_azure_openai = bool(endpoint) # D\u00e9termine si on utilise Azure en fonction de la pr\u00e9sence de l'endpoint\n", + "use_azure_openai = bool(endpoint) # Détermine si on utilise Azure en fonction de la présence de l'endpoint\n", "\n", "llm_configured = False\n", "if use_azure_openai:\n", " # Valider la configuration Azure\n", " if not all([api_key, model_id, endpoint]):\n", - " logger.error(\"\u274c Configuration Azure OpenAI incompl\u00e8te dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID, OPENAI_ENDPOINT requis).\")\n", + " logger.error(\"❌ Configuration Azure OpenAI incomplète dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID, OPENAI_ENDPOINT requis).\")\n", " else:\n", - " logger.info(f\"\u2705 Configuration Azure OpenAI d\u00e9tect\u00e9e (Deployment: {model_id}, Endpoint: {endpoint[:20]}...).\")\n", + " logger.info(f\"✅ Configuration Azure OpenAI détectée (Deployment: {model_id}, Endpoint: {endpoint[:20]}...).\")\n", " llm_configured = True\n", "else:\n", " # Valider la configuration OpenAI standard\n", " if not all([api_key, model_id]):\n", - " logger.error(\"\u274c Configuration OpenAI standard incompl\u00e8te dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID requis).\")\n", + " logger.error(\"❌ Configuration OpenAI standard incomplète dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID requis).\")\n", " else:\n", - " logger.info(f\"\u2705 Configuration OpenAI standard d\u00e9tect\u00e9e (Mod\u00e8le: {model_id}). Org ID: {'Fourni' if org_id else 'Non fourni'}.\")\n", + " logger.info(f\"✅ Configuration OpenAI standard détectée (Modèle: {model_id}). Org ID: {'Fourni' if org_id else 'Non fourni'}.\")\n", " llm_configured = True\n", "\n", "if not llm_configured:\n", @@ -407,10 +435,10 @@ " use_azure_openai = False\n", "\n", "\n", - "# Assurer que la variable use_azure_openai existe pour les cellules suivantes, m\u00eame si la config a \u00e9chou\u00e9 plus t\u00f4t\n", + "# Assurer que la variable use_azure_openai existe pour les cellules suivantes, même si la config a échoué plus tôt\n", "if 'use_azure_openai' not in locals():\n", - " use_azure_openai = False # D\u00e9faut\n", - " logger.warning(\"Variable 'use_azure_openai' non d\u00e9finie (erreur config?), d\u00e9faut \u00e0 False.\")\n", + " use_azure_openai = False # Défaut\n", + " logger.warning(\"Variable 'use_azure_openai' non définie (erreur config?), défaut à False.\")\n", "\n", "logger.info(\"--- Fin Configuration Initiale ---\")\n" ] @@ -420,10 +448,10 @@ "id": "c689b59e", "metadata": { "papermill": { - "duration": 0.022452, - "end_time": "2026-09-15T05:29:14.857725+00:00", + "duration": 0.008466, + "end_time": "2026-09-19T23:44:50.477944", "exception": false, - "start_time": "2026-09-15T05:29:14.835273+00:00", + "start_time": "2026-09-19T23:44:50.469478", "status": "completed" }, "tags": [] @@ -431,25 +459,25 @@ "source": [ "### Configuration du LLM (via .env)\n", "\n", - "Assurez-vous d'avoir un fichier `.env` avec vos identifiants LLM (voir exemple dans le notebook g\u00e9n\u00e9rateur ou la cellule pr\u00e9c\u00e9dente)." + "Assurez-vous d'avoir un fichier `.env` avec vos identifiants LLM (voir exemple dans le notebook générateur ou la cellule précédente)." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "ab60fc96", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:14.902140Z", - "iopub.status.busy": "2026-09-15T05:29:14.901494Z", - "iopub.status.idle": "2026-09-15T05:29:14.917657Z", - "shell.execute_reply": "2026-09-15T05:29:14.916381Z" + "iopub.execute_input": "2026-09-19T23:44:50.495298Z", + "iopub.status.busy": "2026-09-19T23:44:50.494966Z", + "iopub.status.idle": "2026-09-19T23:44:50.500809Z", + "shell.execute_reply": "2026-09-19T23:44:50.500426Z" }, "papermill": { - "duration": 0.039057, - "end_time": "2026-09-15T05:29:14.918819+00:00", + "duration": 0.015315, + "end_time": "2026-09-19T23:44:50.501415", "exception": false, - "start_time": "2026-09-15T05:29:14.879762+00:00", + "start_time": "2026-09-19T23:44:50.486100", "status": "completed" }, "tags": [] @@ -459,14 +487,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:14 [INFO] [Orchestration.Config] \u2705 Configuration OpenAI standard charg\u00e9e (Mod\u00e8le: gpt-5-mini). Org ID: Non fourni.\n" + "01:44:50 [INFO] [Orchestration.Config] ✅ Configuration OpenAI standard chargée (Modèle: gpt-5.2). Org ID: Non fourni.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u2705 Configuration OpenAI standard charg\u00e9e (Mod\u00e8le: gpt-5-mini). Org ID: Non fourni.\n" + "✅ Configuration OpenAI standard chargée (Modèle: gpt-5.2). Org ID: Non fourni.\n" ] } ], @@ -485,37 +513,37 @@ "\n", "api_key = os.getenv(\"OPENAI_API_KEY\")\n", "model_id = os.getenv(\"OPENAI_CHAT_MODEL_ID\")\n", - "endpoint = os.getenv(\"OPENAI_ENDPOINT\") # Endpoint sp\u00e9cifique Azure\n", + "endpoint = os.getenv(\"OPENAI_ENDPOINT\") # Endpoint spécifique Azure\n", "org_id = os.getenv(\"OPENAI_ORG_ID\") # Optionnel pour OpenAI standard\n", "\n", - "# --- D\u00e9finition de use_azure_openai ---\n", + "# --- Définition de use_azure_openai ---\n", "use_azure_openai = bool(endpoint)\n", "# ---------------------------------------\n", "\n", - "# V\u00e9rifications et logs\n", + "# Vérifications et logs\n", "if use_azure_openai:\n", " if not all([api_key, model_id, endpoint]):\n", - " msg = \"\u26a0\ufe0f Configuration Azure OpenAI incompl\u00e8te dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID, OPENAI_ENDPOINT requis).\"\n", + " msg = \"⚠️ Configuration Azure OpenAI incomplète dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID, OPENAI_ENDPOINT requis).\"\n", " cfg_logger.warning(msg)\n", " print(msg)\n", " else:\n", - " msg = f\"\u2705 Configuration Azure OpenAI charg\u00e9e (Deployment: {model_id}, Endpoint: {endpoint[:20]}...).\"\n", + " msg = f\"✅ Configuration Azure OpenAI chargée (Deployment: {model_id}, Endpoint: {endpoint[:20]}...).\"\n", " cfg_logger.info(msg)\n", " print(msg)\n", "else:\n", " if not all([api_key, model_id]):\n", - " msg = \"\u26a0\ufe0f Configuration OpenAI standard incompl\u00e8te dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID requis).\"\n", + " msg = \"⚠️ Configuration OpenAI standard incomplète dans .env (OPENAI_API_KEY, OPENAI_CHAT_MODEL_ID requis).\"\n", " cfg_logger.warning(msg)\n", " print(msg)\n", " else:\n", - " msg = f\"\u2705 Configuration OpenAI standard charg\u00e9e (Mod\u00e8le: {model_id}). Org ID: {'Fourni' if org_id else 'Non fourni'}.\"\n", + " msg = f\"✅ Configuration OpenAI standard chargée (Modèle: {model_id}). Org ID: {'Fourni' if org_id else 'Non fourni'}.\"\n", " cfg_logger.info(msg)\n", " print(msg)\n", "\n", - "# S'assurer que la variable existe m\u00eame si la config est incompl\u00e8te, pour \u00e9viter NameError\n", + "# S'assurer que la variable existe même si la config est incomplète, pour éviter NameError\n", "if 'use_azure_openai' not in locals():\n", - " use_azure_openai = False # D\u00e9faut si erreur pr\u00e9c\u00e9dente\n", - " cfg_logger.warning(\"Variable 'use_azure_openai' non d\u00e9finie due \u00e0 une erreur de config, d\u00e9faut \u00e0 False.\")" + " use_azure_openai = False # Défaut si erreur précédente\n", + " cfg_logger.warning(\"Variable 'use_azure_openai' non définie due à une erreur de config, défaut à False.\")" ] }, { @@ -523,33 +551,33 @@ "id": "s3yp5wc2bg", "metadata": { "papermill": { - "duration": 0.020086, - "end_time": "2026-09-15T05:29:14.960191+00:00", + "duration": 0.008399, + "end_time": "2026-09-19T23:44:50.518445", "exception": false, - "start_time": "2026-09-15T05:29:14.940105+00:00", + "start_time": "2026-09-19T23:44:50.510046", "status": "completed" }, "tags": [] }, "source": [ - "### Interpr\u00e9tation de la configuration LLM\n", + "### Interprétation de la configuration LLM\n", "\n", - "Cette cellule a charg\u00e9 la configuration de votre mod\u00e8le de langage depuis le fichier `.env`. Voici ce qui a \u00e9t\u00e9 configur\u00e9 :\n", + "Cette cellule a chargé la configuration de votre modèle de langage depuis le fichier `.env`. Voici ce qui a été configuré :\n", "\n", "| Variable | Description | Utilisation |\n", "|----------|-------------|-------------|\n", - "| `api_key` | Cl\u00e9 API pour acc\u00e9der au service LLM | Authentification aupr\u00e8s d'OpenAI ou Azure |\n", - "| `model_id` | Identifiant du mod\u00e8le (ex: gpt-4, gpt-3.5-turbo) | Sp\u00e9cifie quel mod\u00e8le sera utilis\u00e9 |\n", + "| `api_key` | Clé API pour accéder au service LLM | Authentification auprès d'OpenAI ou Azure |\n", + "| `model_id` | Identifiant du modèle (ex: gpt-4, gpt-3.5-turbo) | Spécifie quel modèle sera utilisé |\n", "| `endpoint` | URL de l'endpoint Azure (optionnel) | Requis uniquement pour Azure OpenAI |\n", "| `org_id` | ID d'organisation OpenAI (optionnel) | Pour les comptes organisationnels OpenAI |\n", - "| `use_azure_openai` | Bool\u00e9en d\u00e9termin\u00e9 automatiquement | `True` si `endpoint` existe, `False` sinon |\n", + "| `use_azure_openai` | Booléen déterminé automatiquement | `True` si `endpoint` existe, `False` sinon |\n", "\n", "**Deux modes possibles** :\n", "\n", - "1. **OpenAI Standard** : N\u00e9cessite `OPENAI_API_KEY` et `OPENAI_CHAT_MODEL_ID`\n", - "2. **Azure OpenAI** : N\u00e9cessite aussi `OPENAI_ENDPOINT` (l'endpoint Azure d\u00e9termine automatiquement le mode)\n", + "1. **OpenAI Standard** : Nécessite `OPENAI_API_KEY` et `OPENAI_CHAT_MODEL_ID`\n", + "2. **Azure OpenAI** : Nécessite aussi `OPENAI_ENDPOINT` (l'endpoint Azure détermine automatiquement le mode)\n", "\n", - "> **Note** : Si vous voyez un avertissement ci-dessus, v\u00e9rifiez que votre fichier `.env` contient toutes les variables requises pour votre mode (standard ou Azure)." + "> **Note** : Si vous voyez un avertissement ci-dessus, vérifiez que votre fichier `.env` contient toutes les variables requises pour votre mode (standard ou Azure)." ] }, { @@ -557,10 +585,10 @@ "id": "478a85e7", "metadata": { "papermill": { - "duration": 0.021616, - "end_time": "2026-09-15T05:29:15.001673+00:00", + "duration": 0.009157, + "end_time": "2026-09-19T23:44:50.536196", "exception": false, - "start_time": "2026-09-15T05:29:14.980057+00:00", + "start_time": "2026-09-19T23:44:50.527039", "status": "completed" }, "tags": [] @@ -568,18 +596,18 @@ "source": [ "## 2. Configuration de l'environnement Java/Tweety (JPype)\n", "\n", - "Cette section est **cruciale** pour utiliser les fonctionnalit\u00e9s d'analyse logique formelle via Tweety (utilis\u00e9es par le `PropositionalLogicAgent`).\n", + "Cette section est **cruciale** pour utiliser les fonctionnalités d'analyse logique formelle via Tweety (utilisées par le `PropositionalLogicAgent`).\n", "\n", - "**Pr\u00e9requis INDISPENSABLES :**\n", + "**Prérequis INDISPENSABLES :**\n", "\n", - "1. **Installation d'un JDK :** Vous devez avoir un Java Development Kit (JDK) version 11 ou sup\u00e9rieure install\u00e9 sur votre syst\u00e8me.\n", - "2. **Configuration de `JAVA_HOME` :** La variable d'environnement `JAVA_HOME` **doit pointer vers le r\u00e9pertoire racine de votre installation JDK**. C'est la m\u00e9thode la plus fiable pour que JPype trouve la JVM.\n", - " * **Windows :** ex: `C:\\Program Files\\Java\\jdk-17` (Adaptez). Ajoutez aux variables d'environnement syst\u00e8me/utilisateur.\n", - " * **Linux/macOS :** ex: `/usr/lib/jvm/java-17-openjdk-amd64` ou `/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home`. Ajoutez `export JAVA_HOME=/chemin/vers/jdk` \u00e0 votre `~/.bashrc`, `~/.zshrc` ou profil.\n", - " * **Red\u00e9marrage OBLIGATOIRE :** Apr\u00e8s avoir d\u00e9fini `JAVA_HOME`, **red\u00e9marrez votre environnement Jupyter** (serveur JupyterLab/Notebook ET le noyau de ce notebook) pour qu'elle soit prise en compte.\n", - "3. **JARs Tweety :** Les fichiers `.jar` de Tweety (au moins `tweety-full-...jar` et les modules comme `logics.pl-...jar`) doivent \u00eatre dans le dossier `./libs/` (ou le chemin configur\u00e9 dans la cellule suivante).\n", + "1. **Installation d'un JDK :** Vous devez avoir un Java Development Kit (JDK) version 11 ou supérieure installé sur votre système.\n", + "2. **Configuration de `JAVA_HOME` :** La variable d'environnement `JAVA_HOME` **doit pointer vers le répertoire racine de votre installation JDK**. C'est la méthode la plus fiable pour que JPype trouve la JVM.\n", + " * **Windows :** ex: `C:\\Program Files\\Java\\jdk-17` (Adaptez). Ajoutez aux variables d'environnement système/utilisateur.\n", + " * **Linux/macOS :** ex: `/usr/lib/jvm/java-17-openjdk-amd64` ou `/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home`. Ajoutez `export JAVA_HOME=/chemin/vers/jdk` à votre `~/.bashrc`, `~/.zshrc` ou profil.\n", + " * **Redémarrage OBLIGATOIRE :** Après avoir défini `JAVA_HOME`, **redémarrez votre environnement Jupyter** (serveur JupyterLab/Notebook ET le noyau de ce notebook) pour qu'elle soit prise en compte.\n", + "3. **JARs Tweety :** Les fichiers `.jar` de Tweety (au moins `tweety-full-...jar` et les modules comme `logics.pl-...jar`) doivent être dans le dossier `./libs/` (ou le chemin configuré dans la cellule suivante).\n", "\n", - "La cellule suivante tentera de d\u00e9marrer la JVM via `jpype`. Elle utilise une fonction `find_java_home` pour v\u00e9rifier `JAVA_HOME` et tenter une d\u00e9tection automatique, mais **la d\u00e9finition manuelle de `JAVA_HOME` est fortement recommand\u00e9e.** La variable globale `jvm_ready` indiquera si le d\u00e9marrage a r\u00e9ussi." + "La cellule suivante tentera de démarrer la JVM via `jpype`. Elle utilise une fonction `find_java_home` pour vérifier `JAVA_HOME` et tenter une détection automatique, mais **la définition manuelle de `JAVA_HOME` est fortement recommandée.** La variable globale `jvm_ready` indiquera si le démarrage a réussi." ] }, { @@ -588,61 +616,61 @@ "id": "a59062ad", "metadata": { "papermill": { - "duration": 0.026774, - "end_time": "2026-09-15T05:29:15.050475+00:00", + "duration": 0.008957, + "end_time": "2026-09-19T23:44:50.553804", "exception": false, - "start_time": "2026-09-15T05:29:15.023701+00:00", + "start_time": "2026-09-19T23:44:50.544847", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ - "### Pourquoi Java/Tweety est n\u00e9cessaire ?\n", + "### Pourquoi Java/Tweety est nécessaire ?\n", "\n", - "Le **PropositionalLogicAgent** utilise la biblioth\u00e8que Java **TweetyProject** pour effectuer des analyses logiques formelles. Cette biblioth\u00e8que offre des capacit\u00e9s avanc\u00e9es :\n", + "Le **PropositionalLogicAgent** utilise la bibliothèque Java **TweetyProject** pour effectuer des analyses logiques formelles. Cette bibliothèque offre des capacités avancées :\n", "\n", - "| Fonctionnalit\u00e9 | Description |\n", + "| Fonctionnalité | Description |\n", "|----------------|-------------|\n", "| **Logique propositionnelle** | Parsing et manipulation de formules PL |\n", - "| **Solveurs SAT** | V\u00e9rification de satisfiabilit\u00e9 avec SAT4J |\n", - "| **R\u00e9vision de croyances** | Algorithmes de r\u00e9vision de belief bases |\n", - "| **Raisonnement formel** | Inf\u00e9rence et d\u00e9tection de contradictions |\n", + "| **Solveurs SAT** | Vérification de satisfiabilité avec SAT4J |\n", + "| **Révision de croyances** | Algorithmes de révision de belief bases |\n", + "| **Raisonnement formel** | Inférence et détection de contradictions |\n", "\n", "**Architecture technique** :\n", "\n", - "1. **JPype** : Pont Python \u2194 JVM pour appeler du code Java depuis Python\n", - "2. **JDK 11+** : Java Development Kit requis pour ex\u00e9cuter la JVM\n", - "3. **JARs Tweety** : Biblioth\u00e8ques Java (.jar) contenant les algorithmes\n", + "1. **JPype** : Pont Python ↔ JVM pour appeler du code Java depuis Python\n", + "2. **JDK 11+** : Java Development Kit requis pour exécuter la JVM\n", + "3. **JARs Tweety** : Bibliothèques Java (.jar) contenant les algorithmes\n", "\n", "**Modes de fonctionnement** :\n", "\n", - "- **Mode natif** : Si JVM d\u00e9marre correctement, le PropositionalLogicAgent utilise Tweety directement (performance maximale 8/10)\n", - "- **Mode d\u00e9grad\u00e9** : Si JVM \u00e9choue, l'agent fonctionne uniquement via LLM sans v\u00e9rification formelle (performance r\u00e9duite 5/10)\n", + "- **Mode natif** : Si JVM démarre correctement, le PropositionalLogicAgent utilise Tweety directement (performance maximale 8/10)\n", + "- **Mode dégradé** : Si JVM échoue, l'agent fonctionne uniquement via LLM sans vérification formelle (performance réduite 5/10)\n", "\n", "La cellule suivante tente de configurer automatiquement l'environnement Java en :\n", "1. Localisant un JDK portable dans le projet\n", "2. Construisant le classpath avec tous les JARs Tweety\n", - "3. D\u00e9marrant la JVM avec les param\u00e8tres optimaux\n", - "4. Testant l'acc\u00e8s aux classes critiques de Tweety" + "3. Démarrant la JVM avec les paramètres optimaux\n", + "4. Testant l'accès aux classes critiques de Tweety" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "cc5a8f2e", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:15.100117Z", - "iopub.status.busy": "2026-09-15T05:29:15.099693Z", - "iopub.status.idle": "2026-09-15T05:29:15.145748Z", - "shell.execute_reply": "2026-09-15T05:29:15.144573Z" + "iopub.execute_input": "2026-09-19T23:44:50.573858Z", + "iopub.status.busy": "2026-09-19T23:44:50.573491Z", + "iopub.status.idle": "2026-09-19T23:44:57.712222Z", + "shell.execute_reply": "2026-09-19T23:44:57.711536Z" }, "papermill": { - "duration": 0.072757, - "end_time": "2026-09-15T05:29:15.146649+00:00", + "duration": 7.149752, + "end_time": "2026-09-19T23:44:57.713099", "exception": false, - "start_time": "2026-09-15T05:29:15.073892+00:00", + "start_time": "2026-09-19T23:44:50.563347", "status": "completed" }, "tags": [] @@ -652,139 +680,296 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.JPype] \n", - "--- Configuration Auto-Suffisante de la JVM (Option B - Embarqu\u00e9e) ---\n" + "01:44:50 [INFO] [Orchestration.JPype] \n", + "--- Configuration Auto-Suffisante de la JVM (Option B - Embarquée) ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:50 [INFO] [Orchestration.JPype] 🔍 Recherche JDK portable dans l'arborescence projet...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:50 [INFO] [Orchestration.JPype] ✅ JDK portable trouvé: MyIA.AI.Notebooks\\SymbolicAI\\Tweety\\jdk-17-portable\\zulu17.50.19-ca-jdk17.0.11-win_x64\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:50 [INFO] [Orchestration.JPype] 🏠 JAVA_HOME configuré dynamiquement: MyIA.AI.Notebooks\\SymbolicAI\\Tweety\\jdk-17-portable\\zulu17.50.19-ca-jdk17.0.11-win_x64\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:50 [INFO] [Orchestration.JPype] 📦 Construction du classpath Tweety...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:50 [INFO] [Orchestration.JPype] Scan des JARs dans: MyIA.AI.Notebooks\\SymbolicAI\\Tweety\\libs\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:50 [INFO] [Orchestration.JPype] ✅ 77 JARs trouvés dans MyIA.AI.Notebooks\\SymbolicAI\\Tweety\\libs\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:50 [INFO] [Orchestration.JPype] ✅ Classpath construit: 77 JARs Tweety\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.JPype] \ud83d\udd0d Recherche JDK portable dans l'arborescence projet...\n" + "01:44:50 [INFO] [Orchestration.JPype] 🚀 Démarrage JVM avec 77 JARs Tweety...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [WARNING] [Orchestration.JPype] \u26a0\ufe0f JDK portable non trouv\u00e9 dans les chemins standards\n" + "01:44:57 [INFO] [Orchestration.JPype] ✅ JVM démarrée avec succès et domaines enregistrés\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [ERROR] [Orchestration.JPype] \u274c Impossible de localiser un JDK portable - JVM pourrait \u00e9chouer\n" + "01:44:57 [INFO] [Orchestration.JPype] ☕ Java 17.0.11 opérationnel\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.JPype] \ud83d\udce6 Construction du classpath Tweety...\n" + "01:44:57 [INFO] [Orchestration.JPype] 🎯 Test des classes critiques Tweety...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.JPype] Scan des JARs dans: libs\n" + "01:44:57 [INFO] [Orchestration.JPype] ✅ InformationObject: Accessible\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.JPype] Scan des JARs dans: ..\\libs\n" + "01:44:57 [INFO] [Orchestration.JPype] ✅ PlParser: Accessible\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [ERROR] [Orchestration.JPype] \u274c Aucun JAR Tweety trouv\u00e9 dans les chemins standards\n" + "01:44:57 [INFO] [Orchestration.JPype] ✅ PlFormula: Accessible\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [CRITICAL] [Orchestration.JPype] \u274c ERREUR CRITIQUE Configuration Java: Classpath Tweety vide - JARs manquants\n" + "01:44:57 [INFO] [Orchestration.JPype] ✅ BaseRevisionOperator: Accessible\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [CRITICAL] [Orchestration.JPype] PropositionalLogicAgent fonctionnera en mode d\u00e9grad\u00e9 (LLM seulement)\n" + "01:44:57 [INFO] [Orchestration.JPype] 🏆 Test Tweety RÉUSSI: 4/4 classes accessibles\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [WARNING] [Orchestration.JPype] \n", - "\ud83d\udd34 STATUT FINAL: JVM/Tweety NON OP\u00c9RATIONNELS\n" + "01:44:57 [INFO] [Orchestration.JPype] \n", + "🎉 🏆 SUCCÈS TOTAL - INFRASTRUCTURE TWEETY AUTO-SUFFISANTE! 🏆 🎉\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [WARNING] [Orchestration.JPype] Pipeline fonctionnera en mode d\u00e9grad\u00e9 (5/10)\n" + "01:44:57 [INFO] [Orchestration.JPype] ✅ PropositionalLogicAgent prêt pour exécution native\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.JPype] --- Fin Configuration JPype Auto-Suffisante ---\n" + "01:44:57 [INFO] [Orchestration.JPype] ✅ Pipeline argumentatif avec intégration formelle/informelle opérationnel\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [WARNING] [Orchestration.JPype] \u26a0\ufe0f JVM non pr\u00eate - PropositionalLogicAgent en mode d\u00e9grad\u00e9\n" + "01:44:57 [INFO] [Orchestration.JPype] \n", + "🟢 STATUT FINAL: JVM + Tweety OPÉRATIONNELS\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:57 [INFO] [Orchestration.JPype] Pipeline peut atteindre son potentiel maximal (8/10)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:57 [INFO] [Orchestration.JPype] --- Fin Configuration JPype Auto-Suffisante ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "01:44:57 [INFO] [Orchestration.JPype] ✅ Tweety opérationnel - PropositionalLogicAgent en mode natif\n" ] } ], "source": [ - "# %% CELLULE OPTION B - Configuration Java Auto-Suffisante (Initialisation Embarqu\u00e9e)\n", - "# Int\u00e9gration des fonctions valid\u00e9es des scripts de r\u00e9paration pour rendre le notebook autonome\n", + "# %% CELLULE OPTION B - Configuration Java Auto-Suffisante (Initialisation Embarquée)\n", + "# Intégration des fonctions validées des scripts de réparation pour rendre le notebook autonome\n", "\n", "import jpype\n", "import jpype.imports\n", "import os\n", "import pathlib\n", "import platform\n", + "import subprocess\n", "import sys\n", "import logging\n", "from typing import Optional\n", "\n", "logger = logging.getLogger(\"Orchestration.JPype\")\n", - "logger.info(\"\\n--- Configuration Auto-Suffisante de la JVM (Option B - Embarqu\u00e9e) ---\")\n", + "logger.info(\"\\n--- Configuration Auto-Suffisante de la JVM (Option B - Embarquée) ---\")\n", + "\n", + "# --- Fonctions embarquées (extraites des scripts de réparation validés) ---\n", + "\n", + "# --- Reference de localisation commune (#16264) ---\n", + "# La shim #4960 (argumentation_lib/_paths.py) resout les chemins en\n", + "# __file__-relatif, donc insensible au cwd du lanceur (Jupyter, papermill --cwd,\n", + "# outil du depot) : c'est la convention de la famille Argument_Analysis, et elle\n", + "# interdit le walk manuel. Repli explicite si le dossier du notebook n'est pas\n", + "# importable, pour que la cellule reste executable (aucun raise, regle C.1).\n", + "try:\n", + " from argumentation_lib._paths import SYMBOLIC_AI_DIR\n", + " TWEETY_DIR = SYMBOLIC_AI_DIR / \"Tweety\"\n", + "except ImportError:\n", + " logger.warning(\"argumentation_lib non importable -- repli sur un chemin relatif au cwd\")\n", + " TWEETY_DIR = pathlib.Path(\"MyIA.AI.Notebooks/SymbolicAI/Tweety\")\n", + "\n", + "#: Reference partagee avec la serie Tweety : c'est le defaut `--lib-dir` de\n", + "#: download_tweety_tools.py, et le seul repertoire que l'outil canonique\n", + "#: alimente (JARs TweetyProject + JDK Zulu 17 portable). Avant #16264 la cellule\n", + "#: cherchait l'ancien emplacement local Argument_Analysis/libs, vide depuis\n", + "#: #1437 (Phase 1 de l'EPIC #1396) : classpath vide, JVM non demarree, sans que\n", + "#: rien ne le signale a l'etudiant.\n", + "TWEETY_LIBS_DIR = \"libs\"\n", + "TWEETY_JDK_DIR = \"jdk-17-portable\"\n", + "\n", + "# --- Affichage des chemins : jamais l'absolu (#16264) ---\n", + "# Un chemin absolu dans une sortie de cellule divulgue la topologie de la machine\n", + "# d'execution (secrets-hygiene rule 6) et fait rougir le ratchet Output-failure\n", + "# (MACHINE_PATH). Ces logs impriment l'absolu depuis toujours ; ils etaient\n", + "# simplement inatteignables tant que la cellule ne trouvait ni JDK ni JARs. On\n", + "# corrige la SOURCE plutot que de nettoyer la sortie : un chemin relatif ne se\n", + "# regenere pas au run suivant, alors qu'une retouche de sortie serait refaite a\n", + "# chaque execution.\n", + "try:\n", + " _REPO_ROOT = SYMBOLIC_AI_DIR.parent.parent\n", + "except NameError: # repli ImportError ci-dessus : chemins deja relatifs au cwd\n", + " _REPO_ROOT = pathlib.Path(\".\")\n", + "\n", + "\n", + "def display_path(path) -> str:\n", + " \"\"\"Rend un chemin affichable : relatif a la racine du depot, jamais absolu.\"\"\"\n", + " if not path:\n", + " return \"(non defini)\"\n", + " p = pathlib.Path(path)\n", + " try:\n", + " return str(p.relative_to(_REPO_ROOT))\n", + " except ValueError:\n", + " # Hors depot : le nom seul, jamais l'absolu.\n", + " return p.name if p.is_absolute() else str(p)\n", + "\n", + "\n", + "def ensure_tweety_jars(jars_dir: pathlib.Path) -> bool:\n", + " \"\"\"Installe les JARs Tweety manquants via l'outil canonique (idempotent).\n", + "\n", + " Depuis #1437 les 71 JARs TweetyProject ne sont plus suivis par git : un clone\n", + " neuf n'en contient aucun et la JVM ne peut pas demarrer. On invoque le script\n", + " de la serie Tweety plutot que de reimplementer un telechargement ici.\n", + " Retourne True si le repertoire contient des JARs a l'issue de l'appel.\n", + " \"\"\"\n", + " if jars_dir.is_dir() and any(jars_dir.glob(\"*.jar\")):\n", + " return True\n", + "\n", + " downloader = TWEETY_DIR / \"scripts\" / \"download_tweety_tools.py\"\n", + " if not downloader.exists():\n", + " logger.error(\"Bootstrap JARs impossible: %s introuvable\", display_path(downloader))\n", + " return False\n", + "\n", + " logger.info(\"Aucun JAR Tweety dans %s -- bootstrap via %s\",\n", + " display_path(jars_dir), downloader.name)\n", + " try:\n", + " proc = subprocess.run(\n", + " [sys.executable, str(downloader), \"--jars\",\n", + " \"--lib-dir\", str(jars_dir), \"--no-interactive\"],\n", + " capture_output=True, text=True, timeout=1800,\n", + " )\n", + " except Exception as exc:\n", + " logger.error(\"Bootstrap JARs echoue: %s\", exc)\n", + " return False\n", + "\n", + " if proc.returncode != 0:\n", + " logger.error(\"Bootstrap JARs echoue (rc=%s): %s\",\n", + " proc.returncode, (proc.stderr or proc.stdout or \"\")[-800:])\n", + " return jars_dir.is_dir() and any(jars_dir.glob(\"*.jar\"))\n", "\n", - "# --- Fonctions embarqu\u00e9es (extraites des scripts de r\u00e9paration valid\u00e9s) ---\n", "\n", "def find_portable_jdk() -> Optional[str]:\n", " \"\"\"\n", " Localise automatiquement le JDK portable dans l'arborescence du projet.\n", - " Fonction extraite et valid\u00e9e du script de r\u00e9paration.\n", + " Fonction extraite et validée du script de réparation.\n", " \"\"\"\n", - " logger.info(\"\ud83d\udd0d Recherche JDK portable dans l'arborescence projet...\")\n", + " logger.info(\"🔍 Recherche JDK portable dans l'arborescence projet...\")\n", " \n", " # Chemins de recherche prioritaires pour le JDK portable\n", " search_paths = [\n", + " # Reference partagee avec la serie Tweety (defaut --jdk de l'outil).\n", + " TWEETY_DIR / TWEETY_JDK_DIR,\n", + " # Ancien emplacement local a Argument_Analysis : repli, plus alimente.\n", " pathlib.Path(\"MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/jdk-17-portable\"),\n", " pathlib.Path(\"jdk-17-portable\"),\n", " pathlib.Path(\"../jdk-17-portable\"),\n", - " pathlib.Path(\"../../jdk-17-portable\")\n", + " pathlib.Path(\"../../jdk-17-portable\"),\n", " ]\n", " \n", " for base_path in search_paths:\n", " if base_path.exists():\n", - " logger.debug(f\" Scan du r\u00e9pertoire: {base_path}\")\n", + " logger.debug(f\" Scan du répertoire: {display_path(base_path)}\")\n", " \n", " # Chercher des sous-dossiers JDK\n", " jdk_patterns = [\"*jdk*\", \"zulu*\", \"*openjdk*\", \"*corretto*\"]\n", @@ -792,54 +977,59 @@ " jdk_dirs = list(base_path.glob(pattern))\n", " for jdk_dir in jdk_dirs:\n", " if jdk_dir.is_dir():\n", - " # V\u00e9rifier pr\u00e9sence de bin/java\n", + " # Vérifier présence de bin/java\n", " exe_suffix = \".exe\" if platform.system() == \"Windows\" else \"\"\n", " java_exe = jdk_dir / \"bin\" / f\"java{exe_suffix}\"\n", " if java_exe.exists():\n", - " logger.info(f\"\u2705 JDK portable trouv\u00e9: {jdk_dir.absolute()}\")\n", + " logger.info(f\"✅ JDK portable trouvé: {display_path(jdk_dir)}\")\n", " return str(jdk_dir.absolute())\n", " \n", - " logger.warning(\"\u26a0\ufe0f JDK portable non trouv\u00e9 dans les chemins standards\")\n", + " logger.warning(\"⚠️ JDK portable non trouvé dans les chemins standards\")\n", " return None\n", "\n", "def get_tweety_classpath() -> list:\n", " \"\"\"\n", " Construit dynamiquement le classpath avec tous les JARs Tweety disponibles.\n", - " Fonction extraite et valid\u00e9e du script de r\u00e9paration.\n", + " Fonction extraite et validée du script de réparation.\n", " \"\"\"\n", - " logger.info(\"\ud83d\udce6 Construction du classpath Tweety...\")\n", + " logger.info(\"📦 Construction du classpath Tweety...\")\n", " \n", " # Chemins de recherche des JARs\n", - " libs_paths = [\n", - " pathlib.Path(\"libs\"),\n", - " pathlib.Path(\"MyIA.AI.Notebooks/SymbolicAI/libs\"),\n", - " pathlib.Path(\"../libs\")\n", - " ]\n", + " # Reference partagee d'abord (elle seule est alimentee par l'outil\n", + " # canonique) ; les anciens emplacements restent en repli.\n", + " libs_paths = [TWEETY_DIR / TWEETY_LIBS_DIR,\n", + " pathlib.Path(\"libs\"),\n", + " pathlib.Path(\"MyIA.AI.Notebooks/SymbolicAI/libs\"),\n", + " pathlib.Path(\"../libs\")]\n", + "\n", + " # Un clone neuf n'a aucun JAR (gitignores depuis #1437) : bootstrap\n", + " # canonique, declenche uniquement parce que le classpath est vide.\n", + " ensure_tweety_jars(TWEETY_DIR / TWEETY_LIBS_DIR)\n", " \n", " jar_files = []\n", " \n", " for libs_path in libs_paths:\n", " if libs_path.exists() and libs_path.is_dir():\n", - " logger.info(f\" Scan des JARs dans: {libs_path}\")\n", + " logger.info(f\" Scan des JARs dans: {display_path(libs_path)}\")\n", " found_jars = list(libs_path.glob(\"*.jar\"))\n", " if found_jars:\n", " jar_files.extend([str(jar.absolute()) for jar in found_jars])\n", - " logger.info(f\" \u2705 {len(found_jars)} JARs trouv\u00e9s dans {libs_path}\")\n", - " break # Utiliser le premier r\u00e9pertoire avec des JARs\n", + " logger.info(f\" ✅ {len(found_jars)} JARs trouvés dans {display_path(libs_path)}\")\n", + " break # Utiliser le premier répertoire avec des JARs\n", " \n", " if jar_files:\n", - " logger.info(f\"\u2705 Classpath construit: {len(jar_files)} JARs Tweety\")\n", - " return sorted(jar_files) # Tri pour coh\u00e9rence\n", + " logger.info(f\"✅ Classpath construit: {len(jar_files)} JARs Tweety\")\n", + " return sorted(jar_files) # Tri pour cohérence\n", " else:\n", - " logger.error(\"\u274c Aucun JAR Tweety trouv\u00e9 dans les chemins standards\")\n", + " logger.error(\"❌ Aucun JAR Tweety trouvé dans les chemins standards\")\n", " return []\n", "\n", "def test_tweety_critical_classes():\n", " \"\"\"\n", - " Teste l'acc\u00e8s aux classes critiques de Tweety pour validation.\n", - " Utilise la classe corrig\u00e9e d\u00e9couverte lors du debug.\n", + " Teste l'accès aux classes critiques de Tweety pour validation.\n", + " Utilise la classe corrigée découverte lors du debug.\n", " \"\"\"\n", - " logger.info(\"\ud83c\udfaf Test des classes critiques Tweety...\")\n", + " logger.info(\"🎯 Test des classes critiques Tweety...\")\n", " \n", " critical_classes = {\n", " \"InformationObject\": \"org.tweetyproject.beliefdynamics.mas.InformationObject\",\n", @@ -854,30 +1044,30 @@ " try:\n", " test_class = jpype.JClass(class_name)\n", " successful_classes.append(class_alias)\n", - " logger.info(f\" \u2705 {class_alias}: Accessible\")\n", + " logger.info(f\" ✅ {class_alias}: Accessible\")\n", " except Exception as e:\n", - " logger.warning(f\" \u26a0\ufe0f {class_alias}: Inaccessible - {e}\")\n", + " logger.warning(f\" ⚠️ {class_alias}: Inaccessible - {e}\")\n", " \n", " success_rate = len(successful_classes) / len(critical_classes)\n", " \n", " if success_rate >= 0.75: # Au moins 75% des classes critiques\n", - " logger.info(f\"\ud83c\udfc6 Test Tweety R\u00c9USSI: {len(successful_classes)}/{len(critical_classes)} classes accessibles\")\n", + " logger.info(f\"🏆 Test Tweety RÉUSSI: {len(successful_classes)}/{len(critical_classes)} classes accessibles\")\n", " return True\n", " else:\n", - " logger.error(f\"\u274c Test Tweety \u00c9CHOU\u00c9: {len(successful_classes)}/{len(critical_classes)} classes accessibles\")\n", + " logger.error(f\"❌ Test Tweety ÉCHOUÉ: {len(successful_classes)}/{len(critical_classes)} classes accessibles\")\n", " return False\n", "\n", - "# --- S\u00e9quence d'initialisation embarqu\u00e9e ---\n", + "# --- Séquence d'initialisation embarquée ---\n", "\n", - "jvm_ready = False # Variable globale d'\u00e9tat\n", + "jvm_ready = False # Variable globale d'état\n", "\n", "try:\n", - " # \u00c9tape 1: V\u00e9rifier si JVM d\u00e9j\u00e0 d\u00e9marr\u00e9e\n", + " # Étape 1: Vérifier si JVM déjà démarrée\n", " if jpype.isJVMStarted():\n", - " logger.info(\"\u2139\ufe0f JVM d\u00e9j\u00e0 d\u00e9marr\u00e9e - utilisation de l'instance existante\")\n", + " logger.info(\"ℹ️ JVM déjà démarrée - utilisation de l'instance existante\")\n", " jvm_ready = True\n", " \n", - " # Enregistrer les domaines au cas o\u00f9\n", + " # Enregistrer les domaines au cas où\n", " try:\n", " jpype.imports.registerDomain(\"org\", alias=\"org\")\n", " jpype.imports.registerDomain(\"java\", alias=\"java\")\n", @@ -885,7 +1075,7 @@ " except:\n", " pass\n", " else:\n", - " # \u00c9tape 2: Localiser et configurer JAVA_HOME au niveau processus\n", + " # Étape 2: Localiser et configurer JAVA_HOME au niveau processus\n", " portable_jdk = find_portable_jdk()\n", " \n", " if portable_jdk:\n", @@ -893,82 +1083,91 @@ " current_java_home = os.getenv('JAVA_HOME')\n", " if not current_java_home or current_java_home != portable_jdk:\n", " os.environ['JAVA_HOME'] = portable_jdk\n", - " logger.info(f\"\ud83c\udfe0 JAVA_HOME configur\u00e9 dynamiquement: {portable_jdk}\")\n", + " logger.info(f\"🏠 JAVA_HOME configuré dynamiquement: {display_path(portable_jdk)}\")\n", " else:\n", - " logger.info(f\"\ud83c\udfe0 JAVA_HOME d\u00e9j\u00e0 configur\u00e9: {current_java_home}\")\n", + " logger.info(f\"🏠 JAVA_HOME déjà configuré: {display_path(current_java_home)}\")\n", " else:\n", - " logger.error(\"\u274c Impossible de localiser un JDK portable - JVM pourrait \u00e9chouer\")\n", + " logger.error(\"❌ Impossible de localiser un JDK portable - JVM pourrait échouer\")\n", + " logger.error(\" Attendu: %s (download_tweety_tools.py --jdk) -- JAVA_HOME courant: %s\",\n", + " display_path(TWEETY_DIR / TWEETY_JDK_DIR),\n", + " display_path(os.getenv('JAVA_HOME')))\n", " \n", - " # \u00c9tape 3: Construire le classpath Tweety complet\n", + " # Étape 3: Construire le classpath Tweety complet\n", " tweety_jars = get_tweety_classpath()\n", " \n", - " if not tweety_jars:\n", - " raise Exception(\"Classpath Tweety vide - JARs manquants\")\n", - " \n", - " # \u00c9tape 4: D\u00e9marrer la JVM avec configuration optimale\n", - " logger.info(f\"\ud83d\ude80 D\u00e9marrage JVM avec {len(tweety_jars)} JARs Tweety...\")\n", - " \n", - " jvm_args = [\n", - " \"-Xmx2g\", # M\u00e9moire suffisante pour Tweety\n", - " \"-Djava.awt.headless=true\", # Mode headless pour notebooks\n", - " ]\n", - " \n", - " jpype.startJVM(\n", - " *jvm_args,\n", - " classpath=tweety_jars,\n", - " convertStrings=False,\n", - " ignoreUnrecognized=True\n", - " )\n", - " \n", - " # \u00c9tape 5: Enregistrer les domaines Java\n", - " jpype.imports.registerDomain(\"org\", alias=\"org\")\n", - " jpype.imports.registerDomain(\"java\", alias=\"java\")\n", - " jpype.imports.registerDomain(\"net\", alias=\"net\")\n", - " \n", - " logger.info(\"\u2705 JVM d\u00e9marr\u00e9e avec succ\u00e8s et domaines enregistr\u00e9s\")\n", - " jvm_ready = True\n", + " # Étape 4: Démarrer la JVM avec configuration optimale.\n", + " # #16264 : aucun raise si le classpath reste vide (regle C.1) -- la\n", + " # cellule degrade proprement et le diagnostic final dit exactement ce\n", + " # qui manque, au lieu de faire echouer le notebook.\n", + " if tweety_jars:\n", + " logger.info(f\"🚀 Démarrage JVM avec {len(tweety_jars)} JARs Tweety...\")\n", + "\n", + " jvm_args = [\n", + " \"-Xmx2g\", # Mémoire suffisante pour Tweety\n", + " \"-Djava.awt.headless=true\", # Mode headless pour notebooks\n", + " ]\n", + "\n", + " jpype.startJVM(\n", + " *jvm_args,\n", + " classpath=tweety_jars,\n", + " convertStrings=False,\n", + " ignoreUnrecognized=True\n", + " )\n", + "\n", + " # Étape 5: Enregistrer les domaines Java\n", + " jpype.imports.registerDomain(\"org\", alias=\"org\")\n", + " jpype.imports.registerDomain(\"java\", alias=\"java\")\n", + " jpype.imports.registerDomain(\"net\", alias=\"net\")\n", + "\n", + " logger.info(\"✅ JVM démarrée avec succès et domaines enregistrés\")\n", + " jvm_ready = True\n", + " else:\n", + " logger.error(\"❌ Classpath Tweety vide après bootstrap -- JVM non démarrée\")\n", + " logger.error(\" Attendu: %s (JARs TweetyProject, outil canonique \"\n", + " \"download_tweety_tools.py --jars)\",\n", + " display_path(TWEETY_DIR / TWEETY_LIBS_DIR))\n", " \n", - " # \u00c9tape 6: Test de validation Tweety\n", + " # Étape 6: Test de validation Tweety\n", " if jvm_ready:\n", " # Test Java de base\n", " try:\n", " System = jpype.JClass('java.lang.System')\n", " java_version = System.getProperty('java.version')\n", - " logger.info(f\"\u2615 Java {java_version} op\u00e9rationnel\")\n", + " logger.info(f\"☕ Java {java_version} opérationnel\")\n", " except Exception as e:\n", - " logger.warning(f\"\u26a0\ufe0f Test Java de base \u00e9chou\u00e9: {e}\")\n", + " logger.warning(f\"⚠️ Test Java de base échoué: {e}\")\n", " \n", " # Test classes Tweety critiques\n", " tweety_success = test_tweety_critical_classes()\n", " if tweety_success:\n", - " logger.info(\"\\n\ud83c\udf89 \ud83c\udfc6 SUCC\u00c8S TOTAL - INFRASTRUCTURE TWEETY AUTO-SUFFISANTE! \ud83c\udfc6 \ud83c\udf89\")\n", - " logger.info(\"\u2705 PropositionalLogicAgent pr\u00eat pour ex\u00e9cution native\")\n", - " logger.info(\"\u2705 Pipeline argumentatif avec int\u00e9gration formelle/informelle op\u00e9rationnel\")\n", + " logger.info(\"\\n🎉 🏆 SUCCÈS TOTAL - INFRASTRUCTURE TWEETY AUTO-SUFFISANTE! 🏆 🎉\")\n", + " logger.info(\"✅ PropositionalLogicAgent prêt pour exécution native\")\n", + " logger.info(\"✅ Pipeline argumentatif avec intégration formelle/informelle opérationnel\")\n", " else:\n", - " logger.warning(\"\u26a0\ufe0f JVM op\u00e9rationnelle mais classes Tweety partiellement accessibles\")\n", + " logger.warning(\"⚠️ JVM opérationnelle mais classes Tweety partiellement accessibles\")\n", " jvm_ready = False\n", "\n", "except Exception as e:\n", - " logger.critical(f\"\u274c ERREUR CRITIQUE Configuration Java: {e}\")\n", - " logger.critical(\" PropositionalLogicAgent fonctionnera en mode d\u00e9grad\u00e9 (LLM seulement)\")\n", + " logger.critical(f\"❌ ERREUR CRITIQUE Configuration Java: {e}\")\n", + " logger.critical(\" PropositionalLogicAgent fonctionnera en mode dégradé (LLM seulement)\")\n", " jvm_ready = False\n", "\n", - "# --- Conclusion \u00c9tat JVM ---\n", + "# --- Conclusion État JVM ---\n", "if jvm_ready:\n", - " logger.info(\"\\n\ud83d\udfe2 STATUT FINAL: JVM + Tweety OP\u00c9RATIONNELS\")\n", + " logger.info(\"\\n🟢 STATUT FINAL: JVM + Tweety OPÉRATIONNELS\")\n", " logger.info(\" Pipeline peut atteindre son potentiel maximal (8/10)\")\n", "else:\n", - " logger.warning(\"\\n\ud83d\udd34 STATUT FINAL: JVM/Tweety NON OP\u00c9RATIONNELS\")\n", - " logger.warning(\" Pipeline fonctionnera en mode d\u00e9grad\u00e9 (5/10)\")\n", + " logger.warning(\"\\n🔴 STATUT FINAL: JVM/Tweety NON OPÉRATIONNELS\")\n", + " logger.warning(\" Pipeline fonctionnera en mode dégradé (5/10)\")\n", "\n", "logger.info(\"--- Fin Configuration JPype Auto-Suffisante ---\")\n", "\n", - "# === FONCTIONS UTILITAIRES INT\u00c9GR\u00c9ES ===\n", - "# Ces fonctions sont extraites et optimis\u00e9es des scripts de diagnostic/r\u00e9paration\n", + "# === FONCTIONS UTILITAIRES INTÉGRÉES ===\n", + "# Ces fonctions sont extraites et optimisées des scripts de diagnostic/réparation\n", "\n", "def diagnostic_infrastructure_tweety():\n", - " \"\"\"Fonction de diagnostic complet de l'infrastructure Tweety int\u00e9gr\u00e9e.\"\"\"\n", - " logger.info(\"\ud83d\udd0d Diagnostic infrastructure Tweety int\u00e9gr\u00e9...\")\n", + " \"\"\"Fonction de diagnostic complet de l'infrastructure Tweety intégrée.\"\"\"\n", + " logger.info(\"🔍 Diagnostic infrastructure Tweety intégré...\")\n", " \n", " diagnostic_results = {\n", " 'jdk_status': 'OK' if find_portable_jdk() else 'NOK',\n", @@ -984,26 +1183,26 @@ " except:\n", " pass\n", " \n", - " logger.info(f\"\ud83d\udcca R\u00e9sultats: {diagnostic_results}\")\n", + " logger.info(f\"📊 Résultats: {diagnostic_results}\")\n", " return diagnostic_results\n", "\n", "def validate_tweety_ready():\n", - " \"\"\"Validation rapide de l'\u00e9tat op\u00e9rationnel Tweety.\"\"\"\n", + " \"\"\"Validation rapide de l'état opérationnel Tweety.\"\"\"\n", " if not jvm_ready:\n", - " logger.warning(\"\u26a0\ufe0f JVM non pr\u00eate - PropositionalLogicAgent en mode d\u00e9grad\u00e9\")\n", + " logger.warning(\"⚠️ JVM non prête - PropositionalLogicAgent en mode dégradé\")\n", " return False\n", " \n", " try:\n", " # Test classe critique\n", " InformationObject = jpype.JClass('org.tweetyproject.beliefdynamics.mas.InformationObject')\n", " PlParser = jpype.JClass('org.tweetyproject.logics.pl.parser.PlParser')\n", - " logger.info(\"\u2705 Tweety op\u00e9rationnel - PropositionalLogicAgent en mode natif\")\n", + " logger.info(\"✅ Tweety opérationnel - PropositionalLogicAgent en mode natif\")\n", " return True\n", " except Exception as e:\n", - " logger.error(f\"\u274c Classes Tweety inaccessibles: {e}\")\n", + " logger.error(f\"❌ Classes Tweety inaccessibles: {e}\")\n", " return False\n", "\n", - "# Diagnostic automatique \u00e0 l'initialisation\n", + "# Diagnostic automatique à l'initialisation\n", "if 'jvm_ready' in locals():\n", " validate_tweety_ready()" ] @@ -1013,39 +1212,39 @@ "id": "7hq2u546fkr", "metadata": { "papermill": { - "duration": 0.017746, - "end_time": "2026-09-15T05:29:15.183846+00:00", + "duration": 0.009162, + "end_time": "2026-09-19T23:44:57.732112", "exception": false, - "start_time": "2026-09-15T05:29:15.166100+00:00", + "start_time": "2026-09-19T23:44:57.722950", "status": "completed" }, "tags": [] }, "source": [ - "### R\u00e9sultats de la configuration Java/Tweety\n", + "### Résultats de la configuration Java/Tweety\n", "\n", - "La configuration de la JVM est maintenant termin\u00e9e. V\u00e9rifiez les messages ci-dessus pour d\u00e9terminer le statut :\n", + "La configuration de la JVM est maintenant terminée. Vérifiez les messages ci-dessus pour déterminer le statut :\n", "\n", - "**Indicateurs de succ\u00e8s** :\n", + "**Indicateurs de succès** :\n", "\n", "| Message | Signification | Impact |\n", "|---------|---------------|--------|\n", - "| \u2705 JDK portable trouv\u00e9 | Le JDK a \u00e9t\u00e9 localis\u00e9 dans l'arborescence | JAVA_HOME configur\u00e9 automatiquement |\n", - "| \u2705 Classpath construit: N JARs | Les biblioth\u00e8ques Tweety sont disponibles | Fonctions formelles accessibles |\n", - "| \u2705 JVM d\u00e9marr\u00e9e avec succ\u00e8s | La machine virtuelle Java est op\u00e9rationnelle | Pr\u00eat pour ex\u00e9cution native |\n", - "| \u2705 Test Tweety R\u00c9USSI: X/Y classes | Les classes critiques sont accessibles | PropositionalLogicAgent en mode natif |\n", - "| \ud83d\udfe2 STATUT FINAL: JVM + Tweety OP\u00c9RATIONNELS | **Tout fonctionne parfaitement** | **Pipeline \u00e0 potentiel maximal (8/10)** |\n", + "| ✅ JDK portable trouvé | Le JDK a été localisé dans l'arborescence | JAVA_HOME configuré automatiquement |\n", + "| ✅ Classpath construit: N JARs | Les bibliothèques Tweety sont disponibles | Fonctions formelles accessibles |\n", + "| ✅ JVM démarrée avec succès | La machine virtuelle Java est opérationnelle | Prêt pour exécution native |\n", + "| ✅ Test Tweety RÉUSSI: X/Y classes | Les classes critiques sont accessibles | PropositionalLogicAgent en mode natif |\n", + "| 🟢 STATUT FINAL: JVM + Tweety OPÉRATIONNELS | **Tout fonctionne parfaitement** | **Pipeline à potentiel maximal (8/10)** |\n", "\n", - "**Indicateurs de probl\u00e8me** :\n", + "**Indicateurs de problème** :\n", "\n", "| Message | Signification | Solution |\n", "|---------|---------------|----------|\n", - "| \u26a0\ufe0f JDK portable non trouv\u00e9 | Pas de JDK automatique d\u00e9tect\u00e9 | V\u00e9rifiez que le JDK est dans `jdk-17-portable/` |\n", - "| \u274c Classpath Tweety vide | JARs manquants | V\u00e9rifiez le dossier `libs/` |\n", - "| \u274c Test Tweety \u00c9CHOU\u00c9 | Classes inaccessibles | V\u00e9rifiez les versions des JARs |\n", - "| \ud83d\udd34 STATUT FINAL: JVM/Tweety NON OP\u00c9RATIONNELS | **Mode d\u00e9grad\u00e9 activ\u00e9** | **Pipeline limit\u00e9 au LLM (5/10)** |\n", + "| ⚠️ JDK portable non trouvé | Pas de JDK automatique détecté | Vérifiez que le JDK est dans `jdk-17-portable/` |\n", + "| ❌ Classpath Tweety vide | JARs manquants | Vérifiez le dossier `libs/` |\n", + "| ❌ Test Tweety ÉCHOUÉ | Classes inaccessibles | Vérifiez les versions des JARs |\n", + "| 🔴 STATUT FINAL: JVM/Tweety NON OPÉRATIONNELS | **Mode dégradé activé** | **Pipeline limité au LLM (5/10)** |\n", "\n", - "> **Mode d\u00e9grad\u00e9** : Si la JVM n'a pas d\u00e9marr\u00e9, le notebook continuera \u00e0 fonctionner mais le PropositionalLogicAgent utilisera uniquement le LLM pour simuler le raisonnement formel, sans v\u00e9rification par les solveurs SAT de Tweety." + "> **Mode dégradé** : Si la JVM n'a pas démarré, le notebook continuera à fonctionner mais le PropositionalLogicAgent utilisera uniquement le LLM pour simuler le raisonnement formel, sans vérification par les solveurs SAT de Tweety." ] }, { @@ -1053,22 +1252,22 @@ "id": "d201514e", "metadata": { "papermill": { - "duration": 0.02499, - "end_time": "2026-09-15T05:29:15.228420+00:00", + "duration": 0.008818, + "end_time": "2026-09-19T23:44:57.749857", "exception": false, - "start_time": "2026-09-15T05:29:15.203430+00:00", + "start_time": "2026-09-19T23:44:57.741039", "status": "completed" }, "tags": [] }, "source": [ - "## 3. D\u00e9finitions des Composants Partag\u00e9s\n", + "## 3. Définitions des Composants Partagés\n", "\n", - "Cette section d\u00e9finit les **classes** et le **service LLM global** utilis\u00e9s par plusieurs agents. Les **instances** sp\u00e9cifiques (\u00e9tat, StateManager, kernel local, agents) seront cr\u00e9\u00e9es plus tard, dans la fonction d'ex\u00e9cution (Section 8).\n", + "Cette section définit les **classes** et le **service LLM global** utilisés par plusieurs agents. Les **instances** spécifiques (état, StateManager, kernel local, agents) seront créées plus tard, dans la fonction d'exécution (Section 8).\n", "\n", - "* **`RhetoricalAnalysisState` (Classe)** : La classe Python repr\u00e9sentant l'\u00e9tat partag\u00e9 de l'analyse (texte brut, t\u00e2ches, arguments, sophismes, belief sets, r\u00e9ponses, etc.). Inclut maintenant un logging interne plus d\u00e9taill\u00e9.\n", - "* **`StateManagerPlugin` (Classe)** : Le plugin Semantic Kernel qui fournit des fonctions (`@kernel_function`) pour lire et modifier une instance de `RhetoricalAnalysisState`. Sera initialis\u00e9 avec l'instance d'\u00e9tat locale lors de l'ex\u00e9cution.\n", - "* **`global_ai_service_instance` (Instance)** : L'instance unique du service de compl\u00e9tion (OpenAI ou Azure) configur\u00e9e globalement. Elle sera ajout\u00e9e au kernel *local* de chaque agent lors de sa cr\u00e9ation." + "* **`RhetoricalAnalysisState` (Classe)** : La classe Python représentant l'état partagé de l'analyse (texte brut, tâches, arguments, sophismes, belief sets, réponses, etc.). Inclut maintenant un logging interne plus détaillé.\n", + "* **`StateManagerPlugin` (Classe)** : Le plugin Semantic Kernel qui fournit des fonctions (`@kernel_function`) pour lire et modifier une instance de `RhetoricalAnalysisState`. Sera initialisé avec l'instance d'état locale lors de l'exécution.\n", + "* **`global_ai_service_instance` (Instance)** : L'instance unique du service de complétion (OpenAI ou Azure) configurée globalement. Elle sera ajoutée au kernel *local* de chaque agent lors de sa création." ] }, { @@ -1076,70 +1275,70 @@ "id": "a13a208e", "metadata": { "papermill": { - "duration": 0.019916, - "end_time": "2026-09-15T05:29:15.266195+00:00", + "duration": 0.008782, + "end_time": "2026-09-19T23:44:57.767418", "exception": false, - "start_time": "2026-09-15T05:29:15.246279+00:00", + "start_time": "2026-09-19T23:44:57.758636", "status": "completed" }, "tags": [] }, "source": [ - "### Comprendre l'\u00e9tat partag\u00e9 : RhetoricalAnalysisState\n", + "### Comprendre l'état partagé : RhetoricalAnalysisState\n", "\n", - "La classe `RhetoricalAnalysisState` est le **c\u0153ur du syst\u00e8me multi-agents**. Elle repr\u00e9sente une base de donn\u00e9es partag\u00e9e que tous les agents peuvent consulter et modifier.\n", + "La classe `RhetoricalAnalysisState` est le **cœur du système multi-agents**. Elle représente une base de données partagée que tous les agents peuvent consulter et modifier.\n", "\n", - "**Pourquoi un \u00e9tat partag\u00e9 ?**\n", + "**Pourquoi un état partagé ?**\n", "\n", - "Dans une architecture multi-agents, chaque agent a une sp\u00e9cialit\u00e9 (analyse informelle, logique formelle, gestion de projet). Pour collaborer efficacement, ils doivent :\n", - "1. **Acc\u00e9der aux r\u00e9sultats des autres agents** (ex: le logicien a besoin des arguments identifi\u00e9s par l'analyste informel)\n", - "2. **\u00c9viter la redondance** (ne pas refaire le travail d\u00e9j\u00e0 effectu\u00e9)\n", + "Dans une architecture multi-agents, chaque agent a une spécialité (analyse informelle, logique formelle, gestion de projet). Pour collaborer efficacement, ils doivent :\n", + "1. **Accéder aux résultats des autres agents** (ex: le logicien a besoin des arguments identifiés par l'analyste informel)\n", + "2. **Éviter la redondance** (ne pas refaire le travail déjà effectué)\n", "3. **Tracer l'historique** (savoir qui a fait quoi, dans quel ordre)\n", "\n", - "**Structure de l'\u00e9tat** :\n", + "**Structure de l'état** :\n", "\n", "| Attribut | Type | Description | Exemple |\n", "|----------|------|-------------|---------|\n", - "| `raw_text` | `str` | Texte original \u00e0 analyser | \"Si on augmente les imp\u00f4ts...\" |\n", - "| `analysis_tasks` | `Dict[str, str]` | T\u00e2ches d\u00e9finies par le PM | `{\"task_1\": \"Identifier les arguments\"}` |\n", - "| `identified_arguments` | `Dict[str, str]` | Arguments trouv\u00e9s | `{\"arg_1\": \"L'augmentation des imp\u00f4ts...\"}` |\n", - "| `identified_fallacies` | `Dict[str, Dict]` | Sophismes d\u00e9tect\u00e9s | `{\"fallacy_1\": {\"type\": \"ad hominem\", ...}}` |\n", + "| `raw_text` | `str` | Texte original à analyser | \"Si on augmente les impôts...\" |\n", + "| `analysis_tasks` | `Dict[str, str]` | Tâches définies par le PM | `{\"task_1\": \"Identifier les arguments\"}` |\n", + "| `identified_arguments` | `Dict[str, str]` | Arguments trouvés | `{\"arg_1\": \"L'augmentation des impôts...\"}` |\n", + "| `identified_fallacies` | `Dict[str, Dict]` | Sophismes détectés | `{\"fallacy_1\": {\"type\": \"ad hominem\", ...}}` |\n", "| `belief_sets` | `Dict[str, Dict]` | Bases de croyances formelles | `{\"pl_bs_1\": {\"logic_type\": \"Propositional\", ...}}` |\n", - "| `query_log` | `List[Dict]` | Historique des requ\u00eates formelles | `[{\"query\": \"p => q\", \"result\": \"True\"}]` |\n", - "| `answers` | `Dict[str, Dict]` | R\u00e9ponses aux t\u00e2ches | `{\"task_1\": {\"author\": \"InformalAgent\", ...}}` |\n", - "| `final_conclusion` | `Optional[str]` | Synth\u00e8se finale du PM | \"L'analyse r\u00e9v\u00e8le 3 sophismes...\" |\n", - "| `_next_agent_designated` | `Optional[str]` | Prochain agent \u00e0 intervenir | \"PropositionalLogicAgent\" |\n", + "| `query_log` | `List[Dict]` | Historique des requêtes formelles | `[{\"query\": \"p => q\", \"result\": \"True\"}]` |\n", + "| `answers` | `Dict[str, Dict]` | Réponses aux tâches | `{\"task_1\": {\"author\": \"InformalAgent\", ...}}` |\n", + "| `final_conclusion` | `Optional[str]` | Synthèse finale du PM | \"L'analyse révèle 3 sophismes...\" |\n", + "| `_next_agent_designated` | `Optional[str]` | Prochain agent à intervenir | \"PropositionalLogicAgent\" |\n", "\n", "**Fonctions de manipulation** :\n", "\n", - "- `add_task()` : Ajoute une t\u00e2che et retourne son ID\n", - "- `add_argument()` : Enregistre un argument identifi\u00e9\n", + "- `add_task()` : Ajoute une tâche et retourne son ID\n", + "- `add_argument()` : Enregistre un argument identifié\n", "- `add_fallacy()` : Enregistre un sophisme avec justification\n", "- `add_belief_set()` : Ajoute une base de croyances formelle\n", - "- `log_query()` : Trace une requ\u00eate formelle et son r\u00e9sultat\n", - "- `add_answer()` : Enregistre la r\u00e9ponse d'un agent \u00e0 une t\u00e2che\n", + "- `log_query()` : Trace une requête formelle et son résultat\n", + "- `add_answer()` : Enregistre la réponse d'un agent à une tâche\n", "- `set_conclusion()` : Enregistre la conclusion finale\n", "- `designate_next_agent()` / `consume_next_agent_designation()` : Gestion du tour de parole\n", "\n", - "**Tra\u00e7abilit\u00e9** : Chaque modification est logg\u00e9e avec des messages d\u00e9taill\u00e9s pour faciliter le d\u00e9bogage." + "**Traçabilité** : Chaque modification est loggée avec des messages détaillés pour faciliter le débogage." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "a303fa9c", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:15.308036Z", - "iopub.status.busy": "2026-09-15T05:29:15.307613Z", - "iopub.status.idle": "2026-09-15T05:29:15.327523Z", - "shell.execute_reply": "2026-09-15T05:29:15.325924Z" + "iopub.execute_input": "2026-09-19T23:44:57.787944Z", + "iopub.status.busy": "2026-09-19T23:44:57.787743Z", + "iopub.status.idle": "2026-09-19T23:44:57.791748Z", + "shell.execute_reply": "2026-09-19T23:44:57.791332Z" }, "papermill": { - "duration": 0.04418, - "end_time": "2026-09-15T05:29:15.328845+00:00", + "duration": 0.015754, + "end_time": "2026-09-19T23:44:57.792545", "exception": false, - "start_time": "2026-09-15T05:29:15.284665+00:00", + "start_time": "2026-09-19T23:44:57.776791", "status": "completed" }, "tags": [] @@ -1149,31 +1348,31 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [root] Classe RhetoricalAnalysisState d\u00e9finie (via argumentation_lib shim, Phase 2 #2137).\n" + "01:44:57 [INFO] [root] Classe RhetoricalAnalysisState définie (via argumentation_lib shim, Phase 2 #2137).\n" ] } ], "source": [ - "# %% CELLULE [3.1] - D\u00e9finition Classe RhetoricalAnalysisState\n", - "# Phase 2 (#2137) : RhetoricalAnalysisState est d\u00e9sormais fournie par le shim vendored\n", - "# `argumentation_lib` (B.2 \u2014 argumentation_lib/_shared_state.py). L'ancienne d\u00e9finition\n", - "# inline (~190 lignes) est remplac\u00e9e par un import. La shim est un SUR-ENSEMBLE\n", - "# r\u00e9tro-compatible : 21 m\u00e9thodes vs 15 inline, AUCUN gap (toutes les m\u00e9thodes inline\n", - "# pr\u00e9sentes), seules des params optionnels ajout\u00e9s (ex: add_fallacy +family +taxonomy_path).\n", - "# D\u00e9cision ai-01 (See #2137) : Phase 2 = shim-only, z\u00e9ro submodule EPITA.\n", - "# Anti-collision : la lib `argumentation_lib/` appartient \u00e0 po-2023 ; ce notebook ne fait\n", + "# %% CELLULE [3.1] - Définition Classe RhetoricalAnalysisState\n", + "# Phase 2 (#2137) : RhetoricalAnalysisState est désormais fournie par le shim vendored\n", + "# `argumentation_lib` (B.2 — argumentation_lib/_shared_state.py). L'ancienne définition\n", + "# inline (~190 lignes) est remplacée par un import. La shim est un SUR-ENSEMBLE\n", + "# rétro-compatible : 21 méthodes vs 15 inline, AUCUN gap (toutes les méthodes inline\n", + "# présentes), seules des params optionnels ajoutés (ex: add_fallacy +family +taxonomy_path).\n", + "# Décision ai-01 (See #2137) : Phase 2 = shim-only, zéro submodule EPITA.\n", + "# Anti-collision : la lib `argumentation_lib/` appartient à po-2023 ; ce notebook ne fait\n", "# que la CONSOMMER.\n", "\n", "import logging\n", "\n", - "# RhetoricalAnalysisState provient d\u00e9sormais du shim (standalone, import OK sans EPITA).\n", + "# RhetoricalAnalysisState provient désormais du shim (standalone, import OK sans EPITA).\n", "from argumentation_lib import RhetoricalAnalysisState\n", "\n", - "# Logger conserv\u00e9 pour r\u00e9tro-compatibilit\u00e9 (les notebooks 1/2/3 et l'Executor y font\n", - "# potentiellement r\u00e9f\u00e9rence via l'API du shim qui logge en interne sous ce nom).\n", + "# Logger conservé pour rétro-compatibilité (les notebooks 1/2/3 et l'Executor y font\n", + "# potentiellement référence via l'API du shim qui logge en interne sous ce nom).\n", "state_logger = logging.getLogger(\"RhetoricalAnalysisState\")\n", "\n", - "logging.info(\"Classe RhetoricalAnalysisState d\u00e9finie (via argumentation_lib shim, Phase 2 #2137).\")" + "logging.info(\"Classe RhetoricalAnalysisState définie (via argumentation_lib shim, Phase 2 #2137).\")" ] }, { @@ -1181,10 +1380,10 @@ "id": "0d4166a2", "metadata": { "papermill": { - "duration": 0.022827, - "end_time": "2026-09-15T05:29:15.376366+00:00", + "duration": 0.00854, + "end_time": "2026-09-19T23:44:57.809355", "exception": false, - "start_time": "2026-09-15T05:29:15.353539+00:00", + "start_time": "2026-09-19T23:44:57.800815", "status": "completed" }, "tags": [] @@ -1192,63 +1391,63 @@ "source": [ "### Le pont entre Python et Semantic Kernel : StateManagerPlugin\n", "\n", - "Le `StateManagerPlugin` est un **adaptateur** qui rend l'\u00e9tat Python accessible aux agents IA via Semantic Kernel.\n", + "Le `StateManagerPlugin` est un **adaptateur** qui rend l'état Python accessible aux agents IA via Semantic Kernel.\n", "\n", - "**Probl\u00e9matique** : Les agents IA (bas\u00e9s sur des LLMs via Semantic Kernel) ne peuvent pas directement manipuler des objets Python. Ils ont besoin de **fonctions** qu'ils peuvent appeler avec des param\u00e8tres.\n", + "**Problématique** : Les agents IA (basés sur des LLMs via Semantic Kernel) ne peuvent pas directement manipuler des objets Python. Ils ont besoin de **fonctions** qu'ils peuvent appeler avec des paramètres.\n", "\n", - "**Solution** : Le plugin expose les m\u00e9thodes de `RhetoricalAnalysisState` comme des **kernel functions** que les agents peuvent invoquer.\n", + "**Solution** : Le plugin expose les méthodes de `RhetoricalAnalysisState` comme des **kernel functions** que les agents peuvent invoquer.\n", "\n", "**Architecture du plugin** :\n", "\n", "```\n", "Agent IA (LLM)\n", - " \u2193 (appel de fonction)\n", + " ↓ (appel de fonction)\n", "StateManagerPlugin.add_identified_argument(description=\"...\")\n", - " \u2193 (d\u00e9l\u00e9gation)\n", + " ↓ (délégation)\n", "RhetoricalAnalysisState.add_argument(description)\n", - " \u2193 (modification)\n", - "\u00c9tat partag\u00e9 mis \u00e0 jour\n", + " ↓ (modification)\n", + "État partagé mis à jour\n", "```\n", "\n", - "**Fonctions expos\u00e9es** :\n", + "**Fonctions exposées** :\n", "\n", - "| Fonction Kernel | Description | Param\u00e8tres |\n", + "| Fonction Kernel | Description | Paramètres |\n", "|----------------|-------------|------------|\n", - "| `get_current_state_snapshot` | Lit l'\u00e9tat actuel | `summarize: bool` |\n", - "| `add_analysis_task` | Cr\u00e9e une nouvelle t\u00e2che | `description: str` |\n", + "| `get_current_state_snapshot` | Lit l'état actuel | `summarize: bool` |\n", + "| `add_analysis_task` | Crée une nouvelle tâche | `description: str` |\n", "| `add_identified_argument` | Enregistre un argument | `description: str` |\n", "| `add_identified_fallacy` | Enregistre un sophisme | `fallacy_type: str, justification: str, target_argument_id: Optional[str]` |\n", - "| `add_belief_set` | Cr\u00e9e une base de croyances | `logic_type: str, content: str` |\n", - "| `log_query_result` | Trace une requ\u00eate formelle | `belief_set_id: str, query: str, raw_result: str` |\n", - "| `add_answer` | R\u00e9pond \u00e0 une t\u00e2che | `task_id: str, author_agent: str, answer_text: str, source_ids: List[str]` |\n", + "| `add_belief_set` | Crée une base de croyances | `logic_type: str, content: str` |\n", + "| `log_query_result` | Trace une requête formelle | `belief_set_id: str, query: str, raw_result: str` |\n", + "| `add_answer` | Répond à une tâche | `task_id: str, author_agent: str, answer_text: str, source_ids: List[str]` |\n", "| `set_final_conclusion` | Enregistre la conclusion | `conclusion: str` |\n", - "| `designate_next_agent` | D\u00e9signe le prochain agent | `agent_name: str` |\n", + "| `designate_next_agent` | Désigne le prochain agent | `agent_name: str` |\n", "\n", - "**Validation et s\u00e9curit\u00e9** :\n", + "**Validation et sécurité** :\n", "\n", - "- **Validation du type logique** : Seuls `\"propositional\"` et `\"pl\"` sont accept\u00e9s pour `add_belief_set`\n", - "- **Logging d\u00e9taill\u00e9** : Chaque appel est trac\u00e9 avec l'ID de l'\u00e9tat et les param\u00e8tres\n", - "- **Gestion d'erreurs** : Les exceptions sont captur\u00e9es et retourn\u00e9es comme `FUNC_ERROR: ...`\n", + "- **Validation du type logique** : Seuls `\"propositional\"` et `\"pl\"` sont acceptés pour `add_belief_set`\n", + "- **Logging détaillé** : Chaque appel est tracé avec l'ID de l'état et les paramètres\n", + "- **Gestion d'erreurs** : Les exceptions sont capturées et retournées comme `FUNC_ERROR: ...`\n", "\n", - "**D\u00e9corateur `@kernel_function`** : Chaque m\u00e9thode marqu\u00e9e avec ce d\u00e9corateur devient automatiquement accessible aux agents IA via Semantic Kernel." + "**Décorateur `@kernel_function`** : Chaque méthode marquée avec ce décorateur devient automatiquement accessible aux agents IA via Semantic Kernel." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "61903410", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:15.422324Z", - "iopub.status.busy": "2026-09-15T05:29:15.421865Z", - "iopub.status.idle": "2026-09-15T05:29:15.433636Z", - "shell.execute_reply": "2026-09-15T05:29:15.432173Z" + "iopub.execute_input": "2026-09-19T23:44:57.828059Z", + "iopub.status.busy": "2026-09-19T23:44:57.827847Z", + "iopub.status.idle": "2026-09-19T23:44:57.844121Z", + "shell.execute_reply": "2026-09-19T23:44:57.843485Z" }, "papermill": { - "duration": 0.036652, - "end_time": "2026-09-15T05:29:15.435024+00:00", + "duration": 0.027416, + "end_time": "2026-09-19T23:44:57.845076", "exception": false, - "start_time": "2026-09-15T05:29:15.398372+00:00", + "start_time": "2026-09-19T23:44:57.817660", "status": "completed" }, "tags": [] @@ -1258,33 +1457,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [root] Classe StateManagerPlugin d\u00e9finie (via argumentation_lib shim, Phase 2 #2137).\n" + "01:44:57 [INFO] [root] Classe StateManagerPlugin définie (via argumentation_lib shim, Phase 2 #2137).\n" ] } ], "source": [ - "# %% CELLULE [3.2] - D\u00e9finition Classe StateManagerPlugin\n", - "# Phase 2 (#2137) : StateManagerPlugin est d\u00e9sormais fournie par le shim vendored\n", - "# `argumentation_lib` (B.2 \u2014 argumentation_lib/_state_manager_plugin.py). L'ancienne\n", - "# d\u00e9finition inline (~150 lignes) est remplac\u00e9e par un import. La shim est un\n", - "# SUR-ENSEMBLE r\u00e9tro-compatible : 30 m\u00e9thodes vs 10 inline, AUCUN gap. Le lazy import\n", - "# (`get_state_manager_plugin()`) est requis car la classe d\u00e9core ses m\u00e9thodes avec\n", - "# `@kernel_function` (d\u00e9pendance semantic_kernel).\n", + "# %% CELLULE [3.2] - Définition Classe StateManagerPlugin\n", + "# Phase 2 (#2137) : StateManagerPlugin est désormais fournie par le shim vendored\n", + "# `argumentation_lib` (B.2 — argumentation_lib/_state_manager_plugin.py). L'ancienne\n", + "# définition inline (~150 lignes) est remplacée par un import. La shim est un\n", + "# SUR-ENSEMBLE rétro-compatible : 30 méthodes vs 10 inline, AUCUN gap. Le lazy import\n", + "# (`get_state_manager_plugin()`) est requis car la classe décore ses méthodes avec\n", + "# `@kernel_function` (dépendance semantic_kernel).\n", "\n", "import logging\n", "from argumentation_lib import get_state_manager_plugin\n", "\n", - "# S'assurer que la classe \u00e9tat est d\u00e9finie (vient de la cellule [3.1] via le shim)\n", + "# S'assurer que la classe état est définie (vient de la cellule [3.1] via le shim)\n", "if 'RhetoricalAnalysisState' not in globals():\n", - " raise NameError(\"Classe RhetoricalAnalysisState non d\u00e9finie (ex\u00e9cutez la cellule [3.1]).\")\n", + " raise NameError(\"Classe RhetoricalAnalysisState non définie (exécutez la cellule [3.1]).\")\n", "\n", - "# R\u00e9cup\u00e8re la classe StateManagerPlugin depuis le shim (lazy import semantic_kernel).\n", + "# Récupère la classe StateManagerPlugin depuis le shim (lazy import semantic_kernel).\n", "StateManagerPlugin = get_state_manager_plugin()\n", "\n", - "# Logger conserv\u00e9 pour r\u00e9tro-compatibilit\u00e9.\n", + "# Logger conservé pour rétro-compatibilité.\n", "sm_logger = logging.getLogger(\"Orchestration.StateManager\")\n", "\n", - "logging.info(\"Classe StateManagerPlugin d\u00e9finie (via argumentation_lib shim, Phase 2 #2137).\")" + "logging.info(\"Classe StateManagerPlugin définie (via argumentation_lib shim, Phase 2 #2137).\")" ] }, { @@ -1292,63 +1491,63 @@ "id": "a754dbe1", "metadata": { "papermill": { - "duration": 0.018874, - "end_time": "2026-09-15T05:29:15.474052+00:00", + "duration": 0.010201, + "end_time": "2026-09-19T23:44:57.865798", "exception": false, - "start_time": "2026-09-15T05:29:15.455178+00:00", + "start_time": "2026-09-19T23:44:57.855597", "status": "completed" }, "tags": [] }, "source": [ - "### Service LLM global : un seul mod\u00e8le pour tous les agents\n", + "### Service LLM global : un seul modèle pour tous les agents\n", "\n", - "Pour des raisons d'efficacit\u00e9 et de coh\u00e9rence, tous les agents partagent la **m\u00eame instance de service LLM**.\n", + "Pour des raisons d'efficacité et de cohérence, tous les agents partagent la **même instance de service LLM**.\n", "\n", "**Avantages de cette approche** :\n", "\n", "| Avantage | Explication |\n", "|----------|-------------|\n", - "| **Coh\u00e9rence** | Tous les agents utilisent le m\u00eame mod\u00e8le avec les m\u00eames capacit\u00e9s |\n", - "| **Performance** | \u00c9vite la duplication de connexions et de configurations |\n", - "| **Simplicit\u00e9** | Un seul point de configuration centralis\u00e9 |\n", - "| **Co\u00fbt** | Optimise l'utilisation des quotas API |\n", + "| **Cohérence** | Tous les agents utilisent le même modèle avec les mêmes capacités |\n", + "| **Performance** | Évite la duplication de connexions et de configurations |\n", + "| **Simplicité** | Un seul point de configuration centralisé |\n", + "| **Coût** | Optimise l'utilisation des quotas API |\n", "\n", "**Instanciation selon le mode** :\n", "\n", - "1. **Mode Azure OpenAI** : Cr\u00e9e une instance `AzureChatCompletion` avec :\n", - " - `deployment_name` : Nom du d\u00e9ploiement Azure (ex: \"gpt-4\")\n", + "1. **Mode Azure OpenAI** : Crée une instance `AzureChatCompletion` avec :\n", + " - `deployment_name` : Nom du déploiement Azure (ex: \"gpt-4\")\n", " - `endpoint` : URL de l'endpoint Azure\n", - " - `api_key` : Cl\u00e9 d'authentification Azure\n", + " - `api_key` : Clé d'authentification Azure\n", "\n", - "2. **Mode OpenAI Standard** : Cr\u00e9e une instance `OpenAIChatCompletion` avec :\n", - " - `ai_model_id` : Identifiant du mod\u00e8le (ex: \"gpt-4-turbo\")\n", - " - `api_key` : Cl\u00e9 API OpenAI\n", + "2. **Mode OpenAI Standard** : Crée une instance `OpenAIChatCompletion` avec :\n", + " - `ai_model_id` : Identifiant du modèle (ex: \"gpt-4-turbo\")\n", + " - `api_key` : Clé API OpenAI\n", " - `org_id` : ID d'organisation (optionnel)\n", "\n", - "**Utilisation ult\u00e9rieure** :\n", + "**Utilisation ultérieure** :\n", "\n", - "Cette instance `global_ai_service_instance` sera **ajout\u00e9e au kernel local** de chaque agent lors de sa cr\u00e9ation (sections 4, 5, 6). Chaque agent aura son propre kernel (pour isoler ses plugins et fonctions), mais tous partageront le m\u00eame service LLM sous-jacent.\n", + "Cette instance `global_ai_service_instance` sera **ajoutée au kernel local** de chaque agent lors de sa création (sections 4, 5, 6). Chaque agent aura son propre kernel (pour isoler ses plugins et fonctions), mais tous partageront le même service LLM sous-jacent.\n", "\n", - "> **Note importante** : Cette cellule cr\u00e9e uniquement l'instance du service. Les kernels et agents seront cr\u00e9\u00e9s plus tard, dans la fonction d'ex\u00e9cution (Section 8)." + "> **Note importante** : Cette cellule crée uniquement l'instance du service. Les kernels et agents seront créés plus tard, dans la fonction d'exécution (Section 8)." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "95c09e20", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:15.522978Z", - "iopub.status.busy": "2026-09-15T05:29:15.522344Z", - "iopub.status.idle": "2026-09-15T05:29:16.189493Z", - "shell.execute_reply": "2026-09-15T05:29:16.188187Z" + "iopub.execute_input": "2026-09-19T23:44:57.889580Z", + "iopub.status.busy": "2026-09-19T23:44:57.888987Z", + "iopub.status.idle": "2026-09-19T23:44:58.547663Z", + "shell.execute_reply": "2026-09-19T23:44:58.547056Z" }, "papermill": { - "duration": 0.691601, - "end_time": "2026-09-15T05:29:16.190708+00:00", + "duration": 0.672531, + "end_time": "2026-09-19T23:44:58.548442", "exception": false, - "start_time": "2026-09-15T05:29:15.499107+00:00", + "start_time": "2026-09-19T23:44:57.875911", "status": "completed" }, "tags": [] @@ -1358,46 +1557,46 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.LLM] --- Configuration du Service LLM Global ---\n" + "01:44:57 [INFO] [Orchestration.LLM] --- Configuration du Service LLM Global ---\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:15 [INFO] [Orchestration.LLM] Configuration Service Global: OpenAIChatCompletion...\n" + "01:44:57 [INFO] [Orchestration.LLM] Configuration Service Global: OpenAIChatCompletion...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:16 [INFO] [Orchestration.LLM] Service LLM global OpenAI (gpt-5-mini) cr\u00e9\u00e9.\n" + "01:44:58 [INFO] [Orchestration.LLM] Service LLM global OpenAI (gpt-5.2) créé.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "07:29:16 [INFO] [root] --- Fin D\u00e9finitions Composants Partag\u00e9s ---\n" + "01:44:58 [INFO] [root] --- Fin Définitions Composants Partagés ---\n" ] } ], "source": [ - "# %% CELLULE [3.3] - Cr\u00e9ation Service LLM Global\n", + "# %% CELLULE [3.3] - Création Service LLM Global\n", "# (Remplace une partie de l'ancienne cellule 24085a21)\n", "\n", "import logging\n", "import os\n", "from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, AzureChatCompletion\n", "\n", - "# R\u00e9cup\u00e9rer loggers et variables de config (suppos\u00e9s d\u00e9finis)\n", + "# Récupérer loggers et variables de config (supposés définis)\n", "llm_logger = logging.getLogger(\"Orchestration.LLM\")\n", "if not llm_logger.handlers and not llm_logger.propagate: # Assurer handler\n", " handler = logging.StreamHandler(); formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(name)s] %(message)s', datefmt='%H:%M:%S'); handler.setFormatter(formatter); llm_logger.addHandler(handler); llm_logger.setLevel(logging.INFO)\n", "\n", "if 'api_key' not in globals() or 'model_id' not in globals() or 'use_azure_openai' not in globals():\n", - " raise RuntimeError(\"Variables de configuration LLM non trouv\u00e9es. Ex\u00e9cutez la cellule [1].\")\n", + " raise RuntimeError(\"Variables de configuration LLM non trouvées. Exécutez la cellule [1].\")\n", "\n", "global_ai_service_instance = None\n", "llm_logger.info(\"--- Configuration du Service LLM Global ---\")\n", @@ -1412,7 +1611,7 @@ " endpoint=endpoint,\n", " api_key=api_key\n", " )\n", - " llm_logger.info(f\"Service LLM global Azure ({model_id}) cr\u00e9\u00e9.\")\n", + " llm_logger.info(f\"Service LLM global Azure ({model_id}) créé.\")\n", " else:\n", " llm_logger.info(\"Configuration Service Global: OpenAIChatCompletion...\")\n", " if 'org_id' not in globals(): org_id = None # Assurer existence\n", @@ -1422,7 +1621,7 @@ " api_key=api_key,\n", " org_id=org_id\n", " )\n", - " llm_logger.info(f\"Service LLM global OpenAI ({model_id}) cr\u00e9\u00e9.\")\n", + " llm_logger.info(f\"Service LLM global OpenAI ({model_id}) créé.\")\n", "except Exception as e:\n", " llm_logger.warning(f\"Service LLM global non configure: {e}\")\n", " llm_logger.warning(\"Les fonctionnalites dependent du service LLM seront en mode degrade.\")\n", @@ -1431,7 +1630,7 @@ "if not global_ai_service_instance:\n", " llm_logger.warning(\"Service LLM global non disponible (None). Mode degrade active.\")\n", "\n", - "logging.info(\"--- Fin D\u00e9finitions Composants Partag\u00e9s ---\")\n", + "logging.info(\"--- Fin Définitions Composants Partagés ---\")\n", "\n", "# Rappel: PAS d'instance de RhetoricalAnalysisState ou StateManagerPlugin ou Kernel ici.\n" ] @@ -1441,31 +1640,31 @@ "id": "76c485ec", "metadata": { "papermill": { - "duration": 0.021975, - "end_time": "2026-09-15T05:29:16.235326+00:00", + "duration": 0.01068, + "end_time": "2026-09-19T23:44:58.569831", "exception": false, - "start_time": "2026-09-15T05:29:16.213351+00:00", + "start_time": "2026-09-19T23:44:58.559151", "status": "completed" }, "tags": [] }, "source": [ - "## 4. Agent : \ud83e\uddd1\u200d\ud83c\udfeb ProjectManagerAgent (D\u00e9finitions)\n", + "## 4. Agent : 🧑‍🏫 ProjectManagerAgent (Définitions)\n", "\n", "Cet agent est responsable de l'orchestration globale de l'analyse.\n", "\n", - "**R\u00f4le :**\n", - "* Analyser la demande initiale et l'\u00e9tat actuel (`StateManager.get_current_state_snapshot`).\n", - "* D\u00e9finir les t\u00e2ches d'analyse pour les agents sp\u00e9cialistes (`StateManager.add_analysis_task` via `PM.semantic_DefineTasksAndDelegate`).\n", - "* Assigner les t\u00e2ches et d\u00e9signer le prochain agent \u00e0 intervenir (`StateManager.designate_next_agent`). **Attention:** Doit utiliser le nom exact de l'agent (e.g., `PropositionalLogicAgent`).\n", - "* Suivre l'avancement en consultant l'\u00e9tat (t\u00e2ches d\u00e9finies vs t\u00e2ches r\u00e9pondues).\n", - "* Synth\u00e9tiser les r\u00e9sultats une fois les analyses pertinentes termin\u00e9es (`StateManager.set_final_conclusion` via `PM.semantic_WriteAndSetConclusion`).\n", + "**Rôle :**\n", + "* Analyser la demande initiale et l'état actuel (`StateManager.get_current_state_snapshot`).\n", + "* Définir les tâches d'analyse pour les agents spécialistes (`StateManager.add_analysis_task` via `PM.semantic_DefineTasksAndDelegate`).\n", + "* Assigner les tâches et désigner le prochain agent à intervenir (`StateManager.designate_next_agent`). **Attention:** Doit utiliser le nom exact de l'agent (e.g., `PropositionalLogicAgent`).\n", + "* Suivre l'avancement en consultant l'état (tâches définies vs tâches répondues).\n", + "* Synthétiser les résultats une fois les analyses pertinentes terminées (`StateManager.set_final_conclusion` via `PM.semantic_WriteAndSetConclusion`).\n", "\n", - "**Composants D\u00e9finis Ci-dessous :**\n", + "**Composants Définis Ci-dessous :**\n", "* `ProjectManagerPlugin` (Classe)\n", - "* Prompts S\u00e9mantiques (`prompt_define_tasks_v10`, `prompt_write_conclusion_v6`)\n", + "* Prompts Sémantiques (`prompt_define_tasks_v10`, `prompt_write_conclusion_v6`)\n", "* Fonction de configuration `setup_pm_kernel`\n", - "* Instructions Syst\u00e8me `PM_INSTRUCTIONS` (V8)" + "* Instructions Système `PM_INSTRUCTIONS` (V8)" ] }, { @@ -1473,10 +1672,10 @@ "id": "f7a615c6", "metadata": { "papermill": { - "duration": 0.023437, - "end_time": "2026-09-15T05:29:16.280788+00:00", + "duration": 0.016439, + "end_time": "2026-09-19T23:44:58.599230", "exception": false, - "start_time": "2026-09-15T05:29:16.257351+00:00", + "start_time": "2026-09-19T23:44:58.582791", "status": "completed" }, "tags": [] @@ -1484,60 +1683,60 @@ "source": [ "### Composants du ProjectManagerAgent\n", "\n", - "Le **ProjectManagerAgent** est le chef d'orchestre de l'analyse. Il coordonne les agents sp\u00e9cialistes et synth\u00e9tise leurs r\u00e9sultats.\n", + "Le **ProjectManagerAgent** est le chef d'orchestre de l'analyse. Il coordonne les agents spécialistes et synthétise leurs résultats.\n", "\n", - "**Responsabilit\u00e9s** :\n", + "**Responsabilités** :\n", "\n", - "1. **Analyse de l'\u00e9tat** : Consulter l'\u00e9tat partag\u00e9 pour comprendre o\u00f9 en est l'analyse\n", - "2. **Planification** : Cr\u00e9er les t\u00e2ches d'analyse appropri\u00e9es selon la progression\n", - "3. **D\u00e9l\u00e9gation** : D\u00e9signer l'agent sp\u00e9cialiste qui doit intervenir ensuite\n", - "4. **Suivi** : V\u00e9rifier que les t\u00e2ches sont compl\u00e9t\u00e9es avant de passer \u00e0 la suivante\n", - "5. **Synth\u00e8se** : R\u00e9diger une conclusion finale une fois toutes les analyses termin\u00e9es\n", + "1. **Analyse de l'état** : Consulter l'état partagé pour comprendre où en est l'analyse\n", + "2. **Planification** : Créer les tâches d'analyse appropriées selon la progression\n", + "3. **Délégation** : Désigner l'agent spécialiste qui doit intervenir ensuite\n", + "4. **Suivi** : Vérifier que les tâches sont complétées avant de passer à la suivante\n", + "5. **Synthèse** : Rédiger une conclusion finale une fois toutes les analyses terminées\n", "\n", "**Architecture du PM** :\n", "\n", "```\n", "ProjectManagerAgent\n", - "\u251c\u2500\u2500 ProjectManagerPlugin (vide actuellement, pour futures fonctions natives)\n", - "\u251c\u2500\u2500 Fonctions S\u00e9mantiques (bas\u00e9es sur des prompts)\n", - "\u2502 \u251c\u2500\u2500 semantic_DefineTasksAndDelegate (planification et d\u00e9l\u00e9gation)\n", - "\u2502 \u2514\u2500\u2500 semantic_WriteAndSetConclusion (synth\u00e8se finale)\n", - "\u2514\u2500\u2500 Instructions Syst\u00e8me (directives de comportement)\n", + "├── ProjectManagerPlugin (vide actuellement, pour futures fonctions natives)\n", + "├── Fonctions Sémantiques (basées sur des prompts)\n", + "│ ├── semantic_DefineTasksAndDelegate (planification et délégation)\n", + "│ └── semantic_WriteAndSetConclusion (synthèse finale)\n", + "└── Instructions Système (directives de comportement)\n", "```\n", "\n", "**Approche \"CODE-ONLY\" (V17)** :\n", "\n", - "Le prompt de planification contient des **blocs de code litt\u00e9raux** que le LLM doit copier exactement selon l'\u00e9tat. Cette approche r\u00e9duit l'improvisation et assure une s\u00e9quence pr\u00e9visible de t\u00e2ches.\n", + "Le prompt de planification contient des **blocs de code littéraux** que le LLM doit copier exactement selon l'état. Cette approche réduit l'improvisation et assure une séquence prévisible de tâches.\n", "\n", - "**S\u00e9quence standard des t\u00e2ches** :\n", + "**Séquence standard des tâches** :\n", "\n", - "| Condition | T\u00e2che cr\u00e9\u00e9e | Agent d\u00e9sign\u00e9 | Objectif |\n", + "| Condition | Tâche créée | Agent désigné | Objectif |\n", "|-----------|-------------|---------------|----------|\n", "| `tasks_answered = []` | `task_1` : Arguments | `InformalAnalysisAgent` | Identifier les arguments principaux |\n", "| `tasks_answered = [\"task_1\"]` | `task_2` : Sophismes | `InformalAnalysisAgent` | Analyser les sophismes |\n", "| `tasks_answered = [\"task_1\", \"task_2\"]` | `task_3` : Traduction PL | `PropositionalLogicAgent` | Traduire en logique propositionnelle |\n", - "| `tasks_answered = 3` + belief_set | `task_4` : Requ\u00eates PL | `PropositionalLogicAgent` | Ex\u00e9cuter des requ\u00eates formelles |\n", - "| `tasks_answered = 4` + queries | Conclusion | `ProjectManagerAgent` | Synth\u00e9tiser les r\u00e9sultats |\n", + "| `tasks_answered = 3` + belief_set | `task_4` : Requêtes PL | `PropositionalLogicAgent` | Exécuter des requêtes formelles |\n", + "| `tasks_answered = 4` + queries | Conclusion | `ProjectManagerAgent` | Synthétiser les résultats |\n", "\n", - "Les cellules suivantes d\u00e9finissent les composants du PM (plugin, prompts, fonction de configuration, instructions syst\u00e8me)." + "Les cellules suivantes définissent les composants du PM (plugin, prompts, fonction de configuration, instructions système)." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "8bafcee0", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:16.327832Z", - "iopub.status.busy": "2026-09-15T05:29:16.327298Z", - "iopub.status.idle": "2026-09-15T05:29:16.338282Z", - "shell.execute_reply": "2026-09-15T05:29:16.336868Z" + "iopub.execute_input": "2026-09-19T23:44:58.631289Z", + "iopub.status.busy": "2026-09-19T23:44:58.630896Z", + "iopub.status.idle": "2026-09-19T23:44:58.637436Z", + "shell.execute_reply": "2026-09-19T23:44:58.636466Z" }, "papermill": { - "duration": 0.03682, - "end_time": "2026-09-15T05:29:16.339589+00:00", + "duration": 0.023739, + "end_time": "2026-09-19T23:44:58.638776", "exception": false, - "start_time": "2026-09-15T05:29:16.302769+00:00", + "start_time": "2026-09-19T23:44:58.615037", "status": "completed" }, "tags": [] @@ -1547,7 +1746,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:16 [INFO] [Orchestration.AgentPM.Defs] Plugin PM (vide) et prompts semantiques (V17 - CODE-ONLY) definis.\n" + "01:44:58 [INFO] [Orchestration.AgentPM.Defs] Plugin PM (vide) et prompts semantiques (V17 - CODE-ONLY) definis.\n" ] } ], @@ -1658,10 +1857,10 @@ "id": "036e58ad", "metadata": { "papermill": { - "duration": 0.028632, - "end_time": "2026-09-15T05:29:16.392476+00:00", + "duration": 0.010405, + "end_time": "2026-09-19T23:44:58.659863", "exception": false, - "start_time": "2026-09-15T05:29:16.363844+00:00", + "start_time": "2026-09-19T23:44:58.649458", "status": "completed" }, "tags": [] @@ -1669,48 +1868,48 @@ "source": [ "### Configuration du kernel du ProjectManager\n", "\n", - "La fonction `setup_pm_kernel` configure le kernel Semantic Kernel sp\u00e9cifique au ProjectManagerAgent en y ajoutant :\n", + "La fonction `setup_pm_kernel` configure le kernel Semantic Kernel spécifique au ProjectManagerAgent en y ajoutant :\n", "\n", - "1. **Le plugin natif** `ProjectManagerPlugin` (actuellement vide, pr\u00e9vu pour de futures extensions)\n", - "2. **Les fonctions s\u00e9mantiques** bas\u00e9es sur les prompts d\u00e9finis pr\u00e9c\u00e9demment\n", + "1. **Le plugin natif** `ProjectManagerPlugin` (actuellement vide, prévu pour de futures extensions)\n", + "2. **Les fonctions sémantiques** basées sur les prompts définis précédemment\n", "\n", - "**Fonctions s\u00e9mantiques ajout\u00e9es** :\n", + "**Fonctions sémantiques ajoutées** :\n", "\n", - "| Fonction | Prompt source | Description | Param\u00e8tres requis |\n", + "| Fonction | Prompt source | Description | Paramètres requis |\n", "|----------|---------------|-------------|-------------------|\n", - "| `PM.semantic_DefineTasksAndDelegate` | `prompt_define_tasks_v17` | Cr\u00e9e la prochaine t\u00e2che et d\u00e9signe l'agent | `analysis_state_snapshot`, `raw_text` |\n", - "| `PM.semantic_WriteAndSetConclusion` | `prompt_write_conclusion_v8` | R\u00e9dige et enregistre la conclusion finale | `analysis_state_snapshot`, `raw_text` |\n", + "| `PM.semantic_DefineTasksAndDelegate` | `prompt_define_tasks_v17` | Crée la prochaine tâche et désigne l'agent | `analysis_state_snapshot`, `raw_text` |\n", + "| `PM.semantic_WriteAndSetConclusion` | `prompt_write_conclusion_v8` | Rédige et enregistre la conclusion finale | `analysis_state_snapshot`, `raw_text` |\n", "\n", - "**Gestion de la compatibilit\u00e9 Semantic Kernel** :\n", + "**Gestion de la compatibilité Semantic Kernel** :\n", "\n", "Cette fonction supporte deux modes selon la version de Semantic Kernel :\n", "\n", "- **SK 1.0+** : Utilise `PromptTemplateConfig` avec `InputVariable` et `allow_dangerously_set_content=True`\n", - "- **SK < 1.0** : Mode legacy avec param\u00e8tres simples\n", + "- **SK < 1.0** : Mode legacy avec paramètres simples\n", "\n", "**Pourquoi `allow_dangerously_set_content=True` ?**\n", "\n", - "Semantic Kernel 1.0+ applique par d\u00e9faut un encodage strict pour la s\u00e9curit\u00e9. Cependant, les snapshots JSON de l'\u00e9tat contiennent d\u00e9j\u00e0 du contenu structur\u00e9 qui ne doit pas \u00eatre r\u00e9-encod\u00e9. Le flag `allow_dangerously_set_content=True` indique au syst\u00e8me que nous g\u00e9rons nous-m\u00eames la s\u00e9curit\u00e9 du contenu.\n", + "Semantic Kernel 1.0+ applique par défaut un encodage strict pour la sécurité. Cependant, les snapshots JSON de l'état contiennent déjà du contenu structuré qui ne doit pas être ré-encodé. Le flag `allow_dangerously_set_content=True` indique au système que nous gérons nous-mêmes la sécurité du contenu.\n", "\n", - "> **Note** : Cette fonction sera appel\u00e9e lors de la cr\u00e9ation du PM dans la section d'ex\u00e9cution (Section 8). Elle ne cr\u00e9e pas encore d'instance d'agent." + "> **Note** : Cette fonction sera appelée lors de la création du PM dans la section d'exécution (Section 8). Elle ne crée pas encore d'instance d'agent." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "7a1a3c2e", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:16.442416Z", - "iopub.status.busy": "2026-09-15T05:29:16.441966Z", - "iopub.status.idle": "2026-09-15T05:29:16.460309Z", - "shell.execute_reply": "2026-09-15T05:29:16.458901Z" + "iopub.execute_input": "2026-09-19T23:44:58.683250Z", + "iopub.status.busy": "2026-09-19T23:44:58.682750Z", + "iopub.status.idle": "2026-09-19T23:44:58.691044Z", + "shell.execute_reply": "2026-09-19T23:44:58.690596Z" }, "papermill": { - "duration": 0.043604, - "end_time": "2026-09-15T05:29:16.461660+00:00", + "duration": 0.021755, + "end_time": "2026-09-19T23:44:58.691913", "exception": false, - "start_time": "2026-09-15T05:29:16.418056+00:00", + "start_time": "2026-09-19T23:44:58.670158", "status": "completed" }, "tags": [] @@ -1879,65 +2078,65 @@ "id": "1b9bb59a", "metadata": { "papermill": { - "duration": 0.022541, - "end_time": "2026-09-15T05:29:16.508176+00:00", + "duration": 0.009762, + "end_time": "2026-09-19T23:44:58.711757", "exception": false, - "start_time": "2026-09-15T05:29:16.485635+00:00", + "start_time": "2026-09-19T23:44:58.701995", "status": "completed" }, "tags": [] }, "source": [ - "### Instructions syst\u00e8me du ProjectManager\n", + "### Instructions système du ProjectManager\n", "\n", - "Les `PM_INSTRUCTIONS` d\u00e9finissent les **directives de comportement** que le ProjectManagerAgent doit suivre. Elles sont fournies au LLM comme contexte syst\u00e8me.\n", + "Les `PM_INSTRUCTIONS` définissent les **directives de comportement** que le ProjectManagerAgent doit suivre. Elles sont fournies au LLM comme contexte système.\n", "\n", - "**Objectif** : Garantir que le PM respecte strictement la s\u00e9quence de t\u00e2ches pr\u00e9d\u00e9finie et utilise les bons agents.\n", + "**Objectif** : Garantir que le PM respecte strictement la séquence de tâches prédéfinie et utilise les bons agents.\n", "\n", - "**Principes cl\u00e9s** :\n", + "**Principes clés** :\n", "\n", "1. **Approche CODE-ONLY** : Le PM doit copier exactement les appels de fonction du prompt, sans improvisation\n", - "2. **S\u00e9quence stricte** : 4 t\u00e2ches dans un ordre fixe (arguments \u2192 sophismes \u2192 traduction PL \u2192 requ\u00eates PL)\n", + "2. **Séquence stricte** : 4 tâches dans un ordre fixe (arguments → sophismes → traduction PL → requêtes PL)\n", "3. **Noms d'agents exacts** : \n", - " - `InformalAnalysisAgent` pour les t\u00e2ches 1 et 2\n", - " - `PropositionalLogicAgent` pour les t\u00e2ches 3 et 4 (jamais InformalAnalysisAgent)\n", - "4. **Pas d'improvisation** : Interdiction de cr\u00e9er des t\u00e2ches suppl\u00e9mentaires non pr\u00e9vues\n", + " - `InformalAnalysisAgent` pour les tâches 1 et 2\n", + " - `PropositionalLogicAgent` pour les tâches 3 et 4 (jamais InformalAnalysisAgent)\n", + "4. **Pas d'improvisation** : Interdiction de créer des tâches supplémentaires non prévues\n", "\n", - "**Tableau de r\u00e9f\u00e9rence** (inclus dans les instructions) :\n", + "**Tableau de référence** (inclus dans les instructions) :\n", "\n", - "| Condition | T\u00e2che | Agent |\n", + "| Condition | Tâche | Agent |\n", "|-----------|-------|-------|\n", "| `tasks_answered` vide | `task_1`: Arguments | `InformalAnalysisAgent` |\n", "| `tasks_answered = 1` | `task_2`: Sophismes | `InformalAnalysisAgent` |\n", "| `tasks_answered = 2` | `task_3`: Traduction PL | `PropositionalLogicAgent` |\n", - "| `tasks_answered = 3` + belief_set | `task_4`: Requ\u00eates PL | `PropositionalLogicAgent` |\n", + "| `tasks_answered = 3` + belief_set | `task_4`: Requêtes PL | `PropositionalLogicAgent` |\n", "| `tasks_answered = 4` + queries | Conclusion | `ProjectManagerAgent` |\n", "\n", - "**R\u00e8gles interdites** :\n", + "**Règles interdites** :\n", "\n", - "- Cr\u00e9er des t\u00e2ches de \"v\u00e9rification factuelle\" (hors scope)\n", - "- Modifier les descriptions de t\u00e2ches\n", - "- Appeler `add_answer()` (r\u00e9serv\u00e9 aux agents sp\u00e9cialistes)\n", + "- Créer des tâches de \"vérification factuelle\" (hors scope)\n", + "- Modifier les descriptions de tâches\n", + "- Appeler `add_answer()` (réservé aux agents spécialistes)\n", "\n", - "> **\u00c9volution** : Cette approche stricte (V15) a \u00e9t\u00e9 d\u00e9velopp\u00e9e pour corriger des d\u00e9rives observ\u00e9es dans les versions ant\u00e9rieures o\u00f9 le PM improvisait des t\u00e2ches non pertinentes." + "> **Évolution** : Cette approche stricte (V15) a été développée pour corriger des dérives observées dans les versions antérieures où le PM improvisait des tâches non pertinentes." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "f2a524ce", "metadata": { "execution": { - "iopub.execute_input": "2026-09-15T05:29:16.555857Z", - "iopub.status.busy": "2026-09-15T05:29:16.555399Z", - "iopub.status.idle": "2026-09-15T05:29:16.563280Z", - "shell.execute_reply": "2026-09-15T05:29:16.561742Z" + "iopub.execute_input": "2026-09-19T23:44:58.731296Z", + "iopub.status.busy": "2026-09-19T23:44:58.730977Z", + "iopub.status.idle": "2026-09-19T23:44:58.734661Z", + "shell.execute_reply": "2026-09-19T23:44:58.734296Z" }, "papermill": { - "duration": 0.032273, - "end_time": "2026-09-15T05:29:16.564505+00:00", + "duration": 0.014086, + "end_time": "2026-09-19T23:44:58.735367", "exception": false, - "start_time": "2026-09-15T05:29:16.532232+00:00", + "start_time": "2026-09-19T23:44:58.721281", "status": "completed" }, "tags": [] @@ -1947,7 +2146,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "07:29:16 [INFO] [Orchestration.AgentPM.Instructions] Instructions Systeme PM_INSTRUCTIONS (V15 - CODE-ONLY) definies.\n" + "01:44:58 [INFO] [Orchestration.AgentPM.Instructions] Instructions Systeme PM_INSTRUCTIONS (V15 - CODE-ONLY) definies.\n" ] } ], @@ -1999,10 +2198,10 @@ "id": "61dwms8dzi", "metadata": { "papermill": { - "duration": 0.025651, - "end_time": "2026-09-15T05:29:16.610573+00:00", + "duration": 0.008303, + "end_time": "2026-09-19T23:44:58.753513", "exception": false, - "start_time": "2026-09-15T05:29:16.584922+00:00", + "start_time": "2026-09-19T23:44:58.745210", "status": "completed" }, "tags": [] @@ -2010,7 +2209,7 @@ "source": [ "## Conclusion : Synthese de la configuration initiale\n", "\n", - "Ce notebook d'initialisation a d\u00e9fini tous les **composants de base** necessaires au syst\u00e8me multi-agents d'analyse rhetorique. Recapitulons ce qui a ete configure :\n", + "Ce notebook d'initialisation a défini tous les **composants de base** necessaires au système multi-agents d'analyse rhetorique. Recapitulons ce qui a ete configure :\n", "\n", "### 1. Infrastructure technique\n", "\n", @@ -2022,50 +2221,50 @@ "\n", "### 2. Composants partages\n", "\n", - "| Composant | Type | R\u00f4le |\n", + "| Composant | Type | Rôle |\n", "|-----------|------|------|\n", - "| `RhetoricalAnalysisState` | Classe Python | Base de donn\u00e9es partagee de l'analyse |\n", + "| `RhetoricalAnalysisState` | Classe Python | Base de données partagee de l'analyse |\n", "| `StateManagerPlugin` | Plugin SK | Interface entre LLM et etat Python |\n", - "| `global_ai_service_instance` | Service LLM | Mod\u00e8le de langage partage par tous les agents |\n", + "| `global_ai_service_instance` | Service LLM | Modèle de langage partage par tous les agents |\n", "\n", "### 3. Agent ProjectManager\n", "\n", "| Composant | Type | Fonction |\n", "|-----------|------|----------|\n", "| `ProjectManagerPlugin` | Plugin SK | Extensions natives (vide actuellement) |\n", - "| `prompt_define_tasks_v17` | Prompt s\u00e9mantique | Planification et delegation CODE-ONLY |\n", - "| `prompt_write_conclusion_v8` | Prompt s\u00e9mantique | Synthese finale avec verifications |\n", + "| `prompt_define_tasks_v17` | Prompt sémantique | Planification et delegation CODE-ONLY |\n", + "| `prompt_write_conclusion_v8` | Prompt sémantique | Synthese finale avec verifications |\n", "| `setup_pm_kernel()` | Fonction | Configuration du kernel PM |\n", - "| `PM_INSTRUCTIONS_V15` | Instructions syst\u00e8me | Directives de comportement strictes |\n", + "| `PM_INSTRUCTIONS_V15` | Instructions système | Directives de comportement strictes |\n", "\n", "### Points cles a retenir\n", "\n", - "1. **Architecture modulaire** : Chaque agent a son propre kernel avec ses plugins sp\u00e9cifiques, mais tous partagent le m\u00eame etat et le m\u00eame service LLM\n", - "2. **Etat partage = memoire commune** : Tous les r\u00e9sultats sont centralises dans `RhetoricalAnalysisState`\n", + "1. **Architecture modulaire** : Chaque agent a son propre kernel avec ses plugins spécifiques, mais tous partagent le même etat et le même service LLM\n", + "2. **Etat partage = memoire commune** : Tous les résultats sont centralises dans `RhetoricalAnalysisState`\n", "3. **Mode CODE-ONLY** : Le PM suit des scripts stricts pour eviter l'improvisation\n", "4. **Deux modes Tweety** : Natif (avec JVM) ou degrade (LLM seul)\n", "\n", - "### Prochaines \u00e9tapes\n", + "### Prochaines étapes\n", "\n", "Les notebooks suivants definiront les agents specialises et l'orchestration :\n", "- **Notebook 1** : `InformalAnalysisAgent` - Identification des arguments et sophismes\n", - "- **Notebook 2** : `PropositionalLogicAgent` - Traduction en logique formelle et requ\u00eates\n", - "- **Notebook 3** : Strat\u00e9gies d'orchestration et ex\u00e9cution de la conversation collaborative" + "- **Notebook 2** : `PropositionalLogicAgent` - Traduction en logique formelle et requêtes\n", + "- **Notebook 3** : Stratégies d'orchestration et exécution de la conversation collaborative" ] } ], "metadata": { "cost": { - "api_provider": "OpenAI (gpt-5-mini, configur\u00e9 via .env)", + "api_provider": "OpenAI (gpt-5-mini, configuré via .env)", "api_usd_est": 0.0, "cpu_min": 2, - "external_account": "OpenAI requis (OPENAI_API_KEY + OPENAI_CHAT_MODEL_ID lus via dotenv cell[7]) pour amorcer le pipeline Argument_Analysis ; ce carnet d'init cr\u00e9e le service mais n'effectue aucun appel API dans le run commis", + "external_account": "OpenAI requis (OPENAI_API_KEY + OPENAI_CHAT_MODEL_ID lus via dotenv cell[7]) pour amorcer le pipeline Argument_Analysis ; ce carnet d'init crée le service mais n'effectue aucun appel API dans le run commis", "gpu_min": 0, "gpu_required": false, "metadata_written": "2026-08-05", "network": true, - "notes": "Carnet d'INIT (cell[0]) de la s\u00e9rie Argument_Analysis_Agentic : configure Semantic Kernel + OpenAIChatCompletion (gpt-5-mini lu depuis .env) + JVM JPype/Tweety (42 JARs, Java 17.0.18 op\u00e9rationnel dans le run commis), cr\u00e9e le service LLM global (cell[19]). Run commis : config charg\u00e9e + service cr\u00e9\u00e9, AUCUNE compl\u00e9tion API (0 token, 0 USD) \u2014 l'init ne d\u00e9finit que les composants (\u00e9tat partag\u00e9, plugins, prompts PM). Le co\u00fbt API r\u00e9el est port\u00e9 par les carnets aval (1-informal, 3-orchestration, capstone) qui encha\u00eenent les invocations LLM. external_account d\u00e9clar\u00e9 car cell[7] lit OPENAI_API_KEY : un compte OpenAI configur\u00e9 est n\u00e9cessaire pour que l'init r\u00e9ussisse.", - "reduced_pedagogical": "sans cl\u00e9 OpenAI : avertissement 'Configuration OpenAI standard incompl\u00e8te' (cell[5]/cell[7]), service LLM non cr\u00e9\u00e9, pipeline aval bloqu\u00e9 ; les cellules utilisant le LLM basculent en mode d\u00e9grad\u00e9", + "notes": "Carnet d'INIT (cell[0]) de la série Argument_Analysis_Agentic : configure Semantic Kernel + OpenAIChatCompletion (gpt-5-mini lu depuis .env) + JVM JPype/Tweety (42 JARs, Java 17.0.18 opérationnel dans le run commis), crée le service LLM global (cell[19]). Run commis : config chargée + service créé, AUCUNE complétion API (0 token, 0 USD) — l'init ne définit que les composants (état partagé, plugins, prompts PM). Le coût API réel est porté par les carnets aval (1-informal, 3-orchestration, capstone) qui enchaînent les invocations LLM. external_account déclaré car cell[7] lit OPENAI_API_KEY : un compte OpenAI configuré est nécessaire pour que l'init réussisse.", + "reduced_pedagogical": "sans clé OpenAI : avertissement 'Configuration OpenAI standard incomplète' (cell[5]/cell[7]), service LLM non créé, pipeline aval bloqué ; les cellules utilisant le LLM basculent en mode dégradé", "reproducibility": "HIGH", "validator": "manual", "vram_gb": 0, @@ -2086,18 +2285,20 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.7" + "version": "3.13.3" }, "papermill": { "default_parameters": {}, - "duration": 11.901335, - "end_time": "2026-09-15T05:29:17.749074+00:00", + "duration": 15.460569, + "end_time": "2026-09-19T23:44:59.333376", "environment_variables": {}, "exception": null, - "input_path": "Argument_Analysis_Agentic-0-init_agent.ipynb", - "output_path": "Argument_Analysis_Agentic-0-init_agent.ipynb", - "parameters": {}, - "start_time": "2026-09-15T05:29:05.847739+00:00", + "input_path": "D:\\Dev\\CoursIA-16264\\MyIA.AI.Notebooks\\SymbolicAI\\Argument_Analysis\\Argument_Analysis_Agentic-0-init_agent.ipynb", + "output_path": "D:\\Dev\\CoursIA-16264\\MyIA.AI.Notebooks\\SymbolicAI\\Argument_Analysis\\Argument_Analysis_Agentic-0-init_agent_output.ipynb", + "parameters": { + "BATCH_MODE": "true" + }, + "start_time": "2026-09-19T23:44:43.872807", "version": "2.7.0" } },