Sruthú: Freagraí a Fháil i bhFíor-Am
Ar an leathanach seo
Sruthú: Freagraí a Fháil i bhFíor-Am
Ligeann sruthú duit an freagra a fháil token ar token seachas fanacht go gcríochnóidh an ghiniúint ar fad. Ní snas ar an gcomhéadan amháin atá ann: is é seo an difríocht idir chatbot a mhothaíonn mall agus ceann a mhothaíonn tapaidh, fiú nuair atá feidhmíocht an fhreastalaí mar an gcéanna.
Cén fáth Sruthú a Úsáid
Gan sruthú, bíonn úsáideoirí uaireanta ag stánadh ar scáileán bán ar feadh deich go dtí tríocha soicind sula dtagann an freagra iomlán amach ar fad. Le sruthú, feictear na chéad fhocail i gceann soicind, agus tosaíonn tú ag léamh agus an ghiniúint fós ar siúl. Tá an fad iomlán mar an gcéanna; níl an tuiscint air. Chun é a chumasú, níl uait ach paraiméadar amháin, stream=True, a thiontaíonn luach fillte create() ina iteróir imeachtaí.
from openai import OpenAI
client = OpenAI()
# GAN sruthú — fanacht ar gach rud
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Tagann sé amach ar fad ag an am céanna tar éis an fhanachta
# LE sruthú — token ar token
stream = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence.",
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print() # Líne nua ag an deireadh
Imeachtaí Tipithe, Ní Sruth Gan Idirdhealú
Ní téacs amháin a iompraíonn an sruth. Cuireann sé in iúl duit nuair a chruthaítear an freagra, nuair a chuirtear gach mír aschurtha leis, nuair a thagann blúirí, agus nuair a tharlaíonn an críochnú—áirítear méadracha úsáide san imeacht deiridh. Déanann tú scagadh ar event.type chun a fháil amach cad atá á láimhseáil agat. Ligeann an struchtúr seo duit, mar shampla, táscaire lódála a thaispeáint chomh luath agus a lasctar response.created agus comhaireamh a dhéanamh ar thokenanna ag an deireadh gan glao API eile a dhéanamh.
stream = client.responses.create(
model="gpt-5.6-terra",
input="Hello!",
stream=True
)
for event in stream:
match event.type:
case "response.created":
print(f"[Response created] ID: {event.response.id}")
case "response.output_item.added":
print(f"[New output item]")
case "response.output_text.delta":
print(f"[Text] {event.delta}", end="")
case "response.output_text.done":
print(f"\n[Text complete]")
case "response.completed":
print(f"[Done] Tokens: {event.response.usage.total_tokens}")
# Aschur:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25
I bhfeidhmchlár fíor, beidh ort beirt rudaí a dhéanamh beagnach i gcónaí ag an am céanna: na blúirí a thaispeáint agus an téacs iomlán a athchruthú ionas gur féidir leat é a chartlannú nó é a thabhairt ar ais don ghlaóir. Is simplí an riail: carn de réir mar a dhéanann tú iteráid, mar nuair a ídítear an sruth, ní féidir é a chúlú.
def stream_and_collect(prompt: str) -> str:
"""Sruthaigh an freagra agus é á charnadh ag an am céanna."""
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True
)
full_text = ""
for event in stream:
if event.type == "response.output_text.delta":
full_text += event.delta
print(event.delta, end="", flush=True)
print() # Líne nua
return full_text
result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")
Sruthú agus Glao Feidhme
Déantar glaonna feidhme a shruthú freisin, le himeachtaí dá gcuid féin: tagann argóintí i mblúirí trí response.function_call_arguments.delta, agus cuireann response.function_call_arguments.done in iúl go bhfuil an JSON críochnaithe. Tá tábhacht phraiticiúil leis seo—ná déan iarracht na hargóintí a dhíshreangú riamh roimh an imeacht done, nó ní bheidh agat ach JSON gearrtha.
stream = client.responses.create(
model="gpt-5.6-terra",
input="What time is it in Tokyo?",
tools=[{
"type": "function",
"name": "get_time",
"description": "Get the time in a city",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"}
},
"required": ["city"]
}
}],
stream=True
)
for event in stream:
match event.type:
case "response.output_text.delta":
print(event.delta, end="")
case "response.function_call_arguments.delta":
print(f"[Args] {event.delta}", end="")
case "response.function_call_arguments.done":
print(f"\n[Function call complete]")
# Aschur:
# [Args] {"city": "Tokyo"}
# [Function call complete]
An Cás Asincronach
Chomh luath agus a fhreastalaíonn d’fheidhmchlár ar iliomad úsáideoirí ag an am céanna, athraigh go AsyncOpenAI: chuirfeadh an cliant sioncronach bac ar an lúb imeachtaí ar feadh na giniúna ar fad, rud a chuirfeadh ar d’iarratais eile fanacht. Níl difríocht sa chomhréir ach dhá eochairfhocal—await ar an gcruthú agus async for ar an iteráid.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Sruthú asincronach ar an bhfreagra."""
stream = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True
)
async for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print()
asyncio.run(stream_async("Tell a short joke."))
Ar an ngréasán, tá sruthú gan úsáid má stopann sé ag do fhreastalaí: caithfidh tú é a shíneadh go dtí an brabhsálaí. Cumasaíonn FastAPI é seo le StreamingResponse, á bheathú ag gineadóir a sheolann blúirí de réir mar a thagann siad.
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
app = FastAPI()
client = OpenAI()
@app.get("/chat")
async def chat(question: str):
def generate():
stream = client.responses.create(
model="gpt-5.6-terra",
input=question,
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
yield event.delta
return StreamingResponse(generate(), media_type="text/plain")
Earráidí le Linn Sruthaithe
Tá mionsonra amháin a thuilleann do aire: i sruthú, is féidir le hearráid tarlú tar éis blúirí a bheith taispeánta cheana. Feiceann an t-úsáideoir freagra ansin a thosaíonn ach a ghearrtar as. Dá bhrí sin, cuimsigh an iteráid féin, ní hamháin cruthú an tsrutha, ionas gur féidir leat cur isteach a chur in iúl go glan seachas fágáil ag crochadh ar abairt.
from openai import APIError
def stream_with_errors(prompt: str):
"""Sruthú le láimhseáil láidir earráidí."""
try:
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print()
except APIError as e:
print(f"\nAPI error during streaming: {e.message}")
except Exception as e:
print(f"\nUnexpected error: {e}")
stream_with_errors("Explain streaming in 2 sentences.")
Príomhphointí
- Cumasaigh sruthú le
stream=Truechun taithí fhíor-ama a bheith agat - Déan scagadh ar imeachtaí de réir
event.typechun gach cineál sonraí a láimhseáil i gceart - Tá blúirí téacs in
response.output_text.delta - Cuireann
response.completedin iúl an deireadh agus áirítear méadracha úsáide ann - Úsáid
AsyncOpenAIle haghaidh sruthaithe i bhfeidhmchláir asincronacha - Láimhseáil earráidí i gcónaí, fiú i mód sruthaithe