Introduction aux Messages dans LangChain

Dans LangChain, les messages servent d'unités de contexte de base pour les modèles de langage. Ils représentent les entrées et sorties du modèle, transportant le contenu et les métadonnées nécessaires pour maintenir l'état de la conversation lors des interactions avec les LLM.

Types de Messages

LangChain propose quatre catégories principales de messages :

• SystemMessage : Instructions initiales pour confiugrer le comportement du modèle, comme définir son rôle ou des directives de réponse.
• HumanMessage : Représente les entrées utilisateur, qui peuvent inclure du texte, des images, de l'audio ou d'autres contenus multimodaux.
• AIMessage : Réponses générées par le modèle, contenant du texte, des appels d'outils et des métadonnées.
• ToolMessage : Résultats des appels d'outils, utilisés pour renvoyer les sorties d'outils au modèle.

Utilisation des Messages

Les messages peuvent être gérés de différentes manières selon les besoins :

Prompts Textuels

Pour des tâches simples sans historique de conversation, les chaînes de caractères suffisent. Voici un exemple :

# Exemple avec une seule requête
reponse = modele.invoke("Raconte une blague")

# Traitement par lots pour des requêtes indépendantes
questions = ["Pourquoi les perroquets ont des plumes colorées ?", "Comment volent les avions ?", "Qu'est-ce que l'informatique quantique ?"]
resultats = modele.batch(questions)

Cette approche convient pour des demandes ponctuelles où la simplicité est prioritaire.

Prompts avec Objets Message

Pour les conversations multi-tours ou le contenu multimodal, il est préférable d'utiliser des objets message structurés :

from langchain.messages import SystemMessage, HumanMessage, AIMessage

conversation = [
    SystemMessage("Tu es un expert en poésie"),
    HumanMessage("Écris un haïku sur le printemps"),
    AIMessage("Les fleurs de cerisier s'épanouissent...")
]
resultat = modele.invoke(conversation)

Alternativement, un format dictionnaire peut être utilisé, mais les objets message offrent une meilleure sécurité de type.

Construction des Objets Message

LangChain propose plusieurs méthodes pour créer des messages, chacune adaptée à différents scénarios.

Mode Simple

Passage direct d'une chaîne de caractères à la classe message :

from langchain.messages import SystemMessage
msg_direct = SystemMessage("Tu es un maître des blagues qui génère des réponses humoristiques selon les demandes")

Mode Dictionnaire

Utilisation d'un dictionnaire pour une flexibilité accrue :

msg_dict = {"role": "system", "content": "Tu es un maître des blagues qui génère des réponses humoristiques selon les demandes"}

Mode Complet

Utilisation de tous les paramètres pour un contrôle fin :

from langchain.messages import SystemMessage
msg_complet = SystemMessage(
    id="msg_sys_1",
    name="systeme",
    content="Tu es un maître des blagues qui génère des réponses humoristiques selon les demandes",
    additional_kwargs={"session_id": "sess_456"}
)

Mode Blocs de Contenu

Pour des structures complexes, notamment pour le multimédia :

from langchain.messages import SystemMessage
from openai.types.beta.threads import TextContentBlock
blocs = [
    TextContentBlock(type="text", text=TextContentBlock.Text("Tu es un expert en humour, recevant des demandes de blagues.")),
    TextContentBlock(type="text", text=TextContentBlock.Text("Évite les blagues contenant des gros mots"))
]
msg_blocs = SystemMessage(content_blocks=blocs)

Le choix de la méthode dépend des besoins en sécurité de type, de flexibilité et de fonctionnalités avancées.

Détails des Types de Messages Spécifiques

SystemMessage

Utilisé pour définir le contexte initial du modèle. Exemple :

instruction_sys = SystemMessage("Tu es un assistant de codage utile.")
conversation = [
    instruction_sys,
    HumanMessage("Comment créer une API REST ?")
]
reponse = modele.invoke(conversation)

HumanMessage

Peut contenir du texte ou des métadonnées supplémentaires. Exemple avec des attributs optionnels :

msg_utilisateur = HumanMessage(
    content="Bonjour !",
    name="alice",
    id="msg_789"
)

AIMessage

Représente la sortie du modèle, incluant potentiellement des appels d'outils et du contenu multimodal. Exemple d'initialisation et d'utilisation :

from langchain.messages import SystemMessage, HumanMessage, AIMessage
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

load_dotenv()
modele = init_chat_model(
    "deepseek:deepseek-chat",
    temperature=0.2,
    max_retries=3
)

instruction = SystemMessage(
    id="inst_sys",
    name="systeme",
    content="Génère des blagues sur les programmeurs",
    additional_kwargs={"token_id": "tok_123"}
)
demande = HumanMessage(content="Raconte une blague sur les développeurs")
historique = [instruction, demande]
reponse = modele.invoke(historique)

Les propriétés clés de AIMessage incluent content, tool_calls, et usage_metadata.

AIMessageChunk

Pour le streaming, les réponses arrivent en morceaux qui peuvent être assemblés :

morceaux = []
message_complet = None
for chunk in modele.stream(historique):
    morceaux.append(chunk)
    print(chunk.text)
    if message_complet is None:
        message_complet = chunk
    else:
        message_complet = message_complet + chunk

ToolMessage

Utilisé pour renvoyer les résultats des outils au modèle. Exemple :

from langchain.messages import AIMessage, ToolMessage, HumanMessage

msg_ai = AIMessage(
    content=[],
    tool_calls=[{
        "name": "obtenir_meteo",
        "args": {"lieu": "Paris"},
        "id": "appel_456"
    }]
)

resultat_outil = "Ensoleillé, 25°C"
msg_outil = ToolMessage(
    content=resultat_outil,
    tool_call_id="appel_456"
)

conversation = [
    HumanMessage("Quel temps fait-il à Paris ?"),
    msg_ai,
    msg_outil
]
reponse_finale = modele.invoke(conversation)

Paramètres importants : content, tool_call_id, et optionnellement name et artifact.

Support Multimodal

LangChain permet de gérer des données multimodales comme les images, à condition que le modèle sous-jacent le supporte. Exemple avec une image encodée en Base64 :

import base64
import httpx
from langchain.messages import HumanMessage

# Téléchargement et encodage d'une image
url_image = "https://exemple.com/image.jpg"
reponse_http = httpx.get(url_image)
donnee_image = base64.b64encode(reponse_http.read()).decode("utf-8")

msg_image = HumanMessage(content=[
    {"type": "text", "text": "Que montre cette image ?"},
    {"type": "image", "image": {"data": donnee_image, "format": "base64"}}
])
reponse = modele.invoke([msg_image])

Il est crucial de vérifier la compatibilité du modèle avec le multimodal et de gérer les limites de fenêtre de tokens.

Blocs de Contenu (Content Blocks)

Les blocs de contenu standardisent le format des messages pour différents types de médias. Ils incluent des variantes pour le texte, le raisonnement, les images, l'audio, la vidéo, les fichiers et les appels d'outils.

Par exemple, un bloc de texte est structuré comme suit :

{
    "type": "text",
    "text": "Bonjour monde",
    "annotations": []
}

D'auters blocs comme ImageContentBlock ou ToolCall suivent des schémas similaires avec des attributs spécifiques à leur type.