Chainlit : un cadre Python pour les interfaces conversationnelles, désormais maintenu par la communauté

Le problème concret : éviter d'écrire un frontend de chat

Une application conversationnelle en Python se heurte vite à un mur qui n'a rien à voir avec le modèle. Il faut un champ de saisie, un flux de réponses qui s'affichent progressivement, un historique, et surtout un moyen de montrer ce qui se passe entre la question et la réponse. Le README résume la promesse en une phrase : construire des applications conversationnelles prêtes pour la production en quelques minutes plutôt qu'en quelques semaines. La cible est donc l'équipe qui a déjà la logique métier en Python et qui ne veut pas ouvrir un second dépôt en React pour la couche de discussion.

Le périmètre réel est plus étroit que le slogan. Chainlit ne fournit ni modèle, ni orchestrateur, ni base vectorielle. Il fournit le serveur, le protocole entre le navigateur et votre code, et un ensemble de décorateurs qui décrivent le cycle de vie d'une conversation. Les exemples du cookbook cités dans le README s'appuient sur OpenAI, Anthropic, LangChain, LlamaIndex, ChromaDB ou Pinecone, ce qui confirme la position : Chainlit est la couche d'affichage et d'événements, pas la couche de raisonnement.

Le décorateur comme unité d'architecture

Le mécanisme tient dans un fichier Python unique. On importe `chainlit as cl`, on décore une fonction asynchrone avec `@cl.on_message`, et cette fonction reçoit un objet `cl.Message` à chaque saisie de l'utilisateur. La réponse ne se retourne pas : elle s'envoie avec `cl.Message(content=...).send()`. Cette distinction est structurante. Une fonction qui retourne une valeur est synchrone du point de vue de l'appelant ; une fonction qui envoie des messages peut en envoyer plusieurs, dans l'ordre, et espacer ces envois dans le temps.

C'est là que `@cl.step(type="tool")` intervient. L'exemple du README déclare une coroutine `tool()` qui attend deux secondes via `cl.sleep(2)` avant de renvoyer une chaîne. Cette étape est appelée depuis le gestionnaire de message, et son résultat est ensuite envoyé à l'utilisateur. Le type déclaré, ici `tool`, sert à étiqueter l'étape dans l'interface. Le flux est donc : le navigateur envoie un message, le serveur exécute votre coroutine, chaque étape produit un événement, et l'interface affiche ces événements au fur et à mesure. Autrement dit, la progression n'est pas déduite, elle est déclarée par le code applicatif.

Démarrer : deux commandes et un fichier

L'installation tient en une ligne : `pip install chainlit`. Le README propose ensuite `chainlit hello`, qui ouvre une application de démonstration dans le navigateur. C'est un test de fumée, pas un modèle de projet : si la page s'affiche, la chaîne d'outils est fonctionnelle.

Pour une application réelle, on crée un fichier, par exemple `demo.py`, contenant les décorateurs décrits plus haut, puis on lance `chainlit run demo.py -w`. L'option `-w` active la surveillance des fichiers, ce qui recharge l'application à chaque modification. C'est le mode de travail normal pendant le développement ; le README ne détaille pas de commande de production distincte, et il faut se référer à la documentation du site pour ce point.

Une variante existe pour tester le code en cours de développement : `pip install git+https://github.com/Chainlit/chainlit.git#subdirectory=backend/`. Le README précise que cette installation depuis GitHub exige Node et pnpm présents sur la machine. C'est un détail qui compte : le paquet publié sur PyPI embarque le frontend compilé, alors que l'installation depuis les sources vous fait construire cette partie vous-même.

La maintenance communautaire change le calcul de risque

Le README ouvre sur un avertissement qu'on ne peut pas ignorer. Depuis le 1er mai 2025, l'équipe d'origine s'est retirée du développement actif. Le projet est maintenu par le groupe @Chainlit/chainlit-maintainers dans le cadre d'un Maintainer Agreement, et le texte précise que Chainlit SAS n'offre aucune garantie sur les futures mises à jour. Les responsabilités transférées sont nommées : revue de code, publications, sécurité.

Ce n'est pas un abandon, et la différence est nette. Les publications récentes montrent une version 2.11.0 en avril 2026, une 2.11.1 le même mois, puis une 2.12.0 en août 2026, avec un dernier push en septembre 2026. Le rythme est irrégulier mais non nul. Pour une équipe qui évalue le projet, la question n'est donc pas « est-ce mort » mais « qui corrige une faille dans le serveur WebSocket, et sous quel délai contractuel ». La réponse, telle que le README la formule, est un groupe de bénévoles. Si votre organisation exige un fournisseur identifiable pour les correctifs de sécurité, ce point seul peut écarter Chainlit.

