Limitazioni della Piattaforma
In questa pagina
Conosci i Limiti
La piattaforma Mistral Workflows è in Public Preview (ad aprile 2026). Come qualsiasi sistema di orchestrazione, impone vincoli tecnici che devi comprendere per progettare flussi di lavoro robusti. Questi limiti non sono semplici note a piè di pagina nella documentazione; si manifestano in produzione, spesso nelle fasi finali, sotto forma di errori di serializzazione o flussi di lavoro terminati inaspettatamente senza alcun avviso nel tuo codice. Conoscerli in anticipo cambia il modo in cui strutturi la tua logica di elaborazione.
La tabella seguente riassume i vincoli principali e la conseguenza concreta del superamento di ciascuno di essi.
| Limitazione | Valore | Conseguenza se superato |
|---|---|---|
| Ritardo tra le attività | 2 secondi | Latenza inevitabile tra ogni chiamata di attività |
| Input/output per invocazione | 2 MB | Errore di serializzazione, il flusso di lavoro fallisce |
| Eventi per esecuzione | 51.200 | Flusso di lavoro terminato forzatamente |
| Dimensione totale per esecuzione | 50 MB | Flusso di lavoro terminato forzatamente |
| Timeout predefinito | 1 ora | Flusso di lavoro annullato (configurabile fino a 7 giorni) |
| Timeout massimo | 7 giorni | Flusso di lavoro annullato automaticamente |
| I/O nei flussi di lavoro | Vietato | Errore di non determinismo durante il replay |
Due Secondi tra Ogni Attività
La piattaforma impone un ritardo minimo di 2 secondi tra le chiamate alle attività. Questa latenza non è un problema di gioventù; è intrinseca all’architettura di orchestrazione, che persiste ogni evento prima di procedere. È il prezzo della durabilità.
L’impatto è facile da calcolare e spesso sorprendente. Un flusso di lavoro che concatena dieci attività sequenziali consuma almeno venti secondi di tempo di orchestrazione, indipendentemente dalla durata delle attività stesse. Se ogni attività viene eseguita in cinquanta millisecondi, hai progettato un lavoro da mezzo secondo che impiega venti secondi per restituire un risultato.
La soluzione consiste nel raggruppare le operazioni che non devono essere separate in un’unica attività. Confronta queste due versioni della stessa pipeline NLP.
# SUBOTTIMALE: 3 attività = 6 secondi di latenza di orchestrazione
@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
# OTTIMIZZATO: 1 attività = 2 secondi di latenza di orchestrazione
@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)
La regola per la suddivisione diventa semplice: crea un’attività separata solo se hai bisogno della garanzia di persistenza tra due operazioni. Se due operazioni possono fallire insieme senza causare problemi—come la tokenizzazione locale e il calcolo degli embedding concatenati in memoria—raggruppale.
Due Megabyte per Invocazione
Ogni chiamata di attività è limitata a 2 MB per l’input e 2 MB per l’output, basandosi sulla rappresentazione JSON serializzata dei dati. Un report PDF, un insieme di immagini o un’esportazione CSV di grandi dimensioni supereranno facilmente questo limite, causando il fallimento del flusso di lavoro con un errore di serializzazione.
La soluzione si riassume in una frase: passa riferimenti, mai payload. L’attività scarica i dati dallo storage esterno, li elabora localmente (dove è limitata solo dalla memoria del worker) e restituisce l’URL del risultato.
@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
"""Scarica, elabora e ricarica il file.
Solo gli URL passano attraverso il flusso di lavoro."""
async with httpx.AsyncClient() as client:
# Scarica da S3/GCS
response = await client.get(fichier_url)
contenu = response.content # Potrebbe essere 100 MB
# Elabora il file
resultat = traiter(contenu)
# Carica il risultato
await client.put(
"https://storage.example.com/résultats/output.json",
content=resultat
)
return {"url_resultat": "https://storage.example.com/résultats/output.json"}
Il Budget di Eventi e Volume
Ogni esecuzione è limitata a 51.200 eventi. La piattaforma genera un evento per ogni avvio di attività, ogni completamento di attività, ogni segnale ricevuto e ogni timer attivato. In pratica, una chiamata di attività costa circa due o tre eventi una volta contati i metadati, portando un flusso di lavoro di cento attività intorno ai 250-300 eventi. In altre parole, il limite consente dalle quindici alle ventimila chiamate di attività per esecuzione: molto oltre ciò che la maggior parte dei casi d’uso richiede.
Raggiungerai questo limite solo con l’elaborazione in blocco—ad esempio, iterando su cinquantamila documenti in un’unica esecuzione. Il pattern di continuazione, dettagliato nella prossima lezione, risolve il problema: il flusso di lavoro elabora un batch, quindi avvia un nuovo flusso di lavoro per il batch successivo, azzerando il contatore degli eventi.
Il secondo limite riguarda il volume: la dimensione cumulativa di tutti gli eventi in un’esecuzione non deve superare i 50 MB. Questo limite si riempie più velocemente se le tue attività restituiscono oggetti ricchi, poiché ogni risultato viene scritto nel log. Si applica lo stesso riflesso: restituisci un identificatore piuttosto che una struttura completa, archivia i risultati intermedi in un servizio esterno, pagina l’elaborazione in batch; nella stragrande maggioranza dei casi, questo è sufficiente.
Nessun I/O nel Flusso di Lavoro
L’ultima riga della tabella non è un limite dimensionale, ma una regola di progettazione, già trattata sotto il determinismo. Il codice del flusso di lavoro non deve contenere operazioni di input/output: nessuna chiamata di rete (httpx, aiohttp, requests), nessuna lettura o scrittura di file (open, aiofiles), nessun accesso al database e nessuna lettura di variabili d’ambiente per guidare la ramificazione. Tutte queste operazioni risiedono nelle attività, i cui risultati vengono registrati e quindi riproducibili in modo identico.
Punti chiave
- 2 secondi di latenza minima tra ogni attività: raggruppa le operazioni correlate
- 2 MB massimi per input/output di ogni attività: usa lo storage esterno per i dati di grandi dimensioni
- 51.200 eventi e 50 MB massimi per esecuzione: usa il pattern di continuazione per flussi di lavoro molto lunghi
- Nessun I/O nel codice del flusso di lavoro: tutto va nelle attività
- Queste limitazioni derivano dall’architettura Temporal sottostante e dallo stato di Public Preview