Source: https://ailoot.ai/models/pt-pt/mistralai-mistral-medium-3-5-u003a-batch/
Canonical: https://ailoot.ai/models/pt-pt/mistralai-mistral-medium-3-5-u003a-batch/
Language: pt-pt

# Mistral: Mistral Medium 3.5 (batch)

[Markdown](https://ailoot.ai/models/pt-pt/mistralai-mistral-medium-3-5-u003a-batch/index.md) · [JSON](https://ailoot.ai/models/pt-pt/mistralai-mistral-medium-3-5-u003a-batch/facts.json)

## [Mistral: Mistral Medium 3.5 (batch)](https://ailoot.ai/models/pt-pt/mistralai-mistral-medium-3-5-u003a-batch/)

Mistral Medium 3.5 combina seguimento de instruções, raciocínio e programação num modelo denso de texto e imagem com 128 mil milhões de parâmetros. Tem um contexto de 256k indicado pelo fabricante, definições de raciocínio por pedido, chamadas nativas de funções e saída estruturada para fluxos documentais e com agentes.

- [**Ailoot Ultra · Processamento em lote** `POST /v1/batches` `mistralai/mistral-medium-3-5:batch`](https://ailoot.ai/models/pt-pt/mistralai-mistral-medium-3-5-u003a-batch/#method-0)

Sobre o modelo

Esta descrição apresenta as capacidades do modelo. As entradas, saídas e opções disponíveis no Ailoot para o método selecionado estão indicadas abaixo.

Mistral Medium 3.5 é o modelo denso de 128 mil milhões de parâmetros da Mistral AI que combina seguimento de instruções, raciocínio e programação num único conjunto de pesos. Recebe texto e imagens e devolve texto. O fabricante destina-o a tarefas com agentes e programação, embora o mesmo ponto de controlo possa produzir uma resposta direta de conversa ou usar o modo de raciocínio documentado para uma tarefa mais exigente.

Modelo unificado e capacidades visuais

A ficha publicada especifica 128 mil milhões de parâmetros densos e uma janela de contexto de 256k. O codificador visual é treinado para lidar com diferentes dimensões e proporções de imagem. As imagens podem fornecer elementos de prova para tarefas de programação ou documentos: uma captura de ecrã de uma interface, um diagrama que acompanha um requisito ou uma página com informação que o modelo deve interpretar. O resultado pode ser uma explicação escrita, código ou campos estruturados, em vez de uma imagem gerada.

O fabricante descreve suporte multilingue para dezenas de línguas, incluindo inglês, francês, espanhol, alemão, italiano, português, neerlandês, chinês, japonês, coreano e árabe. Destaca também o cumprimento de instruções de sistema e chamadas nativas de funções com saída JSON. Defina o público, a língua e as regras de resposta separadamente do material examinado, para que a formulação de um documento de origem continue a servir como elemento de prova para a tarefa.

Definições de raciocínio

A ficha documenta dois valores de esforço de raciocínio por pedido. O valor none produz uma resposta orientada por instruções sem modo de raciocínio; high ativa o raciocínio e é recomendado para prompts complexos e programação com agentes. Trata-se de uma escolha de modo dentro do mesmo ponto de controlo Medium 3.5, e não de outra identidade de modelo.

Para esforço de raciocínio high, o fabricante recomenda temperature 0.7 e top-p 0.95. Para none, documenta temperaturas entre 0.0 e 0.7 conforme a tarefa e deixa top-p por definir ou em 1.0. São recomendações da versão. Escolha primeiro a finalidade da saída: uma extração concisa de campos, uma alteração de código com explicação ou uma comparação que exija várias decisões justificadas.

Uma tarefa prática de raciocínio pode fornecer um requisito, a implementação e a entrada que revela uma divergência. Peça ao modelo que identifique o percurso relevante, explique a discrepância e proponha a menor alteração que preserve a interface pública. Peça o código revisto separadamente das hipóteses e dos exemplos. O modelo gera uma proposta; compilar, executar e aplicar exigem o ambiente de desenvolvimento ligado ao agente.

Ferramentas, documentos e edições previsíveis

A ficha do serviço do fabricante enumera também saídas estruturadas, saídas previstas, perguntas sobre documentos, prefixos de resposta, processamento em lote e conversas com agentes. Para extração, defina os nomes dos campos, os tipos e o tratamento dos valores em falta. O modo JSON fornece uma representação estruturada, enquanto um esquema personalizado define um formato mais específico na interface ligada. Peça apenas o registo quando um programa o for analisar e uma explicação separada quando uma pessoa precisar de inspecionar a interpretação.

As perguntas sobre documentos combinam texto e estrutura preparados por OCR com a compreensão do modelo de linguagem. Para uma comparação, identifique os documentos e a condição a avaliar, pedindo depois cada conclusão com a localização da respetiva fonte. Uma saída útil pode separar requisitos comuns, divergências e questões em aberto. Perguntas diretas sobre imagens podem focar uma etiqueta de gráfico ou um elemento de interface; preservar títulos, unidades e papéis das imagens ajuda a manter a resposta ligada ao material fornecido.

As saídas previstas estão documentadas para tarefas em que grande parte da resposta pretendida já é conhecida, como regenerar um ficheiro de código ou documento com edições limitadas. Forneça o conteúdo existente e identifique a alteração específica, preservando as partes que devem permanecer. Isto difere de pedir um artefacto inteiramente novo ou de continuar a partir de um prefixo de resposta conhecido. As funcionalidades do serviço descrevem opções de submissão e formatação; não alteram as entradas de texto e imagem nem a saída textual do modelo.

Num fluxo assistido por ferramentas, a aplicação fornece descrições e parâmetros das funções, o modelo escolhe uma função e prepara argumentos, e a aplicação executa-a e devolve o resultado. Uma ferramenta de cálculo pode receber valores lidos de uma imagem fornecida, enquanto uma ferramenta de consulta pode fornecer a informação em falta para a resposta seguinte. Mantenha o resultado da ferramenta associado à operação que o produziu. O raciocínio com agentes depende desse ambiente, não de a geração de texto executar por si só ações externas.

Preparação de sessões longas

Use o contexto de 256k para código-fonte relacionado, documentos e histórico da conversa, mantendo explícito o objetivo efetivo. Uma sessão de programação pode reter o módulo, quem o chama e os requisitos, pedindo uma alteração definida. Uma sessão documental pode manter juntas as secções relevantes e devolver uma tabela curta ou um trecho revisto. A capacidade de contexto não especifica um comprimento máximo de resposta separado; o exemplo de geração de 1 024 tokens da ficha é uma ilustração, não esse limite.

O fabricante indica que uma configuração publicada anterior continha um erro de contexto longo e que este foi corrigido, incluindo a sua relevância para pontos de controlo derivados. Preserve a configuração corrigida da versão ao usar os pesos em sessões longas. Os modos híbridos e a arquitetura de 128 mil milhões de parâmetros do Medium 3.5 não devem ser atribuídos ao Medium 3.1 nem a um ponto de controlo de cabeça de previsão com nome próprio apenas por partilharem a família.

**Ailoot Ultra · Processamento em lote** `POST /v1/batches` `mistralai/mistral-medium-3-5:batch`

[`mistralai/mistral-medium-3-5:batch`](https://ailoot.ai/models/pt-pt/#m=mistralai%2Fmistral-medium-3-5%3Abatch&route=Ultra&caller=mistralai%2Fmistral-medium-3-5%3Abatch&fmt=batches)

Mistral /`mistralai/mistral-medium-3-5:batch`

### Introdução

Mistral Medium 3.5 combina seguimento de instruções, raciocínio e programação num modelo denso de texto e imagem com 128 mil milhões de parâmetros. Tem um contexto de 256k indicado pelo fabricante, definições de raciocínio por pedido, chamadas nativas de funções e saída estruturada para fluxos documentais e com agentes.

Entradas aceites

Texto

Resultados

Texto

### Disponível no Ailoot · entradas e métodos

**Ailoot Ultra · Processamento em lote** `POST /v1/batches`

Entrada

`text`

Saída

`text`

Formato de saída

JSON em linha de results\[\].response.body

| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`endpoint` | Tipo`string` | RequisitoObrigatório | Valores e limites /v1/chat/completions | Predefinição— |
| Campo`model` | Tipo`string` | RequisitoObrigatório | Valores e limites mistralai/mistral-medium-3-5:batch | Predefinição— |
| Campo`requests` | Tipo`batch_item[]` | RequisitoObrigatório | Valores e limites Número mínimo de elementos: 1 | Predefinição— |
| Campo`requests[].custom_id` | Tipo`string` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`requests[].body.messages` | Tipo`message[]` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`completion_window` | Tipo`string` | RequisitoOpcional | Valores e limites 24h | Predefinição— |
| Campo`provider` | Tipo`object\|null` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`requests[].body.model` | Tipo`string` | RequisitoOpcional | Valores e limites mistralai/mistral-medium-3-5:batch, mistralai/mistral-medium-3-5 | Predefinição— |
| Campo`provider.only` | Tipo`string[]` | RequisitoOpcional | Valores e limites mistral | Predefinição— |
| Campo`provider.allow_fallbacks` | Tipo`boolean\|null` | RequisitoOpcional | Valores e limites false, null | Predefinição— |

Parâmetros e ciclo de vida do método

| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`required` | Contratoendpoint, model, requests |
| Parâmetro`material_types` | Contratotext |
| Parâmetro`representation` | Contratorequests\[\] em linha; cada item tem custom\_id e body |
| Parâmetro`request_endpoint_profile` | Contrato/v1/chat/completions |
| Parâmetro`file_material` | ContratoQuem faz a chamada pode ler localmente o conteúdo JSONL UTF-8 efetivo para requests\[\]. Não é utilizada qualquer finalidade de carregamento, input\_file\_id ou referência a ficheiro. Se o material do cliente estiver em falta ou vazio, a preparação é interrompida antes do POST. |
| Parâmetro`serialization_order` | Contratoendpoint, model, provider (se fornecido), completion\_window (se fornecido), requests em último lugar |
| Parâmetro`optional_controls` | Contratoprovider.only, provider.allow\_fallbacks, completion\_window |
| Parâmetro`schema_scope` | ContratoCorpos de pedidos de texto de Chat Completions na estrutura de lote em linha documentada. |

Ciclo de vida: `asynchronous`

`GET /v1/batches/{operation_id}` · response.id efetivo da resposta original de criação; mesmo utilizador/chave/grupo

### Tarifários

As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.

Modo rápido

Não especificado Quando o modo rápido está selecionado

Modo flex

Não especificado Quando o modo flex está selecionado

Esforço máximo de raciocínio

Não especificado Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)

Preços da cache explícita

Não ativado Quando é pedida cache explícita

#### Tarifas Ailoot

#### Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

| Configuração | Tabela de tarifas | Tokens de contexto, mais de | Tokens de contexto, até ao limite inclusive | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoTarifas base dos tokens | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.0015** / 1K tokens Saída · Tokens de saída **$0.0075** / 1K tokens Entrada · Leitura da cache **—** / 1K tokens Entrada · Escrita na cache **—** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoEscalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.0015** / 1K tokens Saída · Tokens de saída **$0.0075** / 1K tokens Entrada · Leitura da cache **—** / 1K tokens Entrada · Escrita na cache **—** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |

O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)

### Exemplos de pedidos

#### Ailoot Ultra · Processamento em lote

curl · dados de teste preservadosPython HTTP · JSONL real do clientePython · guarde cada resultado concluído

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json
from pathlib import Path
body=json.loads('{"endpoint":"/v1/chat/completions","model":"mistralai/mistral-medium-3-5:batch","requests":[{"custom_id":"req-0001","body":{"messages":[{"role":"user","content":"Hello!"}],"max_tokens":16}}]}')
Path("batch-request.json").write_text(json.dumps(body,ensure_ascii=False),encoding="utf-8")
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/batches \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @batch-request.json -D batch-response-headers.txt -o batch-create-response.json
```

```python
import json, os
from pathlib import Path
from urllib.request import Request, urlopen

def prepare_requests(customer_path):
    path = Path(customer_path)
    if not path.is_file(): raise ValueError("Customer JSONL file is missing")
    items = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
    if not items: raise ValueError("Customer JSONL contains no requests")
    ids = set()
    for item in items:
        if set(item) != {"custom_id", "body"}: raise ValueError("Each item needs custom_id and body")
        cid = item["custom_id"]
        if not isinstance(cid, str) or not cid.strip() or cid in ids: raise ValueError("custom_id must be nonempty and unique")
        ids.add(cid)
        if not isinstance(item["body"], dict) or not item["body"].get("messages"): raise ValueError("Supply actual text messages")
        supplied_model = item["body"].get("model")
        if supplied_model is not None and supplied_model not in ['mistralai/mistral-medium-3-5:batch', 'mistralai/mistral-medium-3-5']: raise ValueError("body.model must be an exact documented caller or wire ID")
    return {"endpoint":"/v1/chat/completions", "model":"mistralai/mistral-medium-3-5:batch", "requests":items}

if __name__ == "__main__":
    material = os.environ.get("AILOOT_BATCH_REQUESTS_JSONL", "")
    if not material: raise SystemExit("Set AILOOT_BATCH_REQUESTS_JSONL to your actual customer file")
    body = prepare_requests(material)
    key = os.environ.get("AILOOT_API_KEY", "")
    if not key: raise SystemExit("Set AILOOT_API_KEY")
    request = Request("https://api.ailoot.ai/v1/batches", data=json.dumps(body, ensure_ascii=False).encode("utf-8"), headers={"Authorization":"Bearer " + key, "Content-Type":"application/json"}, method="POST")
    with urlopen(request) as response:
        raw = response.read()
        Path("batch-create-response.json").write_bytes(raw)
        print(raw.decode("utf-8"))
```

```python
import json
from pathlib import Path
raw = Path("batch-status-response.json").read_bytes()
response = json.loads(raw)
if response.get("status") != "completed":
    raise SystemExit("Keep the original operation; read its status without resubmitting")
results = response.get("results")
if not isinstance(results, list) or not results:
    raise SystemExit("Preserve the original response; completed results are missing")
Path("batch-results.jsonl").write_text("".join(json.dumps(item, ensure_ascii=False) + "\n" for item in results), encoding="utf-8")
# Preserve batch-status-response.json with aggregate usage and every result/error.
```

### Receber e guardar os resultados

#### Ailoot Ultra · Processamento em lote

JSON em linha de results\[\].response.body

- `GET /v1/batches/{operation_id}`

##### Verificar o estado da tarefa

curl · estado da operação original

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
BATCH_OPERATION_ID="$(python3 - <<'PY_ID'
import json
from pathlib import Path
from urllib.parse import quote
response = json.loads(Path("batch-create-response.json").read_text(encoding="utf-8"))
operation = response.get("id")
if not isinstance(operation, str) or not operation: raise SystemExit("No actual original operation ID; preserve the response and do not resubmit")
print(quote(operation, safe=""))
PY_ID
)"
curl --fail-with-body --silent --show-error "https://api.ailoot.ai/v1/batches/$BATCH_OPERATION_ID" \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o batch-status-response.json
```

##### Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Conserve o JSON completo do estado original, todos os resultados/custom\_id e o corpo completo da resposta ou do erro. Guarde os results\[\] concluídos em formato JSONL, sem filtrar.

##### Se for necessário verificar a resposta original

Preserve o ID original da operação. A resposta 503 result\_pending\_check inclui X-Should-Retry:false; nunca volte a enviar um lote original de estado desconhecido.

Campos da resposta

| Campo | Tipo |
| --- | --- |
| Campo`results[].custom_id` | Tipostring |
| Campo`results[].response.body.choices[].message.content` | Tipostring\|null |
| Campo`results[].error` | Tipoobject\|null |
| Campo`usage` | Tipoobject\|null |
| Campo`id` | Tipostring |
| Campo`model` | Tipostring |
| Campo`endpoint` | Tipostring |
| Campo`status` | Tipostring |
| Campo`request_counts` | Tipoobject |
| Campo`results[].id` | Tipostring |
| Campo`results[].response.status_code` | Tipointeger |
| Campo`results[].response.request_id` | Tipostring |

Erros e passos seguintes

| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoEstrutura em linha documentada inválida, chaves duplicadas, identidade do item inválida ou conflito com as capacidades configuradas do modelo. | Passo seguinteCorrija os campos indicados antes de qualquer novo envio. |
| Resposta401 · `authentication_error` | CondiçãoChave de API inválida. | Passo seguinteUse a chave Ailoot autorizada. |
| Resposta403 · `permission_error` | CondiçãoGrupo de processamento em lote indisponível. | Passo seguinteVerifique os direitos de acesso da chave/do grupo. |
| Resposta422 · `invalid_request_error` | CondiçãoO processamento em lote usa faturação por débito do saldo; a criação com subscrição é rejeitada. | Passo seguinteUse o grupo autorizado com faturação por débito do saldo. |
| Resposta422 · `price_unavailable` | CondiçãoNão é possível calcular uma estimativa de preço para os dados de entrada do lote. | Passo seguinteConserve a resposta; use os dados de entrada documentados para a família. |
| Resposta402 · `billing_error` | CondiçãoReserva para processamento em lote indisponível. | Passo seguinteResolva a questão da admissão antes de um novo pedido. |
| Resposta503 · `price_unavailable` | CondiçãoPreço do método de processamento em lote/tarifas nativas indisponíveis. | Passo seguinteConserve a resposta; não substitua os preços. |
| Resposta503 · `api_error` | CondiçãoA rota exata do fornecedor está indisponível. | Passo seguinteConserve a resposta para corrigir a rota. |
| Resposta503 · `result_pending_check` | CondiçãoO resultado original requer verificação; X-Should-Retry:false. | Passo seguinteGuarde o operation\_id/id original e consulte o respetivo estado; nunca repita o POST original. |
| Resposta404 · `not_found` | CondiçãoA operação de consulta do estado do lote não existe ou pertence a outra identidade. | Passo seguinteUse o id original exato e o mesmo utilizador/chave/grupo. |

### Aliases

#### Aliases do modelo

**Ailoot Ultra** [`mistralai/mistral-medium-3-5:batch`](https://ailoot.ai/models/pt-pt/#m=mistralai%2Fmistral-medium-3-5%3Abatch&route=Ultra&caller=mistralai%2Fmistral-medium-3-5%3Abatch&fmt=batches)

#### Aliases dos caminhos dos métodos

Use os caminhos dos métodos indicados acima.

#### IDs de chamada relacionados

[`mistralai/mistral-medium-3-5:batch`](https://ailoot.ai/models/pt-pt/#m=mistralai%2Fmistral-medium-3-5%3Abatch&route=Ultra&caller=mistralai%2Fmistral-medium-3-5%3Abatch&fmt=batches)

FAQ · Mistral: Mistral Medium 3.5 (batch)

Que entradas e resultados estão disponíveis?

`POST /v1/batches` · `mistralai/mistral-medium-3-5:batch`: `text` → `text`

Que campos utiliza o pedido?

`POST /v1/batches` · `mistralai/mistral-medium-3-5:batch`: `endpoint`, `model`, `requests`, `completion_window`, `provider`

Que limites se aplicam?

`POST /v1/batches` · `mistralai/mistral-medium-3-5:batch`: `requests.min_items`: `1`

Ligue o Ailoot ao Claude Code, OpenCode, Hermes ou à sua aplicação.

## A empresa e a sua carteira de projetos

A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.

## Compre tokens com desconto.

Desconto por subscrição para trabalho regular. Códigos promocionais — até 50% na compra de tokens.

Subscrição

Escolha um plano com desconto para os pedidos regulares.

Código promocional até 50%

Introduza o código na compra. O preço é recalculado conforme a campanha em vigor.

Custos no histórico

O modelo, os tokens e o montante são guardados para cada pedido.

[Escolher subscrição](https://ailoot.ai/docs/pt-pt/billing/subscriptions/) · [Ver preços dos modelos](https://ailoot.ai/models/pt-pt/)

## Ligue a API ao produto que vende.

SaaS, aplicações e bots — ao abrigo da oferta e do contrato de licença Ailoot. Para revenda, peça uma licença de revendedor.

Aplicação comercial

Integre geração de texto, imagens, vídeo e som nas funcionalidades pagas do seu serviço.

Licença de revendedor

Envie uma descrição do projeto e do modelo de acesso. Peça condições escritas de utilização e revenda.

Documentos no site

A oferta, o contrato de licença e a política de tratamento de dados estão disponíveis antes da ligação.

[Pedir licença de revendedor](mailto:support@ailoot.ai) · [Oferta e contrato de licença](https://ailoot.ai/legal/offer?lang=pt-pt)

## Ailoot · A empresa e a sua carteira de projetos





A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.





A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.





A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.
