Como hospedar o Kolibri-1 e qual hardware ele exige

Hospedar o Kolibri-1: a resposta curta

É possível hospedar o Kolibri-1 localmente, mas não num VPS comum. A Aleph Alpha, de Heidelberg, publica o modelo sob a licença Apache 2.0. Os pesos no formato FP8 ocupam cerca de 78 GB. O método oficial é usar o vLLM em pelo menos uma H200 ou em duas placas gráficas com 80 GB de memória cada. Não existe um método oficial para CPU, GGUF, llama.cpp ou Ollama.

Para muitos leitores na Alemanha, há uma questão principal: os dados permanecem dentro da própria organização? Com o Kolibri-1, isso é possível, e a licença não impede essa utilização. O obstáculo é o hardware.

Estado das informações: tudo o que é apresentado aqui baseia-se no Model Card de Aleph-Alpha/Kolibri-1, na revisão e52eb4627d11516b0c01de49210ab5a4e4061444 (Hugging Face, 3 de outubro de 2026), e no pacote aleph-alpha-inference, na versão 1.0.0. Última verificação em 13 de outubro de 2026. Revisões posteriores podem apresentar outros valores. Verifique-as antes de alugar ou comprar hardware.

O que a Model Card define sobre Kolibri-1

• Arquitetura: MoE (Mixture of Experts). O modelo é composto por muitas redes parciais, os especialistas. Para cada token, apenas alguns fazem cálculos.
• Tamanho: 78 mil milhões de parâmetros no total, dos quais 3,46 mil milhões estão ativos por token. São 50 camadas com 384 especialistas cada, dos quais 6 são selecionados por token.
• Contexto: 262.144 tokens nativamente. Segundo a Card, a qualidade foi validada até 1.048.576 tokens.
• Pesos: FP8 (números de vírgula flutuante de 8 bits) no formato float8_e4m3fn, em blocos de 128×128. O embedding e o LM-Head usam bfloat16. Segundo a Card, ocupam cerca de 78 GB no total. O próprio repositório tem 78,9 GB.
• Dados de treino: 62,5 % em inglês, 23,9 % em alemão e 13,6 % em código, num pré-treino de 20 biliões de tokens. Inclui também um tokenizer que, segundo a Card, foi adaptado à estrutura das palavras alemãs.
• Licença: Apache 2.0. O repositório não é gated. Portanto, não precisas de solicitar acesso.

O ponto mais importante está nas duas primeiras linhas. 3,46 mil milhões de parâmetros ativos significam poucos cálculos por token. No entanto, a memória necessária depende dos 78 mil milhões de parâmetros. O router seleciona especialistas diferentes para cada token. Por isso, todos os especialistas têm de permanecer sempre na memória da GPU. Um modelo MoE faz cálculos como um modelo pequeno, mas ocupa memória como um modelo grande.

O tokenizer também tem um efeito prático. Um tokenizer divide o texto em tokens. Se for pouco adequado à língua, uma palavra alemã longa é dividida em muitos fragmentos pequenos. Isso consome contexto e tempo de cálculo. Um tokenizer adaptado ao alemão precisa de menos tokens para o mesmo texto.

Os valores de benchmark da Card

A Aleph Alpha apresenta dois valores globais para o modelo pós-treinado. São resultados da avaliação própria do fabricante, não de um teste independente.

[
  {
    "label": "Deutsch (Overall DE)",
    "overall": 70.8
  },
  {
    "label": "Englisch (Overall EN)",
    "overall": 75.5
  }
]

Em alemão, o Kolibri-1 atinge 70.8 pontos segundo a Card; em inglês, 75.5. Assim, este modelo também é um pouco mais forte em inglês. Só um teste com os teus próprios documentos mostra se é suficiente para as tuas tarefas.

O que mudou em relação ao Pharia

A série de modelos anterior da Aleph Alpha chamava-se Pharia. A Card de Pharia-1-LLM-7B-control menciona a Open Aleph License. Esta permite investigação e ensino não comerciais. Para utilização comercial, era necessário contactar diretamente a Aleph Alpha. O Kolibri-1 está, por outro lado, sob a licença Apache 2.0. Podes utilizar o modelo na empresa e também redistribuí-lo depois de o alterar, desde que incluas o texto da licença e os avisos correspondentes.

Qual GPU o Kolibri-1 requer?

