Ce projet est né dans le cadre d’une formation que j’ai suivie sur l’ingénierie des modèles de langage (LLM engineering), offerte sur Udemy et donnée par Ed Donner. Il s’agit d’un cours très à jour, axé sur des cas concrets, et animé par un instructeur dynamique. Je le recommande sincèrement à toute personne qui souhaite aller au-delà de l’utilisation superficielle des LLM.

Durant cette formation, Ed Donner expliquait avoir implémenté, sur son blogue personnel, un jeu de Connect Four permettant de faire s’affronter différents modèles de langage. L’idée était simple, mais puissante : utiliser un jeu aux règles claires pour comparer les capacités de raisonnement stratégique de différents LLM.

En découvrant ce projet, je me suis dit que je voulais faire la même chose, mais avec un jeu différent.

Le déclic : un jeu mathématique simple, mais profond

Je me suis alors souvenu d’un vidéaste français en mathématiques, Mickaël Launay (Micmaths), qui avait présenté dans une de ses vidéos un jeu de baguettes aux règles très simples.

On place un certain nombre de baguettes sur une table. Deux joueurs jouent à tour de rôle et retirent chacun un nombre limité de baguettes. Selon la version du jeu, le joueur qui prend la dernière baguette gagne ou perd.

Ce jeu, que j’ai appris par la suite s’appelle le jeu de Nim, est particulièrement intéressant, car il existe souvent une stratégie mathématique parfaite permettant de gagner à tous les coups, à condition de la comprendre.

Dans sa vidéo, Mickaël Launay allait plus loin en modifiant les règles :

• permettre de retirer 1 ou 3 baguettes
• ou 1, 2 ou 4 baguettes
• ou encore introduire des règles dynamiques dépendant de l’état du jeu

À chaque fois, il tentait de démontrer mathématiquement la stratégie gagnante. C’est à ce moment que l’idée s’est imposée : le jeu de Nim est un terrain de test idéal pour des LLM.

Pourquoi le jeu de Nim est parfait pour tester des LLM

• Les règles sont simples et faciles à expliquer à un modèle.
• Les calculs requis sont raisonnables, ce qui limite les coûts d’inférence.
• Le jeu exige un véritable raisonnement logique et stratégique.
• Les erreurs sont faciles à identifier et à comparer entre modèles.

J’ai donc décidé d’implémenter plusieurs variantes du jeu de Nim, afin de tester comment différents LLM s’adaptent à des règles fixes, puis à des règles de plus en plus complexes.

Règles du jeu

Règles générales

• Le jeu débute avec 21 baguettes.
• Deux joueurs jouent à tour de rôle.
• Le joueur qui retire la dernière baguette perd.

Version de base

• Chaque joueur peut retirer 1 ou 2 baguettes.

Variante A (règles dynamiques)

• Si le nombre de baguettes restantes est pair, le joueur peut retirer 1, 2 ou 4 baguettes.
• Si le nombre de baguettes restantes est impair, le joueur peut retirer 1, 3 ou 4 baguettes.

Variante B (contrainte mémoire)

• Chaque joueur peut retirer 1, 2 ou 3 baguettes.
• Il est interdit de retirer le même nombre de baguettes deux tours consécutifs.

Ces variantes permettent de tester la capacité d’un modèle à raisonner sur l’état courant du jeu, intégrer des règles conditionnelles, se souvenir des coups précédents et adapter sa stratégie dynamiquement.

Fonctionnement côté LLM

À chaque tour, une requête est envoyée au modèle de langage sélectionné. Cette requête contient les règles du jeu, le nombre de baguettes restantes et les coups légalement possibles.

{
  "evaluation": "brief assessment of the current game state",
  "threats": "any immediate risks if you play poorly",
  "opportunities": "any winning patterns or advantages in the current position",
  "strategy": "concise reasoning behind the chosen move",
  "move_remove": "number of sticks to remove"
}

Cette structure est conçue pour forcer le modèle à expliciter son raisonnement, plutôt que de simplement produire un coup sans justification.

Implémentation technique

Le projet a d’abord été développé avec Gradio, ce qui facilitait l’expérimentation rapide. Gradio n’étant pas supporté par mon serveur, j’ai transformé le projet en une application Flask, compatible avec mon environnement de production.

Modèles testés

• Modèles propriétaires : OpenAI, Gemini, Anthropic, Grok
• Modèles open source : via Ollama en local ou via Groq

Étant donné les limites de calcul de mon serveur, seuls OpenAI et Gemini sont activés en production, mais l’architecture permet d’en intégrer plusieurs autres.

Code source

Le projet est open source et disponible sur GitHub : https://github.com/a3jeu/nim-llm-game