Sortie en streaming LangChain

La sortie en streaming fait que les réponses de l'IA s'affichent caractère par caractère comme une frappe au clavier, ce qui améliore considérablement l'expérience utilisateur. L'Agent de LangChain dispose d'une prise en charge complète et intégrée de la sortie en streaming.


Pourquoi la sortie en streaming est nécessaire

Si invoke() est utilisé, les utilisateurs doivent attendre que l'Agent termine toutes les étapes (plusieurs appels au modèle + exécution d'outils) avant de voir le résultat. Pour les tâches complexes, cela peut prendre plus de dix secondes, voire davantage.

La sortie en streaming résout ce problème : chaque Token généré est renvoyé immédiatement, ce qui permet aux utilisateurs de voir la progression en temps réel.

MéthodeExpérience utilisateurScénarios applicables
invoke()Attendre → Voir le résultat complet d'un seul coupScripts, API, traitement par lots
stream()Voir chaque Token en temps réelInterfaces de chat, affichage en temps réel

stream_mode="messages" — Streaming Token par Token

C'est le mode de streaming à la granularité la plus fine, où chaque chunk correspond à un Token :

Exemple

from dotenv import load_dotenv
load_dotenv()

from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage

model = init_chat_model("deepseek:deepseek-v4-flash")
agent = create_agent(
    model=model,
    system_prompt="Vous êtes l'assistant de EXAMPLE Tutorial.",
)

# stream_mode="messages" renvoie les tokens un par un
print("Sortie en streaming en temps réel :")
for msg_chunk, metadata in agent.stream(
    {"messages": [HumanMessage(content="Présentez Python en une phrase")]},
    stream_mode="messages",
):
    # msg_chunk est un AIMessageChunk
    # chaque chunk ne contient qu'un petit morceau de contenu
    if msg_chunk.content:
        print(msg_chunk.content, end="", flush=True)
print()  # saut de ligne à la fin

Résultat de l'exécution :

Live streaming output:
Example is a free online learning platform for programming beginners, offering rich technical tutorials and hands-on examples.

Comprendre les métadonnées

Les métadonnées contiennent des informations sur la source de ce chunk :

Exemple