A Card indica dois níveis. Mínimo: 2× A100 80 GB, 2× H100 SXM5, 1× H200, 1× B200 ou 1× B300. Recomendado: 2× H100 SXM5, 2× H200, 1× B200 ou 1× B300.

Por que uma única H100 não é suficiente? O cálculo é simples. Subtraia os pesos da memória da GPU, a VRAM (video random access memory). O que sobra é usado principalmente pelo vLLM para o KV-cache. O KV-cache armazena as chaves e os valores (keys e values) das camadas de Attention para cada token do contexto. Sem ele, o modelo não consegue manter o contexto.

[
  {
    "config": "1\u00d7 H100 80 GB",
    "vram_gb": 80,
    "gewichte_gb": 79,
    "rest_gb": 1
  },
  {
    "config": "1\u00d7 H200",
    "vram_gb": 141,
    "gewichte_gb": 79,
    "rest_gb": 62
  },
  {
    "config": "2\u00d7 A100 80 GB",
    "vram_gb": 160,
    "gewichte_gb": 79,
    "rest_gb": 81
  },
  {
    "config": "2\u00d7 H100 SXM5",
    "vram_gb": 160,
    "gewichte_gb": 79,
    "rest_gb": 81
  },
  {
    "config": "2\u00d7 H200",
    "vram_gb": 282,
    "gewichte_gb": 79,
    "rest_gb": 203
  }
]

Uma H100 tem 80 GB, e os pesos ocupam 79 GB. Teoricamente, sobram 1 GB. Isso não é suficiente para um contexto utilizável. Uma H200 deixa 62 GB livres, e duas H200 deixam 203 GB livres. A reserva real é menor. Por padrão, o vLLM usa apenas 92 % da memória da GPU (--gpu-memory-utilization, valor padrão 0.92 no vLLM 0.29.0), e as ativações também precisam de espaço. Estes valores são cálculos aproximados arredondados, não uma medição.

Duas características da arquitetura reduzem a carga sobre o KV-cache. Primeiro, de acordo com a Card, o Kolibri-1 combina camadas com Sliding-Window-Attention e camadas com Attention completa na proporção de 4:1. Uma camada Sliding-Window armazena apenas os tokens de uma janela fixa. Por isso, o respetivo cache não cresce com o comprimento total do contexto. Segundo, a Card recomenda --kv-cache-dtype fp8. Assim, cada entrada do cache ocupa metade da memória necessária em 16 bits. As camadas com Attention completa continuam a crescer a cada token. Com 262.144 tokens, isto fica apertado numa única H200.

Por que um VPS comum não consegue executar o Kolibri-1

A Aleph Alpha publica apenas o método com vLLM e GPU. A página não menciona execução em CPU, GGUF, llama.cpp nem Ollama. Um VPS comum com CPU não tem memória de vídeo. Por isso, não tem a base necessária para esse método.

Ainda assim, existem conversões para GGUF feitas pela comunidade no Hugging Face. A pesquisa por "kolibri-1 gguf" listava oito repositórios para o Kolibri-1 em 6 de outubro de 2026; em 13 de outubro de 2026, eram onze. O ficheiro Q4_K_M tem cerca de 47,5 GB e, em teoria, caberia num servidor com 64 GB de RAM. No entanto, os repositórios que verificámos em 6 de outubro de 2026 afirmam que o llama.cpp normal não conhece a arquitetura kolibri1. É necessária uma versão com patches num commit específico. Até 13 de outubro de 2026, nada mudou: no llama.cpp, existe apenas um pedido de funcionalidade aberto para o Kolibri-1. Alguns autores testaram contextos longos. A Prompt48 relata que o Q4_K_M recuperou exatamente uma informação de teste (Needle) numa A100 com 195.935 tokens e, com contexto ampliado, com 718.803 tokens. A Hob-forge recuperou três factos ocultos com até 253.646 tokens, numa execução com -c 262144. Estes são testes de recuperação, não benchmarks. A Prompt48 e a Hob-forge afirmam explicitamente que ainda não existe uma comparação de benchmark com o original em FP8. Isto não é uma base adequada para dados empresariais. É uma experiência.

O guia sobre o tamanho que um LLM pode ter para a sua RAM mostra passo a passo quanta RAM um modelo necessita em cada quantização. O motivo pelo qual o vLLM é a ferramenta adequada neste caso é explicado em a comparação entre Ollama e vLLM: o vLLM foi concebido para muitas solicitações paralelas em GPUs, enquanto o Ollama facilita o arranque com modelos quantizados.

