A Mistral AI deixou de ser “a alternativa europeia” para se tornar uma opção séria para quem constrói produtos com IA. Depois de fechar uma ronda Série C de 1,7 mil milhões de euros liderada pela ASML em setembro de 2025 (a ASML sozinha injetou 1,3 mil milhões de euros), a empresa francesa atingiu uma avaliação de 11,7 mil milhões de euros, segundo dados da Sacra. Este tutorial mostra, passo a passo, como criar uma conta, autenticar pedidos, escolher o modelo certo e construir um chatbot com pesquisa aumentada por recuperação (RAG) completo, pronto a correr em produção.

Vais sair daqui com um projeto funcional em Python, código para streaming e function calling, uma tabela de preços real por modelo e uma checklist de segurança que evita os erros mais caros que os programadores cometem ao integrar a API Mistral AI. O tempo estimado para completar todos os passos é de 60 minutos.

Porque a Mistral AI importa para programadores europeus

Quando a Mistral AI foi fundada em 2023 por antigos investigadores da Meta e da Google DeepMind, o argumento de venda era simples: a Europa precisava de um fornecedor de modelos de fronteira que não dependesse de infraestrutura norte-americana. Três anos depois, esse argumento ganhou peso financeiro real. A ronda liderada pela ASML em setembro de 2025 não foi só dinheiro; trouxe um parceiro industrial europeu com interesse direto em manter a Mistral competitiva a longo prazo, algo que se reflete na velocidade a que a gama de modelos tem evoluído.

Para uma equipa de engenharia em Lisboa, Porto ou noutro ponto de Portugal, isto traduz-se em três vantagens práticas. Primeiro, a latência de rede tende a ser menor quando os pedidos ficam dentro da infraestrutura europeia. Segundo, os contratos empresariais já nascem alinhados com o RGPD, sem precisares de negociar cláusulas adicionais de transferência de dados. Terceiro, o preço por token do Mistral Small 4 ($0,15 de input, $0,60 de output por milhão de tokens) coloca-o entre os modelos mais baratos do mercado para tarefas de produção em grande volume, sem sacrificar qualidade a ponto de comprometer a experiência do utilizador.

Este tutorial assume que já decidiste experimentar a Mistral, seja por custo, por soberania de dados ou simplesmente por curiosidade técnica. A partir daqui é tudo mão na massa.

Pré-requisitos: contas, versões e ferramentas

Antes de avançar, confirma que tens o seguinte preparado. Cada item inclui a versão testada neste tutorial, para evitares incompatibilidades a meio do processo.

  • Conta na consola da Mistral AI (console.mistral.ai) com um método de pagamento registado, para desbloquear os limites de utilização acima do nível gratuito
  • Python 3.9 ou superior (recomenda-se 3.11+) ou Node.js 18 ou superior, dependendo da linguagem escolhida
  • SDK oficial mistralai versão 2.9.3 para Python, ou @mistralai/mistralai versão 2.6.3 para JavaScript/TypeScript
  • Um editor de código (VS Code, PyCharm ou equivalente)
  • Conhecimento básico de APIs REST, variáveis de ambiente e JSON
  • Opcional: a biblioteca numpy, usada no exemplo de pipeline RAG mais à frente

Com isto tratado, os próximos 12 passos levam-te da criação da chave de API até um chatbot RAG completo, com gestão de erros e segurança incluídas desde o início, não como um extra de última hora.

Passo 1: Criar conta e gerar a chave de API

Regista-te em console.mistral.ai com um email profissional. Depois de confirmar a conta, entra na secção “API Keys” e cria uma nova chave, dando-lhe um nome descritivo (por exemplo, chatbot-suporte-producao). A Mistral só mostra o valor completo da chave uma vez, por isso copia-a de imediato para um gestor de segredos ou para um ficheiro .env local que nunca será enviado para um repositório Git.

