Un espace de délibération collective où 5 intelligences artificielles convergent autour d'une seule volonté architecturale.
Plenum est une application Python qui permet de communiquer simultanément avec Claude, Gemini, DeepSeek, ChatGPT et Kimi K2 dans une interface unique. Chaque IA reçoit le message de l'utilisateur, répond en parallèle, puis lit les réponses de ses pairs avant le tour suivant.
plenum/
├── core/
│ ├── plenum.py # Orchestrateur principal (asyncio)
│ ├── memory.py # Historique cumulatif par session
│ └── display.py # Affichage grille terminal
├── agents/
│ ├── base_agent.py # Interface commune (ABC)
│ ├── claude.py # API Anthropic
│ ├── gemini.py # API Google (google-genai)
│ ├── deepseek.py # API DeepSeek (compatible OpenAI)
│ ├── chatgpt.py # API OpenAI
│ └── kimi.py # API Moonshot AI (compatible OpenAI)
├── main.py # Point d'entrée
├── .env # Clés API (ne jamais commiter)
├── .env.example # Template des variables d'environnement
└── requirements.txt # Dépendances Python
Tour N :
User ──────────────────────────────────────────► message
│
┌─────────▼──────────┐
│ plenum.broadcast()│ asyncio.gather()
└─────────┬──────────┘
│
┌───────────┼───────────┐──────────┐──────────┐
▼ ▼ ▼ ▼ ▼
Claude Gemini DeepSeek ChatGPT Kimi
│ │ │ │ │
└───────────┴───────────┴──────────┴──────────┘
│
réponses collectées
│
Tour N+1 : ▼
Chaque IA reçoit : message User + réponses des 4 autres
Phase 1 — User envoie un message → les 5 IA répondent en parallèle.
Phase 2 — User répond → chaque IA reçoit sa réponse + les réponses des 4 autres.
Phase 3 — L'historique s'accumule et est injecté au tour suivant.
- Python 3.11+
- Un venv hors du disque si celui-ci est FAT32/exFAT
# Crée le venv dans le home (évite les erreurs de symlinks sur FAT32)
python3 -m venv .venv
source .venv/bin/activatepip install anthropic google-genai openai python-dotenvCrée un fichier .env à la racine du projet :
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=...
DEEPSEEK_API_KEY=...
OPENAI_API_KEY=sk-...
MOONSHOT_API_KEY=...| Variable | Provider | Lien | Coût |
|---|---|---|---|
ANTHROPIC_API_KEY |
Anthropic | console.anthropic.com | Pay-as-you-go |
GEMINI_API_KEY |
aistudio.google.com/app/apikey | Gratuit (quota) | |
DEEPSEEK_API_KEY |
DeepSeek | platform.deepseek.com/api_keys | ~0.01$/M tokens |
OPENAI_API_KEY |
OpenAI | platform.openai.com/api-keys | ~5$ minimum |
MOONSHOT_API_KEY |
Moonshot AI | platform.moonshot.cn | ~1$ minimum |
Le Plenum fonctionne avec n'importe quel sous-ensemble de clés. Les agents sans clé sont automatiquement marqués indisponibles au démarrage.
# Active le venv
source ~/envs/plenum/bin/activate
# Lance le Plenum
python main.py# Vérifie que Claude répond avant d'assembler tout le Plenum
python test_claude.pyTous les agents héritent de BaseAgent et implémentent ask(). Le polymorphisme permet à plenum.py de parler à une seule interface sans connaître les détails de chaque API.
Sans async : 5 IA × 3s = 15s d'attente. Avec gather() : ~3s totales. Chaque appel API est une coroutine lancée simultanément.
Gemini utilise un SDK non-async. run_in_executor() pousse l'appel bloquant dans un thread séparé, libérant la boucle asyncio. Résultat : comportement identique aux autres agents pour gather().
DeepSeek, ChatGPT et Kimi utilisent le même SDK openai. Seules base_url et model diffèrent. C'est devenu le standard de facto des LLMs.
À partir du tour 2, chaque IA reçoit les réponses des autres injectées dans son prompt via _inject_peers_context(). C'est ce qui transforme 5 monologues parallèles en une vraie délibération collective.
-
base_agent.py— interface commune -
core/plenum.py— orchestrateur async -
agents/claude.py— API Anthropic -
agents/gemini.py— API Google -
agents/deepseek.py— API DeepSeek -
agents/chatgpt.py— API OpenAI -
agents/kimi.py— API Moonshot -
core/memory.py— historique persistant -
core/display.py— grille terminal -
main.py— assemblage final - Export session JSON
- Interface TUI (rich/textual)
YEVI Mawuli Peniel User — Licence Systèmes Embarqués & IoT, IFRI-UAC, Cotonou. Ego Sum Optimus Optimus