Comment streamer la réponse d'un LLM avec FastAPI ?

Découvrez comment streamer la réponse d'un LLM avec FastAPI grâce aux Server-Sent Events.

Publié le par Gabriel Trouvé (mis à jour le )

53 minutes

Vous avez certainement déjà copié-collé vos notes de réunion dans ChatGPT pour créer des comptes rendus. Mais quand vous avez des tâches récurrentes qui reviennent chaque semaine, et pour plusieurs collaborateurs, il peut être utile d'avoir un outil dédié.

Avoir son propre outil comporte plusieurs avantages :

  • un prompt écrit une seule fois pour des comptes rendus structurés de manière homogène

  • pas de copier-coller, le résultat peut être enregistré ou envoyé par mail

  • le choix du modèle avec un paiement à l'usage

Nous allons développer un petit outil internet pour l'entreprise de Patrick : Boréal Systèmes. Patrick colle ses notes et le compte rendu s'écrit en direct sous ses yeux.

Nous utiliserons FastAPI, qui gère nativement le streaming depuis la version 0.135.0 sortie en mars 2026, PydanticAI et l'API d'OpenAI.

C'est quoi le streaming d'un LLM ?

Un LLM ne produit pas une réponse en un bloc, il va la générer au fur et à mesure, token par token. Un token correspond à un petit morceau de texte, mais n'hésitez pas à aller lire notre glossaire sur CarnetIA.

Sans streaming, le serveur attend le dernier token avant de tout envoyer, alors qu'avec le streaming, chaque morceau est transmis au navigateur au fur et à mesure qu'il est prêt.

Ça ne veut pas dire que la réponse complète arrive plus vite, mais pour vos utilisateurs, c'est bien mieux d'afficher la réponse token par token : le temps paraît passer plus vite.

SSE, WebSocket ou JSON Lines : quel format choisir ?

Le format le plus courant est le Server-Sent Events (SSE). Il s'agit d'une requête HTTP dont la connexion reste ouverte et dans laquelle le serveur envoie des en-têtes (dont Content-Type: text/event-stream) et des blocs de texte, séparés par une ligne vide :

event: token
data: " Patrick"

event: token
data: " valide"
SHELL

Chaque bloc est nommé avec un contenu. Il s'agit d'un format standardisé que les navigateurs lisent nativement via EventSource.

Ici, le WebSocket n'aurait pas d'intérêt, car il ouvre un canal dans les deux sens. Nous n'avons besoin que d'un seul.

Le JSON Lines envoie un objet JSON par ligne :

{"type":"token","texte":"Réunion"}
{"type":"token","texte":" du"}
JSON

FastAPI n'ajoute ni ping pour garder la connexion ouverte, ni en-têtes pour les proxys. Ces en-têtes permettent de demander à Nginx de transmettre chaque morceau quand il arrive.

Conclusion : on part sur du Server-Sent Events.

Préparation du projet

Je pense que si vous avez regardé les derniers guides sur Docstring, vous connaissez bien uv. C'est ce que je vais utiliser sur ce projet pour les dépendances.

uv init --no-package compte-rendu-stream
cd compte-rendu-stream
uv add "fastapi[standard]" "pydantic-ai-slim[openai]"
uv add --dev pytest
SHELL
  • fastapi[standard] permet d'installer FastAPI, sa commande fastapi dev et httpx

  • pydantic-ai-slim[openai] installe Pydantic AI avec juste ce qu'il faut pour OpenAI, on évite d'embarquer tous les fournisseurs

  • pytest nous servira pour... les tests 😛. Nous avons un article sur cette librairie

Récupérez votre clé API sur la plateforme d'OpenAI et placez-la dans un fichier .env à la racine :

OPENAI_API_KEY=sk-.............
SHELL

Nous ferons comme dans l'article sur la transcription audio : nous chargerons le fichier .env avec l'option --env-file.

Pour le guide, on utilise gpt-6-luna, le million de tokens est à 0,10 $ / 0,50 $, et il est suffisant pour des comptes rendus.

Comment streamer une réponse avec FastAPI ?

Déjà, sans brancher de LLM, prenons une liste de mots envoyés un par un.

Avant FastAPI 0.135.0

Avant la version 0.135.0 de FastAPI, il fallait passer par StreamingResponse et écrire son propre format SSE. Créez un fichier ancienne_methode.py :

import asyncio
import json
from collections.abc import AsyncIterator

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

MOTS = ["Réunion", " du", " lundi", " :", " Patrick", " présente", " le", " budget."]