Cria um ficheiro .gitignore a incluir .env antes de escreveres qualquer código. Isto parece óbvio, mas chaves da Mistral publicadas acidentalmente no GitHub são uma das causas mais comuns de faturas inesperadas, porque bots automatizados varrem repositórios públicos à procura exatamente deste padrão.

# .env
MISTRAL_API_KEY=a_tua_chave_aqui

Passo 2: Instalar o SDK e preparar o ambiente

Cria um ambiente virtual isolado e instala o SDK oficial. Fixar a versão evita que uma atualização automática mude o comportamento do teu código sem aviso.

python3 -m venv venv
source venv/bin/activate
pip install mistralai==2.9.3 python-dotenv numpy

Se preferires JavaScript ou TypeScript, o equivalente é o pacote oficial @mistralai/mistralai, publicado no registo npm e atualmente na versão 2.6.3:

npm install @mistralai/mistralai dotenv

Passo 3: A primeira chamada de chat completion

Com o ambiente pronto, faz a primeira chamada real. O cliente autentica-se através de um cabeçalho Bearer contra o endpoint base https://api.mistral.ai/v1, mas o SDK trata disso automaticamente, bastando passar a chave no construtor.

import os
from dotenv import load_dotenv
from mistralai import Mistral

load_dotenv()
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

resposta = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "Explica o que é RAG em duas frases, em português de Portugal."}
    ],
)

print(resposta.choices[0].message.content)

Ao correr este script deves obter uma resposta em texto corrido, sem formatação extra, algo como: “RAG combina um modelo de linguagem com uma base de conhecimento externa, que é pesquisada em tempo real. Em vez de depender só da memória do modelo, o sistema injeta os documentos relevantes no pedido antes de gerar a resposta.” Se o script falhar aqui, salta já para a secção de resolução de problemas mais abaixo antes de continuares.

Passo 4: Escolher o modelo certo para a tarefa

A Mistral não tem um único modelo “para tudo”. Em 2026 a gama principal divide-se em três níveis de qualidade e custo, mais uma família de modelos leves chamada Ministral 3, pensada para tarefas rápidas e baratas como classificação, extração ou encaminhamento de pedidos. Escolher o modelo errado é, sozinho, a forma mais rápida de disparar a fatura no fim do mês.

ModeloInput / 1M tokensInput em cache / 1MOutput / 1M tokensContextoMelhor para
Mistral Large 3$0,50$0,05$1,50~128K tokensRaciocínio geral, tarefas complexas
Mistral Medium 3.5$1,50$0,15$7,50~131K tokensProdução equilibrada, qualidade alta
Mistral Small 4$0,15$0,015$0,60~128K tokensAlto volume, custo baixo
Ministral 3 14B$0,20$0,02$0,20~128K tokensTarefas leves, encaminhamento
Ministral 3 8B$0,15$0,015$0,15~128K tokensClassificação, etiquetagem
Ministral 3 3B$0,10$0,01$0,10~128K tokensChamadas utilitárias, filtros
Codestral$0,30$0,03$0,90~32K tokens (FIM)Geração e conclusão de código

Preços tirados diretamente da página oficial de preços da Mistral (docs.mistral.ai/inference/pricing), atualizada em agosto de 2026. Para começar um protótipo, usa sempre o alias -latest (como mistral-large-latest ou mistral-small-latest) em vez de fixar uma versão datada. Isto poupa-te de ter de reescrever código sempre que a Mistral lança uma versão nova do mesmo nível.

Como se compara o Large 3 a outros modelos de topo

