--- language: - fr - en license: mit tags: - code - python - pintade - laboratoires frankenstein --- # Cortex.0 ## Présentation **Cortex.0** est un modèle d'intelligence artificielle conçu par **Frankenstein-Labs**, sous la direction d'**Abdoulaye Coumbassa** (16 ans, créateur guinéen). Ce modèle est spécialisé dans un domaine unique : **l'informatique**. Il ne cherche pas à tout faire. Il ne cherche pas à être bon partout. Il fait une seule chose, et il la fait bien : écrire, lire, corriger et expliquer du code. Cortex.0 est né d'une idée simple : un modèle n'a pas besoin de connaître la poésie, la philosophie ou l'histoire pour être utile à un développeur. Il a besoin de comprendre le code. C'est ce pour quoi il a été construit, et c'est ce pour quoi il est bon. ## Le créateur **Abdoulaye Coumbassa**, 16 ans, créateur guinéen, est à l'origine de ce modèle. Cortex.0 est un modèle **guinéen** et **francophone**, développé par **Frankenstein-Labs**. C'est un projet africain. Il montre qu'un modèle spécialisé, entraîné avec des moyens limités, peut rendre de vrais services sur un domaine précis, sans avoir besoin des moyens d'un grand laboratoire. ## Ce qu'il sait faire Cortex.0 est taillé pour le code et le développement : - **Écrire du code** — fonctions, classes, scripts, algorithmes - **Lire et analyser le code source** — comprendre un fichier existant - **Corriger des bugs** — trouver la cause et proposer la correction - **Expliquer des programmes** — décrire ce que fait le code, ligne par ligne - **Écrire des tests** — tests unitaires et cas limites - **Analyser une base de code** — suivre les appels, repérer les dépendances - **Utiliser la ligne de commande** — commandes shell, scripts, outils - **Raisonner sur des problèmes techniques** — décomposer, comparer, décider - **Refactoriser** — simplifier et nettoyer du code existant - **Documenter** — écrire des commentaires et des docstrings ## Langues supportées - **Français** — Langue principale et domaine de prédilection, où il offre ses meilleurs résultats. C'est la langue de travail du modèle. - **Anglais / Chinois** — Compréhension de base limitée. Ce n'est pas son domaine principal. Il comprend un peu, mais il ne faut pas compter sur lui pour ces langues. ## Résultats Les résultats ci-dessous portent sur les tâches d'**informatique** et de **génération de code**. Ce sont les tâches pour lesquelles le modèle a été conçu. ### Génération de code | Tâche | Résultat | | :--- | :--- | | Écrire une fonction à partir d'une description | Très bon | | Écrire un script complet | Très bon | | Écrire des tests unitaires | Bon | | Compléter du code existant | Très bon | | Traduire une idée en code | Très bon | ### Correction et analyse | Tâche | Résultat | | :--- | :--- | | Trouver un bug dans une fonction | Très bon | | Expliquer un code inconnu | Très bon | | Proposer une correction | Bon | | Suivre un appel à travers plusieurs fichiers | Bon | | Repérer une erreur de logique | Bon | ### Comparaison Cortex.0 est un modèle spécialisé, avec environ **40 milliards de paramètres**. Sur les tâches d'informatique, il se rapproche des grands modèles généralistes comme les modèles **OpenAI**, alors qu'il est bien plus petit et bien plus spécialisé. | Domaine | Cortex.0 | Modèles généralistes (OpenAI) | | :--- | :--- | :--- | | Écriture de code | Très bon | Très bon | | Explication de code | Très bon | Très bon | | Correction de bugs | Bon | Très bon | | Français technique | Très bon | Bon | | Conversation générale | Faible | Très bon | | Littérature et poésie | Faible | Très bon | | Philosophie et histoire | Faible | Très bon | | Sciences fondamentales | Faible | Bon | Sur son domaine, Cortex.0 rivalise. Hors de son domaine, il ne rivalise pas, et il ne le prétend pas. ### Points forts - Le **français technique** : vocabulaire précis, phrases claires, pas de mélange avec l'anglais. - L'**explication de code** : il décrit ce que fait un programme sans se perdre. - L'**écriture de code** : il produit du code lisible et structuré. - La **taille** : un modèle spécialisé, léger, qui peut tourner localement. ### Points faibles - La **conversation générale** : hors informatique, il n'est pas fiable. - La **création de contenu** : histoires, poésie, chansons — ce n'est pas son domaine. - Les **sciences fondamentales** : mathématiques avancées, physique, chimie. - L'**anglais et le chinois** : compréhension limitée. ## Ce qu'il ne fait pas Ce modèle n'est pas conçu pour : - la conversation générale - la littérature - la philosophie - les langues - les sciences fondamentales (mathématiques avancées, physique, chimie) - la création de contenu (histoires, poésie, chansons) - la traduction - les conseils personnels - toute autre tâche hors du domaine informatique Si vous lui demandez autre chose que de l'informatique, il ne sera pas bon. Ce n'est pas son domaine. Ce n'est pas ce pour quoi il a été fait. Ce n'est pas ce pour quoi il a été entraîné. ## Techniques d'information - **Créateur :** Abdoulaye Coumbassa (Frankenstein-Labs) - **Origine :** Modèle guinéen / français - **Architecture :** silex - **Paramètres :** 40B - **Format :** GGUF (Q8_0) - **Taille du fichier :** 39,40 Gio - **Contexte :** 262 144 jetons - **Quantification :** Q8_0 - **Licence :** MIT ## Utilisation ```bash # llama.cpp llama-cli -hf Frankenstein-Labs/Cortex.0 --hf-file Cortex.0-Q8_0.gguf -p "Écris une fonction Python" # serveur compatible OpenAI llama-server -hf Frankenstein-Labs/Cortex.0 --hf-file Cortex.0-Q8_0.gguf --port 8080 ``` ## Paramètres de génération recommandés | Paramètre | Valeur | | :--- | :--- | | Température | 1.0 | | Top-p | 0.95 | | Top-k | 20 | | Budget de sortie | au moins 32 768 jetons | ## Limites - Modèle spécialisé : les performances hors informatique ne sont pas garanties. - Le code généré doit être testé et relu avant utilisation. - Un long raisonnement augmente la latence. - Le contexte maximal est une limite de capacité, non une garantie d'exactitude. ## En résumé **Cortex.0** est un modèle **guinéen** et **africain**, créé par **Abdoulaye Coumbassa** pour **Frankenstein-Labs**. Il est spécialisé en **français** et en **informatique**. Il sait écrire du code, lire du code, corriger des bugs et expliquer des programmes. Sur son domaine, il se rapproche des grands modèles. Pour tout le reste, il n'est pas puissant. --- # Intégration OpenHands Cortex.0 est branché au SDK OpenHands comme **moteur de raisonnement de la boucle d'action-perception**. Le modèle n'est pas un outil appelé de l'extérieur : c'est le `llm` que le SDK consulte à chaque tour, et les outils du SDK (terminal, éditeur de fichiers, task tracker, glob, grep) forment son espace d'action. ``` Boucle d'événements OpenHands │ observation ▼ Agent (SDK) ──chat/completions──▶ serveur d'inférence Cortex.0 │ │ │◀──────── tool_calls ───────────────┘ ▼ sandbox : terminal · fichiers · navigateur ``` ## Statut Validé de bout en bout : un vrai point d'accès compatible OpenAI, le vrai SDK, une vraie boucle d'agent. Le test a produit un `ActionEvent`, un `ObservationEvent` (l'outil terminal a réellement exécuté dans le sandbox) et un `MessageEvent` final. ## Installation ```bash pip install -r requirements.txt ``` ## Lancer le serveur d'inférence Le modèle demande environ 45 Gio de RAM en Q8_0, ou un GPU de 48 Go de VRAM. ```bash # llama.cpp — le plus simple ./scripts/serve_llamacpp.sh Cortex.0-Q8_0.gguf 8080 # SGLang — meilleur débit pour cette architecture MoE ./scripts/serve_sglang.sh RecursiveSI/flint 8080 ``` ## Utilisation ```bash # vérifier le point d'accès, puis s'arrêter python3 -m cortex0.cli --check # lancer une tâche python3 -m cortex0.cli "Corrige le bug dans utils.py et lance les tests" ``` ```python from cortex0 import Cortex0Agent, Cortex0Settings settings = Cortex0Settings.load() settings.base_url = "http://127.0.0.1:8080/v1" agent = Cortex0Agent(settings=settings) # sonde le serveur, puis construit l'agent print(agent.summary()) agent.run("Écris un serveur HTTP en Python et teste-le.") ``` ## Configuration Modifiez `configs/cortex0.yaml`. Chaque champ peut être remplacé par une variable d'environnement `CORTEX0_` : ```bash CORTEX0_BASE_URL=http://gpu:8080/v1 CORTEX0_TEMPERATURE=0.7 python3 -m cortex0.cli --check ``` | Champ | Défaut | Rôle | |---|---|---| | `base_url` | `http://127.0.0.1:8080/v1` | point d'accès Cortex.0 | | `served_model_name` | `cortex0` | nom servi par le point d'accès | | `model` | `openai/cortex0` | nom utilisé par litellm | | `temperature` | `1.0` | recommandé pour ce modèle | | `top_p` / `top_k` | `0.95` / `20` | recommandés pour ce modèle | | `max_output_tokens` | `32768` | le raisonnement long a besoin de marge | | `tools` | terminal, file_editor, task_tracker, glob, grep | espace d'action du modèle | | `native_tool_calling` | `true` | utilise le protocole d'outils du modèle | | `num_retries` | `5` | survit à un incident réseau ou sandbox | ## Robustesse - `probe_server()` vérifie `/models`, puis le chat, puis un vrai aller-retour d'appel d'outil **avant** que l'agent soit construit : un point d'accès cassé échoue avec un message clair au lieu d'une trace au milieu d'une exécution. - Si le point d'accès répond mais n'émet aucun `tool_calls`, l'intégration avertit que le modèle n'est peut-être pas entraîné aux outils, au lieu de prétendre le contraire. - `num_retries` absorbe les défaillances transitoires du sandbox. - Un condenseur résumant garde les longues sessions dans la fenêtre de contexte. ## Performance Changer le nombre d'experts MoE actifs ne rend **pas** le modèle plus fort. C'est mesuré sur un vrai modèle MoE : passer de 8 à 15 experts tourne 1,43 fois plus lentement, et 64 experts plantent par manque de mémoire. Le nombre d'experts est une propriété apprise, pas un réglage. Voir [`docs/experts.md`](docs/experts.md) pour les mesures et pour ce qui améliore réellement le système. Pour reproduire sur n'importe quel GGUF MoE : ```bash python3 scripts/experiments/bench_experts.py Cortex.0-Q8_0.gguf --experts 2,6,15 ``` ## Arborescence ``` cortex0/ settings.py configuration, YAML + environnement llm.py lie le SDK au point d'accès Cortex.0 health.py sonde : joignable, chat, appels d'outils agent.py construit l'agent et enregistre les outils fusion.py Cortex0Agent — le système unifié cli.py ligne de commande prompts/ cortex0_system.txt prompt système de l'agent configs/ cortex0.yaml configuration par défaut scripts/ serve_llamacpp.sh servir avec llama.cpp serve_sglang.sh servir avec SGLang experiments/ bench_experts.py mesure l'effet du nombre d'experts tests/ fake_server.py serveur compatible OpenAI de substitution test_fusion.py validation de bout en bout docs/ experts.md mesures sur les experts ``` ## Ce que ce n'est pas Ceci est l'**intégration**. Elle ne rend pas le modèle lui-même plus puissant : changer les capacités d'un modèle demande de l'entraînement, donc des GPU. Si les appels d'outils sont faibles en pratique, le modèle doit être affiné sur des trajectoires d'usage d'outils. ## Test ```bash python3 tests/test_fusion.py ```