Begränsningar i plattformen
På denna sida
Känn dina begränsningar
Mistral Workflows-plattformen befinner sig i Public Preview (från och med april 2026). Liksom alla orkestreringssystem finns det tekniska begränsningar som du måste förstå för att designa robusta arbetsflöden. Dessa gränser är inte bara fotnoter i dokumentationen; de dyker upp i produktion, ofta sent i processen, som serialiseringsfel eller arbetsflöden som avslutas oväntat utan varning i din kod. Att känna till dem i förväg ändrar hur du strukturerar din bearbetningslogik.
Tabellen nedan sammanfattar de viktigaste begränsningarna och den konkreta konsekvensen av att överskrida var och en.
| Begränsning | Värde | Konsekvens vid överskridande |
|---|---|---|
| Fördröjning mellan aktiviteter | 2 sekunder | Undvikbar latens vid varje aktivitetsanrop |
| In-/utdata per anrop | 2 MB | Serialiseringsfel, arbetsflödet misslyckas |
| Händelser per körning | 51 200 | Arbetsflödet avslutas tvångsmässigt |
| Total storlek per körning | 50 MB | Arbetsflödet avslutas tvångsmässigt |
| Standardtimeout | 1 timme | Arbetsflödet avbryts (konfigurerbart upp till 7 dagar) |
| Maximal timeout | 7 dagar | Arbetsflödet avbryts automatiskt |
| I/O i arbetsflöden | Förbjudet | Fel gällande icke-determinism vid replay |
Två sekunder mellan varje aktivitet
Plattformen tillämpar en minsta fördröjning på 2 sekunder mellan aktivitetsanrop. Denna latens är inget barnsjukdomsproblem; den är inneboende i orkestreringsarkitekturen, som sparar varje händelse innan den fortsätter. Det är priset för hållbarhet.
Påverkan är lätt att beräkna och ofta överraskande. Ett arbetsflöde som kedjar tio sekventiella aktiviteter förbrukar minst tjugo sekunders orkestreringstid, oavsett hur länge aktiviteterna i sig tar. Om varje aktivitet körs på femtio millisekunder har du designat ett jobb på en halv sekund som tar tjugo sekunder att returnera ett resultat.
Lösningen är att bunta ihop operationer som inte behöver vara separata till en enda aktivitet. Jämför dessa två versioner av samma NLP-pipeline.
# SUBOPTIMALT: 3 aktiviteter = 6 sekunders orkestreringslatens
@workflows.workflow.define(name="pipeline_lent")
class SlowPipeline:
@workflows.workflow.entrypoint
async def run(self, text: str) -> dict:
tokens = await tokenize(text)
embeddings = await calculate_embeddings(tokens)
clusters = await cluster(embeddings)
return clusters
# OPTIMERAT: 1 aktivitet = 2 sekunders orkestreringslatens
@workflows.activity()
async def complete_nlp_processing(text: str) -> dict:
tokens = tokenize_local(text)
embeddings = calculate_embeddings_local(tokens)
clusters = cluster_local(embeddings)
return {"clusters": clusters}
@workflows.workflow.define(name="pipeline_rapide")
class FastPipeline:
@workflows.workflow.entrypoint
async def run(self, text: str) -> dict:
return await complete_nlp_processing(text)
Regeln för uppdelning blir enkel: skapa en separat aktivitet endast om du behöver garantin för beständighet mellan två operationer. Om två operationer kan misslyckas tillsammans utan att orsaka problem – som lokal tokenisering och beräkning av inbäddningar kedjade i minnet – bör du bunta ihop dem.
Två megabyte per anrop
Varje aktivitetsanrop är begränsat till 2 MB för indata och 2 MB för utdata, baserat på den serialiserade JSON-representationen av datan. En PDF-rapport, en uppsättning bilder eller en stor CSV-export kommer lätt att överskrida detta, vilket får arbetsflödet att misslyckas med ett serialiseringsfel.
Lösningen kan sammanfattas i en mening: skicka referenser, aldrig datamängder. Aktiviteten laddar ner data från extern lagring, bearbetar den lokalt (där den bara begränsas av arbetarens minne) och returnerar resultat-URL:en.
@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
"""Ladda ner, bearbeta och ladda upp filen igen.
Endast URL:er passerar genom arbetsflödet."""
async with httpx.AsyncClient() as client:
# Ladda ner från S3/GCS
response = await client.get(fichier_url)
contenu = response.content # Kan vara 100 MB
# Bearbeta filen
resultat = traiter(contenu)
# Ladda upp resultatet
await client.put(
"https://storage.example.com/résultats/output.json",
content=resultat
)
return {"url_resultat": "https://storage.example.com/résultats/output.json"}
Budget för händelser och volym
Varje körning är begränsad till 51 200 händelser. Plattformen genererar en händelse för varje aktivitetsstart, varje aktivitets slutförande, varje mottagen signal och varje utlöst timer. I praktiken kostar ett aktivitetsanrop cirka två till tre händelser när metadata räknas in, vilket placerar ett arbetsflöde med hundra aktiviteter runt 250 till 300 händelser. Med andra ord tillåter taket femton till tjugo tusen aktivitetsanrop per körning: långt bortom vad de flesta användningsfall kräver.
Du kommer bara att nå denna gräns vid bulkbearbetning – till exempel vid iterering genom femtio tusen dokument i en enda körning. Fortsättningsmönstret, som beskrivs i nästa lektion, löser detta: arbetsflödet bearbetar en batch och startar sedan ett nytt arbetsflöde för nästa batch, vilket nollställer händelseräknaren.
Den andra gränsen gäller volym: den kumulativa storleken på alla händelser i en körning får inte överstiga 50 MB. Detta fylls snabbare om dina aktiviteter returnerar rika objekt, eftersom varje resultat skrivs till loggen. Samma reflex gäller – returnera en identifierare snarare än en fullständig struktur, lagra mellanresultat i en extern tjänst, paginera bearbetningen i batchar – och det räcker i de allra flesta fall.
Ingen I/O i arbetsflödet
Den sista raden i tabellen är inte en storleksbegränsning utan en designregel, som redan täckts under determinism. Arbetsflödeskod får inte innehålla några in-/utoperationsanrop: inga nätverksanrop (httpx, aiohttp, requests), ingen fil läsning eller skrivning (open, aiofiles), ingen databåtkomst och ingen läsning av miljövariabler för att styra förgreningar. Alla dessa operationer hör hemma i aktiviteter, vars resultat loggas och därför kan spelas upp identiskt.
Viktiga punkter
- 2 sekunder minsta latens mellan varje aktivitet – bunta ihop relaterade operationer
- 2 MB maximum per aktivitets in-/utdata – använd extern lagring för stora datamängder
- 51 200 händelser och 50 MB maximum per körning – använd fortsättningsmönstret för mycket långa arbetsflöden
- Ingen I/O i arbetsflödeskod – allt hör hemma i aktiviteter
- Dessa begränsningar härrör från den underliggande Temporal-arkitekturen och statusen Public Preview