Guias de referência de 2026 posicionam o Mistral Large 3 no grupo de topo dos modelos generalistas, próximo dos modelos de fronteira da OpenAI, Anthropic e Google em benchmarks de raciocínio padrão, com uma vantagem clara de preço por token face a esses concorrentes. Não existem, à data deste artigo, tabelas de benchmark independentes e totalmente atualizadas que cubram todos os modelos de fronteira lançados nos últimos meses, por isso a recomendação prática é simples: testa o Small 4 primeiro nas tuas próprias tarefas reais, e só sobes para o Large 3 se a qualidade não for suficiente. Um benchmark genérico raramente reflete com precisão o desempenho num caso de uso específico, como responder a perguntas sobre a tua própria base de conhecimento.

Passo 5: Ativar respostas em streaming

Para uma interface de chat, esperar pela resposta completa antes de mostrar qualquer texto cria uma sensação de lentidão. O streaming resolve isto, entregando o texto token a token à medida que é gerado.

stream = client.chat.stream(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Escreve três frases curtas sobre Lisboa."}],
)

for pedaco in stream:
    delta = pedaco.data.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

No terminal, o resultado aparece palavra a palavra em tempo real, em vez de surgir tudo de uma vez ao fim de dois ou três segundos. Numa interface web, cada fragmento (delta) deve ser enviado ao browser via Server-Sent Events ou WebSocket, e concatenado no lado do cliente.

Passo 6: Function calling para ligar a API a ações reais

Function calling (também chamado “tools”) permite que o modelo decida quando precisa de invocar uma função do teu sistema, como consultar uma base de dados ou uma API externa, em vez de inventar uma resposta. O modelo não executa código: devolve o nome da função e os argumentos, e o teu programa é que corre a lógica.

tools = [
    {
        "type": "function",
        "function": {
            "name": "obter_estado_encomenda",
            "description": "Devolve o estado atual de uma encomenda a partir do número",
            "parameters": {
                "type": "object",
                "properties": {
                    "numero_encomenda": {"type": "string"}
                },
                "required": ["numero_encomenda"],
            },
        },
    }
]

resposta = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Onde está a encomenda 45210?"}],
    tools=tools,
    tool_choice="auto",
)

chamada = resposta.choices[0].message.tool_calls[0]
print(chamada.function.name, chamada.function.arguments)

A saída típica é algo como obter_estado_encomenda {"numero_encomenda": "45210"}. O passo seguinte, que muitos tutoriais esquecem de mostrar, é correr a tua função real com esse argumento e devolver o resultado ao modelo numa nova mensagem com role: "tool", para que ele formule a resposta final em linguagem natural.

Passo 7: Gerar embeddings para pesquisa semântica

Embeddings transformam texto num vetor numérico que representa o seu significado. É a base de qualquer sistema RAG: em vez de procurar palavras exatas, comparas vetores para encontrar o conteúdo mais próximo em significado, mesmo que use palavras diferentes.

resposta_embed = client.embeddings.create(
    model="mistral-embed",
    inputs=["A política de reembolsos aplica-se durante 30 dias após a compra."],
)

vetor = resposta_embed.data[0].embedding
print(len(vetor))

Para embeddings especializados em código-fonte, a Mistral disponibiliza o modelo codestral-embed separadamente, a $0,15 por milhão de tokens de input, sem custo de output porque uma chamada de embeddings não gera texto novo. Não mistures vetores gerados por modelos diferentes no mesmo índice: a distância entre eles deixa de ter significado e a pesquisa passa a devolver resultados aleatórios.

Passo 8: Construir um pipeline RAG simples

Com chat completions e embeddings a funcionar, o próximo passo é juntá-los. Um pipeline RAG mínimo tem três fases: dividir o documento em blocos, gerar um vetor por bloco, e escolher o bloco mais relevante para a pergunta antes de a enviar ao modelo.

import numpy as np

def dividir_em_blocos(texto, palavras_por_bloco=200):
    palavras = texto.split()
    return [
        " ".join(palavras[i:i + palavras_por_bloco])
        for i in range(0, len(palavras), palavras_por_bloco)
    ]

def gerar_vetores(blocos):
    resp = client.embeddings.create(model="mistral-embed", inputs=blocos)
    return [np.array(item.embedding) for item in resp.data]

