Implementē straumēšanu Python valodā
Šajā lapā
No prototipa uz produkciju
Iepriekšējā nodarbībā tika apskatīti SSE straumēšanas koncepti. Grūtākā daļa vēl priekšā: pārvērst demonstrācijas ciklu klientā, kas iztur slodzi, pārdzīvo tīkla kļūdas un baro tīmekļa saskarni. Šī nodarbība seko reālam projekta attīstības ceļam — vispirms skelets, tad kļūdu apstrāde, tad asinhronitāte, tad HTTP eksponēšana un visbeidzot mērījumi.
Pamata paraugs
Viss sākas ar šo desmit rindu skeletu, ko pielāgosi katram projektam. Tas dara divas lietas vienlaicīgi: parāda tokenus, tiklīdz tie ierodas, un uzkrāj tos funkcijas atgriešanai.
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
def stream_chat(messages: list, model: str = "mistral-large-latest") -> str:
"""Nosūta straumēšanas pieprasījumu un parāda tokenus reāllaikā."""
stream = client.chat.stream(
model=model,
messages=messages
)
full_text = ""
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
full_text += content
print(content, end="", flush=True)
print() # Jauna rinda
return full_text
Šī versija darbojas lokālam skriptam. Tai ir fatāls trūkums produkcijā: tā drukā terminālī, tāpēc spēj veikt tikai termināļa darbu.
Visaptveroša kļūdu apstrāde
Tīkla kļūdas, noildzes un ātruma ierobežojumi nav hipotētiski scenāriji: tie ir neizbēgami pie reālas satiksmes mēroga. Zemāk esošais klients atrisina abas problēmas. Tas automātiski atkārto 429 kļūdas, izmantojot eksponenciālu atkāpšanos, un vairs neko nedrukā: tas ģenerē tipizētus notikumus, izmantojot yield, atstājot izsauktājziņai lēmumu, ko ar tiem darīt — parādīt, nosūtīt uz WebSocket vai ierakstīt datubāzē.
from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import time
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
def stream_with_retry(
messages: list,
model: str = "mistral-large-latest",
max_retries: int = 3,
max_tokens: int = 2000
) -> dict:
"""Straumēšana ar automātisku atkārtošanu un metrikām."""
for attempt in range(max_retries):
try:
stream = client.chat.stream(
model=model,
messages=messages,
max_tokens=max_tokens
)
full_text = ""
finish_reason = None
chunk_count = 0
for chunk in stream:
delta = chunk.data.choices[0].delta
if delta.content:
full_text += delta.content
chunk_count += 1
yield {"type": "token", "content": delta.content}
if chunk.data.choices[0].finish_reason:
finish_reason = chunk.data.choices[0].finish_reason
yield {
"type": "done",
"full_text": full_text,
"finish_reason": finish_reason,
"chunks": chunk_count
}
return
except SDKError as e:
if e.status_code == 429 and attempt < max_retries - 1:
wait_time = 2 ** attempt # Eksponenciāla atkāpšanās
yield {"type": "retry", "wait": wait_time, "attempt": attempt + 1}
time.sleep(wait_time)
else:
yield {"type": "error", "message": str(e), "status": e.status_code}
return
except Exception as e:
yield {"type": "error", "message": str(e), "status": None}
return
Eksponenciālā atkāpšanās 2 ** attempt gaida 1 sekundi, tad 2, tad 4. Šī progresija nav dekoratīva: ja visi klienti atkārtotu mēģinājumus vienādā fiksētā ritmā, tie trāpītu API sinhronizētos viļņos un pagarinātu tieši to piesātinājumu, no kura cieš. Ņem vērā arī to, ka tikai 429 kļūda izraisa atkārtošanu — 401 kļūdas atkārtošana nederīgas atslēgas dēļ tikai aizkavētu diagnostiku.
Izsauktājziņas pusē patēriņš kļūst par vienkāršu notikumu lasīšanu:
messages = [
{"role": "system", "content": "You are a technical assistant."},
{"role": "user", "content": "Explain design patterns in Python."}
]
for event in stream_with_retry(messages):
if event["type"] == "token":
print(event["content"], end="", flush=True)
elif event["type"] == "retry":
print(f"\n[Retry {event['attempt']}, waiting {event['wait']}s...]")
elif event["type"] == "done":
print(f"\n\n--- Done ({event['chunks']} chunks, {event['finish_reason']})")
elif event["type"] == "error":
print(f"\n[Error: {event['message']}]")
Asinhrona straumēšana ar asyncio
Sinhronais klients bloķē savu pavedienu visas ģenerācijas laikā. Tīmekļa serverī, kam jāapstrādā piecdesmit vienlaicīgas sarunas, tas nozīmē piecdesmit pavedienu imobilizēšanu tikai gaidīšanai. Asinhronais klients noņem šo ierobežojumu:
from mistralai.client import Mistral
import asyncio
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
async def async_stream_chat(messages: list) -> str:
"""Asinhrona straumēšana vienlaicīgām lietotnēm."""
stream = await client.chat.stream_async(
model="mistral-large-latest",
messages=messages
)
full_text = ""
async for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
full_text += content
print(content, end="", flush=True)
print()
return full_text
# Izpilde
async def main():
messages = [{"role": "user", "content": "Hello, introduce yourself."}]
result = await async_stream_chat(messages)
print(f"\nTotal: {len(result)} characters")
asyncio.run(main())
Loģika ir identiska sinhrónajai versijai; mainās tikai stream_async, await izsaukumā un async for ciklā.
Integrācija ar FastAPI
Tālāk tev jāizvada šī straume no Python procesa uz pārlūkprogrammu. FastAPI to apstrādā ar StreamingResponse, ja vien pārformatē katru fragmentu uz SSE formātu, kas apskatīts iepriekšējā nodarbībā:
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mistralai.client import Mistral
import os
import json
app = FastAPI()
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
async def generate_stream(prompt: str):
"""SSE ģenerators priekš FastAPI."""
stream = await client.chat.stream_async(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}]
)
async for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
data = json.dumps({"content": content})
yield f"data: {data}\n\n"
yield "data: [DONE]\n\n"
@app.get("/chat/stream")
async def chat_stream(prompt: str):
return StreamingResponse(
generate_stream(prompt),
media_type="text/event-stream"
)
Divas detaļas nosaka, vai šis galapunkts darbojas pareizi. Dubultā jaunrinda \n\n, kas beidz katru yield, ir tas, kas atdala notikumus SSE protokolā: bez tās pārlūks bezgalīgi gaida notikumu, ko tas uzskata par nepabeigtu. Un media_type="text/event-stream" ir tas, kas ļauj JavaScript klientam patērēt atbildi ar EventSource, nevis standarta fetch.
Veiktspējas mērīšana
Kad straume ir ieviesta, vēlēsies uzzināt, kā tā darbojas. Optimizēšanai pietiek ar divām metrikām:
import time
start = time.perf_counter()
first_token_time = None
token_count = 0
stream = client.chat.stream(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Write a paragraph about Paris."}]
)
for chunk in stream:
if chunk.data.choices[0].delta.content:
if first_token_time is None:
first_token_time = time.perf_counter() - start
token_count += 1
total_time = time.perf_counter() - start
print(f"Time to First Token (TTFT): {first_token_time:.3f}s")
print(f"Tokens generated: {token_count}")
print(f"Total time: {total_time:.3f}s")
print(f"Tokens/second: {token_count / total_time:.1f}")
TTFT (Time to First Token) — laiks starp pieprasījuma nosūtīšanu un pirmā rakstzīmes parādīšanu — ir vissvarīgākais lietotāja pieredzes rādītājs. Tam ir prioritāte pār kopējo laiku: piecpadsmit sekunžu ģenerēšana, kuras pirmais vārds parādās trīs desmitdaļās sekundes, šķitīs ātra, savukārt piecu sekunžu ģenerēšana, kas piegādāta vienā blokā, šķitīs lēna. Mēri to uz saviem reālajiem uzdevumiem, ieskaitot sistēmas ziņojumu — divu lappušu garš sistēmas ziņojums pagarina TTFT pat pirms pirmā tokena ģenerēšanas.
Galvenās atziņas
- Izmanto ģeneratora paraugu (
yield), lai izplatītu straumētos tokenus - Ievies eksponenciālu atkāpšanos 429 kļūdām (ātruma ierobežojums)
- Vienlaicīgām tīmekļa lietotnēm dod priekšroku
stream_async - Mēri TTFT un tokenus sekundē, lai optimizētu veiktspēju
- Ar FastAPI
StreamingResponse+text/event-streamnogādā SSE uz pārlūkprogrammu