async def generer_evenements() -> AsyncIterator[str]:
    for mot in MOTS:
        await asyncio.sleep(0.3)
        # Le format SSE est à écrire à la main, sans oublier la ligne vide finale
        yield f"event: token\ndata: {json.dumps(mot)}\n\n"
    yield "event: done\ndata: [DONE]\n\n"


@app.get("/demo")
async def demo() -> StreamingResponse:
    return StreamingResponse(
        generer_evenements(),
        media_type="text/event-stream",
        # Des en-têtes à ne pas oublier... et à connaître
        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
    )
PYTHON

asyncio.sleep() sert uniquement à simuler le temps de génération d'un LLM.

Vous pouvez maintenant lancer le serveur pour tester :

uv run fastapi dev ancienne_methode.py
SHELL

Puis dans un autre terminal, curl permet de voir les évènements :

curl -N http://127.0.0.1:8000/demo
SHELL

Passons maintenant aux choses sérieuses !

Depuis FastAPI 0.135.0

FastAPI gère maintenant le SSE nativement.

Créez le fichier nouvelle_methode.py :

import asyncio
from collections.abc import AsyncIterable

from fastapi import FastAPI
from fastapi.sse import EventSourceResponse, ServerSentEvent

app = FastAPI()

MOTS = ["Réunion", " du", " lundi", " :", " Patrick", " présente", " le", " budget."]


@app.get("/demo", response_class=EventSourceResponse)
async def demo() -> AsyncIterable[ServerSentEvent]:
    for mot in MOTS:
        # On simule le temps de génération d'un LLM
        await asyncio.sleep(0.3)
        yield ServerSentEvent(data=mot, event="token")
    # Un dernier événement pour signaler la fin du flux
    yield ServerSentEvent(raw_data="[DONE]", event="done")
PYTHON
  • response_class=EventSourceResponse indique que la route renvoie du flux SSE

  • yield pour que chaque valeur devienne un évènement envoyé au client

  • -> AsyncIterable[ServerSentEvent] est le typage que vous retrouverez dans la documentation

  • ServerSentEvent permet de remplir les champs de l'évènement

  • data est encodé en JSON, tandis que raw_data envoie le texte tel quel

Et maintenant testons ça !

uv run fastapi dev nouvelle_methode.py
SHELL

Puis curl avec l'option -i pour afficher les en-têtes :

curl -N -i http://127.0.0.1:8000/demo
SHELL
Aperçu

Aperçu

Les en-têtes cache-control et x-accel-buffering sont là d'office !

Comment streamer la réponse de l'IA avec Pydantic AI ?

Si je ne me trompe pas, ça va faire le troisième article où j'évoque Pydantic AI. Nous avons d'ailleurs un article dédié à cette librairie.

Ce que renvoie OpenAI

Regardons d'abord ce que renvoie l'API d'OpenAI quand on lui demande de streamer :

curl https://api.openai.com/v1/responses \
  -N \
  -H "Authorization: Bearer votre_cle_api" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-6-luna", "input": "Dis bonjour à Patrick en une phrase.", "stream": true}'
SHELL

Voici un extrait de la sortie :

event: response.created
data: {"type":"response.created","response":{"id":"resp_026da9024e7c90a5006ac736dea30487d18781b4a59a24ae2e","object":"response","created_at":1791440606,"status":"in_progress",[...],"model":"gpt-6-luna",[...],"store":true,[...]},"sequence_number":0}

[...]

event: response.output_text.delta
data: {"type":"response.output_text.delta","content_index":0,"delta":"Bonjour",[...],"sequence_number":4}

event: response.output_text.delta
data: {"type":"response.output_text.delta","content_index":0,"delta":" Patrick",[...],"sequence_number":5}

[...]

event: response.output_text.done
data: {"type":"response.output_text.done",[...],"sequence_number":14,"text":"Bonjour Patrick, j’espère que tu vas bien !"}

[...]

event: response.completed
data: {"type":"response.completed","response":{"id":"resp_026da9024e7c90a5006ac736dea30487d18781b4a59a24ae2e","object":"response","created_at":1791440606,"status":"completed",[...],"usage":{"input_tokens":15,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":14,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":29},"user":null,"metadata":{}},"sequence_number":17}
SHELL

On retrouve les formats event / data. Les principaux évènements :

  • response.created : OpenAI ouvre la réponse avec un identifiant

  • response.output_text.delta : un nouveau morceau de texte. Il s'agit d'une différence, chaque évènement reçu ne contient que ce qui s'est ajouté depuis le précédent

  • response.output_text.done : le texte est terminé, et l'évènement le renvoie en entier, il ne nous servira pas

  • response.completed : la génération est terminée

  • error : 😭

