LLM 0.32a0 : Révolution dans la gestion des modèles Python

LLM 0.32a0 : Une refonte majeure

La version alpha 0.32a0 de la bibliothèque Python LLM représente une transformation significative dans la manière d'interagir avec les modèles de langage. Cette mise à jour est une refonte majeure de la bibliothèque Python LLM et de l'outil CLI pour accéder aux LLM, tout en restant compatible avec les versions précédentes. Depuis avril 2023, LLM a évolué pour s'adapter aux avancées rapides dans le domaine des modèles de langage, nécessitant une refonte pour mieux gérer les divers types d'entrées et de sorties.

Historique et évolution des fonctionnalités

Initialement, LLM fonctionnait sur un modèle simple basé sur des prompts et des réponses textuelles. On envoyait un texte au modèle et recevait une réponse textuelle, comme illustré par l'exemple suivant :

model = llm.get_model("[gpt](/glossaire/gpt)-5.5")
response = model.prompt("Capitale de la France ?")
print(response.text())

Cependant, cette approche est devenue insuffisante avec l'évolution des modèles, qui supportent désormais des entrées d'image, d'audio et de vidéo, ainsi que des schémas JSON structurés. LLM a donc dû s'adapter pour intégrer ces nouvelles capacités. LLM fournit une abstraction sur des milliers de modèles différents via son système de plugins. Cette abstraction originale, qui consistait en une entrée textuelle renvoyant une sortie textuelle, n'était plus capable de représenter tout ce dont j'avais besoin.

Nouveaux mécanismes d'interaction

La version 0.32a0 introduit deux changements majeurs. Premièrement, les entrées peuvent être représentées comme une séquence de messages, une méthode inspirée par l'interface conversationnelle bidirectionnelle de ChatGPT. Cela permet de structurer les interactions comme des dialogues continus, facilitant l'émulation d'API de complétion de chat.

Par exemple, une conversation pourrait commencer par :

user: Capitale de la France ?

Et se poursuivre avec :

user: Capitale de la France ?
assistant: Paris

Les API JSON des principaux fournisseurs suivent ce modèle, comme le montre l'exemple avec l'API de complétion de chat d'OpenAI :

curl https://api.openai.com/v1/chat/completions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
"model": "gpt-5.5",
"content": "Capitale de la France ?"
"role": "assistant",
"content": "Paris"
"content": "Allemagne ?"

Avant la version 0.32, LLM modélisait cela comme des conversations, mais ne permettait pas de reprendre une discussion déjà commencée. Désormais, grâce à l'utilisation de fonctions comme llm.user() et llm.assistant(), il est possible de structurer des conversations complexes dès le départ. Les fonctions llm.user() et llm.assistant() sont de nouvelles fonctions de construction conçues pour être utilisées dans le tableau messages=[]. L'option prompt= précédente fonctionne toujours, mais LLM l'actualise en un tableau messages à un seul élément en arrière-plan. Vous pouvez également maintenant répondre à une réponse, en alternative à la construction d'une conversation.

L'outil CLI de llm contournait cela par un mécanisme personnalisé pour persister et déployer des conversations en utilisant SQLite, mais cela n'est jamais devenu une partie stable de l'API LLM — et il y a de nombreux endroits où vous pourriez vouloir utiliser la bibliothèque Python sans vous engager à utiliser SQLite comme couche de stockage.

Streaming des résultats

L'autre nouveauté majeure de cette version est le streaming des résultats. Auparavant, LLM supportait le streaming de manière basique, mais la nouvelle version permet de traiter des flux de données mixtes, incluant du texte, des appels d'outils, et potentiellement des images ou des extraits audio. Cela est crucial pour les modèles capables de renvoyer des contenus variés.

Le nouvel alpha LLM modélise le streaming comme un flux de parties de messages typés. Voici un exemple de la nouvelle interface de streaming :

model = llm.get_model("gpt-5.5")
prompt = "inventer 3 chiens cool, d'abord parler de vos motivations"
def describe_dog(name: str, bio: str) -> str:
    """Enregistrer le nom et la biographie d'un chien hypothétique."""
    return f"{name}: {bio}"
def sync_example():
    response = model.prompt(
        tools=[describe_dog],
        for event in response.stream_events():
            if event.type == "text":
                print(event.chunk, end="", flush=True)
            elif event.type == "tool_call_name":
                print(f"\nAppel d'outil : {event.chunk}(", end="", flush=True)
            elif event.type == "tool_call_args":
                print(event.chunk, end="", flush=True)

Mécanisme de sérialisation et désérialisation

La version 0.32a0 introduit également un nouveau mécanisme de sérialisation et désérialisation des réponses, offrant aux utilisateurs la possibilité de créer des alternatives personnalisées pour la persistance des conversations. Voici comment cela fonctionne :

serializable = response.to_dict()
# serializable est un dictionnaire de style JSON
# stockez-le où vous le souhaitez, puis déployez-le :
response = Response.from_dict(serializable)

Le dictionnaire retourné est en réalité un TypedDict défini dans le nouveau module llm/serialization.py.

Perspectives futures

Je publie cela en tant qu'alpha afin de pouvoir mettre à jour divers plugins et tester le nouveau design dans des environnements réels pendant quelques jours. Bien que cette version soit encore en phase alpha, elle préfigure une version stable qui devrait conserver ces avancées, sauf si des tests révèlent des défauts de conception. Il reste une tâche importante : redessiner le système de journalisation SQLite pour mieux capturer les détails plus fins renvoyés par cette nouvelle abstraction. Idéalement, j'aimerais modéliser cela comme un graphe, pour mieux soutenir des situations comme une API de complétion de chat de style OpenAI où les mêmes conversations sont constamment étendues puis répétées avec chaque prompt. Je veux pouvoir stocker cela sans les dupliquer dans la base de données. Cette mise à jour représente un pas important vers une utilisation plus flexible et puissante des modèles de langage, répondant aux besoins croissants des développeurs et des utilisateurs avancés.