Przejdź do głównej treści
Polski— Wybierz język
Menu

Strumieniowanie odpowiedzi w Pythonie

Lekcja 6 z 14 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Problem, który rozwiązuje strumieniowanie
  2. Użycie chat.stream()
  3. Co zawiera fragment
  4. Wyświetlanie i zapisywanie jednocześnie
  5. Wariant asynchroniczny
  6. Kiedy strumieniować, a kiedy tego nie robić
  7. Kluczowe wnioski

Problem, który rozwiązuje strumieniowanie

Korzystając z chat.complete(), czekasz, aż model wygeneruje całą odpowiedź, zanim otrzymasz choćby jeden znak. Przy krótkiej odpowiedzi opóźnienie to pozostaje niezauważone. Jednak w przypadku szczegółowej analizy, długiego fragmentu kodu czy rozumowania rozłożonego na wiele akapitów, użytkownik wpatruje się w pusty ekran przez kilka sekund. W interfejsie czatu nawet kilka sekund ciszy może sprawić wrażenie, że aplikacja zawiesiła się.

Strumieniowanie zmienia to odczucie: odpowiedź dociera przyrostowo, kawałek po kawałku, i wyświetla się stopniowo, dokładnie tak jak w znanych Ci interfejsach czatu. Całkowity czas generowania nie skraca się ani o milisekundę, ale pierwsze słowo pojawia się niemal natychmiast. To właśnie to początkowe opóźnienie jest tym, co użytkownik faktycznie odczuwa.

Użycie chat.stream()

Mistral SDK V2 udostępnia metodę chat.stream(), która zwraca iterator fragmentów zamiast pojedynczego obiektu:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": "Describe the steps to deploy a Flask application on a Linux server."
        }
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

# Final newline
print()

Dwa szczegóły w tej pętli mają kluczowe znaczenie. Sprawdzenie if content jest niezbędne, ponieważ niektóre fragmenty docierają bez tekstu i w przeciwnym razie wypisałyby None. Z kolei flush=True wymusza na Pythonie natychmiastowe zapisanie danych na wyjściu, zamiast czekania na wypełnienie bufora. Bez tego cały tekst pojawiłby się jednym blokiem na samym końcu, co całkowicie niweczyłoby oczekiwany efekt.

Aspektchat.complete()chat.stream()
ZwrotKompletny obiektIterator fragmentów
Postrzegane opóźnienieWysokie (całkowity czas oczekiwania)Niskie (szybki pierwszy token)
Dostęp do teksturesponse.choices[0].message.contentchunk.data.choices[0].delta.content
Zużycie tokenówDostępne w odpowiedziDostępne w ostatnim fragmencie

Co zawiera fragment

Każdy fragment niesie ze sobą deltę, czyli ułamek tworzonej odpowiedzi. Analizując ją, uzyskujesz dostęp zarówno do tekstu, jak i metadanych oznaczających koniec strumienia:

for chunk in stream:
    delta = chunk.data.choices[0].delta

    # Treść tekstowa (może być None dla niektórych fragmentów)
    text = delta.content

    # Powód zatrzymania (None z wyjątkiem ostatniego fragmentu)
    end = chunk.data.choices[0].finish_reason

    if text:
        print(text, end="", flush=True)

    if end:
        print(f"\n[Stream end: {end}]")

Przepływ zawsze podlega tej samej choreografii: pierwszy fragment zazwyczaj niesie rolę assistant, fragmenty pośrednie dostarczają tekst w małych kawałkach, a ostatni zawiera finish_reason. Sprawdzając ten końcowy fragment, ustalasz, czy odpowiedź zakończyła się normalnie, czy została ucięta przez limit max_tokens.

Wyświetlanie i zapisywanie jednocześnie

Strumieniowanie ma swoją wadę: tekst przewija się na ekranie, ale nigdzie go nie przechowujesz. Tymczasem aplikacja działająca w środowisku produkcyjnym często potrzebuje archiwizować odpowiedź w bazie danych dla celów historii rozmowy. Rozwiązaniem jest akumulowanie fragmentów podczas ich wyświetlania:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {"role": "user", "content": "List five Python web frameworks."}
    ]
)

full_response = []

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        full_response.append(content)
        print(content, end="", flush=True)

print()

# Odtworzona pełna odpowiedź
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")

Zwróć uwagę na użycie listy, a następnie końcowego "".join() zamiast konkatenacji stringów w każdej iteracji pętli. Przy długiej odpowiedzi to drugie podejście kopiowałoby cały zgromadzony tekst dla każdego otrzymanego fragmentu, co jest nieefektywne.

Wariant asynchroniczny

W serwerze WWW – takim jak FastAPI czy aiohttp – wersja synchroniczna blokuje wątek podczas całego procesu generowania, zamrażając inne trwające żądania. Dlatego SDK udostępnia metodę chat.stream_async():

import asyncio
import os
from mistralai.client import Mistral

async def generate_response():
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    stream = await client.chat.stream_async(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": "Explain the concept of a coroutine in Python."}
        ]
    )

    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            print(content, end="", flush=True)

    print()

asyncio.run(generate_response())

Struktura jest identyczna jak w wersji synchronicznej, z wyjątkiem słów kluczowych await i async for. Gdy tylko Twój kod działa w serwerze WWW, jest to wariant, którego musisz użyć.

Kiedy strumieniować, a kiedy tego nie robić

W interfejsie czatu strumieniowanie jest zawsze obowiązkowe: chodzi o komfort czytania. Po stronie backendowego API warto je włączyć, o ile Twój frontend potrafi konsumować zdarzenia Server-Sent Events. Przy każdej odpowiedzi dłuższej niż kilka zdań zysk na postrzeganym opóźnieniu usprawiedliwia dodatkowe komplikacje. Z drugiej strony, w skrypcie wsadowym przetwarzającym tysiąc dokumentów i zapisującym wyniki do pliku, nikt nie patrzy na ekran: chat.complete() pozostaje prostsze i w pełni wystarczające.

Kluczowe wnioski

  • chat.stream() zwraca iterator fragmentów do wyświetlania przyrostowego
  • Treść znajduje się w chunk.data.choices[0].delta.content
  • Używaj flush=True w wywołaniach print(), aby uzyskać wyświetlanie w czasie rzeczywistym
  • Odtwórz pełną odpowiedź, akumulując fragmenty, jeśli jest to konieczne
  • Wersja asynchroniczna chat.stream_async() jest zalecana w aplikacjach internetowych