Ce que Chainlit ne fait pas

La limitation la plus visible concerne l'installation depuis les sources. Elle requiert Node et pnpm, ce qui signifie que la pile de build n'est pas uniquement Python même si le code applicatif l'est. Une équipe qui construit ses images Docker avec un environnement Python minimal devra ajouter une étape Node, ou accepter la version PyPI.

Le second point est plus subtil. Le README ne décrit aucun mécanisme d'authentification, de limitation de débit ou de persistance des conversations. Ce silence n'est pas une preuve d'absence, mais il signifie qu'on ne peut pas déduire de ce document que ces sujets sont traités par défaut. Une application Chainlit exposée sur Internet public est donc un serveur web comme un autre, avec les mêmes obligations. Le README ne dit rien non plus sur le déploiement, la mise à l'échelle horizontale ou la gestion de sessions réparties entre plusieurs instances ; ce sont des questions à poser avant de dimensionner.

Enfin, l'écosystème d'exemples est orienté vers des fournisseurs de modèles hébergés. Si votre contrainte est l'exécution entièrement locale, rien dans le README ne l'empêche, mais rien ne l'accompagne non plus.

Streamlit et Gradio : une différence de modèle d'exécution

L'alternative la plus proche est Streamlit, souvent cité pour le même usage. La différence tient au modèle d'exécution. Streamlit réexécute le script entier à chaque interaction et reconstruit l'interface à partir de l'état ; la logique d'affichage et la logique métier vivent dans le même flux descendant. Chainlit fait l'inverse : le code s'exécute dans des gestionnaires d'événements asynchrones, et l'interface est mise à jour par des envois explicites. Cela rend les boucles longues et les appels d'outils étalés dans le temps plus naturels dans Chainlit, parce qu'on ne reconstruit rien, on publie des événements.

Gradio se situe ailleurs encore. Sa primitive est la fonction entrée-sortie attachée à des composants, ce qui convient bien aux démonstrations de modèle et aux interfaces à champs multiples. Chainlit suppose une conversation comme structure principale, avec des étapes imbriquées. Pour une application où l'utilisateur remplit un formulaire et reçoit un résultat, Gradio demande moins de code. Pour un agent qui enchaîne plusieurs outils et doit montrer sa progression, Chainlit est mieux placé. Le choix se fait donc sur la forme de l'interaction, pas sur la popularité.

Licence et coût de mise à jour

Chainlit est publié sous Apache-2.0. Cette licence autorise l'usage commercial, la modification et la redistribution, à condition de conserver les mentions de copyright et le fichier de licence, et elle inclut une concession de brevet de la part des contributeurs. Elle ne demande pas de publier vos modifications. Rien dans le README n'indique de clause supplémentaire, de marque déposée à respecter au-delà du nom, ou de service payant obligatoire. Ce paragraphe décrit la licence, il ne constitue pas un avis juridique : faites relire le fichier LICENSE et le CONTRIBUTING.md par qui de droit si votre contexte l'exige.

Le coût de mise à jour se lit dans les numéros de version. Entre 2.11.0 et 2.12.0, le saut de mineure peut apporter des changements de comportement dans les décorateurs ou le protocole d'événements. Le README ne fournit pas de journal des changements ni de politique de compatibilité, donc la seule source fiable reste les notes de version publiées. Pour une application en production, cela implique de figer la version dans vos dépendances et de tester chaque montée de version dans un environnement séparé, en particulier si vous utilisez `@cl.step`, dont le rendu dépend de l'interface.

Conclusion éditoriale

Chainlit convient aux équipes Python qui veulent une interface de chat pour un prototype interne sans écrire de frontend, et qui acceptent de dépendre d'une maintenance bénévole encadrée par un Maintainer Agreement. Il ne convient pas à un produit exposé à des utilisateurs externes sans revue de sécurité propre, ni aux équipes qui refusent une pile Node pour builder le paquet. Avant d'adopter, vérifiez deux choses dans le dépôt : le rythme des commits depuis mai 2025 et la procédure de publication décrite dans CONTRIBUTING.md.

Sources officielles

1. Chainlit/chainlit on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases