Documentação

Escolha seu objetivo e provedor, gere o exemplo correto e confira acesso antes de consumir inferência.

Consulte GET https://mangabarouter.store/v1/models com sua chave para listar os nomes disponíveis. Essa consulta verifica acesso ao catálogo; uma resposta 200 não comprova que a inferência funciona. Copie o nome exato do catálogo e consulte o provedor e a data da verificação.

OpenAI, Hermes e OpenClaw: use a base https://mangabarouter.store/v1 com o adaptador Chat Completions. Anthropic e Claude Code: use a base https://mangabarouter.store com Messages. Para Codex, veja a seção de Responses abaixo. A compatibilidade depende também das ferramentas e do formato de mensagens usados pelo cliente.

401: confira a chave do roteador, sua revogação e o endereço configurado; listar modelos não exclui um erro de autenticação no provedor. 429: respeite Retry-After e reduza chamadas simultâneas. Timeout: reduza o histórico e evite repetições paralelas. Consulte seus limites na aba Chaves e a ocupação antes de começar.

Velocidades são medianas do tráfego observado nos últimos 30 dias, por modelo e provedor, com pelo menos três amostras elegíveis. Não são promessa de tempo de resposta. Um nome ausente do anúncio atual pode permanecer disponível para compatibilidade; sua retirada exige revisão.

Apontar para o roteador (https://mangabarouter.store/v1) com uma chave mr-… liga limite por chave, cache, fallback entre gateways e o log de tráfego. Apontar direto para o gateway (https://app.mangaba.ia.br/v1) com uma chave sk-… é mais curto, mas nada disso acontece.

Use o assistente para gerar a configuração com o modelo e o provedor atuais. Os exemplos abaixo precisam ser verificados com a versão do seu cliente:

• Minha aplicação usa o SDK da OpenAI — seção 2: mudam duas linhas.
• Uso o SDK da Anthropic — seção 3: mesma ideia, base sem /v1.
• Claude Code no terminal — seção 4: script pronto.
• Codex (CLI da OpenAI) — seção 5: config.toml pronto.
• OpenClaw — seção 6: openclaw.json pronto.
• Hermes (Nous Research) — seção 7: config.yaml pronto.
• Cursor / Claude Desktop (MCP) — seção 11: JSON-RPC pronto.
• Busca semântica (RAG) — seção 12: embeddings e rerank.
• Voz e health check — seção 13: TTS, transcrição e monitoramento.
• Classificar, pontuar, decidir (sem gerar texto) — seção 14: decisão tipada com o Jev.

Os provedores usam infraestruturas diferentes, incluindo CPU e GPU remota. Conversas e agentes têm tempos diferentes de processamento e fila. Configure um timeout compatível com seu caso; os exemplos usam até 10 minutos.

curl https://mangabarouter.store/v1/chat/completions \
  -H "Authorization: Bearer mr-SUA_CHAVE" \
  -H "Content-Type: application/json" \
  -d '{"model":"mangaba-mini",
       "messages":[{"role":"user","content":"oi"}]}'

A chave sai de Chaves de API, dentro do console. Ela aparece uma única vez — o banco guarda só o hash.

from openai import OpenAI

client = OpenAI(
    base_url="https://mangabarouter.store/v1",   # <- só isto muda
    api_key="mr-SUA_CHAVE",
)

r = client.chat.completions.create(
    model="mangaba-coder",
    messages=[{"role": "user", "content": "Olá!"}],
    stream=True,
)

Nenhuma outra linha do seu código muda: o roteador fala o mesmo protocolo, com streaming e tool calling.

# a base NÃO leva /v1: o SDK Anthropic acrescenta /v1/messages sozinho
export ANTHROPIC_BASE_URL=https://mangabarouter.store
export ANTHROPIC_API_KEY=mr-SUA_CHAVE
export ANTHROPIC_MODEL=mangaba-coder

# em curl, o caminho completo:
curl https://mangabarouter.store/v1/messages \
  -H "x-api-key: mr-SUA_CHAVE" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"model":"mangaba-coder","max_tokens":60,
       "messages":[{"role":"user","content":"Olá!"}]}'

Aceita x-api-key ou Authorization: Bearer, com system no topo, tool use e streaming — os eventos SSE saem no formato Anthropic.

O Claude Code fala Messages API, então funciona aqui — mas exige três ajustes que ninguém adivinha na primeira tentativa. Salve como ~/.local/bin/claude-mangaba e dê chmod +x:

#!/bin/zsh
export ANTHROPIC_BASE_URL="https://mangabarouter.store"
export ANTHROPIC_AUTH_TOKEN="mr-SUA_CHAVE"

# sem os cinco nomes abaixo o cliente manda claude-* e leva 400
export ANTHROPIC_MODEL="mangaba-coder"
export ANTHROPIC_DEFAULT_SONNET_MODEL="mangaba-coder"
export ANTHROPIC_DEFAULT_OPUS_MODEL="mangaba-coder"
export ANTHROPIC_SMALL_FAST_MODEL="mangaba-mini"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="mangaba-mini"

export API_TIMEOUT_MS="600000"              # o padrao desiste antes da CPU terminar
export CLAUDE_CODE_MAX_CONTEXT_TOKENS="65536"  # janela real; senao ele presume 200k
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"

exec claude --tools "" "$@"                 # so conversa; veja a nota abaixo

Por que --tools "": as 25 ferramentas padrão viajam inteiras em cada turno. Medido em 28/ago: com elas o corpo passa de 70 KB (~18k tokens de entrada) e uma pergunta trivial leva 5min57s; sem elas são 7,6 KB (2.325 tokens) e 54s. Em CPU o gargalo é ler o prompt, não gerar a resposta. Negar ferramenta por permissão não ajuda — a definição continua sendo enviada. Para reativar quando precisar: claude-mangaba --tools "Read,Grep,Bash".

Sobre o tempo: um turno pode passar de um minuto, e por isso o API_TIMEOUT_MS alto importa. O roteador aguenta até 800s por requisição — medido em 28/ago, um prompt de 22,7k tokens de entrada voltou em 427s. Não há mais motivo para apontar direto ao gateway.

A linha [claude-code:unrecognized_model] é só telemetria de nome fora do catálogo dele, e não afeta a chamada. E respostas ficam mais lentas conforme a conversa cresce: cada turno reenvia o histórico inteiro.

O Codex fala a Responses API, que o roteador traduz para o gateway. Crie ~/.codex/config.toml:

model = "mangaba-coder"
model_provider = "mangaba"

[model_providers.mangaba]
name = "Mangaba"
base_url = "https://mangabarouter.store/v1"
env_key = "MANGABA_API_KEY"
wire_api = "responses"

export MANGABA_API_KEY=mr-SUA_CHAVE
codex

Use wire_api = "responses": as versões atuais do Codex aposentaram o modo chat. O aviso "Model metadata not found" é inofensivo — o nome não está no catálogo interno dele.

Acrescente ao ~/.openclaw/openclaw.json:

{
  "models": {
    "providers": {
      "mangaba": {
        "baseUrl": "https://mangabarouter.store/v1",
        "apiKey": "mr-SUA_CHAVE",
        "api": "openai-completions",
        "models": [
          { "id": "mangaba-coder", "name": "Mangaba Coder",
            "reasoning": false, "input": ["text"],
            "contextWindow": 65536, "maxTokens": 8192 },
          { "id": "mangaba-mini", "name": "Mangaba 4B",
            "reasoning": false, "input": ["text"],
            "contextWindow": 65536, "maxTokens": 8192 }
        ]
      }
    }
  },
  "agents": {
    "defaults": { "model": { "primary": "mangaba/mangaba-coder" } }
  },
  "tools": { "profile": "minimal" }
}

profile: minimal importa: o perfil completo envia 34 definições de ferramenta em cada turno e só a leitura do prompt leva vários minutos em CPU. Se ativar o perfil coding, acrescente "deny": ["cron", "node_inference"] — essas duas usam anyOf no esquema, que o servidor de inferência não compila, e o turno falha com "backend HTTP 400".

Acrescente ao ~/.hermes/config.yaml:

model:
  default: mangaba/mangaba-coder
  provider: mangaba
  max_tokens: 2048
providers:
  mangaba:
    api: https://mangabarouter.store/v1
    api_key: mr-SUA_CHAVE

O Hermes dispara chamadas paralelas num mesmo turno; o roteador segura as excedentes em fila por até 2 minutos em vez de recusar — se aparecer 429, é a fila cheia de verdade, e insistir só piora. Teste rápido: hermes -z "oi".

É o tropeço mais comum ao trocar de protocolo, porque cada SDK monta o caminho de um jeito:

• SDK da OpenAI — a base leva /v1: https://mangabarouter.store/v1, e a biblioteca acrescenta /chat/completions.
• SDK da Anthropic — a base não leva /v1: https://mangabarouter.store, porque a biblioteca já acrescenta /v1/messages.

Com /v1 nos dois lugares, a chamada vira /v1/v1/messages e o roteador responde 404 dizendo quais rotas existem — é o sintoma de “não volta nada”.

Uma rota da API da Anthropic não existe aqui: /v1/messages/count_tokens. Clientes que a chamam para estimar tokens recebem 404 e devem seguir sem ela.

O cache devolve em milissegundos o que a inferência em CPU levaria dezenas de segundos — mas só entra em jogo quando repetir a resposta é honesto:

• Pega com temperature: 0 ou sem temperatura, e sem tools.
• Não pega com amostragem ligada (temperature > 0) — ali a variação é o ponto — nem em chamadas com ferramentas, cujo resultado depende do mundo lá fora.
• stream não faz diferença: a mesma pergunta acerta o cache pedindo streaming ou não, e a resposta guardada é reemitida como SSE.

Confira no cabeçalho X-Mangaba-Cache: hit | miss de cada resposta.

São dois limites diferentes, e o erro diz qual:

• Da sua chave, ajustável em Chaves de API (padrão: 60 req/min e 200.000 tokens/hora). A mensagem cita o número configurado.
• Do gateway, fixo em 30 req/min e 60.000 tokens/hora por chave dele. Quando esse estoura, o roteador tenta o próximo gateway da cadeia.

Respeite o cabeçalho Retry-After quando houver e espalhe as chamadas: em CPU, paralelismo não acelera — divide a mesma CPU.

Em Gateways, cadastre mais de um e ordene com as setas. O roteador tenta o primeiro; se ele devolver 5xx, 429 ou não responder, vai para o próximo — e o log mostra quantas tentativas foram feitas e quem atendeu (também no cabeçalho X-Mangaba-Gateway).

Erro 4xx que não seja 429 não aciona fallback: prompt inválido continuaria inválido no próximo gateway.

curl https://mangabarouter.store/v1/mcp \
  -H "Authorization: Bearer mr-SUA_CHAVE" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

# chamar uma ferramenta (chat):
# '{"jsonrpc":"2.0","id":2,"method":"tools/call",
#   "params":{"name":"chat","arguments":{"messages":[{"role":"user","content":"oi"}]}}}'

Protocolo JSON-RPC 2.0 com os métodos tools/list, tools/call e initialize. Aqui a autenticação é a sua chave mr-…, e o roteador aplica fallback entre gateways como nas demais rotas.

curl https://mangabarouter.store/v1/embeddings \
  -H "Authorization: Bearer mr-SUA_CHAVE" \
  -H "Content-Type: application/json" \
  -d '{"model":"mangaba-embed","input":["contrato de prestação de serviço"]}'

Comece pelo mangaba-embed (1024 dimensões, ~4 textos/s). O mangaba-embed-pro (4096) e o mangaba-embed-1536 são mais precisos e mais lentos (~1 texto/s no total): lotes grandes são divididos automaticamente, mas indexe bases grandes aos poucos. Cada modelo de embedding tem sua dimensão (768–4096): não misture dimensões no mesmo índice. Depois de buscar, reordene por relevância com POST /v1/rerank. Lotes com textos repetidos reaproveitam o cache item a item.

# texto -> fala (devolve áudio):
curl https://mangabarouter.store/v1/audio/speech \
  -H "Authorization: Bearer mr-SUA_CHAVE" \
  -H "Content-Type: application/json" \
  -d '{"model":"mangaba-voz","input":"Olá, mundo","voice":"cadu"}' --output fala.wav

# fala -> texto (única rota multipart: arquivo + model):
curl https://mangabarouter.store/v1/audio/transcriptions \
  -H "Authorization: Bearer mr-SUA_CHAVE" \
  -F file=@audio.wav -F model=mangaba-audio

# saúde do serviço (pública, sem chave):
curl https://mangabarouter.store/v1/health

Áudio não passa pelo cache e conta nos mesmos limites da chave. O /v1/health é o único caminho público: use para monitoramento sem expor chave.

