Le Guide Complet pour Construire un Bot de Poker IA en 2026

Tu peux livrer un bot de poker IA fonctionnel en moins de 50 lignes de Python. Il ne battra pas encore un vrai adversaire, mais il se connecte, s'assoit a une table et joue des mains. Apres ca, le chemin vers un bot competitif, c'est surtout de l'ingenierie — pas une percee de recherche.

Ce guide parcourt tout le trajet : les quatre blocs dont tout bot de poker a besoin, quel framework open-source utiliser pour commencer, comment fonctionne la boucle de decision, les maths derriere l'equite et les ranges, ou tu peux vraiment tester contre de vrais adversaires en 2026, et ce qui est legal ou non.

Divulgation : je suis le fondateur d'openpoker.ai, une arene gratuite IA-vs-IA Hold'em. J'y renvoie quand c'est la bonne reponse ; le reste de ce guide est agnostique au framework.

Points cles

• Un bot de poker a quatre parties : evaluation de main, parsing de l'etat de table, politique de decision et moyen de tester. Si elles sont bonnes, le reste est de l'iteration.
• PokerKit (uoftcprg) est le point de depart le plus pratique en 2026 — Python pur, licence MIT, 99% de couverture de tests. OpenSpiel pour la recherche ; RLCard pour le RL academique.
• Les sites en argent reel comme PokerStars interdisent explicitement les bots (PokerStars ToS) — teste plutot dans des arenes IA seulement.
• Ne commence pas par du deep learning. Un bot heuristique bien regle est plus rapide a livrer, plus facile a debugger et competitif face a des methodes plus sophistiquees jusqu'a ce que tu aies epuise les gains simples.

Qu'est-ce qu'un bot de poker IA, exactement ?

Un bot de poker IA est un programme qui joue au poker de maniere autonome : il se connecte a une partie, lit l'etat de la table, decide d'une action et la soumet — main apres main, sans humain dans la boucle. Les bots de poker modernes ont franchi le seuil du pro humain en deux vagues : d'abord en heads-up (DeepStack et Libratus, tous deux en 2017), puis a six joueurs en 2019 avec Pluribus de Brown et Sandholm a Carnegie Mellon et Facebook AI (Science, 2019). Ce qui a fait de ces systemes des jalons, ce n'etait pas la puissance brute de calcul — c'etait que les jeux a information imparfaite sont vraiment difficiles.

Les echecs et le Go sont des jeux a information parfaite : la position de chaque piece est visible, donc un bon evaluateur plus de la recherche gagnent. Le poker cache des cartes. Tu ne peux pas calculer « le meilleur coup » parce que le meilleur coup depend de ce que ton adversaire pourrait avoir et de ce qu'il pense que tu pourrais avoir et de bluffs sans bonne reponse objective. C'est pour ca qu'un moteur de dames des annees 90 est surhumain, mais que les bots de poker pratiques n'ont emerge qu'a la fin des annees 2010.

Chaque bot de poker — du script de 50 lignes a Pluribus — a les memes quatre blocs :

1. Evaluation de main — donnees sept cartes, quelle est la meilleure main de poker en 5 cartes et comment se compare-t-elle a une autre ?
2. Parsing de l'etat de la table — lire les messages entrants et les transformer en quelque chose que ton code peut traiter (tes cartes privees, le board, la taille du pot, qui doit encore agir, les tailles de stacks).
3. Politique de decision — etant donne l'etat parse, choisir une action : fold, check, call, bet ou raise.
4. Un moyen de tester — self-play, simulateurs, ou vrais adversaires, par ordre croissant d'utilite.

Les deux premiers sont des problemes resolus. Le troisieme est la ou se trouve le travail interessant. Le quatrieme determine si tu progresses vraiment.

Note de terminologie : un bot joue de maniere autonome en temps reel. Un solver comme PioSolver ou GTO+ calcule une strategie hors-ligne contre un modele fixe et est utilise par des humains pour etudier. Ils partagent les maths mais resolvent des problemes differents.

Pour les maths derriere l'estimation de la force de main, vois notre deep-dive maths du poker pour bots.

Quel framework devrais-tu utiliser ?

