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

Kötegelt lekérések fájl nélkül: akár 10 000 kérés inline módon

4. lecke 16 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. A fájlalapú kötegelés könnyűsúlyú alternatívája
  2. Fájlalapú vs. inline kötegelés
  3. Inline feladat létrehozása
  4. Gyakorlati példa: Jegyek osztályozása
  5. Mikor melyik megközelítést válaszd?
  6. Főbb megállapítások

Frissítve: 2026. november 3.: November 3-i frissítés: a files.download egy HTTP-választ (httpx2.Response) ad vissza; a .decode() hívása előtt olvasd be a tartalmát a .read() metódussal.

A fájlalapú kötegelés könnyűsúlyú alternatívája

Az inline kötegelés lehetővé teszi, hogy a kötegelt lekéréseket közvetlenül az API-hívásban küldd el, kihagyva a fájlfeltöltés lépését. Ez az ideális módszer, ha közepes volumenű lekéréseid vannak (akár 10 000), és egyszerűsíteni szeretnéd a munkafolyamatodat.

Fájlalapú vs. inline kötegelés

Mielőtt belevágnánk a kódba, tisztázzuk a két megközelítés közötti különbségeket:

Szempont Fájlalapú kötegelés Inline kötegelés
Maximális volumen 1 000 000 lekérés 10 000 lekérés
Előfeltételek JSONL-fájl feltöltése Nincs
Lépések Feltöltés + Feladat létrehozása Feladat létrehozása (egyetlen hívás)
Felhasználási esetek Éles környezet, nagy volumen Tesztelés, prototípuskészítés, közepes volumen

Inline feladat létrehozása

Az input_files paraméter helyett egy requests paramétert adsz át, amely közvetlenül tartalmazza a lekérések listáját:

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Inline lekérések előkészítése
inline_requests = [
    {
        "custom_id": f"req-{i:04d}",
        "body": {
            "max_tokens": 150,
            "messages": [
                {
                    "role": "system",
                    "content": "You are a text classification expert."
                },
                {
                    "role": "user",
                    "content": f"Classify this text: {text}"
                }
            ]
        }
    }
    for i, text in enumerate(my_texts)
]

# Feladat létrehozása inline lekérésekkel
job = client.batch.jobs.create(
    requests=inline_requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

print(f"Inline job created: {job.id}")
print(f"Number of requests: {len(inline_requests)}")

A kód eltérése minimális: input_files= helyett requests=. A munkafolyamat többi része (állapotkövetés, eredmények letöltése) megegyezik.

Gyakorlati példa: Jegyek osztályozása

Íme egy teljes példa ügyfélszolgálati jegyek osztályozására:

from mistralai.client import Mistral
import json
import time

client = Mistral(api_key="your-api-key")

# Ügyfélszolgálati jegyek szimulálása
tickets = [
    {"id": "TK-001", "message": "I cannot log in to my account"},
    {"id": "TK-002", "message": "How do I cancel my subscription?"},
    {"id": "TK-003", "message": "The app crashes on startup"},
    {"id": "TK-004", "message": "Can you add dark mode?"},
    {"id": "TK-005", "message": "My invoice is incorrect"},
]

# Inline lekérések összeállítása
requests = [
    {
        "custom_id": ticket["id"],
        "body": {
            "max_tokens": 50,
            "messages": [
                {
                    "role": "system",
                    "content": (
                        "Classify the ticket into one of these categories: "
                        "AUTHENTICATION, BILLING, BUG, "
                        "FEATURE, SUBSCRIPTION. "
                        "Reply with the category only."
                    )
                },
                {"role": "user", "content": ticket["message"]}
            ]
        }
    }
    for ticket in tickets
]

# Inline köteg indítása
job = client.batch.jobs.create(
    requests=requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

# Várakozás és eredmények lekérése
while True:
    status = client.batch.jobs.get(job_id=job.id)
    if status.status in ("SUCCESS", "FAILED", "CANCELLED"):
        break
    time.sleep(5)

# Eredmények feldolgozása
if status.status == "SUCCESS":
    data = client.files.download(file_id=status.output_file)
    for line in data.read().decode("utf-8").strip().split("\n"):
        entry = json.loads(line)
        ticket_id = entry["custom_id"]
        category = entry["response"]["body"]["choices"][0]["message"]["content"]
        print(f"{ticket_id} -> {category.strip()}")

Mikor melyik megközelítést válaszd?

A döntő tényező nem csupán a volumen, hanem az, hogy a kötegelés hol illeszkedik a munkafolyamatodba. Prototípuskészítés során egy promptot néhány száz példán tesztelsz, finomítod, majd újra futtatod. Ha minden iterációnál köztes JSONL-fájlt írsz, az csak lassítja a ciklust. Az inline kötegelés megszünteti ezt a súrlódást: a szkripted menet közben generálja a lekéréseket, ugyanabban a hívásban elküldi őket, és percek alatt iterálhatsz. Ugyanez a logika vonatkozik a könnyűsúlyú integrációkra, az egyszeri elemző szkriptekre vagy a napi feldolgozásra is, amennyiben az 10 000 lekérés alatt marad.

A fájlalapú kötegelés akkor kerül előtérbe, ha a kötegelés éles környezeti láncszemmé válik. Először mechanikailag: 10 000 lekérés felett ez az egyetlen lehetőség. De ami fontosabb, szerkezetileg: a feltöltött fájl tartós artefaktum. Több feladathoz is újra felhasználhatod, nyilvántartásként megőrizheted, hogy pontosan mit küldtél be, és tisztán elválaszthatod az előkészítő lépést (amely felépíti, validálja és verziókezeli a fájlt) a végrehajtó lépéstől (amely elindítja a feladatot). Amikor egy kötegelt feladat éjszakánként fut ügyféladatokon, ez a nyomon követhetőség nem luxus; ez teszi lehetővé, hogy hat hónap múlva is megválaszolhasd a kérdést: „Mit küldtünk a modellnek március 12-én?“

A gyakorlatban sok csapat mindkettőt használja: inline módot a promptfejlesztés során, majd átvált fájlalapú kötegelésre az iparosításkor. Mivel az eredmények követésére és lekérésére szolgáló kód mindkét módnál azonos, a migráció csupán a requests= paraméter input_files=-re cserélésére korlátozódik.

Főbb megállapítások

  • Az inline kötegelés kihagyja a feltöltési lépést, mivel a lekéréseket közvetlenül a requests paraméteren keresztül adod át
  • Az inline feladatok limitje lekérésenként 10 000, szemben a fájlalapú kötegelés 1 milliós limitjével
  • Az állapotkövetés és az eredmények letöltése mindkét módnál azonos
  • Prototípuskészítéshez és közepes volumenhez az inline-t részesítsd előnyben; nagy volumenű éles környezethez használd a fájlalapú kötegelést