Instalar o Kolibri-1 com vLLM

Precisas de um servidor Linux com uma GPU NVIDIA compatível e o respetivo controlador instalado. O que deves ter em conta ao alugar o servidor está descrito em visão geral dos VPS com GPU. Primeiro, confirma o hardware efetivamente disponível:

nvidia-smi --query-gpu=name,memory.total --format=csv

A saída mostra o nome e a memória, em MiB, de cada placa. Uma H100 deve indicar cerca de 81.000 MiB, e uma H200 cerca de 143.000 MiB. Se o comando não indicar nenhum controlador, o controlador NVIDIA não está instalado. Nesse caso, o vLLM também não encontra nenhuma GPU.

Depois, cria um ambiente Python próprio. O pacote instala o vLLM e o PyTorch dentro de intervalos de versões definidos. Num ambiente separado, isso não interfere com os restantes programas do servidor.

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/kolibri
source ~/kolibri/bin/activate
pip install 'aleph-alpha-inference==1.0.0'
pip show vllm aleph-alpha-inference

O Card escreve pip install 'aleph-alpha-inference>=1'. Aqui, a versão está fixada em 1.0.0. Assim, uma versão posterior não altera a configuração sem aviso. A versão 1.0.0 requer Python 3.10 ou posterior e vLLM a partir de 0.29.0, mas inferior a 0.30.0. Por isso, pip show deve mostrar uma versão vLLM 0.29.x. O pacote é um plugin para vLLM. Regista os parsers kolibri1 para raciocínio e chamadas de ferramentas. Sem o plugin, o vLLM não reconhece estes nomes.

A Aleph Alpha também disponibiliza uma imagem de contentor: ghcr.io/aleph-alpha/aleph-alpha-inference. Quem gere servidores GPU com contentores pode usar esta opção.

Desativar a telemetria do vLLM

Por predefinição, o vLLM envia estatísticas de utilização anónimas. Se o objetivo for impedir que qualquer dado saia do servidor, desativa essa opção antes do arranque:

export VLLM_NO_USAGE_STATS=1
export DO_NOT_TRACK=1

Iniciar o servidor

O comando segue o Card, com duas adições: uma revisão fixa e uma ligação a localhost.

vllm serve Aleph-Alpha/Kolibri-1 \
  --revision e52eb4627d11516b0c01de49210ab5a4e4061444 \
  --host 127.0.0.1 --port 8000 \
  --kv-cache-dtype fp8 \
  --reasoning-parser kolibri1 \
  --tool-call-parser kolibri1 \
  --enable-auto-tool-choice

--revision define qual a revisão dos pesos a carregar. Sem esta opção, o vLLM carrega a versão atual de main. Se a Aleph Alpha alterar o repositório, o modelo será alterado no próximo download. --host 127.0.0.1 torna a API acessível apenas localmente. Sem esta opção, o vLLM fica à escuta em todas as interfaces de rede. A porta 8000 fica aberta assim que a firewall permitir o acesso.

Com duas GPUs, acrescenta --tensor-parallel-size 2. Esta opção distribui cada camada pelas duas placas. Sem ela, o vLLM utiliza apenas uma GPU, e os pesos não cabem numa única placa de 80 GB.

No primeiro arranque, o vLLM descarrega cerca de 79 GB do Hugging Face para ~/.cache/huggingface. Reserva espaço livre suficiente em disco para esse download e para o ambiente Python. Depois do primeiro download bem-sucedido, podes usar export HF_HUB_OFFLINE=1 para impedir qualquer contacto posterior com o Hugging Face. Os pesos serão então carregados apenas a partir da cache local.

Se a memória não for suficiente para o contexto completo de 262.144 tokens, o vLLM não inicia. A mensagem de erro indica que a cache KV é demasiado pequena para o comprimento máximo da sequência. Nesse caso, define um limite menor, por exemplo, --max-model-len 65536. O Card inicia o contexto expandido até 1.048.576 tokens com --max-model-len 1048576 e --hf-overrides '{"max_position_embeddings": 1048576}'. Esta configuração requer bastante mais memória e deve ser usada nas configurações recomendadas.

Verificar se o modelo responde

Assim que o log indicar que o servidor está a funcionar na porta 8000, testa a API compatível com OpenAI:

curl http://127.0.0.1:8000/v1/models
curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "Aleph-Alpha/Kolibri-1", "messages": [{"role": "user", "content": "Was ist die Hauptstadt von Frankreich?"}], "chat_template_kwargs": {"enable_thinking": false}}'

