Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Streamelés és eszközök

9. lecke 14 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Streamelés függvényhívással
  2. Az alapszabály
  3. Streamelés megvalósítása eszközökkel
  4. Eszközhívások újjáépítése streamelés közben
  5. Architektúra eszközökkel történő streameléshez
  6. Késleltetés és felhasználói élmény
  7. Server-Sent Events (SSE) webes alkalmazásokhoz
  8. Főbb megállapítások

Streamelés függvényhívással

A streamelés lehetővé teszi, hogy a modell válaszát fokozatosan, tokenről tokenre kapd meg. Ez elengedhetetlen a felhasználóbarát felületekhez. De hogyan működik együtt a streamelés a függvényhívással?

Az alapszabály

A függvényhívások egyetlen csomagban érkeznek vissza, nem fokozatosan streamelve. Ez jelentős különbség a normál szöveghez képest, amely tokenenként érkezik.

A gyakorlatban:

  • A válasz szövege fokozatosan streamelődik
  • A tool_calls egyszerre, egyetlen eseményben érkeznek meg

Ennek a korlátozásnak jó oka van: egy eszköz hívásának teljesnek kell lennie (név + érvényes JSON argumentumok), hogy végrehajthasd. A töredékes JSON használhatatlan lenne.

Streamelés megvalósítása eszközökkel

stream = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    stream=True
)

collected_tool_calls = []
collected_content = ""

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

    # Streamelt szöveg
    if delta.content:
        collected_content += delta.content
        print(delta.content, end="", flush=True)

    # Eszközhívások (egy blokkban érkeznek)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # A stream végének ellenőrzése
    if chunk.choices[0].finish_reason == "tool_calls":
        # A modell eszközeredményeket vár
        break
    elif chunk.choices[0].finish_reason == "stop":
        # A válasz véget ért, nem történt eszköz hívás
        break

Eszközhívások újjáépítése streamelés közben

Bizonyos esetekben az eszköz hívásának argumentumai több részletben is érkezhetnek a streamen belül. Ezeket újra össze kell állítanod:

tool_calls_buffer = {}

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

    if delta.tool_calls:
        for tc_chunk in delta.tool_calls:
            idx = tc_chunk.index

            if idx not in tool_calls_buffer:
                tool_calls_buffer[idx] = {
                    "id": tc_chunk.id,
                    "function": {
                        "name": tc_chunk.function.name or "",
                        "arguments": ""
                    }
                }

            if tc_chunk.function.name:
                tool_calls_buffer[idx]["function"]["name"] = tc_chunk.function.name
            if tc_chunk.function.arguments:
                tool_calls_buffer[idx]["function"]["arguments"] += tc_chunk.function.arguments

Ez a pufferelési módszer biztosítja, hogy minden eszköz hívását helyesen állítsd össze, még akkor is, ha az adatok töredékesen érkeznek.

Architektúra eszközökkel történő streameléshez

Egy valós alkalmazásban két párhuzamos streamet kell kezelned:

  1. Valós idejű megjelenítés: a szöveg mutatása, ahogy beérkezik
  2. Eszközhívások gyűjtése: a végrehajtáshoz szükséges hívások összegyűjtése
async def handle_streaming_response(stream):
    content_parts = []
    tool_calls = []
    current_tool = None

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

        if delta.content:
            content_parts.append(delta.content)
            yield {"type": "text", "data": delta.content}

        if delta.tool_calls:
            for tc in delta.tool_calls:
                tool_calls.append(tc)

        if chunk.choices[0].finish_reason == "tool_calls":
            # Eszközök végrehajtása, majd újraindítás
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Késleltetés és felhasználói élmény

Az eszközökkel végzett streamelés természetes szüneteket tartalmaz a folyamatban:

  1. A felhasználó felteszi a kérdését
  2. A modell elkezdi a gondolkodást (nincs látható token)
  3. A modell úgy dönt, hogy meghív egy eszközt (megkapod a tool_call-t)
  4. Szünet — végrehajtod a függvényt
  5. Visszaküldöd az eredményt
  6. A modell generálja a válaszát (fokozatosan streamelve)

A felhasználói élmény érdekében jeleníts meg egy jelzést a 4. lépés során:

🔍 Időjárás keresése Párizsban...

Ez megakadályozza, hogy a felhasználó azt higgye, az alkalmazás lefagyott.

Server-Sent Events (SSE) webes alkalmazásokhoz

Ha webes API-t építesz, használd az SSE-t a stream továbbítására:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/chat")
async def chat(message: str):
    async def event_stream():
        stream = client.chat.completions.create(
            model="grok-4.5",
            messages=[{"role": "user", "content": message}],
            tools=tools,
            stream=True
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"

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

Főbb megállapítások

  • Az eszköz hívások egyetlen csomagban érkeznek, nem fokozatosan streamelve
  • A normál szöveg továbbra is tokenenként streamelődik
  • A töredékes eszköz hívásokat egy index alapján indexelt pufferrel állítsd össze
  • Kezelj két párhuzamos streamet: szöveg megjelenítése + eszköz hívások gyűjtése
  • Jeleníts meg jelzést az eszköz végrehajtása alatt a jobb felhasználói élmény érdekében
  • Használj SSE-t webes alkalmazásokhoz