def bloco_mais_relevante(pergunta, blocos, vetores):
    vetor_pergunta = np.array(
        client.embeddings.create(model="mistral-embed", inputs=[pergunta]).data[0].embedding
    )
    pontuacoes = [np.dot(vetor_pergunta, v) for v in vetores]
    return blocos[int(np.argmax(pontuacoes))]

Este exemplo guarda tudo em memória, o que chega para protótipos e para bases de conhecimento pequenas (até algumas centenas de blocos). Para produção, troca a lista de vetores por uma base de dados vetorial dedicada, mas a lógica de divisão em blocos e de comparação de vetores mantém-se igual.

Para escolher onde guardar os vetores em produção, a decisão depende do volume de documentos e da infraestrutura que já usas. O Qdrant e o pgvector (uma extensão do PostgreSQL) são escolhas comuns quando já tens uma base de dados relacional e queres evitar adicionar mais um serviço à stack. O Chroma funciona bem para protótipos e volumes moderados, correndo localmente sem servidor dedicado. Nenhuma destas opções depende da Mistral: o pipeline que construíste acima gera os vetores, e a base de dados escolhida só trata do armazenamento e da pesquisa por semelhança, normalmente através de distância de cosseno ou produto interno, o mesmo cálculo que fizemos à mão com np.dot.

Passo 9: Projeto completo – chatbot de suporte com RAG

Agora junta tudo num script funcional: carrega uma base de conhecimento, recupera o bloco mais relevante e injeta-o no pedido de chat, para que o modelo responda com base em factos reais em vez de inventar.

base_conhecimento = """
A garantia dos produtos cobre 24 meses a partir da data de compra.
Devoluções são aceites em até 30 dias, com o produto na embalagem original.
O suporte técnico está disponível de segunda a sexta, das 9h às 18h.
"""

blocos = dividir_em_blocos(base_conhecimento)
vetores = gerar_vetores(blocos)

def responder(pergunta_utilizador):
    contexto = bloco_mais_relevante(pergunta_utilizador, blocos, vetores)
    resposta = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {
                "role": "system",
                "content": f"Responde apenas com base neste contexto: {contexto}",
            },
            {"role": "user", "content": pergunta_utilizador},
        ],
    )
    return resposta.choices[0].message.content

print(responder("Quanto tempo tenho para devolver um produto?"))

A resposta esperada é algo como: “Tens até 30 dias após a compra para devolver o produto, desde que esteja na embalagem original.” Nota que usámos mistral-small-latest aqui, não o modelo mais caro: para responder com base num contexto já fornecido, um modelo pequeno costuma chegar, e isso reduz o custo por pedido em cerca de 60% face ao Large 3.

Passo 10: Gerir limites de taxa e erros de forma resiliente

A documentação da Mistral não publica valores exatos de pedidos por minuto para cada plano, mas confirma que contas gratuitas têm limites mais apertados do que contas pagas. Na prática, isto significa que o teu código tem de tratar o erro HTTP 429 como algo normal, não excecional, e voltar a tentar com um atraso crescente.

import time
from mistralai.models import SDKError

def chamar_com_retentativas(mensagens, modelo="mistral-large-latest", tentativas=4):
    atraso = 1
    for tentativa in range(tentativas):
        try:
            return client.chat.complete(model=modelo, messages=mensagens)
        except SDKError as erro:
            codigo = getattr(erro, "status_code", None)
            if codigo == 429 and tentativa < tentativas - 1:
                time.sleep(atraso)
                atraso *= 2
                continue
            raise

Este padrão de recuo exponencial (1s, 2s, 4s, 8s) evita que o teu serviço colapse sob picos de tráfego e, ao mesmo tempo, não bombardeia a API da Mistral com pedidos repetidos que só vão continuar a falhar.

Passo 11: Reforçar a segurança da integração