A primeira chamada deve listar Aleph-Alpha/Kolibri-1 como modelo. A segunda deve devolver JSON em que choices[0].message.content indica Paris. enable_thinking: false desativa o modo de raciocínio para este pedido. Por predefinição, o modo está ativo. Segundo o Card, reasoning_effort também funciona com o valor none. Para o sampling, o Card recomenda temperature=1.0, top_p=0.97 e top_k=128.

Para acederes a partir do teu computador, não precisas de abrir uma porta. Basta um túnel SSH:

ssh -L 8000:127.0.0.1:8000 user@dein-server

Depois, a API fica disponível no teu computador em http://127.0.0.1:8000. Se outros serviços da rede precisarem de aceder, define também --api-key e coloca à frente um reverse proxy com TLS (transport layer security).

Quanto custa uma hora de Kolibri-1 em euros?

Os preços do aluguer de GPU variam muito consoante o fornecedor e a região. O cálculo abaixo usa duas premissas, com referência a outubro de 2026: 3,50 euros por hora para uma H200 e 2,50 euros por hora para uma H100 SXM5, em ambos os casos on demand e sem IVA. Alguns fornecedores especializados ficam abaixo destes valores. Os hyperscalers nas regiões da UE ficam muitas vezes bastante acima. Substitua estes valores pelas suas próprias ofertas. O método de cálculo mantém-se igual.

[
  {
    "plan": "1\u00d7 H200, rund um die Uhr",
    "eur_pro_stunde": 3.5,
    "stunden_pro_monat": 730,
    "eur_pro_monat": 2555
  },
  {
    "plan": "2\u00d7 H100 SXM5, rund um die Uhr",
    "eur_pro_stunde": 5,
    "stunden_pro_monat": 730,
    "eur_pro_monat": 3650
  },
  {
    "plan": "1\u00d7 H200, nur B\u00fcrozeit",
    "eur_pro_stunde": 3.5,
    "stunden_pro_monat": 176,
    "eur_pro_monat": 616
  }
]

Um mês tem, em média, 730 horas. Se uma H200 funcionar continuamente, custa 2555 euros por mês. A variante recomendada, com duas H100, custa 3650 euros. Quem só mantiver a máquina ligada durante o horário de expediente, ou seja, 8 horas em 22 dias úteis, totalizando 176 horas, pagará 616 euros. Nesse caso, cada arranque carrega novamente os pesos para a memória da GPU, o que demora alguns minutos.

A partir de que ponto compensa em comparação com tokens de API?

A Card não indica, com referência a outubro de 2026, nenhuma API alojada para Kolibri-1. Uma comparação com preços por token significa, portanto, comparar Kolibri-1 numa GPU própria com outro modelo através de uma API. Para o cálculo, assumimos dois preços por milhão de tokens, combinando entrada e saída: 0,50 euros para um modelo económico e 2 euros para um modelo mais caro.

[
  {
    "plan": "1\u00d7 H200, rund um die Uhr",
    "mio_token_bei_0_50_eur": 5110,
    "mio_token_bei_2_eur": 1277.5,
    "token_pro_sekunde_bei_0_50_eur": 1944
  },
  {
    "plan": "2\u00d7 H100 SXM5, rund um die Uhr",
    "mio_token_bei_0_50_eur": 7300,
    "mio_token_bei_2_eur": 1825,
    "token_pro_sekunde_bei_0_50_eur": 2778
  },
  {
    "plan": "1\u00d7 H200, nur B\u00fcrozeit",
    "mio_token_bei_0_50_eur": 1232,
    "mio_token_bei_2_eur": 308,
    "token_pro_sekunde_bei_0_50_eur": 1944
  }
]

A 0,50 euros por milhão de tokens, a H200 em funcionamento contínuo só cobre os seus custos a partir de 5110 milhões de tokens por mês. Isto corresponde, em média, a 1944 tokens por segundo, continuamente, dia e noite. A 2 euros por milhão de tokens, o limiar da variante usada apenas durante o horário de expediente desce para 308 milhões de tokens. Tem de medir se uma única placa consegue atingir este débito com a combinação de comprimentos dos prompts e das respostas que utiliza. O cálculo indica apenas a partir de que volume a questão se torna relevante.

