Aleph-Alpha/Kolibri-1 — new model trending #28 on Hugging Face

| Computing Resources | *Pre-training* (based on actual measurements), *excluding mid-training and long-context*: Hardware: 768 NVIDIA B200 (96 HGX 8xB200 nodes); Parallelism: EP8 FSDP16 DP6; Time: 21 days (511h, 392k GPUh)<br>*Mid-training*: 5 days, 90k GPUh (same setup as above)<br>*Long-Context*: 13h, 10k GPUh (same setup as above except parallelism: FSDP128 DP6)<br>FLOPS: **6.4e23** |

| Tech Report | <https://aleph-alpha.com/downloads/tech-report.pdf> |

## Intended use

Kolibri is intended to process text input and output in German and English

and to perform a wide range of tasks beyond natural-language generation, for

example multi-step reasoning, coding, structured extraction,

retrieval-augmented generation, long-document processing and agentic tool

calling.

Kolibri was pre-trained on sequences of 16,384 tokens, mid-trained on 65,536

and trained on 262,144 tokens in a final long-context phase, which is its

native context length. Because positional encoding is applied only in the

sliding-window layers, the context can be extended beyond that length

without any position scaling, in principle to arbitrary lengths. We have

validated quality and serving efficiency up to 1,048,576 tokens. For

latency- or throughput-sensitive deployments and for complex tasks, we

recommend contexts of at most 262,144 tokens. See the

[technical report](https://aleph-alpha.com/downloads/tech-report.pdf) for details.

For the kinds of systems Kolibri is meant to be integrated into, see AI

system types below; for uses that we encourage users to refrain from, see

Responsible Use.

## Design goals

Kolibri is designed to deliver strong German and English performance at low

serving cost. Its mixture-of-experts architecture activates only a small

fraction of its parameters for each token, keeping compute per token low

while retaining the capacity of a much larger model. The trade-off is

memory: the full model must be held in memory even though only part of it is

active at any time. To keep long contexts affordable, most attention layers

focus on nearby text, while a smaller number attend across the whole

context. We also developed a tokenizer tailored to German word structure, so

German text is processed efficiently without sacrificing English. Supporting

two languages rather than many is a deliberate choice of depth over breadth.

## AI system types

Kolibri is intended for integration into conversational assistants and

agentic workflows in German and English, in which a person reviews the

model's output before it is acted on rather than autonomous systems that act

unreviewed. It suits document-processing and drafting systems,

question-answering systems over an organisation's own material, and internal

knowledge and research tools. Its tool-calling and structured-output

capabilities make it appropriate for orchestration layers that call APIs,

execute code or run searches, provided the calling system validates the

results. In decision-support systems it belongs on the advisory side,

surfacing evidence and drafting options for a human to weigh, and it is not

intended as the deciding component. More broadly, it is built for human-AI

collaboration rather than unsupervised operation.

## Sustainability

### Energy consumption

9.5×10² MWh (estimated), including node power and data-centre overhead

(PUE). This includes pre-training, mid-training and long-context training.

It excludes SFT and RL, peak, idle and low-load states, and proxy and

ablation models.

### Energy measurement

For pre-training, we obtained the average power usage per node and the power

usage effectiveness (PUE) from the cluster provider. We multiplied these

with the number of nodes and the runtime to obtain a total energy estimate.

## Getting started

Kolibri requires the **aleph-alpha-inference** package that provides the

Kolibri vLLM plugin. You can either use the provided container image

`ghcr.io/aleph-alpha/aleph-alpha-inference`, or install the package from

[Aleph-Alpha/aleph-alpha-inference](https://github.com/Aleph-Alpha/aleph-alpha-inference),

which also installs the vLLM version it supports:

```bash

pip install 'aleph-alpha-inference>=1'

```

Serve the model with reasoning and tool-calling enabled:

```bash

vllm serve Aleph-Alpha/Kolibri-1 --kv-cache-dtype fp8 \

--reasoning-parser kolibri1 \

--tool-call-parser kolibri1 \

--enable-auto-tool-choice

```

To serve contexts beyond 262,144 tokens, add `--max-model-len 1048576

--hf-overrides '{"max_position_embeddings": 1048576}'`.

The recommended sampling parameters for the model are `temperature=1.0`,

`top_p=0.97` and `top_k=128`.

### Querying the server (OpenAI-compatible API)

```python

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(

model="Aleph-Alpha/Kolibri-1",

messages=[

{

"role": "user",

"content": "Erkläre kurz, was ein Mixture-of-Experts-Modell ist.",

},

],

extra_body={

"chat_template_kwargs": {

"reasoning_effort": "high",

"enable_thinking": True,

}

},

)

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

Text extracted automatically; images, tables and formatting may be missing. Original: https://huggingface.co/Aleph-Alpha/Kolibri-1