Não há, à data deste artigo, nenhum CVE público documentado especificamente contra a API da Mistral AI em 2025-2026. Isso não significa que a integração seja imune a erros do lado do programador, que continuam a ser a causa mais comum de incidentes em aplicações com LLMs. A Open Web Application Security Project (OWASP) mantém a prompt injection como o risco número um na sua lista de riscos para aplicações LLM, e essa lógica aplica-se a qualquer fornecedor de modelo, incluindo a Mistral.

  • Nunca coloques a chave de API em código do lado do cliente (browser ou app móvel); mantém-na sempre no servidor
  • Roda a chave imediatamente se suspeitares de exposição acidental, por exemplo num commit público
  • Valida e sanitiza qualquer conteúdo externo (páginas web, PDFs, emails) antes de o injetares no contexto do RAG, porque instruções escondidas nesse conteúdo podem tentar manipular o modelo
  • Nunca executes diretamente código ou comandos gerados pelo modelo sem revisão ou sandboxing
  • Usa o modelo gratuito Mistral Moderation 2 para filtrar conteúdo tóxico antes de o mostrares a utilizadores finais

Vale a pena sublinhar: sendo uma empresa francesa sujeita ao RGPD por defeito, a Mistral é frequentemente escolhida por equipas em Portugal e no resto da UE precisamente por questões de residência de dados, algo que os fornecedores norte-americanos por vezes exigem contratos empresariais dedicados para garantir.

Se o teu chatbot vai buscar contexto a fontes externas (páginas web, documentos enviados por utilizadores, resultados de outras APIs), trata esse conteúdo como não fiável por defeito. Um ficheiro PDF pode conter texto invisível com instruções destinadas a manipular o modelo, um ataque conhecido como prompt injection indireta. A defesa mais eficaz não é tentar detetar todos os padrões possíveis de ataque, é limitar o que o modelo pode fazer: separa claramente instruções do sistema do conteúdo recuperado, nunca deixes o modelo executar ações irreversíveis sem confirmação humana, e regista todas as chamadas de function calling para conseguires auditar comportamento anómalo mais tarde.

Passo 12: Calcular o custo real em produção

Antes de lançar o projeto, faz as contas com números realistas em vez de assumir que "vai ficar barato". A tabela abaixo estima o custo mensal de um chatbot de suporte com um volume moderado de tráfego, assumindo uma média de 600 tokens de input (pergunta + contexto RAG) e 250 tokens de output por interação.

Volume mensalModelo usadoCusto estimado de inputCusto estimado de outputTotal aproximado/mês
5.000 interaçõesSmall 4$0,45$0,75~$1,20
50.000 interaçõesSmall 4$4,50$7,50~$12,00
50.000 interaçõesLarge 3$15,00$18,75~$33,75
500.000 interaçõesSmall 4$45,00$75,00~$120,00

Nota como trocar de Large 3 para Small 4 reduz o custo em cerca de 65% no mesmo volume, sem que o utilizador final costume notar diferença numa tarefa simples de perguntas e respostas sobre um documento. Usar o cache de input (10% do preço normal quando o mesmo contexto se repete entre pedidos, como acontece com uma mensagem de sistema fixa) pode cortar ainda mais a fatura em cenários com prompts longos e repetidos.

Outros modelos da gama: moderação, OCR e voz

A maior parte dos tutoriais para de falar assim que o chatbot funciona, mas a gama da Mistral vai bem além de texto. Vale a pena conheceres estes modelos antes de decidires construir de raiz algo que já existe pronto a usar via API.

  • Mistral Moderation 2: classifica conteúdo potencialmente problemático (violência, discurso de ódio, conteúdo sexual, entre outras categorias) e é gratuito, tanto para input como para output. Não há motivo para não o usares como primeira linha de defesa antes de mostrares respostas geradas a utilizadores finais.
  • OCR 4.1: extrai texto de documentos digitalizados e PDFs, cobrado a $4 por 1.000 páginas de input (com desconto para páginas em cache). É útil quando a tua base de conhecimento para RAG começa como papel digitalizado em vez de texto já pronto.
  • Voxtral Mini Transcribe 2: transcreve áudio para texto a $0,003 por minuto de input, praticamente gratuito para a maioria dos casos de uso de suporte ao cliente por voz.
  • Voxtral TTS: converte texto em voz sintetizada, cobrado a $16 por milhão de caracteres de output, com input gratuito.