Le SDK d'OpenAI serait suffisant en soi, et on ne garderait que les delta, mais Pydantic AI apporte plusieurs choses :

  • récupérer uniquement les morceaux de texte

  • la consommation de tokens

  • une seule famille d'exceptions à gérer

  • des modèles factices pour les tests

  • changer de fournisseur comme de chemise

Brancher Pydantic AI

Dans main.py :

from collections.abc import AsyncIterable

from fastapi import FastAPI
from fastapi.sse import EventSourceResponse, ServerSentEvent
from pydantic import BaseModel, Field
from pydantic_ai import Agent


MODELE = "openai:gpt-6-luna"

agent = Agent(
    MODELE,
    instructions=(
        "Tu rédiges en français le compte rendu d'une réunion de Boréal Systèmes "
        "à partir des notes brutes d'un collaborateur. "
        "Structure-le en Markdown avec ces sections : Résumé, Décisions, Actions, "
        "Questions ouvertes. N'invente rien : si une information manque, ne la "
        "mentionne pas."
    ),
)

app = FastAPI()


class Notes(BaseModel):
    texte: str = Field(min_length=20, max_length=20_000)


@app.post("/compte-rendu", response_class=EventSourceResponse)
async def compte_rendu(notes: Notes) -> AsyncIterable[ServerSentEvent]:
    async with agent.run_stream(notes.texte) as resultat:
        # debounce_by=None : chaque morceau part dès qu'il arrive
        async for morceau in resultat.stream_text(delta=True, debounce_by=None):
            yield ServerSentEvent(data=morceau, event="token")

    # La consommation n'est complète qu'une fois le flux terminé
    usage = resultat.usage
    yield ServerSentEvent(
        data={
            "tokens_entree": usage.input_tokens,
            "tokens_sortie": usage.output_tokens,
            "cout_dollars": usage.cost,
        },
        event="usage",
    )
    yield ServerSentEvent(raw_data="[DONE]", event="done")
PYTHON
  • le préfixe openai: indique à Pydantic AI de passer par l'API Responses d'OpenAI

  • le modèle Notes permet de valider le corps de la requête

  • agent.run_stream() lance la génération en streaming

  • stream_text(delta=True) renvoie uniquement les nouveaux morceaux et non le texte complet accumulé

  • resultat.usage indique le nombre de tokens et usage.cost renvoie une estimation si Pydantic AI connaît les prix, sinon None

Lancez le serveur :

uv run --env-file .env fastapi dev main.py
SHELL

Testons maintenant avec curl :

curl -N -X POST http://127.0.0.1:8000/compte-rendu \
  -H "Content-Type: application/json" \
  -d '{"texte": "Réunion lundi avec Patrick et Sébastien : budget de 12k validé, Patrick envoie le détail vendredi."}'
SHELL

Voici une partie de la réponse :

event: token
data: "##"

event: token
data: " R\u00e9s"

event: token
data: "um\u00e9"

[...]

event: token
data: " notes"

event: token
data: "."

event: usage
data: {"tokens_entree": 98, "tokens_sortie": 162, "cout_dollars": 9.08e-05}

event: done
data: [DONE]
SHELL

Le compte rendu est bien arrivé morceau par morceau, puis l'évènement usage nous donne la consommation de la requête.

Comment afficher le flux avec Streamlit ?

Patrick n'est pas à l'aise avec curl, donc on va créer une interface avec Streamlit, qui permet de créer une page web en Python !

uv add streamlit
SHELL

Créez le fichier app_streamlit.py :

import json
from collections.abc import Iterator

import httpx
import streamlit as st

URL = "http://127.0.0.1:8000/compte-rendu"


def lire_evenements(reponse: httpx.Response) -> Iterator[tuple[str, str]]:
    """Découpe le flux SSE en couples (type, données), au fil de l'eau."""
    type_evenement = "message"
    for ligne in reponse.iter_lines():
        if ligne.startswith("event: "):
            type_evenement = ligne.removeprefix("event: ")
        elif ligne.startswith("data: "):
            yield type_evenement, ligne.removeprefix("data: ")
            type_evenement = "message"


def lire_texte(reponse: httpx.Response, infos: dict) -> Iterator[str]:
    """Renvoie le texte morceau par morceau et range la consommation dans infos."""
    for type_evenement, donnees in lire_evenements(reponse):
        if type_evenement == "token":
            yield json.loads(donnees)
        elif type_evenement == "usage":
            infos["usage"] = json.loads(donnees)