print("Afficher les informations sur les métadonnées :"\n")
for msg_chunk, metadata in agent.stream(
    {"messages": [HumanMessage(content="Bonjour, présentez-vous")]},
    stream_mode="messages",
):
    if msg_chunk.content and len(msg_chunk.content) > 5:
        print(f"Contenu : {msg_chunk.content}")
        print(f"Nœud source : {metadata.get('langgraph_node')}")
        print(f"Type de message : {type(msg_chunk).__name__}")
        break  # afficher uniquement le premier bloc significatif

Résultat de l'exécution :

Inspect metadata:

Content: Hello! I am an AI assistant
Source node: model
Message type: AIMessageChunk

stream_mode="updates" — Visualisation du processus d'exécution de l'agent étape par étape

Ce mode est très utile lors de la construction d'interfaces qui doivent afficher le « processus de réflexion » :

Exemple

from langchain.tools import tool


@tool
def search_course(keyword: str) -> str:
    """Rechercher des cours sur EXAMPLE"""
    courses = {
        "python": "Tutoriel de base Python3 (30 chapitres, 20 heures)",
        "html": "Tutoriel de base HTML (25 chapitres, 15 heures)",
    }
    return courses.get(keyword.lower(), "Aucun cours associé trouvé")


agent = create_agent(
    model=init_chat_model("deepseek:deepseek-v4-flash", temperature=0),
    tools=[search_course],
    system_prompt="Vous êtes un consultant de cours chez EXAMPLE.",
)

# utiliser le mode updates pour voir chaque étape
print("=== Processus d'exécution de l'agent ==="\n")
for chunk in agent.stream(
    {"messages": [HumanMessage(content=Aidez-moi à vérifier les cours Python)]},
    stream_mode="updates",
):
    for node_name, update in chunk.items():
        print(f"[{node_name}]", end=" ")
        if "messages" in update:
            for msg in update["messages"]:
                if msg.type == "ai":
                    if hasattr(msg, 'tool_calls') and msg.tool_calls:
                        calls = [tc['name'] for tc in msg.tool_calls]
                        print(fAppels de requête : {calls})
                    elif msg.content:
                        print(fRéponse : {msg.content[:80]})
                elif msg.type == "tool":
                    print(fL'outil a renvoyé [{msg.name}] : {msg.content})

Résultat de l'exécution :

=== Agent 执行过程 ===

[model] 请求调用: ['search_course']
[tools] 工具返回 [search_course]: Python3 基础教程(30章,20小时)
[model] Reply: Example has the Python3 basics tutorial, 30 chapters, about 20 hours of study, perfect for Python beginners.

stream_mode="custom" — Envoi d'événements personnalisés

Grâce au runtime.stream_writer() du middleware, vous pouvez envoyer des événements personnalisés au flux :

Exemple

from langchain.agents.middleware import before_model, after_model


@before_model
def notify_before(state, runtime):
    Envoyer des événements personnalisés avant l'invocation du modèle
    runtime.stream_writer({
        "type": "status",
        "message": Réflexion...,
    })
    return None


@after_model
def notify_after(state, runtime):
    Envoyer des événements personnalisés après l'invocation du modèle
    last_msg = state["messages"][-1] if state.get("messages") else None
    has_tools = hasattr(last_msg, 'tool_calls') and last_msg.tool_calls

    if has_tools:
        tool_names = [tc['name'] for tc in last_msg.tool_calls]
        runtime.stream_writer({
            "type": "status",
            "message": fAppel des outils : {', '.join(tool_names)}...,
        })
    else:
        runtime.stream_writer({
            "type": "status",
            "message": Réponse terminée,
        })
    return None


agent = create_agent(
    model=init_chat_model("deepseek:deepseek-v4-flash", temperature=0),
    tools=[search_course],
    middleware=[notify_before, notify_after],
    system_prompt="Vous êtes un consultant de cours chez EXAMPLE.",
)

# Utilisez stream_mode=["updates", "custom"] pour recevoir les deux événements en même temps
print(=== Sortie de streaming mixte ===\n")
for mode, chunk in agent.stream(
    {"messages": [HumanMessage(content=Vérifier les cours Python)]},
    stream_mode=["updates", "custom"],
):
    if mode == "custom":
        print(f[Événement personnalisé] Statut : {chunk['message']})
    elif mode == "updates":
        for node_name, update in chunk.items():
            if "messages" in update:
                for msg in update["messages"]:
                    if msg.type == "ai" and msg.content:
                        print(f[Réponse] {msg.content})

Résultat de l'exécution :

=== 混合流式输出 ===

[custom event] Status: thinking...
[custom event] Status: calling tool: search_course...
[reply] Example has the Python3 basics tutorial, 30 chapters, about 20 hours of study.
[custom event] Status: thinking...
[custom event] Status: answer completed

Les modes stream_mode peuvent être combinés, comme stream_mode=["updates", "custom", "messages"]. Cependant, un trop grand nombre de modes augmentera le nombre d'événements dans le flux, il est donc recommandé de les sélectionner selon les besoins.


Sortie en streaming asynchrone

Dans les services web, l'utilisation du streaming asynchrone peut éviter de bloquer la boucle d'événements :

Exemple

import asyncio


async def stream_agent():
    Exécuter l'Agent de manière asynchrone en mode streaming
    agent = create_agent(
        model=init_chat_model("deepseek:deepseek-v4-flash"),
        system_prompt="Vous êtes l'assistant de EXAMPLE Tutorial.",
    )

    full_response = ""
    async for msg_chunk, metadata in agent.astream(
        {"messages": [HumanMessage(content=Présentez Python en une phrase)]},
        stream_mode="messages",
    ):
        if msg_chunk.content:
            full_response += msg_chunk.content
            print(msg_chunk.content, end="", flush=True)

    print(f"\n\nLongueur de la réponse complète : {len(full_response)} caractères)


# Exécuter la fonction asynchrone
asyncio.run(stream_agent())

Exemple d'intégration FastAPI

Exemple

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage

app = FastAPI()
agent = create_agent(
    model=init_chat_model("deepseek:deepseek-v4-flash"),
    system_prompt="Vous êtes l'assistant de EXAMPLE Tutorial.",
)


@app.get("/chat")
async def chat(message: str):
    Interface de chat, renvoie une réponse de streaming SSE
    async def generate():
        async for msg_chunk, metadata in agent.astream(
            {"messages": [HumanMessage(content=message)]},
            stream_mode="messages",
        ):
            if msg_chunk.content:
                # Format SSE : data: xxx
                yield f"data: {msg_chunk.content}\n\n"
        yield "data: [DONE]\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
    )

# Démarrer : uvicorn main:app --reload

Dans un environnement de production, il est recommandé de créer l'instance Agent en tant que singleton global afin d'éviter de la recréer à chaque requête. Le coût de création d'un Agent est faible (principalement la compilation du graphe), mais réutiliser l'instance est plus efficace.


Référence rapide de stream_mode

ModeGranularitéObjet d'itérationUtilisation typique
messagesNiveau token(AIMessageChunk, metadata)Effet de frappe, chat en temps réel
updatesNiveau nœud{node_name: state_update}Afficher le processus de réflexion
valuesNiveau nœud (complet)État completInstantané de l'état, débogage
customPersonnalisédict arbitraireNotification de progression, push de statut
debugDétailléInformations de débogageDépannage pendant le développement
Autres extensions