Combinar estes modelos com o chatbot RAG que construíste neste tutorial abre caminho para um assistente de suporte que recebe uma chamada de voz, transcreve com o Voxtral, procura a resposta na base de conhecimento com embeddings, gera texto com o Small 4 ou Large 3, e responde de volta em voz sintetizada. Cada peça usa uma chamada de API separada, mas a arquitetura de fundo é exatamente a mesma que já viste nos passos anteriores.

Erros comuns que custam dinheiro e tempo

Depois de rever integrações reais e relatos de programadores, estes são os erros que aparecem com mais frequência.

  • Usar o modelo mais caro para tudo. Escolher Medium 3.5 para classificar emails é como usar um camião para levar o lixo à esquina; um Ministral 3 8B resolve por uma fração do preço.
  • Ignorar o recuo exponencial. Repetir pedidos imediatamente após um erro 429 só piora o problema e pode levar a bloqueios temporários mais longos.
  • Enviar documentos inteiros sem dividir em blocos. Isto desperdiça tokens de contexto e reduz a precisão da recuperação, porque o vetor de um documento gigante representa mal qualquer secção específica.
  • Confundir os nomes dos planos do Le Chat com os IDs de modelo da API. "Le Chat Pro" é um produto de interface, não um valor válido para o campo model de uma chamada.
  • Não validar o schema JSON das funções de tools. Um campo properties mal formado faz o function calling falhar silenciosamente, sem erro explícito na maioria dos casos.
  • Esquecer de rodar chaves antigas. Chaves de teste que ficam ativas meses depois de o projeto passar a produção são um risco desnecessário.

Resolução de problemas: os erros mais frequentes

Lista de referência rápida para os problemas que mais aparecem ao integrar a API Mistral AI, com a causa provável e a correção.

SintomaCausa provávelCorreção
Erro 401 UnauthorizedChave de API em falta, inválida ou revogadaConfirma que MISTRAL_API_KEY está definida e gera uma chave nova na consola
Erro 429 Too Many RequestsLimite de pedidos por minuto excedidoImplementa recuo exponencial e reduz a concorrência de chamadas
"model not found"Nome de modelo desatualizado (ex.: uma versão antiga já substituída pelo Large 3)Usa aliases -latest ou confirma o ID atual na página de modelos
Respostas cortadas a meioJanela de contexto excedida pela soma de sistema, histórico e respostaReduz o tamanho dos blocos RAG ou aumenta o limite de tokens de output
Function calling não devolve tool_callsSchema JSON mal formado ou tool_choice em faltaValida o schema com um validador JSON e define explicitamente tool_choice="auto"
Pesquisa RAG devolve resultados sem sentidoVetores de modelos de embedding diferentes misturados no mesmo índiceRegenera todo o índice com um único modelo de embeddings
Streaming para a meio sem avisoLigação de rede instável ou timeout do lado do clienteImplementa reconexão automática e trata fragmentos incompletos
Custo mensal muito acima do esperadoA usar Large 3 ou Medium 3.5 para tarefas simplesFaz downgrade para Small 4 ou Ministral 3 nas tarefas que não exigem raciocínio complexo

Dicas avançadas para produção

