Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Migração a partir do Magistral

Aula 8 de 12 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Onde está o seu código?
  2. Tabela de mapeamento
  3. O que muda no código
  4. Validação da migração
  5. Aproveitar ao máximo a migração
  6. Pontos-chave

Lição reescrita em 2 de novembro de 2026. Esta lição descrevia originalmente o raciocínio «sempre ativo» do Magistral. Como todos os modelos Magistral foram desativados em 31 de julho de 2026, cobre agora a migração para reasoning_effort. Fontes: Models — deprecated and removed models · Reasoning · Native reasoning (deprecated).

Onde está o seu código?

As versões mais recentes do Magistral, Small 1.2 e Medium 1.2 (-2509), foram preteridas na primavera de 2026 e desativadas em 31 de julho de 2026; as versões 1.0 e 1.1 já tinham sido desativadas em 30 de novembro de 2025. Qualquer código que ainda invoque magistral-small-latest, magistral-medium-latest ou um identificador datado dessa família está a apontar para um modelo que já não existe. A migração deixou de ser algo a planear: é algo a fazer agora.

Tabela de mapeamento

Estava a usarSubstituição designada pela MistralO que recomendamos hoje
Magistral Small (1.0, 1.1, 1.2)Mistral Small 4mistral-small-2603 com reasoning_effort="high"
Magistral Medium (1.0, 1.1, 1.2)Mistral Medium 3.5Small 4 se a qualidade for suficiente, caso contrário mistral-large-4-0 com reasoning_effort="high"

Por que não seguir à risca a substituição designada pela Mistral para o Magistral Medium? Porque o Mistral Medium 3.5 está ele próprio preterido desde 31 de outubro de 2026, com desativação agendada para 30 de abril de 2027, sendo o Large 4 o seu sucessor. Migrar para ele significa comprometer-se com uma segunda migração daqui a seis meses. O Large 4 está em Pré-visualização Pública: se esse nível de maturidade não se adequar ao seu ambiente de produção, o Medium 3.5 permanece uma possível etapa intermédia, desde que agende já a próxima troca.

O que muda no código

O Magistral raciocinava sempre; os modelos atuais só raciocinam quando lho pede. O equivalente natural de «sempre ativo» é, portanto, reasoning_effort="high".

# Antes: Magistral (desativado)
response = client.chat.complete(
    model="magistral-medium-latest",
    messages=[
        {"role": "system", "content": "You are a rigorous analyst."},
        {"role": "user", "content": question},
    ],
    prompt_mode=None,   # desativava o prompt de sistema padrão do Magistral
)

# Depois: Mistral Large 4 com raciocínio explícito
response = client.chat.complete(
    model="mistral-large-4-0",
    messages=[
        {"role": "system", "content": "You are a rigorous analyst."},
        {"role": "user", "content": question},
    ],
    reasoning_effort="high",
)

Quatro itens a tratar no processo:

  1. Identificadores de modelo: procure por magistral no seu código, ficheiros de configuração e variáveis de ambiente.
  2. prompt_mode: a documentação de raciocínio já não o menciona; remova-o das suas chamadas.
  3. Prompts de sistema: elimine o modelo de raciocínio específico do Magistral (o fragmento thinking colocado na mensagem de sistema) e mantenha apenas as instruções de método e formato (Lição 6).
  4. Leitura de respostas: a estrutura do Magistral 25.07 e 25.09 (ThinkChunk seguido de TextChunk) corresponde aos modelos atuais, pelo que o seu código de leitura permanece válido. Acrescente apenas o tratamento para o caso de cadeia de caracteres simples, que o Small 4 e o Medium 3.5 devolvem quando reasoning_effort="none". Se o seu código vinha do Magistral 25.06 e procurava tags <think> no texto, substitua-o pela função separer da Lição 3.

Validação da migração

Não mude às cegas. Reproduza uma amostra dos seus casos reais, juntamente com as suas respostas de referência, e compare três métricas: qualidade (precisão, conformidade do formato), tokens consumidos (usage.completion_tokens) e latência. Um script simples resolve a questão:

import time

def comparer(client, cas, configs):
    """cas: list of (question, verifier); configs: list of (model, level)."""
    for model, niveau in configs:
        justes = tokens = 0
        debut = time.perf_counter()
        for question, verifier in cas:
            r = client.chat.complete(
                model=model,
                messages=[{"role": "user", "content": question}],
                reasoning_effort=niveau,
            )
            _, reponse = separer(r.choices[0].message.content)
            justes += bool(verifier(reponse))
            tokens += r.usage.completion_tokens
        duree = time.perf_counter() - debut
        print(f"{model} ({niveau}) : {justes}/{len(cas)} correct, {tokens} tokens, {duree:.0f} s")

comparer(client, mes_cas, [
    ("mistral-small-2603", "high"),
    ("mistral-large-4-0", "medium"),
    ("mistral-large-4-0", "high"),
])

A função verifier depende do seu domínio: comparação com um valor esperado, presença de elementos obrigatórios ou validação de JSON. É isto que transforma uma impressão numa decisão.

Aproveitar ao máximo a migração

Já que vai tocar em todas as chamadas de modelo, use esta oportunidade para fixar identificadores datados em produção (mistral-small-2603 em vez de mistral-small-latest) e para centralizar a escolha do modelo e do nível de raciocínio numa única configuração. A próxima preterição — e haverá uma — será então uma correção de uma linha.

Pontos-chave

  • O Magistral foi desativado em 31 de julho de 2026: qualquer chamada remanescente visa um modelo indisponível
  • Magistral Small → Small 4; Magistral Medium → Small 4 ou Large 4 em vez do Medium 3.5, que está ele próprio preterido
  • «Sempre ativo» traduz-se por reasoning_effort="high"
  • Remova prompt_mode e o modelo de raciocínio dos prompts de sistema
  • Valide nos seus casos reais (qualidade, tokens, latência) e, em seguida, fixe os identificadores datados