# state = o contexto; questions = o que decidir. Volta JSON com probabilidades.
curl https://mangabarouter.store/v1/systemone \
  -H "Authorization: Bearer mr-SUA_CHAVE" \
  -H "Content-Type: application/json" \
  -d '{"model":"brier-v5",
       "state":"Minha internet caiu de novo, terceira vez hoje. Preciso de ajuda urgente.",
       "questions":{
         "setor":{"type":"choice","instructions":"Qual setor deve atender",
                  "criteria":{"suporte":"Queda ou lentidão","financeiro":"Boleto ou cobrança","comercial":"Planos"}},
         "frustracao":{"type":"score","instructions":"Quão irritado o cliente está",
                       "criteria":["calmo","irritado mas educado","muito irritado"]},
         "urgente":{"type":"noul","instructions":"A mensagem expressa urgência"}}}'

# resposta (resumida): answers.setor.choice = "suporte", probabilities por opção,
# answers.frustracao.score = 1, answers.urgente.noul = 0.99, e usage.input_tokens

# troque só o model para mudar de modelo:
#   "model":"jev-latest" pago/externo, maior qualidade, <1 s
#   "model":"brier-v5"  da Mangaba AI, recomendado entre os abertos (vence o Jev em B2W)
#   "model":"kev-4b"    aberto, ~1,2 s
#   "model":"kev-0.8b"  leve, alto volume, ~1 s
# regras do campo criteria:
#   choice -> objeto {opção: descrição}
#   score  -> lista de níveis, do menor para o maior
#   noul   -> {"true": ..., "false": ...} ou omitido
#   instructions é obrigatório em todos os tipos

O Jev não escreve texto: responde só com escolhas, notas e probabilidades, em menos de um segundo. Use para triagem, roteamento de intenção e gate de confiança antes de chamar um modelo de chat ou escalar para humano. Três tipos de pergunta: choice (uma opção entre várias), score (nível numa escala que você define) e noul (sim/não com probabilidade). O Jev está disponível para todas as contas; quem cadastrar a própria chave da TypeSafe (Gateways › Chaves próprias) passa a usá-la. Os modelos abertos (kev-0.8b e kev-4b) rodam na nossa infraestrutura e ainda estão em avaliação: no teste de 04/10 nenhum deles superou o Jev no geral. O brier-v5, da Mangaba AI, é o recomendado entre os abertos: venceu o Jev em avaliações de produtos e empatou em inferência (os nomes brier-v2 e brier-v3 seguem aceitos e são atendidos por ele); o kev-4b é mais rápido, e o kev-0.8b serve para alto volume. Para decisões importantes, use o jev-latest. Sem streaming; cache de 24h para o mesmo estado e perguntas.

O TypeSafe (Jev, seção 14) aceita a sua chave; sem ela, a conta usa a da instalação. Em Gateways › Chaves próprias de provedor, cole a chave: o roteador confirma com o provedor, cifra e cadastra na sua conta. A partir daí cada chamada ao Jev gasta o seu saldo, nunca o de outra conta.

A sua conta pode ter mais de um provedor de inferência ligado. O roteador olha o campo model e manda a chamada para quem serve aquele modelo — você não muda de URL nem de chave para trocar de provedor.

Para saber quem serve o quê, chame GET https://mangabarouter.store/v1/models: cada entrada traz owned_by com o nome do provedor. A mesma lista aparece agrupada no seletor do Playground, dentro do console.

Quando dois provedores oferecem o mesmo nome de modelo, vale a ordem de prioridade dos gateways. Para fixar um deles, escreva provedor/modelo — poc/mangaba-agente, por exemplo. Prefixo que não corresponde a nenhum provedor é ignorado, e o modelo continua valendo.

Reserva automática. Se o provedor do modelo cair, o roteador tenta a reserva: para o mangaba-titan, primeiro o mangaba-zero-32b (GPU compartilhada) e depois o mangaba-agente (CPU). O campo model da resposta diz quem atendeu. Pedir com provedor/modelo (por exemplo gpu-l40s/mangaba-titan) é escolha explícita e desliga a reserva: se aquele provedor cair, a chamada volta com erro.