Depois de teres o básico a funcionar, estas práticas fazem a diferença entre um protótipo e um sistema fiável.

  • Cascata de modelos: usa um Ministral 3 barato para classificar a intenção do pedido e só invocas o Large 3 quando a tarefa exige raciocínio mais profundo.
  • Cache de input: mantém a mensagem de sistema e o contexto fixo no início do prompt, para beneficiares do preço reduzido de input em cache em pedidos repetidos.
  • Modo de saída estruturada: pede JSON diretamente na definição do pedido quando precisares de integrar a resposta noutro sistema, em vez de tentares extrair dados de texto livre com expressões regulares.
  • Regista o consumo de tokens por pedido: guarda o campo usage de cada resposta numa base de dados própria, para conseguires prever a fatura antes de ela chegar.
  • Considera residência de dados: se trabalhas com dados sensíveis de clientes na UE, confirma as opções empresariais da Mistral relativas a alojamento europeu antes de assinar um contrato.

Quando precisas que a resposta do modelo encaixe diretamente numa base de dados ou noutro sistema, pede JSON estruturado em vez de tentares extrair dados de texto livre com expressões regulares frágeis. Isto reduz drasticamente os erros de parsing em produção.

resposta = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {"role": "user", "content": "Extrai nome, email e motivo de contacto deste texto: ..."}
    ],
    response_format={"type": "json_object"},
)

import json
dados = json.loads(resposta.choices[0].message.content)
print(dados["nome"], dados["email"])

Antes de promoveres qualquer integração para produção, separa claramente os ambientes. Usa uma chave de API distinta para desenvolvimento e outra para produção, com limites de despesa configurados na consola para cada uma. Isto evita que um script de teste esquecido a correr em loop consuma o orçamento mensal todo antes de alguém dar por isso. Regista também o identificador de cada pedido (disponível na resposta da API) junto com os logs da tua aplicação, porque é a primeira informação que vais precisar de fornecer se abrires um pedido de suporte junto da Mistral sobre um comportamento inesperado.

Testar a integração antes de lançar

Um erro comum é só descobrir que a integração está frágil quando já está em produção e um utilizador se queixa. Escreve pelo menos um teste automatizado que verifica se a chave de API está válida e se o modelo responde dentro de um tempo aceitável, e corre-o como parte do processo de deployment, não só manualmente de vez em quando.

import time

def verificar_saude_api():
    inicio = time.time()
    try:
        resposta = client.chat.complete(
            model="mistral-small-latest",
            messages=[{"role": "user", "content": "responde apenas com 'ok'"}],
        )
        duracao = time.time() - inicio
        assert "ok" in resposta.choices[0].message.content.lower()
        assert duracao < 10, f"resposta demorou {duracao:.1f}s, acima do limite aceitável"
        return True
    except Exception as erro:
        print(f"falha na verificação de saúde da API Mistral: {erro}")
        return False

Integra esta verificação num pipeline de integração contínua ou num endpoint de health check que o teu sistema de monitorização consulta periodicamente. Se a Mistral tiver uma interrupção de serviço ou se a tua chave for revogada por engano, queres saber isso antes dos teus utilizadores, não depois. Para sistemas críticos, considera também um plano de contingência simples: se a chamada à API falhar repetidamente após todas as retentativas, mostra uma mensagem de erro clara ao utilizador em vez de deixar a interface bloqueada à espera de uma resposta que nunca chega.

API Mistral AI vs outras APIs de IA generativa

Não existe um vencedor absoluto entre fornecedores de LLM, existe a ferramenta certa para cada projeto. Antes de escolheres, vale a pena comparar características que não mudam todos os meses, ao contrário dos preços.

CaracterísticaMistral AIOutros fornecedores principais
Sede da empresaFrança (UE)Normalmente EUA
Modelos de pesos abertosSim, várias famílias sob licença abertaVaria por fornecedor, muitas vezes fechado
SDK oficial Pythonmistralai (v2.9.3)Cada fornecedor tem o seu próprio pacote
Foco declaradoCusto-benefício e soberania de dados europeiaVaria (escala, multimodalidade, ecossistema)

