Limitações da Plataforma
Nesta página
Conheça os Limites
A plataforma Mistral Workflows encontra-se em Pré-visualização Pública (a partir de abril de 2026). Tal como qualquer sistema de orquestração, impõe restrições técnicas que deve compreender para desenhar fluxos de trabalho robustos. Estes limites não são meras notas de rodapé na documentação; manifestam-se em produção, muitas vezes tardiamente, sob a forma de erros de serialização ou fluxos de trabalho terminados inesperadamente sem qualquer aviso no seu código. Conhecê-los antecipadamente altera a forma como estrutura a sua lógica de processamento.
A tabela abaixo resume as principais restrições e a consequência concreta de exceder cada uma delas.
| Limitação | Valor | Consequência se excedido |
|---|---|---|
| Atraso entre atividades | 2 segundos | Latência inevitável entre cada chamada de atividade |
| Entrada/saída por invocação | 2 MB | Erro de serialização, o fluxo de trabalho falha |
| Eventos por execução | 51.200 | Fluxo de trabalho terminado à força |
| Tamanho total por execução | 50 MB | Fluxo de trabalho terminado à força |
| Tempo limite padrão | 1 hora | Fluxo de trabalho cancelado (configurável até 7 dias) |
| Tempo limite máximo | 7 dias | Fluxo de trabalho cancelado automaticamente |
| E/S nos fluxos de trabalho | Proibido | Erro de não determinismo durante a repetição |
Dois Segundos Entre Cada Atividade
A plataforma impõe um atraso mínimo de 2 segundos entre chamadas de atividade. Esta latência não é um problema inicial; é inerente à arquitetura de orquestração, que persiste cada evento antes de prosseguir. É o preço da durabilidade.
O impacto é fácil de calcular e frequentemente surpreendente. Um fluxo de trabalho que encadeia dez atividades sequenciais consome pelo menos vinte segundos de tempo de orquestração, independentemente do tempo que as próprias atividades demoram. Se cada atividade for executada em cinquenta milissegundos, concebeu uma tarefa de meio segundo que leva vinte segundos para devolver um resultado.
A solução consiste em agrupar operações que não precisam de ser separadas numa única atividade. Compare estas duas versões do mesmo pipeline de PLN.
# SUBÓTIMO: 3 atividades = 6 segundos de latência de orquestração
@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
# OTIMIZADO: 1 atividade = 2 segundos de latência de orquestração
@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)
A regra para a divisão torna-se simples: crie uma atividade separada apenas se necessitar da garantia de persistência entre duas operações. Se duas operações puderem falhar em conjunto sem causar problemas — como a tokenização local e o cálculo de incorporações encadeados na memória — agrupe-as.
Dois Megabytes Por Invocação
Cada chamada de atividade está limitada a 2 MB para entrada e 2 MB para saída, com base na representação JSON serializada dos dados. Um relatório em PDF, um conjunto de imagens ou uma grande exportação CSV excederão facilmente este limite, fazendo com que o fluxo de trabalho falhe com um erro de serialização.
A solução resume-se a uma frase: passe referências, nunca cargas úteis. A atividade transfere os dados do armazenamento externo, processa-os localmente (onde está limitada apenas pela memória do worker) e devolve o URL do resultado.
@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
"""Transferir, processar e voltar a carregar o ficheiro.
Apenas os URLs passam pelo fluxo de trabalho."""
async with httpx.AsyncClient() as client:
# Transferir do S3/GCS
response = await client.get(fichier_url)
contenu = response.content # Pode ser 100 MB
# Processar o ficheiro
resultat = traiter(contenu)
# Carregar o resultado
await client.put(
"https://storage.example.com/résultats/output.json",
content=resultat
)
return {"url_resultat": "https://storage.example.com/résultats/output.json"}
O Orçamento de Eventos e Volume
Cada execução está limitada a 51.200 eventos. A plataforma gera um evento para cada início de atividade, cada conclusão de atividade, cada sinal recebido e cada temporizador acionado. Na prática, uma chamada de atividade custa cerca de dois a três eventos uma vez contados os metadados, colocando um fluxo de trabalho de cem atividades à volta de 250 a 300 eventos. Por outras palavras, o limite permite quinze a vinte mil chamadas de atividade por execução: muito além do que a maioria dos casos de uso requer.
Só atingirá este limite com processamento em massa — por exemplo, iterando sobre cinquenta mil documentos numa única execução. O padrão de continuação, detalhado na próxima lição, resolve isto: o fluxo de trabalho processa um lote e, em seguida, lança um novo fluxo de trabalho para o lote seguinte, redefinindo o contador de eventos.
O segundo limite diz respeito ao volume: o tamanho cumulativo de todos os eventos numa execução não deve exceder 50 MB. Este limite é atingido mais rapidamente se as suas atividades devolverem objetos ricos, uma vez que cada resultado é escrito no registo. Aplica-se o mesmo reflexo — devolva um identificador em vez de uma estrutura completa, armazene resultados intermédios num serviço externo, paginate o processamento em lotes — e isso é suficiente na vasta maioria dos casos.
Sem E/S no Fluxo de Trabalho
A última linha da tabela não é um limite de dimensionamento, mas sim uma regra de conceção, já abordada sob o tópico do determinismo. O código do fluxo de trabalho não deve conter operações de entrada/saída: sem chamadas de rede (httpx, aiohttp, requests), sem leitura ou escrita de ficheiros (open, aiofiles), sem acesso à base de dados e sem leitura de variáveis de ambiente para orientar ramificações. Todas estas operações residem em atividades, cujos resultados são registados e, portanto, repetíveis de forma idêntica.
Pontos-chave
- 2 segundos de latência mínima entre cada atividade — agrupe operações relacionadas
- 2 MB máximo por entrada/saída de atividade — utilize armazenamento externo para dados volumosos
- 51.200 eventos e 50 MB máximo por execução — utilize o padrão de continuação para fluxos de trabalho muito longos
- Sem E/S no código do fluxo de trabalho — tudo deve estar nas atividades
- Estas limitações decorrem da arquitetura Temporal subjacente e do estado de Pré-visualização Pública