Commence avec PokerKit si tu veux livrer un bot. Utilise OpenSpiel pour la recherche, RLCard pour des experiences de RL academique, et lis le papier Pluribus pour l'inspiration seulement — ce n'est pas une bibliotheque. Le choix se reduit presque toujours a ce que tu optimises : maths de cartes pretes pour la production (PokerKit), infrastructure RL multi-jeux (OpenSpiel), ou rampe d'acces rapide aux papiers de RL (RLCard).

Pour la plupart des gens construisant un bot de poker en 2026, commence par PokerKit. C'est du Python pur, licence MIT, supporte un eventail etendu de variantes de poker, et livre une evaluation de main haute vitesse couverte a 99% par des tests (PokerKit sur GitHub). Il est maintenu par le Computer Poker Research Group de l'Universite de Toronto et c'est l'option la plus production-friendly pour quelqu'un qui veut ecrire de la logique de jeu sans reimplementer les maths des cartes.

Si tu fais de la recherche — ou que tu veux un banc d'essai multi-jeux pour des experiences d'apprentissage par renforcement — utilise OpenSpiel de Google DeepMind (OpenSpiel sur GitHub). Il regroupe des dizaines de jeux avec des implementations de reference de CFR (counterfactual regret minimization) et REINFORCE pour Kuhn poker, Leduc poker et Goofspiel. Les variantes de poker sont abstraites, ce qui est genial pour la recherche et frustrant pour le jeu pratique.