st.title("Compte rendu de réunion")
notes = st.text_area("Notes de réunion", height=200)

if st.button("Générer le compte rendu") and notes:
    infos = {}
    # timeout=30 : délai maximal entre deux morceaux reçus
    with httpx.stream("POST", URL, json={"texte": notes}, timeout=30) as reponse:
        if reponse.status_code != 200:
            st.error(f"Erreur {reponse.status_code}")
        else:
            st.write_stream(lire_texte(reponse, infos))

    if "usage" in infos:
        usage = infos["usage"]
        st.caption(
            f"{usage['tokens_entree']} tokens en entrée, "
            f"{usage['tokens_sortie']} en sortie"
        )
PYTHON
  • httpx.stream() envoie la requête et lit la réponse au fur et à mesure

  • iter_lines() lit le corps au fur et à mesure qu'il arrive

  • lire_evenements() regroupe les lignes en couples

  • lire_texte() est un générateur qui renvoie le texte et range usage dans le dictionnaire infos

  • st.write_stream() affiche chaque morceau dès qu'il arrive

Lancez l'API :

uv run --env-file .env fastapi dev main.py
SHELL

Et Streamlit dans un second terminal :

uv run streamlit run app_streamlit.py
SHELL

Dans la page Streamlit, amusez-vous à coller des notes de réunion, vous verrez que le rendu est sympa niveau expérience utilisateur.

Comment tester un endpoint « IA » sans dépenser de crédits ?

On en parlait dans cet article : Pydantic AI fournit TestModel, un modèle factice pour les tests.

TestModel renvoie une réponse prévisible que l'on peut définir, et on peut remplacer le modèle de l'agent pendant le test.

Créez le fichier test_main.py :

import json

from fastapi.testclient import TestClient
from pydantic_ai import models
from pydantic_ai.models.test import TestModel

from main import agent, app

# Filet de sécurité : aucun appel réel au LLM pendant les tests
models.ALLOW_MODEL_REQUESTS = False

client = TestClient(app)

NOTES = {"texte": "Réunion lundi : Patrick présente le budget 2027."}


def lire_evenements(corps: str) -> list[tuple[str, str]]:
    """Découpe le corps SSE en une liste de couples (type, données)."""
    evenements = []
    for bloc in corps.strip().split("\n\n"):
        lignes = dict(ligne.split(": ", 1) for ligne in bloc.split("\n"))
        evenements.append((lignes.get("event", "message"), lignes.get("data", "")))
    return evenements


def test_le_compte_rendu_arrive_en_plusieurs_morceaux():
    """
    Given un modèle de test qui répond un texte connu
    When on demande un compte rendu
    Then le texte arrive en plusieurs événements token, suivis de usage et done
    """
    texte_attendu = "Patrick présente le budget 2027 de Boréal Systèmes."
    with agent.override(model=TestModel(custom_output_text=texte_attendu)):
        reponse = client.post("/compte-rendu", json=NOTES)

    assert reponse.status_code == 200
    assert reponse.headers["content-type"].startswith("text/event-stream")

    evenements = lire_evenements(reponse.text)
    morceaux = [json.loads(data) for type_, data in evenements if type_ == "token"]
    assert len(morceaux) > 1
    assert "".join(morceaux) == texte_attendu
    assert [type_ for type_, _ in evenements[-2:]] == ["usage", "done"]


def test_des_notes_trop_courtes_sont_refusees():
    """
    Given des notes de moins de 20 caractères
    When on demande un compte rendu
    Then FastAPI répond 422 avant même d'appeler le LLM
    """
    reponse = client.post("/compte-rendu", json={"texte": "trop court"})

    assert reponse.status_code == 422
PYTHON
  • models.ALLOW_MODEL_REQUESTS = False est une garde pour empêcher tout test qui tenterait d'appeler un vrai modèle

  • le temps du with, l'agent n'appelle plus OpenAI, il répond avec TestModel qui renvoie toujours le texte découpé mot par mot

  • reponse.text contient tous les évènements et lire_evenements() les découpe comme on le fait avec Streamlit

Lancez les tests en chargeant le .env :

uv run --env-file .env pytest -v
SHELL

Bien que la clé soit chargée, avec agent.override() et ALLOW_MODEL_REQUESTS, on n'appelle jamais OpenAI 😎.

Bravo, tu es prêt à passer à la suite

Rechercher sur le site

Inscris-toi à Docstring

Pour commencer ton apprentissage.

Tu as déjà un compte ? Connecte-toi.