Instructions to use Frankenstein-Labs/Cortex-ai with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Frankenstein-Labs/Cortex-ai with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Frankenstein-Labs/Cortex-ai")

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Frankenstein-Labs/Cortex-ai")
model = AutoModelForCausalLM.from_pretrained("Frankenstein-Labs/Cortex-ai", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Frankenstein-Labs/Cortex-ai with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Frankenstein-Labs/Cortex-ai"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Frankenstein-Labs/Cortex-ai",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/Frankenstein-Labs/Cortex-ai

SGLang

How to use Frankenstein-Labs/Cortex-ai with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Frankenstein-Labs/Cortex-ai" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Frankenstein-Labs/Cortex-ai",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Frankenstein-Labs/Cortex-ai" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Frankenstein-Labs/Cortex-ai",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use Frankenstein-Labs/Cortex-ai with Docker Model Runner:
```
docker model run hf.co/Frankenstein-Labs/Cortex-ai
```

CORTEX AI

L'intelligence artificielle d'un jeune créateur africain, pensée pour le monde francophone.

CORTEX AI est le moteur d'intelligence de l'écosystème CORTEX. Le projet est créé et développé par Abdoulaye Coumbassa, jeune créateur de 16 ans, fondateur de Frankenstein-Labs.

CORTEX AI est construit sur DeepSeek-V4-Pro, un modèle ouvert publié par DeepSeek-AI. Frankenstein-Labs apporte l'identité du projet, la documentation francophone, la couche d'intégration, la direction technique et l'écosystème autour du modèle.

Le projet

CORTEX AI existe pour une raison simple : rendre accessible, en français, une intelligence de niveau mondial.

La très grande majorité des modèles de pointe sont documentés, expliqués et outillés en anglais. Pour un développeur, un étudiant ou une entreprise d'Afrique francophone, cela représente une barrière réelle : documentation inaccessible, exemples absents, vocabulaire technique éloigné, support inexistant.

CORTEX AI prend ce problème à l'envers. Le modèle est technique, mais tout ce qui l'entoure est pensé en français, par quelqu'un qui connaît les réalités du terrain : contraintes de bande passante, matériel limité, besoin de résultats concrets plus que de démonstrations.

L'ambition

L'ambition du projet est claire et assumée : placer à disposition du monde francophone une intelligence au niveau des meilleurs modèles propriétaires, sans dépendre d'une API fermée, sans facturation à l'usage, et sans barrière linguistique.

DeepSeek positionne DeepSeek-V4-Pro comme largement compétitif avec les modèles propriétaires les plus avancés, et en avance sur plusieurs épreuves d'ingénierie logicielle et de tâches agentiques. Ces résultats sont ceux de DeepSeek et restent consultables à la source ; ils sont cités ici et non reproduits par nos soins.

L'écosystème CORTEX

Composant	Rôle	État
CORTEX AI	Le moteur d'intelligence et la distribution du modèle	Publié
CORTEX Engine	Orchestration : agents, tâches, outils, exécution	En conception
CORTEX IDE	Environnement de développement assisté par l'IA	En conception
CORTEX Cloud	Développement cloud assisté par CORTEX	En conception

Ces quatre briques sont conçues pour fonctionner ensemble. Aujourd'hui, seul CORTEX AI existe comme artefact publié ; les autres relèvent de la feuille de route, pas du logiciel livré.

Vision

Construire un écosystème de développement natif de l'IA où l'intelligence, les agents, les environnements d'exécution et le travail logiciel forment un seul système — et le faire depuis l'Afrique francophone.

La règle du projet est la transparence : dire clairement ce qui est disponible, ce qui est expérimental, et ce qui reste à construire.

Le créateur

Abdoulaye Coumbassa est le créateur et le développeur de CORTEX AI et de l'écosystème CORTEX. Il est le fondateur de Frankenstein-Labs et a dit un jour que CORTEX AI est son plus grand chef-d'œuvre.

Ce projet est né d'une conviction : l'Afrique francophone ne doit pas être un marché de consommation de l'intelligence artificielle, mais un lieu de conception. CORTEX AI est la première pierre de cette démarche.

Cette section ne revendique ni biographie, ni diplôme, ni financement, ni distinction. Elle nomme l'auteur du projet CORTEX AI.

Le modèle

CORTEX AI s'appuie sur un modèle de très grande taille, à mixture d'experts, conçu pour le raisonnement long et la génération de code sur de très grands contextes.

Caractéristique	Valeur
Architecture	`DeepseekV4ForCausalLM` (`model_type: deepseek_v4`)
Paramètres (métadonnées du Hub)	1 650 497 936 906
Couches transformer	61
Couches de prédiction multi-token (MTP)	3
Taille cachée	7 168
Têtes d'attention	128
Experts routés	384, dont 6 activés par token + 1 expert partagé
Vocabulaire	129 280
Contexte maximal	1 048 576 tokens
Quantification des poids	FP8 `e4m3`, blocs 128×128
Stockage des experts	FP4
Poids	SafeTensors, 66 shards, ~892,8 Go
Licence	MIT

Capacités

Raisonnement avancé, avec un mode de réflexion dédié intégré à la couche d'encodage.
Génération de code et ingénierie logicielle sur de longs contextes.
Mathématiques et analyse technique.
Compréhension de contextes très longs, jusqu'à 1 048 576 tokens.
Inférence à mixture d'experts, 384 experts routés, 6 activés par token.
Formats conversationnels agentiques et d'appel d'outils.
Prédiction multi-token, utilisée par le chemin de décodage spéculatif.

Le français et les langues

Le modèle traite nativement le français, l'anglais et le chinois. La documentation, les exemples et l'accompagnement de l'écosystème CORTEX sont fournis en français.

Utilisation

Récupérer le dépôt avec l'outillage Hugging Face (recommandé pour les très gros checkpoints) :

pip install -U "huggingface_hub[hf_xet]"
hf download Frankenstein-Labs/Cortex-ai

Ou uniquement la configuration et le tokenizer :

hf download Frankenstein-Labs/Cortex-ai --include "*.json" "LICENSE"

Chargement

Le dépôt fournit un config.json et un tokenizer compatibles avec Transformers.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "Frankenstein-Labs/Cortex-ai"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

Ce checkpoint pèse environ 893 Go. Il exige plusieurs accélérateurs et un environnement logiciel récent. Vérifiez que votre version de Transformers prend en charge deepseek_v4 avant toute tentative de chargement complet.

Encodage des messages

Le dossier encoding/ est du Python pur, sans dépendance lourde :

from encoding_dsv4 import encode_messages, parse_message_from_completion_text

messages = [
    {"role": "system", "content": "Tu es un assistant utile."},
    {"role": "user", "content": "Combien font 2+2 ?"},
]
prompt = encode_messages(messages, thinking_mode="thinking")

Prérequis

Élément	Valeur
Checkpoint sur disque	~892,8 Go
Type déclaré	`bfloat16`
Quantification	FP8 pour la plupart des poids, FP4 pour les experts routés
Pile CUDA de référence	`torch>=2.10.0`, `transformers>=5.0.0`
Noyaux de référence	`tilelang==0.1.8`, `fast_hadamard_transform`

Le déploiement se fait sur plusieurs GPU ou plusieurs nœuds. Une configuration mono-GPU n'est pas documentée.

État de vérification

Dire ce qui a été mesuré, et ce qui ne l'a pas été.

Mesuré : la cohérence complète du dépôt a été vérifiée. Les 66 shards totalisent exactement 892 727 580 904 octets, soit la taille déclarée dans l'index, et les 149 782 tenseurs de l'index correspondent un à un à ceux des shards. La suite de tests de encoding/ passe, et le tokenizer se charge et fait un aller-retour correct.

Non mesuré : aucun chargement de bout en bout du modèle n'a été exécuté, faute de matériel adapté. Aucun résultat de performance affiché ici n'a été produit par Frankenstein-Labs ; ceux qui sont cités proviennent de la documentation DeepSeek et sont liés à leur source.

Couche vision — expérimentale

Le dépôt contient une couche d'adaptation vision sous cortex_ai/vision/, en cours de développement.

IMAGE → ENCODEUR VISUEL → PROJECTEUR → FUSION → CORTEX AI → RÉPONSE

Deux chemins existent : un pont fonctionnel qui produit une description textuelle de l'image via un modèle externe, et un prototype de fusion native d'embeddings, validé sur un cœur de test réduit.

Cette couche n'est pas opérationnelle sur le checkpoint complet. Aucun encodeur visuel, aucun poids de projecteur et aucune donnée d'entraînement multimodal ne sont inclus. Ce dépôt ne doit pas être présenté comme un modèle de compréhension d'images.

Provenance, licence et attribution

Ce dépôt est une redistribution d'un modèle existant. L'identité CORTEX AI porte sur le projet, sa documentation et son intégration ; elle ne remplace pas l'attribution d'origine.

Élément	Information vérifiée
Modèle d'origine	`deepseek-ai/DeepSeek-V4-Pro-0813`
Architecture d'origine	`DeepseekV4ForCausalLM` (`model_type: deepseek_v4`)
Auteur d'origine	DeepSeek-AI
Licence	MIT — Copyright (c) 2023 DeepSeek
Fichier de licence	`LICENSE`, reproduit à l'identique
Rapport technique	DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence, DeepSeek-AI, 2026 — arXiv:2606.19348
Recette vLLM	recipes.vllm.ai/deepseek-ai/DeepSeek-V4-Pro
Cookbook SGLang	docs.sglang.io

Déclaration d'attribution. Les poids de ce dépôt proviennent de DeepSeek-AI. Frankenstein-Labs ne les a ni entraînés, ni affinés, ni quantifiés, ni modifiés : ce sont les fichiers d'origine, octet pour octet. La conception, l'entraînement et l'évaluation du modèle relèvent de DeepSeek-AI. Le travail de Frankenstein-Labs porte sur l'identité du projet, la documentation francophone, la couche d'intégration et l'écosystème.

Intégrité des poids distribués. Les 67 objets LFS de ce dépôt portent une empreinte SHA-256 identique à celle du dépôt d'origine. Le fichier model.safetensors.index.json est identique. Les 66 shards et les 149 782 tenseurs indexés sont présents, sans fichier manquant ni ajouté. Le fichier LICENSE est reproduit à l'identique.

Citation. Merci de citer le travail d'origine :

@misc{deepseekai2026deepseekv4,
      title={DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence},
      author={DeepSeek-AI},
      year={2026},
}

Feuille de route

CORTEX Engine — orchestration d'agents, de tâches et d'outils.
CORTEX IDE — environnement de développement natif de l'IA.
CORTEX Cloud — workflows de développement cloud assistés.
Documentation francophone complète — guides, tutoriels, exemples pour l'Afrique francophone.
Couche vision — sélection d'un encodeur, entraînement du projecteur, validation de bout en bout.

Avertissement

Ce checkpoint est extrêmement volumineux et nécessite du matériel spécialisé. Vérifiez le runtime, la mémoire des accélérateurs, la pile de pilotes et les obligations de licence avant tout déploiement.

Projet CORTEX AI — créé et développé par Abdoulaye Coumbassa, jeune créateur de 16 ans et fondateur de Frankenstein-Labs. Modèle d'origine : DeepSeek-V4-Pro, DeepSeek-AI, sous licence MIT.

Downloads last month: 1,271

Safetensors

Model size

1.7T params

Tensor type

BF16

I64

F32

F8_E4M3

Model tree for Frankenstein-Labs/Cortex-ai

Base model

deepseek-ai/DeepSeek-V4-Pro-0813

Quantized

(12)

this model

Paper for Frankenstein-Labs/Cortex-ai

DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence

Paper • 2606.19348 • Published Apr 26 • 45