Se o mangaba-titan e a reserva estiverem ocupados ao mesmo tempo (por exemplo, durante um reinício), a resposta é 503 com o cabeçalho Retry-After: 30. Espere esse tempo antes de repetir: as bibliotecas da OpenAI e da Anthropic já fazem isso sozinhas. Repetir na hora só aumenta a fila.

Modelos grandes que rodavam em CPU (Nordeste-Coder, gemma4-26b, Qwen3-Coder e a marca mangaba-coder) agora são atendidos pelo mangaba-titan na GPU: o nome antigo continua aceito e a resposta volta com o modelo que respondeu. Para forçar o original, use o prefixo do provedor, como mangaba-nordeste/Mangaba-Nordeste-Coder.

Na decisão tipada, brier-v2 e brier-v3 continuam aceitos e são atendidos pelo brier-v5; a resposta volta com "model": "brier-v5". Não é preciso mudar a integração.

Nem todo provedor serve toda rota: se um deles não tiver /v1/messages, o roteador tenta o próximo que tiver, em vez de devolver erro.

O roteador recusa qualquer outro nome com 400, antes de sair para a rede: assim ninguém recebe, sem saber, a resposta de um modelo diferente do que pediu.

• mangaba-autoRoteador · escolhe entre os provedoresDeixe o roteador escolher: o Jev lê cada pedido e manda para o modelo certo. Código vai para o mangaba-coder, perguntas simples para o mangaba-mini, imagens e tarefas difíceis para o mangaba-titan. Quando não tem certeza, usa o mais capaz. A resposta informa o modelo escolhido no campo model. · tool calling · visão
• mangaba-titanGPU · 2× NVIDIA L40SO modelo mais capaz da Mangaba. Conduz agentes longos com várias ferramentas, raciocina sobre problemas complexos e lê imagens (prints, fotos, documentos). Também é a melhor escolha para código pesado ou com prazo: é o mais rápido da plataforma: ~76 tok/s por usuário e ~600 tok/s no total, começando a responder em até 4 s mesmo com 32 pedidos simultâneos. Contexto de 192 mil tokens. Roda em GPU dedicada; se ela cair, o mangaba-agente (CPU) assume automaticamente. Se a GPU ficar fora do ar, a conversa segue na reserva automática: mangaba-zero-32b (GPU compartilhada) e, depois, o mangaba-agente (CPU, mais lento).contexto 196.608 tokens · tool calling · visão
• mangaba-coderCPU · Xeon Gold 5218REspecialista em programação: escreve, revisa e corrige código, e opera como agente que chama ferramentas. Indicado para assistentes de código e automações. Desde 08/10 é atendido pelo mangaba-titan (GPU), bem mais rápido que o modelo original em CPU; o nome continua valendo.contexto 65.536 tokens · tool calling
• mangaba-agenteCPU · Xeon Gold 6258RAgente de uso geral: conversa, segue instruções e chama ferramentas com rapidez. Bom padrão para atendimento e fluxos de trabalho em texto. Desde 27/10 é atendido pelo mangaba-titan (GPU), bem mais rápido que o modelo original em CPU, que continua como reserva; o nome continua valendo. Não lê imagens.contexto 65.536 tokens · tool calling
• mangaba-agente-hibridoCPU · Xeon Gold 6258RAgente para fluxos com ferramentas e contexto longo. Desde 25/10 é atendido pelo mangaba-titan (GPU), cerca de 6 vezes mais rápido que o modelo original em CPU; o nome continua valendo. Contexto de 192 mil tokens. · tool calling
• mangaba-boltGPU · NVIDIA GB10Modelo compacto que pensa antes de responder: o mais preciso entre os modelos leves. Na bateria de 25/10 acertou 12 de 12 questões de contas e lógica e fez 6/6 com ferramentas, inclusive chamadas paralelas. Roda em GPU dedicada desde 25/10: ~48 tok/s e ~3 s por conta curta, já com o raciocínio. Se a GPU estiver ocupada, a CPU assume (mais lenta). Contexto de 16 mil tokens. Não lê imagens.contexto 16.384 tokens · tool calling
• mangaba-agente-rapidoGPU · NVIDIA GB10O agente mais rápido da plataforma: ~110 tok/s e prompt de 3 mil tokens lido em ~1 s, em GPU dedicada. Na bateria de 25/10 fez 6/6 com ferramentas (inclusive chamadas paralelas) e 11 de 12 em contas e lógica. Ideal para atendimento, triagem e agentes que precisam responder na hora; para tarefas longas e difíceis, use o mangaba-titan. Não lê imagens.contexto 16.384 tokens · tool calling
• mangaba-vlGPU · NVIDIA GB10Visão e documentos em GPU dedicada: lê imagens, prints, notas e PDFs digitalizados, transcreve texto e chama ferramentas. Na bateria de 25/10 transcreveu a nota de teste sem erro em ~3 s e respondeu contas curtas em menos de 1 s. Responde direto por padrão; para pensar antes de responder, envie chat_template_kwargs.enable_thinking=true. Contexto de 65 mil tokens.contexto 65.536 tokens · tool calling · visão
• mangaba-multimodalGPU · 2× NVIDIA L40SAgente que combina texto e imagem: interpreta fotos, telas e documentos e, na mesma conversa, chama ferramentas. Atendido pelo mangaba-titan (GPU): contexto de 192 mil tokens. · tool calling · visão
• mangaba-raciocinioCPU · Xeon Gold 5218RRaciocínio passo a passo para análises, cálculos e decisões que pedem cuidado. Atendido pelo mangaba-titan (GPU) com o raciocínio ligado: pensa antes de responder, por isso demora mais (dezenas de segundos em problemas difíceis) e acerta mais. Contexto de 192 mil tokens.contexto 65.536 tokens · tool calling · raciocínio
• mangaba-miniCPU · Xeon Gold 5218RAtendimento geral, perguntas e respostas e textos curtos. Desde 25/10 é atendido pelo mangaba-titan (GPU); o nome continua valendo.contexto 65.536 tokens · tool calling · raciocínio
• mangaba-flashCPU · Xeon Sapphire Rapids (AMX)O mais leve e rápido: classifica, roteia pedidos, extrai campos e dá respostas curtíssimas. Não indicado para agentes: na bateria de 11/10 chamou ferramenta sem necessidade e errou JSON (3/6). Para código ou agentes, use o mangaba-titan. · tool calling
• mangaba-visaoCPU · Xeon Gold 5218RLeitura de imagens: OCR, documentos digitalizados, notas e telas. Envie a imagem como image_url no chat. Desde 11/10 é atendido pelo mangaba-titan (GPU), sete vezes mais rápido que o modelo original em CPU; contexto de 192 mil tokens.contexto 8.192 tokens · tool calling · visão
• mangaba-fastCPU · OCR e vetoresRespostas rápidas em texto, com uma imagem por chamada quando precisar. Aceita ferramentas homologadas pelo router. Contexto de 8 mil tokens e até 4 mil de saída. Roda em CPU.contexto 8.192 tokens · tool calling · visão
• mangaba-ocrCPU · OCR e vetoresExtrai o texto de documentos, formulários e tabelas em imagem, preservando a estrutura e a acentuação. Envie só a imagem e o pedido (OCR:, Table Recognition:, Formula Recognition: ou Chart Recognition:), sem instrução de sistema. ~3 s por página, em CPU. · visão
• mangaba-embedCPU · Xeon Gold 6258RRecomendado para começar: transforma textos em vetores de 1024 dimensões para busca semântica e RAG, a ~4 textos por segundo mesmo com vários pedidos ao mesmo tempo. Use em /v1/embeddings. Não gera texto.contexto 8.192 tokens
• mangaba-embed-proCPU · Xeon Gold 6258RVetores de alta precisão (4096 dimensões) para busca semântica exigente. Mais lento: ~1 texto por segundo no total, então indexe bases grandes aos poucos ou use o mangaba-embed. Use em /v1/embeddings. Não gera texto.contexto 8.192 tokens
• mangaba-embed-1536CPU · OCR e vetoresVetores de 1536 dimensões, o tamanho que a maioria dos bancos vetoriais espera por padrão. Mesma velocidade do mangaba-embed-pro (~1 texto por segundo). Use em /v1/embeddings. Não gera texto.
• mangaba-embed-gpuGPU · NVIDIA GB10Vetores de alta precisão (4096 dimensões) calculados em GPU dedicada, com o modelo em precisão cheia. Não misture com o mangaba-embed-pro no mesmo índice: são parecidos, mas não idênticos. Use em /v1/embeddings. Não gera texto.
• mangaba-rerankCPU · Xeon Gold 6258RReordena documentos pela relevância em relação a uma pergunta. Use depois da busca vetorial para entregar ao agente só o que importa.contexto 8.192 tokens
• mangaba-audioCPU · Xeon Gold 6258RTranscreve áudio em texto cerca de 10 vezes mais rápido que o tempo real, em 99 idiomas. Use em /v1/audio/transcriptions.
• mangaba-audio-hqCPU · Xeon Gold 6258RTranscrição de áudio com máxima precisão, para gravações difíceis ou com termos técnicos. Cerca de 3 vezes mais rápido que o tempo real, em 99 idiomas.
• mangaba-vozCPU · Xeon Gold 6258RConverte texto em fala em português do Brasil, com as vozes faber, cadu e jeff. Cerca de 13 vezes mais rápido que o tempo real. Use em /v1/audio/speech.
• mangaba-leveCPU · Xeon Sapphire Rapids (AMX)Agente leve e rápido (~52 tok/s) para tarefas simples, com uma ferramenta por vez. Responde direto, sem raciocínio longo. Em avaliação. Para agentes com várias ferramentas, use o mangaba-titan. · tool calling
• mangaba-operadorGPU · 2× NVIDIA L40SSubagente que executa passos delegados por um agente principal. Desde 08/10 é atendido pelo mangaba-titan (GPU), mais rápido que o modelo original; o nome continua valendo. · tool calling
• mangaba-zero-14bGPU compartilhada · 14BAgente leve em GPU compartilhada: chama ferramentas, inclusive em paralelo, e responde em JSON. Sujeito à cota diária de GPU — indicado para testes e volume baixo; para uso contínuo, prefira o mangaba-titan. Não lê imagens.contexto 32.768 tokens · tool calling
• mangaba-zero-32bGPU compartilhada · 32BAgente de capacidade média em GPU compartilhada: ferramentas, chamadas paralelas e JSON. A primeira chamada após ociosidade leva cerca de 1 minuto. Sujeito à cota diária de GPU — para uso contínuo, prefira o mangaba-titan. Não lê imagens.contexto 32.768 tokens · tool calling
• mangaba-zero-coderGPU compartilhada · códigoEspecialista em código em GPU compartilhada: escreve, revisa e corrige código e chama ferramentas (ler e editar arquivos, rodar comandos). A primeira chamada após ociosidade leva cerca de 1 minuto. Sujeito à cota diária de GPU — para agentes de código contínuos, prefira o mangaba-titan. Não lê imagens.contexto 32.768 tokens · tool calling
• jev-latestTypeSafe · Jev · API parceira (decisão tipada)Modelo de decisão da TypeSafe: recebe um estado (texto ou JSON) e perguntas fechadas (escolha, nota) e devolve respostas tipadas com probabilidade e confiança. Só em POST /v1/systemone; não conversa.contexto 65.536 tokens
• jev-previewTypeSafe · Jev · API parceira (decisão tipada)Versão de prévia do Jev, da TypeSafe. Mesmo uso do jev-latest: decisões tipadas em POST /v1/systemone.contexto 65.536 tokens
• kev-4bCPU · Xeon Gold 6258RModelo de decisão aberto: acertou de 62% a 80% no teste de 04/10 e em sentimento (TweetSentBR) superou o Jev, 66% contra 60%. Abaixo do brier-v5 em inferência e um pouco mais rápido: ~1,2 s por pergunta (~1,5 s com três).
• kev-0.8bCPU · Xeon Gold 6258RDecisão tipada leve e multilíngue, em ~1 s. Em sentimento e avaliações de produtos acerta no nível do Jev (65% a 69%); em raciocínio fica bem atrás. Boa opção para alto volume.
• brier-v5CPU · Xeon Gold 6258RBrier v5, o modelo de decisão da Mangaba AI, treinado em português e contra instruções injetadas no estado. No teste de 18/10 venceu o Jev em avaliações de produtos (B2W: 76% contra 67%, com probabilidades bem mais calibradas) e empatou em inferência (ASSIN2: 79% contra 78%); em sentimento ficou à frente (71% contra 68%). Substitui o brier-v2 e o brier-v3, cujos nomes seguem aceitos.

A velocidade medida de cada um está em /modelos, calculada sobre as chamadas reais. O contexto é a janela por requisição — prompt maior retorna 400.