Instructions to use OVHaiLLM/Olala-v1.0-mini-7A1B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use OVHaiLLM/Olala-v1.0-mini-7A1B with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="OVHaiLLM/Olala-v1.0-mini-7A1B", trust_remote_code=True) messages = [ {"role": "user", "content": "Who are you?"}, ] pipe(messages)# pip install -U transformers accelerate # Load model directly from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained("OVHaiLLM/Olala-v1.0-mini-7A1B", trust_remote_code=True, device_map="auto") - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use OVHaiLLM/Olala-v1.0-mini-7A1B with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "OVHaiLLM/Olala-v1.0-mini-7A1B" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "OVHaiLLM/Olala-v1.0-mini-7A1B", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker
docker model run hf.co/OVHaiLLM/Olala-v1.0-mini-7A1B
- SGLang
How to use OVHaiLLM/Olala-v1.0-mini-7A1B with SGLang:
Install from pip and serve model
# Install SGLang from pip: pip install sglang # Start the SGLang server: python3 -m sglang.launch_server \ --model-path "OVHaiLLM/Olala-v1.0-mini-7A1B" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "OVHaiLLM/Olala-v1.0-mini-7A1B", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker images
docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=<secret>" \ --ipc=host \ lmsysorg/sglang:latest \ python3 -m sglang.launch_server \ --model-path "OVHaiLLM/Olala-v1.0-mini-7A1B" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "OVHaiLLM/Olala-v1.0-mini-7A1B", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }' - Docker Model Runner
How to use OVHaiLLM/Olala-v1.0-mini-7A1B with Docker Model Runner:
docker model run hf.co/OVHaiLLM/Olala-v1.0-mini-7A1B
Olala-v1.0-mini-7A1B
Olala-v1.0-mini-7A1B is a small reasoning model for chat, instruction following and tool use, built on our hybrid Mamba-3 / attention mixture-of-experts architecture.
- Made in Europe, open by design: designed in France by OVHai LLM (OVHcloud group), trained on three European supercomputers (JUPITER, Jean Zay and MeluXina) on 12.8T tokens of public datasets and our own synthetic data, and released with open weights under Apache 2.0.
- Efficient: about 1B active parameters per token, and only 7 of its 36 layers keep a KV cache. It runs on a laptop.
- Reasoning and agentic: it thinks before it answers, with four reasoning-effort levels, and was trained with reinforcement learning to call tools and to search over many turns.
Find more information in our technical report.
Model details
The Olala-v1.0-mini family includes a base model, the SFT checkpoint, this post-trained model and two specialized models.
| Model | Description |
|---|---|
| Olala-v1.0-mini-7A1B-base | Pre-trained base model (12.8T tokens) |
| Olala-v1.0-mini-7A1B-SFT | After supervised fine-tuning, before RL |
| Olala-v1.0-mini-7A1B | Final post-trained model: reasoning, chat and tool use |
| Olala-v1.0-summarise | Specialized for document summarization |
| Olala-v1.0-translate | Specialized for machine translation, including financial documents |
| Property | Specification |
|---|---|
| Checkpoint | Post-trained (SFT + reinforcement learning), text-only language model |
| Parameters | 6.8B total, about 1B active per token |
| Architecture | 36 layers: 29 Mamba-3 and 7 attention layers (one in five), each followed by a mixture-of-experts block with 256 routed experts (6 active) and 1 shared expert |
| Context length | 32K tokens (input + output) A 128K-context version is coming soon. |
| Vocabulary | 151,936 tokens |
| Training data | 12.8T tokens: public datasets and our own synthetic data |
| Languages | Pre-trained on English and 36 other languages (38 in annealing), mostly European, plus Arabic, Chinese, Japanese and Korean (full list in the technical report). Multilingual post-training evaluation covers 11 languages (MGSM) and 8 languages (Multi-IF). |
| License | Apache 2.0 |
Olala-v1.0-mini-7A1B is designed for reasoning, instruction following, multilingual chat and tool calling.
Inference
Hosted inference
Olala 1.0 mini is served by OVHcloud AI Endpoints (directly, or through your Hugging Face account) and by Blade:
| Option | Use it for | How |
|---|---|---|
| OVHcloud AI Endpoints | A production API, OpenAI-compatible, hosted in Europe | Base URL https://oai.endpoints.kepler.ai.cloud.ovh.net/v1, model Olala-v1.0-mini-7A1B; create an AI Endpoints key for more than a few requests per minute |
Hugging Face Inference Providers (ovhcloud) |
The same AI Endpoints service, with your Hugging Face token and billing | The snippet below, or the inference panel on this page |
| Blade (by Shadow) | An OpenAI-compatible API on GPUs in Europe, free to start, with a playground (LLM Studio) | Create a key on the Blade console; base URL https://api.models.blade.sh/v1, model olala |
| OVHcloud AI Deploy | Your own GPU: a fine-tuned model, a private deployment | Run our pre-built vLLM image ovhaillm/olala-vllm (command below). For a fine-tuned model: AI Deploy guide |
| Hugging Face Space | A demo | Call the OVHcloud provider from a Gradio Space (CPU hardware is enough). To run the weights inside a Space, use a Docker Space with our vLLM image ovhaillm/olala-vllm or one of the forks below |
| Hugging Face Inference Endpoints | A dedicated GPU on Hugging Face | A custom container with our vLLM image ovhaillm/olala-vllm: the default engines cannot load the olala architecture |
import os
from openai import OpenAI
client = OpenAI(base_url="https://huggingface.co/proxy/router.huggingface.co/v1", api_key=os.environ["HF_TOKEN"])
response = client.chat.completions.create(
model="OVHaiLLM/Olala-v1.0-mini-7A1B:ovhcloud",
messages=[{"role": "user", "content": "Explain how a heat pump works."}],
temperature=0.8, top_p=0.9,
)
print(response.choices[0].message.content)
Run it yourself
Ollama, LM Studio and the official llama.cpp, vLLM and mlx-lm cannot load Olala 1.0 mini yet: each option below uses one of our forks. With no installation, use OVHcloud AI Endpoints (see Hosted inference).
| You have | Use | Guide |
|---|---|---|
| A Mac with Apple Silicon (M2 or later, 16 GB) | MLX, 5.4 GB | MLX card |
| A Mac M1, a PC without GPU, or one NVIDIA GPU for yourself | llama.cpp (GGUF), 6 to 14 GB | GGUF card |
| An NVIDIA GPU server (24 GB or more) for an application | vLLM, this repo | below |
| Python research code | Transformers, this repo | below |
vLLM (Linux, NVIDIA GPU with 24 GB or more, Python 3.12; tested on L4 and L40S):
git clone https://github.com/OVHai-LLM/vllm.git vllm-fork
VLLM_USE_PRECOMPILED=1 \
VLLM_PRECOMPILED_WHEEL_COMMIT=4135590ffe0119dab806d78a7eee6dff3be2618e \
VLLM_VERSION_OVERRIDE=0.33.0 \
pip install ./vllm-fork
vllm serve OVHaiLLM/Olala-v1.0-mini-7A1B --trust-remote-code \
--mamba-ssm-cache-dtype float32 \
--reasoning-parser olala --tool-call-parser olala --enable-auto-tool-choice \
--max-model-len 32688 --port 8000
Or skip the install with our pre-built image of the same fork, ovhaillm/olala-vllm.
Its entrypoint is vllm serve, so the arguments are the model and its options:
docker run --gpus all --ipc=host -p 8000:8000 \
-v ~/.cache/huggingface:/root/.cache/huggingface \
ovhaillm/olala-vllm:latest \
OVHaiLLM/Olala-v1.0-mini-7A1B --trust-remote-code \
--mamba-ssm-cache-dtype float32 \
--reasoning-parser olala --tool-call-parser olala --enable-auto-tool-choice \
--max-model-len 32688
The image is built on CUDA 13.0: it needs an NVIDIA driver 580 or later on the host.
vLLM: always serve this model with
--mamba-ssm-cache-dtype float32. vLLM's default keeps the Mamba recurrent state in bf16, and long generations then degrade into repetition loops.
The first start compiles the GPU kernels (about 8 minutes). Then use any OpenAI client on http://localhost:8000/v1:
curl -s http://localhost:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{
"model": "OVHaiLLM/Olala-v1.0-mini-7A1B",
"messages": [{"role": "user", "content": "Explain how a heat pump works."}],
"temperature": 0.8, "top_p": 0.9, "top_k": 40,
"chat_template_kwargs": {"reasoning_effort": "medium"}
}'
The reply has the reasoning in reasoning_content, the answer in content and tool calls in tool_calls.
Transformers (research code; an NVIDIA GPU, or the CPU). The model code runs in plain PyTorch, so a standard install is enough:
pip install torch "transformers==5.8.*" accelerate einops
Without extra packages, the Mamba-3 layers and the experts run in plain PyTorch: correct, but slow (on the CPU
alone, about 6 tokens/s on a 64-core server). For speed, also install the kernels the model code picks up by
itself: the Mamba-3 kernels (mamba_ssm) from the
mamba fork (branch dev), scattermoe
and flash_attn. They compile at install time (flash-attn alone can take an hour);
OVHai-LLM/olala-v1 pins a set that works.
from transformers import AutoModelForCausalLM, AutoTokenizer
repo = "OVHaiLLM/Olala-v1.0-mini-7A1B"
tok = AutoTokenizer.from_pretrained(repo, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(repo, trust_remote_code=True, dtype="bfloat16",
device_map="cuda") # or "cpu" without a GPU (slow)
inputs = tok.apply_chat_template(
[{"role": "user", "content": "Explain how a heat pump works."}],
add_generation_prompt=True, reasoning_effort="medium", return_tensors="pt", return_dict=True,
).to(model.device)
out = model.generate(**inputs, max_new_tokens=4096, use_cache=True,
do_sample=True, temperature=0.8, top_p=0.9, top_k=40)
print(tok.decode(out[0, inputs["input_ids"].shape[1]:], skip_special_tokens=False))
Keep use_cache=True (the config turns it off) and send one prompt at a time.
Settings. Sampling: temperature=0.8, top_p=0.9, top_k=40 (all scores on this card use them).
Reasoning effort, how long the model thinks before answering: disabled, low, medium (default) or high
(best for math, slower). Pass it as reasoning_effort to apply_chat_template(), or in
chat_template_kwargs in a vLLM request.
Chat template
Olala 1.0 mini writes in channels. Its reasoning goes in an analysis channel, the answer in a final channel and tool
calls in a tools channel:
<|im_start|>assistant<|channel_start|>analysis<|content|>...reasoning...<|channel_end|><|channel_start|>final<|content|>...answer...<|channel_end|><|im_end|>
Use tokenizer.apply_chat_template() with add_generation_prompt=True to format messages automatically. The
template starts with a built-in system prompt; a system message you pass is added after it as developer
instructions.
Reasoning is enabled by default (medium). With reasoning_effort="disabled", the template closes the analysis
channel empty and the model answers directly.
Reasoning from earlier assistant turns is removed unless preserve_thinking=True.
Tool calling
Pass function schemas through tools=... to apply_chat_template() (or tools in the OpenAI-compatible API
with the vLLM tool parser). Generated calls are XML with JSON arguments, in the tools channel:
<toolcalls><call id="call_0"><name>get_weather</name><arguments>{"city": "Paris"}</arguments></call></toolcalls>
Several independent calls can share one <toolcalls> block. Execute the calls in your application, add the
assistant message with its tool_calls to the history, then append each result as a tool message with its
tool_call_id. Keep passing the tool schemas on later requests.
Examples
Two small repos show Olala 1.0 mini working with tools through any OpenAI-compatible endpoint:
- olala-mini-tools: answer questions about a database in SQL, pick the right connector (CRM, mail, calendar) and fill in its parameters, classify incoming messages. In French and English.
- choose-the-right-beam: an engineering task with three tools (a catalogue in SQL, calculations in Python, project notes). The model reads and writes; the code checks each step. In French.
Fine-tuning
To adapt Olala 1.0 mini to your own data, use the ready-to-run fine-tuning image on Docker Hub (x86-64, one NVIDIA H100). It trains a LoRA adapter on Olala-v1.0-mini-7A1B and merges it into a complete model. You write no training code: you give a file of examples and run one job.
Step by step on OVHcloud: fine-tune with AI Training (en français), then deploy the fine-tuned model with AI Deploy (en français).
Each line of the training file is one conversation. The model learns to produce the assistant turn:
{"messages": [{"role": "system", "content": "You are the support assistant of an online shop. Classify the customer message into one of these categories: delivery, refund, product, account. Answer with the category only."}, {"role": "user", "content": "I still haven't received the order I placed last week."}, {"role": "assistant", "content": "delivery"}], "chat_template_kwargs": {"reasoning_effort": "disabled"}}
"reasoning_effort": "disabled" makes the model answer directly. Put a few thousand examples in data/train.jsonl and a
few hundred others in data/eval.jsonl, then run (tested with the image's command on one H200, the same
Hopper generation as the H100; 1,000 examples train in about 7 minutes):
mkdir -p model data out && chmod 0777 model data out # the image runs as UID 42420
docker run --gpus all --rm \
-v "$PWD/model:/workspace/model" \
-v "$PWD/data:/workspace/data" \
-v "$PWD/out:/workspace/out" \
-e DOWNLOAD_DATA=0 \
-e TRAIN_FILE=/workspace/data/train.jsonl \
-e EVAL_FILE=/workspace/data/eval.jsonl \
-e SKIP_BENCH=1 \
ovhaillm/olala-ai-training:20261117
The first run downloads the model into model/ (about 14 GB); later runs reuse it. The complete fine-tuned model is
written to out/merged/, next to the adapter (out/adapter/). Serve it with vLLM as shown above, or with the
ovhaillm/olala-ai-deploy image on one L4 GPU (tested).
No data yet? Run the same command without the
-eoptions: the job downloads a public English↔French dataset from the European Central Bank, fine-tunes the model on it, and scores the translations (BLEU, chrF++) before and after.
Performance
Benchmarks
Over twelve benchmarks, Olala-v1.0-mini-7A1B averages 68.0, 15.2 points above its SFT checkpoint. It is strongest on instruction following and weakest on competition mathematics.
The table shows all 19 models we evaluated, grouped by size. Scores in %; bold is the best score on each benchmark, underlined the second best.
| Ours | 7-8B MoE, ~1B active | Up to 2B dense | 2.6-4B dense | 7-9B dense | 23B dense | ||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Benchmark | Olala v1.0-mini-7A1B 7B-A1B |
Granite 4.0-H-Tiny 7B-A1B |
LFM2.5 8B-A1B 8B-A1B |
Ling 3.0-tiny 7.9B-A1.3B |
OLMoE 1B-7B-Instruct 7B-A1B |
LFM3-1.7B 1.7B |
Qwen3.5-2B 2B |
LFM2.5 2.6B 2.6B |
Ministral 3-3B-Reasoning 3B |
Qwen3.5-4B 4B |
SmolLM3-3B 3B |
Apertus 8B-Instruct 8B |
EuroLLM 9B-Instruct 9B |
Falcon H1R-7B 7B |
Ministral 3-8B-Reasoning 8B |
Mistral 7B-Instruct-v0.3 7B |
Olmo 3-7B-Think 7B |
Luciole 23B-Instruct 23B |
Luciole 23B-Thinking 23B |
| Instruction following | |||||||||||||||||||
| IFBench | 57.7 | 14.3 | 48.3 | 57.3 | 17.0 | 70.0 | 35.3 | 59.0 | 33.7 | 49.7 | 19.0 | 19.3 | 15.0 | 45.3 | 27.0 | 18.0 | 38.7 | 26.3 | 23.7 |
| Multi-IF | 71.2 | 44.5 | 71.0 | 75.2 | 25.0 | 83.6 | 57.3 | 77.7 | 48.6 | 71.8 | 42.9 | 41.8 | 37.7 | 65.7 | 49.7 | 25.5 | 61.2 | 51.6 | 54.6 |
| LIFEBench | 79.3 | 63.4 | 77.8 | 82.3 | 51.0 | 82.7 | 82.0 | 79.3 | 68.4 | 84.0 | 64.6 | 62.4 | 64.0 | 72.1 | 72.8 | 58.2 | 71.1 | 61.5 | 64.3 |
| Knowledge and reading | |||||||||||||||||||
| GPQA Diamond | 50.5 | 30.3 | 41.9 | 68.7 | 15.7 | 62.6 | 63.1 | 56.1 | 42.4 | 75.8 | 42.9 | 23.7 | 30.3 | 62.1 | 56.6 | 21.2 | 48.5 | 28.8 | 36.4 |
| TruthfulQA | 66.6 | 48.7 | 68.9 | 66.5 | 12.7 | 65.6 | 60.5 | 62.9 | 47.7 | 74.7 | 59.9 | 21.7 | 47.4 | 67.3 | 63.4 | 8.0 | 65.6 | 57.6 | 64.3 |
| DROP | 83.8 | 64.7 | 73.1 | 87.6 | 36.4 | 85.5 | 81.4 | 79.6 | 82.2 | 86.3 | 54.0 | 55.0 | 62.5 | 85.7 | 85.6 | 35.8 | 86.7 | 63.4 | 78.7 |
| Code | |||||||||||||||||||
| HumanEval+ | 88.3 | 77.4 | 79.9 | 92.0 | 32.4 | 92.2 | 48.3 | 90.2 | 92.6 | 83.4 | 81.3 | 34.6 | 36.0 | 93.4 | 93.8 | 32.8 | 91.1 | 44.1 | 77.4 |
| MBPP+ | 75.1 | 72.8 | 64.2 | 79.1 | 26.0 | 80.8 | 49.0 | 74.9 | 78.5 | 73.5 | 70.8 | 44.3 | 48.6 | 82.0 | 81.0 | 45.7 | 79.0 | 62.6 | 71.7 |
| Math | |||||||||||||||||||
| AIME 2024 | 60.7 | 4.0 | 64.7 | 78.7 | 0.7 | 81.3 | 24.0 | 66.7 | 74.7 | 80.7 | 46.0 | 0.0 | 0.0 | 94.0 | 78.0 | 0.0 | 69.3 | 10.0 | 30.0 |
| AIME 2025 | 61.3 | 4.7 | 48.0 | 70.0 | 0.0 | 79.3 | 26.7 | 51.3 | 70.0 | 74.7 | 32.7 | 0.0 | 0.7 | 82.7 | 78.0 | 0.0 | 64.0 | 13.3 | 31.3 |
| AIME 2026 | 52.7 | 10.0 | 48.0 | 75.3 | 0.0 | 80.0 | 27.3 | 57.3 | 73.3 | 82.0 | 45.3 | 0.7 | 0.7 | 90.0 | 82.7 | 0.0 | 67.3 | 6.0 | 23.3 |
| MGSM | 68.7 | 62.0 | 60.5 | 73.7 | 22.0 | 79.3 | 73.3 | 75.7 | 77.7 | 88.8 | 61.7 | 40.7 | 39.8 | 66.9 | 84.8 | 28.7 | 71.7 | 45.9 | 61.0 |
| Tool use | |||||||||||||||||||
| BFCL V3 | 59.6 | 60.2 | 69.7 | 68.3 | n/a | 74.1 | 59.2 | 67.9 | 37.7 | 67.8 | 42.6 | n/a | n/a | 67.8 | 42.0 | 48.2 | n/a | 60.4 | 35.1 |
Luciole-23B-Thinking is an interim checkpoint that is not publicly released. OLMoE-1B-7B has a 4,096-token context window; prompts that do not fit count as wrong. n/a: the model has no native tool-call support.
Evaluation details
We ran every model ourselves, on the same cluster and with the same evaluation code (inspect_ai
querying a vLLM server). Each model uses its own chat template, zero-shot, with the sampling parameters from its
model card and with reasoning enabled when it has it. Every model gets the same context window and no separate
limit on answer length. Olala 1.0 mini models use temperature=0.8, top_p=0.9,
top_k=40, reasoning_effort="high" and a float32 Mamba state.
HumanEval+, MBPP+ and AIME: pass@1 averaged over 5 samples per problem. The other benchmarks use
one sample per question.
MGSM: 11 languages.
Multi-IF: three turns, eight languages, prompt-level strict accuracy averaged over turns and
languages.
LIFEBench: answers of a requested length.
BFCL V3: all 23 categories (4,981 samples). n/a: the model has no native tool calling.
Average: unweighted mean of the 12 other benchmarks. BFCL V3 is left out because some models
cannot be scored on it.
Safety
We tested the SFT checkpoint and the final model on 5,701 attack prompts and 299 benign prompts. Reinforcement learning roughly halves the attack success rate. It also makes the model refuse more benign requests and hit the token limit more often while reasoning. Lower is better on every row.
| Olala-v1.0-mini-7A1B-SFT | Olala-v1.0-mini-7A1B | |
|---|---|---|
| Attacks (n = 5,701) | ||
| Guard attack success rate (%) ↓ | 12.5 | 6.3 |
| Guard attack success rate, strict (%) ↓ | 24.6 | 13.5 |
| Harmful, rubric judge (%) ↓ | 34.9 | 22.2 |
| Benign (n = 299) | ||
| Over-refusal (%) ↓ | 7.0 | 10.7 |
| All prompts | ||
| Reasoning overflow (%) ↓ | 11.8 | 15.0 |
Training
Pre-training: two phases build Olala-v1.0-mini-7A1B-base on 12.8T tokens: a main pre-training on 10.4T tokens (web in English and 36 other languages, code, mathematics, translation pairs), then an annealing on 2.38T tokens where mathematics becomes the largest share and instruction data is added. The training data is described on the base model card.
Olala 1.0 mini was trained on three European supercomputers: JUPITER (Germany), Jean Zay (France) and MeluXina (Luxembourg). The base model was pre-trained on 1,024 GH200 GPUs of JUPITER. Its training emitted about 40 t CO₂e (market-based): see Environmental impact.
Post-training: supervised fine-tuning, then reinforcement learning in four stages.
- Supervised fine-tuning (SFT): 36.9M samples from 27 datasets (about 162B tokens) teach the model to follow the chat template, reason before it answers at four effort levels, call tools and act as an agent. The data covers general chat and instruction following, mathematics and science, code, multilingual tasks, agentic traces and safety.
- Reinforcement learning: a cascade of four stages. Each stage trains one family of tasks and starts from
the end of the previous one.
- Instruction following and math, with knowledge, science, multilingual, safety and tool-calling prompts.
- Code: competitive programming and function-level problems checked by running tests.
- Assistant behaviour: tool use, safety, honesty and conversation quality.
- Agentic: the model calls tools, reads their results and searches over up to 75 turns.
Environmental impact
Training
| Energy | About 1.16 GWh for the whole training: pre-training and annealing on JUPITER (1,024 GH200 GPUs, Germany), supervised fine-tuning and reinforcement learning on Jean Zay (H100 GPUs, France) and MeluXina (Luxembourg) |
| Emissions | About 40 t CO₂e (range 30 to 50 t), market-based: electricity covered by renewable supply contracts |
| Largest share | JUPITER, about 70% of the emissions |
Inference (Boavizta method, whole machine, electricity in France and hardware manufacturing; est. = estimated, other values measured in November 2026)
| Machine | Load | g CO₂e per million generated tokens |
|---|---|---|
| Server with an H100 GPU | 32 or more requests at once | 12 (est.) |
| Laptop (MacBook M1 Pro) | one request at a time | 30 |
| PC with 8 GB of RAM and no GPU | one request at a time | 65 (est.) |
| Server with an H100 GPU | one request at a time | 140 (est.) |
Load matters more than hardware: a busy H100 server emits about ten times less per token than one serving a single request. For a single user, a laptop or a PC without a GPU is the low-carbon option.
Method: training emissions are energy × the carbon intensity of each site's electricity supply contract (market-based). Inference: Boavizta API 2.6, French grid 0.098 kg CO₂e/kWh, PUE 1.2, manufacturing share for the time used.
Uses and limitations
Intended uses
Olala-v1.0-mini-7A1B is a general-purpose text model for developers who build it into their own applications:
- assistants and chat, with instruction following, in English and the main European languages;
- agents and workflows that call tools: databases, APIs, search, code execution;
- reasoning in mathematics, science and code, with an adjustable reasoning effort;
- local and on-premises deployment, when data must stay on your own machines.
Out of scope
- Uses prohibited by law, including the practices banned by Article 5 of the EU AI Act.
- Decisions with legal or similarly significant effects on people (credit, employment, insurance, education, health, justice, access to public services) without review by a qualified person.
- Answering from memory where accuracy matters: facts, figures, legal, medical or financial information. Give the model the source, or a tool to read it.
- Images, audio or any other input than text.
Limitations
- Knowledge: with about 1B active parameters, it stores less factual knowledge than larger models and can state wrong facts with confidence. It was trained to read data through tools rather than answer from memory: give it those tools.
- One job per request: it does best on short, single-purpose requests. For longer work, chain short requests in your code and check each step, as in choose-the-right-beam.
- Languages: its comprehension outside English and the main European languages is weaker than its training mix suggests. Test it on your language before you rely on it.
- Mathematics: of the benchmarks above, competition mathematics is its weakest area.
- Context: 32K tokens, input and output together.
- Repetition: a long reasoning can fall into a repetition loop. Use the recommended sampling parameters, set a
token limit, and on vLLM always serve it with
--mamba-ssm-cache-dtype float32. - Quantization: generic quantization recipes produce NaN on realistic inputs. Use the GGUF and MLX files we publish, or follow their recipe.
- Long prompts on CPU take a long time to process. Prefer a GPU for long documents.
- No clock: it does not know today's date. Give it the date when it matters.
- Knowledge cut-off: its pre-training data goes up to January 2026 (post-training data up to April 2026), so it does not know about later events.
- Bias and safety: it can reproduce biases present in web data and can produce inaccurate or harmful content despite its safety training: in our tests, 6.3 % of attack prompts still succeeded (see Safety), and it refuses about 1 benign request in 10. Add safeguards suited to your application: input and output filters, human review.
Responsibilities
If you modify this model substantially, or place a system built on it on the market under your own name, you may become a provider under the EU AI Act, with the obligations that come with it, including those for high-risk AI systems when your use case is listed in Annex III.
Before you deploy: read the public summary of training content and our copyright policy.
License
| Licence | Apache License, Version 2.0 (SPDX: Apache-2.0) |
| Licensor | OVH LLM SAS, trading as OVHai LLM, 2 rue Kellermann, 59100 Roubaix, France |
| Copyright | Copyright 2026 OVH LLM SAS |
| Release date | 19 November 2026 |
| Distribution | Open weights |
| Notices | NOTICE: keep it when you redistribute the model or a derivative. It includes the attribution of the Qwen tokenizer (Copyright 2024 Alibaba Cloud, Apache 2.0) |
| Training content (EU AI Act) | Public summary of training content, on the European Commission template (Art. 53(1)(d)) |
Citation
@techreport{ovhaillm2026olala,
title = {Olala v1.0 mini Technical Report},
author = {{OVHai LLM Research Team}},
institution = {OVHcloud},
year = {2026},
url = {https://huggingface.co/OVHaiLLM/Olala-v1.0-mini-7A1B/blob/main/Olala-v1.0-mini.pdf},
}
- Downloads last month
- 1,517
Model tree for OVHaiLLM/Olala-v1.0-mini-7A1B
Base model
OVHaiLLM/Olala-v1.0-mini-7A1B-base