RLCard du DATA Lab de Rice University (a l'origine a Texas A&M) est la troisieme option majeure (RLCard sur GitHub) — focalise sur le RL pour les jeux de cartes (Blackjack, Leduc, Texas, Mahjong, DouDizhu, UNO). Il est concu pour essayer des algorithmes de RL, pas pour livrer un bot.

Pluribus lui-meme, malgre etre le systeme IA de poker le plus celebre, n'est pas une bibliotheque — c'est un papier de recherche. Tu ne peux pas faire pip install pluribus. Les reproductions les plus proches sont du code de recherche, souvent ere Python 3.7 et non maintenu.

Pour un regard plus profond sur la comparaison des plateformes d'arene en direct, vois notre comparaison de plateformes de poker IA et les decoupages dedies openpoker vs Pluribus, vs OpenSpiel et vs RLCard.

Comment ecris-tu la boucle de decision ?

Chaque bot de poker, c'est la meme boucle :

while True:
    msg = receive_message()
    if msg["type"] == "your_turn":
        action = decide(state)
        send_action(action, turn_token=msg["turn_token"])

C'est tout. Le code interessant vit dans decide. Tout le reste, c'est de la plomberie.

La plupart des arenes modernes de poker IA — y compris openpoker.ai — utilisent des WebSockets pour que le serveur puisse pousser des mises a jour d'etat sans que ton bot ne fasse du polling. Messages JSON en entree, actions JSON en sortie. Le serveur envoie un flux de messages types : connected, lobby_joined, hand_start, hole_cards (tes cartes privees, en dehors du flux broadcast), community_cards, your_turn (ton tour ; inclut les actions legales et un turn_token a usage unique), player_action, hand_result. Ton boulot, c'est d'ecouter, suivre l'etat a travers les messages et repondre quand c'est ton tour.

Voici un bot minimal qui se connecte, s'assoit et joue une strategie « calling station » — checker quand c'est gratuit, sinon caller, ne folder que quand il n'y a pas d'autre option. C'est du mauvais poker, mais c'est une boucle d'evenements complete :

import asyncio, json, websockets
 
API_KEY = "your-api-key-here"
WS_URL  = "wss://openpoker.ai/ws"
 
async def play():
    headers = {"Authorization": f"Bearer {API_KEY}"}
    async with websockets.connect(WS_URL, additional_headers=headers) as ws:
        await ws.send(json.dumps({"type": "join_lobby", "buy_in": 2000}))
 
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") != "your_turn":
                continue
 
            valid = {a["action"] for a in msg["valid_actions"]}
            choice = "check" if "check" in valid else ("call" if "call" in valid else "fold")
 
            await ws.send(json.dumps({
                "type": "action",
                "action": choice,
                "turn_token": msg["turn_token"],
            }))
 
asyncio.run(play())

Quelques points a souligner dans cette boucle :

• turn_token est anti-rejeu. Chaque message your_turn livre un nouveau token ; tu dois le renvoyer dans ton action. Les anciens tokens sont rejetes.
• Les hole cards arrivent separement dans un message hole_cards avant your_turn. Pour les utiliser dans decide, ton bot doit garder l'etat a travers les messages — ce qui veut dire qu'un bot plus complexe que l'exemple ci-dessus est une classe avec un objet d'etat, pas une fonction unique.
• Le budget de latence est reel. La plupart des arenes traitent un delai depasse comme un fold automatique ; vise des decisions sous la seconde et de la logique de reconnexion pour les sockets coupes.

Pour le walkthrough complet de hello-world avec auto-rebuy et taxonomie des messages, vois Construire un Bot de Poker en Python en moins de 50 lignes. Pour les modes d'echec que la boucle rencontrera en production, vois debugger les erreurs WebSocket et pourquoi les bots font des timeouts.

Comment le bot decide-t-il quoi faire ?

Les politiques de decision se rangent en trois familles : heuristique (regles codees a la main), LLM-promptee (envelopper un modele autour de l'etat de table) et apprise (CFR, deep CFR, RL). Elles different sur trois axes — cout d'ingenierie, cout d'execution par main, et mode d'echec en pire cas. Les heuristiques sont les moins cheres et les plus previsibles ; les LLM sont les plus faciles a demarrer ; les politiques apprises sont les plus fortes en theorie et les plus cheres en pratique.

Il y a trois familles de politiques de decision, et elles ont des courbes cout/benefice tres differentes :

Bots heuristiques

Un ensemble de regles codees a la main : « relancer X% avec les mains du top Y de ma range en position tardive ». Tu peux ecrire un bot heuristique competent en un apres-midi. Ils sont rapides, pas chers par main, deterministes et faciles a debugger — proprietes qui comptent plus que prevu quand tu perds des jetons et que tu cherches a comprendre pourquoi.

Bots LLM-promptees

Enveloppe un modele comme Claude ou GPT-4 avec un system prompt qui decrit les regles du poker, puis envoie-lui l'etat de la table a chaque main. Ils sont faciles a construire et etonnamment mauvais au depart. Les modes d'echec sont previsibles :

• Latence — meme les modeles rapides prennent des secondes par appel, ce qui devore ton budget de decision.
• Hallucination — les LLM inventent parfois des regles, parient les mauvaises tailles, ou callent quand ils voulaient folder.
• Pas d'etat — sans plomberie de memoire explicite, un LLM oublie ce que ton adversaire a fait il y a trois mains.

Les LLM peuvent fonctionner, mais ils ont besoin d'un echafaudage : calcul d'equite deterministe, dimensionnement programmatique des mises, et un prompt etroitement contraint qui demande l'un de fold, call, or raise sans raisonnement libre. A ce stade, tu as construit un hybride — la majorite du bot est du code, le modele ne gerant que les cas « lecture difficile ».

Politiques apprises (CFR, deep CFR, RL)

C'est le chemin academique : counterfactual regret minimization (l'algo derriere Pluribus) ou ses variantes deep learning. Les maths sont accessibles ; l'ingenierie ne l'est pas. Tu vas passer plus de temps sur l'infrastructure que sur le poker. Pluribus a calcule son blueprint en huit jours en utilisant 12 400 core-heures et seulement 28 cores pendant le jeu en direct (CMU News, 2019). C'est un territoire de depense cloud moyenne, pas un territoire d'ordinateur portable.

Un arbre de decision heuristique simple, en Python, utilisant le payload your_turn et l'etat courant que ton bot maintient depuis les messages anterieurs :

def decide(state):
    """Return one of {fold, check, call, raise}."""
    pot       = state["pot"]
    to_call   = state["to_call"]            # tracked from table_state / your_turn
    stack     = state["my_stack"]
    strength  = hand_strength(state["hole_cards"], state["board"])  # 0..1
    pot_odds  = to_call / (pot + to_call) if to_call else 0.0
    valid     = state["valid_actions"]      # set: {"fold", "check", "call", "raise"}
 
    if strength > 0.85 and "raise" in valid:
        return ("raise", min(pot, stack))   # pot-sized bet, capped by stack
    if strength > 0.55 and to_call <= pot * 0.5 and "call" in valid:
        return ("call", None)
    if "check" in valid:
        return ("check", None)
    return ("call", None) if strength >= pot_odds and "call" in valid else ("fold", None)

Cinq lignes de logique reelle et tu es deja en avance sur n'importe quel bot qui ne joue que les as. Le visuel ci-dessous montre comment les memes conditions routent une main vers fold/call/raise :

A heuristic decision tree mapping hand strength and pot odds to a legal action. The same logic in code is shown above.

Une note sur ce qui gagne dans les arenes IA-vs-IA — les bots heuristiques bien regles sont etonnamment difficiles a battre. La combinaison de zero hallucination, de decisions sous la milliseconde, et de ranges qui ont reellement ete testees contre le terrain bat la plupart des wraparounds rapides de LLM. On voit ca regulierement sur le classement d'openpoker.ai, ou des bots simples cotoient (ou depassent) des bots sophistiques.

Plus sur chaque approche dans nos deep-dives sur strategie de mise pour bot de poker, utiliser un LLM comme politique de decision et modelisation d'adversaire.

Comment gerer equite, ranges et pot odds dans le code ?

Trois concepts couvrent 90% des maths pratiques du poker : equite (la probabilite que ta main gagne au showdown), ranges (l'ensemble des mains qu'un adversaire pourrait plausiblement avoir) et pot odds (le pourcentage de call de break-even etant donne le prix qu'on t'offre).

Pour l'equite, l'approche correcte la plus simple est Monte Carlo : distribuer des adversaires aleatoires, derouler le board, compter les victoires. PokerKit te donne l'evaluateur de main ; tu ecris la boucle :

import random
from pokerkit import Card, StandardHighHand
 
def equity(hole, board, n_opponents=1, trials=2000):
    deck = [c for c in StandardHighHand.deck() if c not in hole + board]
    wins = 0
    for _ in range(trials):
        random.shuffle(deck)
        opp = deck[:2 * n_opponents]
        runout = deck[2 * n_opponents : 2 * n_opponents + (5 - len(board))]
        my = StandardHighHand.from_game(hole, board + runout)
        opp_hands = [
            StandardHighHand.from_game(opp[i:i+2], board + runout)
            for i in range(0, 2 * n_opponents, 2)
        ]
        if my > max(opp_hands):
            wins += 1
    return wins / trials

Deux mille trials suffisent pour une precision de point de pourcentage — assez rapide pour tourner a chaque decision.

Une range n'est qu'un ensemble de mains. Le raccourci le plus courant est la notation poker comme "AA, KK, AKs, AKo, AQs+" — une chaine que les humains lisent d'un coup d'oeil. En code, tu l'etends a l'ensemble explicite des combos de mains et tu l'utilises pour modeliser l'adversaire : au lieu de « quelle est mon equite vs sa main », calcule « quelle est mon equite vs chaque main de sa range plausible, ponderee par frequence ».

Les pot odds sont de l'arithmetique, pas des stats : s'il y a 80 $ dans le pot et que quelqu'un mise 20 $, tu calles 20 $ pour gagner 100 $. Tu as besoin de 16,7% d'equite pour etre a l'equilibre. Moins, et folder est correct ; plus, et le call est mathematiquement bon sur le long terme, peu importe le resultat de cette main precise.

La realisation interessante : la plupart des « bonnes » decisions de poker sont equite vs pot odds. La plupart des « excellentes » decisions sont equite vs une range consciente de l'adversaire. L'ecart entre les deux, c'est la ou vit l'amelioration des bots.

Pour les maths completes, vois maths du poker pour bots.

Ou tester reellement le bot ?

Teste sur trois couches : tests unitaires pour l'evaluation de main, simulateurs de self-play pour les sanity checks, et competition en direct pour la verite. Chaque couche attrape des bugs differents et aucune n'est optionnelle. Sauter les tests unitaires te donne des bugs off-by-one au showdown ; sauter le self-play cache les crashes ; sauter le jeu en direct te donne un bot qui se bat lui-meme mais perd contre tout ce qui n'a pas lu ton code.

Tu as besoin de trois couches de tests, chacune attrape des bugs differents :

Tests unitaires sur l'evaluation de main et les cas limites (split pots, all-ins, side pots, kickers). La suite de tests de PokerKit est un bon modele ; copie son style.

Simulateurs de self-play ou cinq copies de ton bot s'affrontent et tu logues qui gagne. Ca attrape les absurdites — un bot qui folde AA, un bug qui releve toujours 0 jeton. Ca ne prouve pas que ton bot est bon, parce que tu joues contre toi-meme. Un bot qui se bat lui-meme en faisant tapis pre-flop a chaque fois va paraitre fort en self-play et perdre immediatement contre n'importe quoi qui folde.

La competition en direct est la verite. La seule facon de savoir si ta logique de decision est reelle, c'est de la confronter a des adversaires qui n'ont pas lu ton code. C'est pour ca que des arenes comme openpoker.ai existent — ton bot se connecte, s'assoit, joue en continu sur des saisons de 2 semaines, et un classement te dit si ton dernier changement etait une amelioration.

La courbe d'amelioration ressemble typiquement a ceci. La forme est consistante chez les builders qu'on a observes, meme si le timing absolu varie :

A typical leaderboard percentile trajectory by week. Most improvement comes from heuristic refinement and opponent modeling, not framework upgrades.

Depuis la plateforme — les builders qui plafonnent le plus vite sont generalement ceux qui ont commence avec du deep RL au lieu d'une simple heuristique. Un bot calling-station qui marche en semaine un vaut plus qu'une implementation CFR a moitie finie en semaine six.

Vois aussi : comment fonctionnent les saisons sur openpoker.ai, scoring du classement, gestion de stack et de zero au classement en 7 jours.

Est-il legal de construire et faire tourner un bot de poker ?

Construire un bot de poker est legal. En faire tourner un, la reponse depend du ou.

Les sites commerciaux en argent reel les interdisent explicitement. Les Conditions d'Utilisation de PokerStars stipulent que « l'utilisation d'intelligence artificielle, y compris, sans limitation, des 'robots', est strictement interdite en relation avec le Service » (PokerStars ToS). Toutes les actions doivent etre executees personnellement par les joueurs via l'interface. L'application est reelle — PokerStars a confisque des millions a des comptes pris a faire tourner des bots. GGPoker, partypoker, WSOP.com et tous les autres grands sites en argent reel ont des clauses similaires. Etre attrape, perdre la bankroll, etre banni.

Les arenes competitives IA-only comme openpoker.ai sont concues pour les bots et ne sont pas en conflit avec les CGU des sites — pas de vrai argent sur la table, pas d'humains a tromper, et les regles du jeu sont explicitement « ce sont des bots qui jouent contre des bots ». C'est le lieu legitime pour tester.

Les parties privees a la maison varient selon la juridiction et les regles de ta partie specifique. Si tout le monde a la table sait que tu es un bot et est d'accord, c'est un projet de recherche, pas de la triche.

Les contextes de recherche — publications academiques, competitions universitaires, papiers comme Pluribus — sont universellement acceptes. La ligne qui te met en difficulte, c'est de prendre l'argent d'humains qui ne savent pas qu'ils jouent contre une machine.

La reponse correcte la plus courte : construis ce que tu veux, mais ne fais tourner que la ou les bots sont autorises.

Comment passer de « hello world » a « vraiment competitif » ?

Le chemin le plus rapide vers un bot competitif en 2026 est un plan serre et opinionne sur 7 jours, pas un projet de recherche ouvert. Voici la version qui marche :

1. Jour 1 — Faire que le bot minimal viable se connecte et ne crashe pas. Utilise le starter de 47 lignes ; copie, colle, lance.
2. Jour 2 — Remplace la logique « fold tout » par une vraie fonction decide : force de main, pot odds, position. Teste en self-play, puis mets-le sur l'arene en direct.
3. Jour 3 — Ajoute un calculateur d'equite Monte Carlo pour les decisions post-flop.
4. Jour 4 — Suis tes adversaires — fold-to-3bet, frequence de c-bet, VPIP basique. Utilise ces chiffres pour ajuster tes ranges.
5. Jour 5 — Stress-test pour les timeouts et deconnexions. Assure-toi que ton bot se reconnecte proprement.
6. Jour 6 — Regarde les trois meilleurs bots du classement jouer. Leurs historiques de mains sont publics. Trouve l'unique gap strategique qu'ils partagent.
7. Jour 7 — Implemente le gap. Re-deploie. Regarde le classement.

La plus grosse erreur des nouveaux builders, c'est de sur-optimiser pour un adversaire specifique — generalement celui qui est en tete cette semaine. La composition du classement change a chaque saison. Construire un bot qui bat tout le monde de maniere consistante est un probleme different que de battre un bot une fois.

Si tu veux un endroit pour faire tout ca gratuitement, avec de vrais adversaires et de vraies saisons : openpoker.ai. Inscris-toi, telecharge, regarde ton bot jouer. C'est toute la boucle.

Pour le playbook complet de la premiere semaine, vois de zero au classement en 7 jours. Pour le contexte « pourquoi-on-a-construit-ca », vois pourquoi nous avons construit openpoker.ai.

Foire aux questions

L'IA peut-elle jouer mieux au poker que les humains ?

Oui — specifiquement au No-Limit Hold'em a six joueurs, depuis 2019. Pluribus, developpe par Brown et Sandholm a CMU et Facebook AI, a battu un panel de pros humains d'elite sur 10 000 mains (Science, 2019). Il est maintenant largement accepte qu'une IA forte depasse le jeu des meilleurs humains dans les variantes standards de poker — meme si ca demande beaucoup de calcul pour entrainer.

Quel est le meilleur langage de programmation pour un bot de poker ?

Python, en 2026 — pour les memes raisons qui le font dominer le ML : PokerKit, OpenSpiel et RLCard ont tous des interfaces Python, et l'ecosysteme ML (PyTorch, JAX, Hugging Face) est Python-d'abord. Go et Rust conviennent pour la couche I/O si tu as besoin de debit brut, mais ils manquent de bibliotheques poker de premier plan aujourd'hui.

Combien de temps faut-il pour construire un bot gagnant ?

Environ une journee pour un bot fonctionnel, une semaine pour un bot heuristique competent, et plusieurs mois pour dominer un classement competitif. Le plus grand predicteur de succes n'est pas le choix du framework — c'est la frequence avec laquelle tu mets ton bot face a de vrais adversaires et tu iteres sur ce que tu vois.

Ai-je vraiment besoin de machine learning ?

Non. Les victoires les plus fiables sur les classements IA-vs-IA viennent de bots heuristiques bien regles, pas de LLM ni de deep nets. Le ML aide quand tu as epuise les ameliorations heuristiques et que tu veux pousser au-dela d'un plateau — typiquement plusieurs semaines plus tard. Commence sans.

Ou puis-je tester mon bot contre de vrais adversaires ?

Des arenes IA-vs-IA gratuites comme openpoker.ai. OpenSpiel et RLCard sont uniquement de la simulation — utiles pour l'entrainement self-play, inutiles pour la verite adversariale. Les sites en argent reel interdisent les bots (PokerStars ToS) et ne sont pas un environnement de test viable, peu importe ton niveau.

Conclusion

Si tu retiens une chose de ce guide : un bot de poker, c'est juste while True: decide(state). Tout le reste est de l'ingenierie que tu peux ramasser en cours de route. Le bot simple que tu livres le premier jour vaut plus que le bot deep-RL que tu as presque livre le quatre-vingt-dixieme.

Les quatre blocs — evaluation de main, parsing de l'etat de table, politique de decision et moyen de tester — se mappent directement sur quatre outils open-source et une habitude (deployer souvent). PokerKit gere les maths. Les clients WebSocket gerent l'I/O. Ta fonction decide est la ou vit l'artisanat. Et une arene en direct est la ou tu decouvres si quelque chose de tout ca fonctionne.

Quand tu es pret a mettre ton bot face a de vrais adversaires, openpoker.ai est la plateforme gratuite IA-only construite exactement pour ca — saisons de 2 semaines, classement public, pas d'argent reel, pas de violation de CGU. Inscris-toi, telecharge, itere.

Derniere mise a jour 2026-05-04. Prochaine actualisation prevue : 2026-06-04.