Escolher um modelo de linguagem (LLM) adequado para uma tarefa é difícil sem executar o mesmo prompt em vários deles. Cada provedor tem sua própria conta, sua própria chave de API e, muitas vezes, seu próprio SDK, então colocar Claude, DeepSeek e um modelo de pesos abertos lado a lado exige bastante configuração.
Neste tutorial, vamos conectar cinco modelos diferentes por meio de um único endpoint compatível com a OpenAI e executar um pequeno script Python que envia o mesmo prompt a cada um deles, permitindo comparar as respostas, os tempos de resposta e o uso de tokens.
Tudo aqui foi testado em uma máquina Linux. Os comandos de instalação abaixo usam apt para Debian e Ubuntu. No Fedora e no RHEL, use dnf em vez disso.
Um endpoint, muitos modelos
Para os fins deste guia, usaremos a AI/ML API, um agregador de APIs que serve modelos da OpenAI, Anthropic, DeepSeek, xAI, Z.ai e de outros desenvolvedores por meio de um único endpoint compatível com a OpenAI em https://api.aimlapi.com/v1.
Como ele usa o protocolo da OpenAI, você pode instalar o SDK Python padrão da OpenAI, apontar base_url para esse endpoint e trocar de modelo mudando uma única string.
Os 5 modelos usados neste tutorial:
Os preços são das páginas de modelos da AI/ML API em 24 de setembro de 2026.
⚠️ O que saber antes de pagar por agregadores de API
Agregadores de API podem ser uma forma conveniente de testar vários modelos por uma única interface, mas tenha cautela antes de usá-los em produção ou de assumir compromissos financeiros significativos.
Comece com o menor depósito disponível e desative a recarga automática até ter confiança no serviço. Teste latência e confiabilidade com sua carga de trabalho real e verifique com cuidado o uso de tokens em relação à sua cobrança.
Importante: em setembro de 2026, a documentação da AI/ML API afirma explicitamente que as recargas não são reembolsáveis, com recargas disponíveis a partir de $20. Seus Termos e Condições afirmam claramente que todas as compras são finais e não reembolsáveis.
Recomendamos fortemente que você leia as páginas de Termos e Condições, Conta e Cobrança e Planos antes de adicionar fundos.
Agora vamos em frente para comparar vários LLMs via AI/ML API no Linux.
Pré-requisitos
Você precisa do Python 3.9 ou mais recente, do pip e de uma chave de API. No Debian ou Ubuntu, execute o seguinte comando para instalá-los:
sudo apt install python3 python3-venv python3-pip
Crie uma chave no painel da AI/ML API, na página de chaves de API.
A cobrança é por uso (pay-as-you-go), e o painel tem um Playground web onde você pode testar um modelo antes de escrever scripts contra ele.
Passo 1: configurar um ambiente isolado
Instale o SDK dentro de um ambiente virtual, não em todo o sistema:
mkdir llm-compare && cd llm-compare
python3 -m venv .venv
source .venv/bin/activate
pip install openai
Em seguida, exporte a chave como variável de ambiente para que ela não fique codificada diretamente no script:
export AIMLAPI_KEY="your_api_key_here"
Para manter a chave fora do histórico do shell, adicione essa linha ao ~/.bashrc com um editor de texto em vez de digitá-la no prompt.
Passo 2: verificar o endpoint com curl
Antes de escrever qualquer script Python, confirme que o endpoint responde. Ele aceita uma requisição POST padrão para /v1/chat/completions com um token Bearer:
curl https://api.aimlapi.com/v1/chat/completions \
-H "Authorization: Bearer $AIMLAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek/deepseek-v4-flash",
"messages": [{"role": "user", "content": "Reply with the single word: ok"}]
}'
A resposta é o JSON habitual da OpenAI, com a resposta em choices[0].message.content e as contagens de tokens em usage. Se essa requisição funcionar, o script abaixo também funcionará.
Passo 3: script Python para comparar vários LLMs
Este script envia o mesmo prompt a cada modelo de uma lista, mede quanto tempo cada requisição leva e imprime as respostas uma após a outra. Salve-o como compare_llms.py:
#!/usr/bin/env python3
"""compare_llms.py - send one prompt to several LLMs through a single
OpenAI-compatible endpoint (AI/ML API) and compare answers, latency and tokens."""
import os
import sys
import time
from openai import OpenAI
BASE_URL = os.environ.get("OPENAI_BASE_URL", "https://api.aimlapi.com/v1")
API_KEY = os.environ.get("AIMLAPI_KEY") or os.environ.get("OPENAI_API_KEY")
# Edit this list, or override it with the MODELS env var (comma-separated).
MODELS = os.environ.get(
"MODELS",
"anthropic/claude-sonnet-5,"
"deepseek/deepseek-v4-pro,"
"deepseek/deepseek-v4-flash,"
"x-ai/grok-build-0-1,"
"zhipu/glm-5-2",
).split(",")
def main() -> int:
if not API_KEY:
sys.exit("Set AIMLAPI_KEY first (create a key at https://aimlapi.com/app/keys).")
prompt = " ".join(sys.argv[1:]) or "Explain what a Linux inode is, in two sentences."
client = OpenAI(base_url=BASE_URL, api_key=API_KEY)
print(f"Prompt: {prompt}\n" + "=" * 60)
for raw in MODELS:
model = raw.strip()
if not model:
continue
start = time.perf_counter()
try:
resp = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": prompt}],
)
except Exception as exc: # network, auth, unknown model, etc.
print(f"\n### {model}\n ERROR: {exc}")
continue
elapsed = time.perf_counter() - start
answer = (resp.choices[0].message.content or "").strip()
usage = resp.usage
tokens = f"{usage.prompt_tokens} in / {usage.completion_tokens} out" if usage else "n/a"
print(f"\n### {model} ({elapsed:.2f}s, {tokens})\n{answer}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
Algumas observações sobre o projeto:
- A lista de modelos vem da variável de ambiente MODELS e recorre aos 5 modelos acima. Você pode editar o arquivo ou executar
MODELS="deepseek/deepseek-v4-flash,zhipu/glm-5-2" python3 compare_llms.pysem tocar no código. - Cada requisição está envolvida em try/except. Um ID de modelo errado ou um erro de rede imprime um erro para aquele modelo, e o script segue para o próximo.
- O script imprime as contagens de tokens de entrada e saída do campo
usage, para que você possa multiplicá-las pelos preços da tabela acima e comparar o custo da mesma resposta entre os modelos. - Ele não define
temperature. DeepSeek V4 Pro e Claude Sonnet 5 têm modos de raciocínio, e algumas configurações de raciocínio ignoram ou rejeitam parâmetros de amostragem. Se você quiser respostas mais estáveis de modelos sem raciocínio, adicionetemperature=0.3à chamada create().
Passo 4: consultar e comparar vários LLMs
Passe seu prompt como argumentos, ou execute o script sem argumentos para usar o prompt padrão:
python3 compare_llms.py "Explain what a Linux inode is, in two sentences."
A saída lista os modelos um após o outro, cada um marcado com o tempo de resposta e a contagem de tokens. Esta é a saída da nossa execução em 24 de setembro de 2026:
Prompt: Explain what a Linux inode is, in two sentences.
============================================================
### anthropic/claude-sonnet-5 (8.44s, 24 in / 126 out)
An inode (index node) is a data structure on a filesystem that stores metadata about a file or directory—such as its size, permissions, ownership, timestamps, and pointers to the actual data blocks on disk—but notably does not store the file's name. Each file is linked to a unique inode via directory entries, allowing multiple filenames (hard links) to reference the same underlying data through a shared inode.
### deepseek/deepseek-v4-pro (4.65s, 95 in / 149 out)
A Linux inode is a filesystem data structure that stores metadata about a file or directory, such as permissions, ownership, timestamps, and pointers to its data blocks. It does not store the file’s name or its actual content; instead, each inode is identified by a unique inode number within its filesystem.
### deepseek/deepseek-v4-flash (2.51s, 42 in / 279 out)
An inode is a filesystem data structure that stores a file’s metadata—such as its type, permissions, ownership, timestamps, size, and pointers to data blocks—but not its name or actual data content. Every file has an inode number unique within its filesystem, and directory entries map human-readable filenames to those inode numbers, which is why hard links can share one inode.
### x-ai/grok-build-0-1 (3.92s, 197 in / 323 out)
In Linux, an inode is a data structure that stores metadata about a file or directory, such as its permissions, ownership, timestamps, size, and pointers to the data blocks on disk. It does not contain the file's name or its actual content; the filename is stored in the directory entry, which references the inode number.
### zhipu/glm-5-2 (15.70s, 24 in / 709 out)
A Linux inode is a data structure that stores metadata about a file or directory, such as its permissions, owner, size, and physical location on the disk. It acts as the bridge between a file's human-readable name and its actual data blocks, notably excluding the file name itself, which is instead stored in the directory structure.
Seus tempos e contagens de tokens variarão de execução para execução, mas alguns pontos se destacam. Todos os 5 modelos deram uma resposta correta de duas frases. DeepSeek V4 Flash foi o mais rápido, com 2,51 segundos, e GLM 5.2 o mais lento, com 15,70 segundos.
As contagens de tokens são a parte mais útil. O prompt foi o mesmo para todos os modelos, mas as contagens de entrada variam de 24 a 197 tokens, porque cada modelo usa seu próprio tokenizador e alguns provedores podem adicionar suas próprias instruções à requisição. As contagens de saída variam ainda mais. O GLM 5.2 cobrou 709 tokens de saída por uma resposta de cerca de 60 palavras, provavelmente porque é um modelo de raciocínio e os tokens gastos pensando são cobrados como saída.
Veja quanto custou essa única requisição em cada modelo, usando os preços da tabela acima:
O DeepSeek V4 Flash tem o menor preço de entrada entre esses modelos. Neste prompt, porém, custou o dobro do DeepSeek V4 Pro, porque produziu mais tokens de saída e seu preço de saída é maior. Listas de preços sozinhas não bastam para comparar modelos, então execute seus próprios prompts e confira as contagens reais de tokens.
Substitua o prompt padrão pelo seu próprio trabalho. Por exemplo, peça aos modelos que expliquem um bug, revisem um script de shell ou gerem um arquivo de configuração.
Passo 5: o que comparar e como escolher os modelos
Três coisas costumam decidir qual modelo usar.
- Latência. O script a imprime para cada requisição. Execute-o várias vezes, porque a primeira chamada a um modelo costuma ser mais lenta que as demais.
- Custo. Cada modelo tem seu próprio preço por milhão de tokens e, para respostas longas, o preço de saída é o que mais pesa. Se você envia milhares de requisições por dia, escolha o modelo mais barato que ainda responda bem o suficiente à sua tarefa. A economia se acumula rapidamente nesse volume.
- Qualidade. Só você pode julgá-la, e ver as respostas lado a lado facilita isso.
Veja o que distingue cada modelo.
- Claude Sonnet 5 é o modelo da Anthropic para codificação e fluxos de trabalho de agentes, lançado em 30 de junho de 2026. A Anthropic diz que ele chega perto de seu modelo de topo Opus por um preço menor. Em nossa execução, deu a resposta mais detalhada com o menor número de tokens de saída, mas seu preço por token é o mais alto desta lista.
- DeepSeek V4 Pro é o maior modelo aqui, com 1,6T de parâmetros. Desde agosto de 2026, você pode definir seu esforço de raciocínio como low, high ou max, de modo que um único modelo cobre tanto respostas rápidas quanto tarefas mais difíceis. Também foi a requisição mais barata em nossa execução.
- DeepSeek V4 Flash foi feito para velocidade. Ele ativa apenas 13B de seus 284B parâmetros por requisição e foi o modelo mais rápido em nosso teste, com 2,51 segundos. Ele serve para tarefas de alto volume em que uma resposta rápida importa mais que profundidade.
- Grok Build 0.1 é o único modelo desta lista treinado especificamente para agentes de codificação, com suporte a ferramentas MCP. A xAI o lançou em 29 de maio de 2026 e diz que ele roda a mais de 100 tokens por segundo. A xAI ainda não publicou pontuações de benchmark para ele.
- GLM 5.2 é o único modelo de pesos abertos aqui, lançado pela Z.ai em 16 de junho de 2026 sob a licença MIT. Você pode chamá-lo pela API ou executá-lo em seus próprios servidores, se seu código não puder sair da sua infraestrutura. A Z.ai relata uma pontuação de 81,0 no Terminal-Bench 2.1. Em nossa execução, foi o modelo mais lento e usou o maior número de tokens de saída.
Para adicionar outros modelos à comparação, procure os IDs exatos no catálogo de modelos da AI/ML API em vez de adivinhar. Nomes e versões mudam, e um ID errado faz o script imprimir um erro naquela linha.
Passo 6: transformar em uma função auxiliar de shell
Depois que o script funcionar, envolva-o em uma função de shell para poder chamá-lo de qualquer diretório. Adicione isto ao seu ~/.bashrc:
askall() {
( cd ~/llm-compare && source .venv/bin/activate && python3 compare_llms.py "$@" )
}
Recarregue o arquivo com o comando:
source ~/.bashrc
Agora "review this regex: ^\d{3}-\d{4}$" "review this regex: ^\d{3}-\d{4}$" envia a pergunta a todos os 5 modelos de qualquer lugar no terminal.
Perguntas frequentes (FAQ)
P: Preciso de uma conta separada para cada provedor de IA?
R: Não. O script envia cada requisição a um único endpoint compatível com a OpenAI, então uma única chave da AI/ML API cobre todos os 5 modelos deste tutorial. Você não precisa de contas na Anthropic, DeepSeek, xAI ou Z.ai, e instala apenas um pacote Python, o openai.
P: Por que um modelo retorna um ERROR na saída?
R: A causa mais comum é um ID de modelo errado ou desatualizado. Verifique o ID exato na página do modelo no catálogo da AI/ML API e atualize a lista MODELS. Outras causas são uma chave de API inválida (HTTP 401), saldo vazio ou um limite de taxa (HTTP 429), que geralmente se resolve após uma breve espera.
P: Como calculo o custo de uma requisição?
R: Multiplique os tokens de entrada pelo preço de entrada do modelo e os tokens de saída pelo preço de saída, depois divida cada um por 1.000.000. Por exemplo, em nossa execução o DeepSeek V4 Flash usou 42 tokens de entrada e 279 de saída, o que custou (42 × $0,39 + 279 × $1,56) / 1.000.000, ou cerca de $0,00045.
P: Posso usar este script com outras APIs compatíveis com a OpenAI?
R: Sim. O script lê o endpoint da variável de ambiente OPENAI_BASE_URL. Por exemplo, defina-a como http://localhost:11434/v1 para consultar modelos locais no Ollama e coloque seus nomes em MODELS. O Ollama ignora a chave de API, mas o script espera uma, então defina AIMLAPI_KEY com qualquer valor.
P: Posso executar esses modelos localmente?
R: Apenas alguns deles. O GLM 5.2 é publicado como pesos abertos sob a licença MIT, mas com 753B parâmetros ele precisa de um servidor com várias GPUs. Claude Sonnet 5 e Grok Build 0.1 não têm pesos públicos, então você só pode usá-los por API. Para experimentos locais em uma única máquina, modelos abertos menores no Ollama são uma escolha mais prática.
P: O que é um agregador de API?
R: É um serviço que oferece um único endpoint e uma única conta de cobrança para muitos modelos de provedores diferentes. Isso o torna conveniente para testar e comparar LLMs sem gerenciar contas separadas. A contrapartida é que você depende de um intermediário para preços, disponibilidade e precisão da cobrança.
P: A AI/ML API é segura para uso?
R: A AI/ML API é um serviço de agregação de API em funcionamento, mas os desenvolvedores devem avaliá-lo conforme seus próprios requisitos antes de depender dele em produção. Comece pequeno e teste o serviço com sua carga de trabalho real.
P: Qual é o valor mínimo que posso adicionar?
R: A documentação atual da AI/ML API lista $20 como o valor mínimo de recarga. Consulte a página de Planos de Assinatura para preços e opções atuais.
P: Posso obter reembolso se não usar meus créditos?
R: De acordo com os Termos e Condições da AI/ML API, as compras são finais e não reembolsáveis. A Central de Ajuda deles também afirma que as recargas não são reembolsáveis. Leia os Termos e Condições antes de adicionar fundos.
P: Devo ativar a recarga automática?
R: É mais seguro manter a recarga automática desativada inicialmente. Primeiro verifique o serviço, a precisão da cobrança e seu uso real. Você pode revisar as configurações relevantes em Gerenciando sua Assinatura.
P: Como posso verificar se estou sendo cobrado corretamente?
R: Execute um pequeno número de requisições de API controladas, registre os modelos e o uso de tokens e compare o custo esperado com o valor deduzido da sua conta. Não presuma que o custo exibido está correto sem testá-lo você mesmo.
P: Devo usar a AI/ML API diretamente em produção?
R: Não faça dela sua única dependência de produção até ter testado sua confiabilidade, latência, taxas de erro e comportamento de cobrança sob sua carga de trabalho específica. Considere manter um provedor de fallback para aplicações críticas.
P: O que devo verificar antes de adicionar uma grande quantia de dinheiro?
R: Verifique os preços atuais, a política de reembolso, as configurações de recarga automática, a disponibilidade de modelos, os limites de taxa, a confiabilidade da API e o comportamento de cobrança. Políticas e preços podem mudar, então confirme a documentação atual antes de comprometer fundos significativos.
P: Onde posso ler os termos oficiais?
R: Veja os Termos e Condições, Gerenciando sua Assinatura e Planos de Assinatura da AI/ML API.
Conclusão
Com um endpoint compatível com a OpenAI, um ambiente virtual e um pequeno script Python, você pode testar Claude Sonnet 5, DeepSeek V4 Pro e Flash, Grok Build 0.1 e GLM 5.2 com seus próprios prompts a partir de um terminal Linux.
Adicionar outro modelo à comparação exige uma linha na lista MODELS: nenhum SDK, conta ou chave novos. Execute-o nas tarefas que você faz todos os dias, compare o tempo, os tokens e as respostas, e escolha o modelo com base nesses resultados.