Se já usas a API da OpenAI ou da Anthropic no mesmo projeto, a boa notícia é que a Mistral segue uma estrutura de messages e tools muito semelhante, o que torna a migração ou a utilização em paralelo relativamente direta. Para comparações detalhadas com essas APIs, consulta os artigos ligados na secção final deste tutorial.

Uma estratégia cada vez mais comum em 2026 não é escolher um único fornecedor, mas usar vários em paralelo consoante o caso de uso: Mistral para tarefas de alto volume e baixo custo onde a soberania de dados europeia pesa na decisão, e outro fornecedor para tarefas específicas onde este se destaque mais. Se seguires essa abordagem, isola a lógica de chamada à API numa camada própria da tua aplicação (um módulo llm_client.py, por exemplo), para poderes trocar de fornecedor por tarefa sem reescrever o resto do sistema. Foi exatamente essa separação que o código deste tutorial já segue, com o cliente Mistral isolado das funções de negócio como responder().

Perguntas frequentes sobre a API Mistral AI

A API da Mistral AI é gratuita?

Existe um nível gratuito com limites reduzidos de pedidos por minuto, mas para uso contínuo é necessário registar um método de pagamento e pagar por token consumido, conforme a tabela de preços deste tutorial.

Qual o modelo mais barato para começar a testar?

O Ministral 3 3B, a $0,10 por milhão de tokens de input e output, é o ponto de entrada mais económico para prototipagem e tarefas simples.

A Mistral usa os meus dados para treinar modelos?

Os planos empresariais costumam incluir garantias contratuais de não retenção de dados para treino. Confirma sempre a política atual na documentação oficial ou no contrato assinado, porque estas condições podem variar por plano.

Posso correr modelos da Mistral localmente em vez de usar a API?

Sim, várias famílias da Mistral têm pesos abertos e podem correr localmente através de ferramentas como o Ollama, com a vantagem de não pagares por token mas a desvantagem de precisares de hardware próprio com GPU adequada.

Qual a diferença entre o Le Chat e a API?

O Le Chat é a interface de conversação da Mistral, pensada para utilizadores finais. A API é a camada de programação que integras no teu próprio produto e que usámos neste tutorial.

Como funciona o cache de input e porque poupa dinheiro?

Quando o início de um prompt se repete entre pedidos (por exemplo, uma mensagem de sistema fixa), a Mistral cobra apenas cerca de 10% do preço normal por essa parte repetida, em vez do preço completo de input.

A Mistral cumpre o RGPD?

Sendo uma empresa sediada na França, a Mistral está sujeita ao RGPD por defeito, o que é uma das razões pelas quais equipas europeias e portuguesas a escolhem para projetos com dados sensíveis de clientes.

Preciso de cartão de crédito para testar a API?

Para os limites gratuitos iniciais normalmente não, mas para desbloquear limites de utilização mais altos e usar em produção, sim, é necessário registar um método de pagamento na consola.

Qual a diferença entre Mistral Small 4 e os modelos Ministral 3?

O Small 4 é um modelo de conversação geral otimizado para custo, enquanto a família Ministral 3 (3B, 8B e 14B parâmetros) foi desenhada para tarefas ainda mais leves e rápidas, como classificação, etiquetagem ou encaminhamento de pedidos antes de chegarem a um modelo maior.

O que acontece se ultrapassar o limite de pedidos por minuto?

A API devolve um erro HTTP 429. O teu código deve tratar isto com recuo exponencial, como mostrado no Passo 10, em vez de repetir o pedido de imediato.

Fontes e documentação oficial usadas neste tutorial: tabela oficial de preços da Mistral, página de modelos da Mistral, documentação da API, repositório oficial do SDK Python, repositório oficial do SDK TypeScript, dados de financiamento da Mistral AI e o OWASP Top 10 para aplicações LLM.