O método detalhado, com utilização e tempo de inatividade, está em no cálculo do ponto de equilíbrio entre servidor GPU e tokens de API. No caso do Kolibri-1, há ainda um fator que nenhuma tabela consegue representar. Quem pretende alojar o Kolibri-1 por causa dos dados muitas vezes nem sequer o compara com uma API. Se os documentos não puderem sair da organização, a API fica excluída. Nesse caso, a questão real é: alugar uma GPU num centro de dados da UE com um acordo de tratamento de dados (AVV) ou comprar hardware próprio. Uma GPU alugada também fica nas instalações de um terceiro. Ao abrigo do RGPD (Regulamento Geral sobre a Proteção de Dados), isto constitui um tratamento de dados por subcontratante, e não uma operação nas próprias instalações.

Quando um modelo local menor é a resposta honesta

O Kolibri-1 vale a pena quando precisa das suas vantagens. De acordo com o Card, estas incluem chamadas de ferramentas e processamento de documentos com contexto longo. 262.144 tokens permitem incluir uma pasta completa de contratos num único pedido. Se as suas tarefas forem mais curtas, o cálculo é diferente.

Para organizar e-mails ou gerar resumos curtos, um modelo com 7 a 14 mil milhões de parâmetros costuma ser suficiente. Quantizado para 4 bits, funciona com o Ollama num VPS com CPU e 16 a 32 GB de RAM. É mais lento do que uma GPU, mas é suficiente para algumas centenas de pedidos por dia. A instrução para alojar o Ollama num VPS mostra como fazer isso. Nesse caso, os custos correspondem ao preço mensal normal de um servidor, e não a uma cobrança por hora de GPU.

O modelo pequeno mais óbvio da mesma organização seria o Pharia-1-LLM-7B-control. No entanto, segundo o texto da licença, a sua licença, a Open Aleph License, permite apenas fins não comerciais e não administrativos. Por isso, não é uma solução para utilização empresarial.

Só é possível tomar uma decisão honesta com um teste. Recolha 50 tarefas reais do seu dia a dia. Peça ao Kolibri-1, numa GPU alugada à hora, e a um modelo pequeno, num VPS com CPU, que as resolvam. Depois, compare as respostas. Algumas horas de aluguer para o teste custam pouco em comparação com a compra de hardware inadequado.

O resultado da mesma pergunta com outro modelo aberto mostra o que é necessário para alojar o Kimi K3 por conta própria. A comparação ajuda a enquadrar os resultados: com cerca de 78 GB de pesos, o Kolibri-1 pertence ao grupo de modelos que ainda cabe numa única placa.

FAQ

Posso usar o Kolibri-1 comercialmente?

Sim. Segundo o Model Card, o Kolibri-1 está disponível sob a licença Apache 2.0. Pode usá-lo na empresa e distribuí-lo também com alterações, desde que inclua o texto da licença e os avisos necessários. Isto diferencia o Kolibri-1 da série Pharia anterior: o Card do Pharia-1-LLM-7B-control indica a Open Aleph License, que, segundo o texto da licença, permite apenas fins não comerciais e não administrativos.

O Kolibri-1 funciona com Ollama ou na CPU?

Não oficialmente. A Aleph Alpha publica apenas o método com vLLM em GPUs NVIDIA, usando o plugin aleph-alpha-inference. Existem ficheiros GGUF em vários repositórios da comunidade, incluindo uma versão de cerca de 47,5 GB em Q4_K_M. É necessário usar um llama.cpp corrigido, porque o llama.cpp normal não reconhece a arquitetura kolibri1. Alguns autores relatam testes de recuperação concluídos com contexto longo, com mais de 700.000 tokens. No entanto, segundo os próprios autores, não existe uma comparação de benchmark com o original FP8.

Uma única H100 com 80 GB é suficiente para o Kolibri-1?

Não. Os pesos FP8 ocupam cerca de 78 GB. Praticamente não sobra memória para a cache KV, que mantém o contexto. O Card indica, entre outras opções, um mínimo de duas H100 SXM5 ou uma H200. Com duas placas, inicie o vLLM com --tensor-parallel-size 2.

Como desativo o modo de raciocínio do Kolibri-1?

O modo de raciocínio está ativado por predefinição. Desative-o por pedido com "chat_template_kwargs": {"enable_thinking": false} no corpo JSON. Segundo o Card, reasoning_effort também funciona com o valor none. Quando o modo está ativado, --reasoning-parser kolibri1 separa o texto do raciocínio da resposta propriamente dita.