Alpha
Contact
Implement · EuroLLM

Can you run it?

Ownership levelSubstantialnone·limited·partial·substantial·fullAnalytical input C ยท 69.2/100

This page is a projection of the one entry record, the Reliability and Data control factors that Implement covers. The full verdict is set by all four factors together, floor-weighted so the weakest caps the whole.

Which domain expands which factor
  • AssessUse & modify + Transparency
  • ImplementData control + Reliability
  • UseReliability
  • SupportTransparency

Install & run

EuroLLM checkpoints are standard safetensors on the verified utter-project org, and all the usual paths work. Pin an exact revision.

# Hugging Face transformers
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "utter-project/EuroLLM-9B-Instruct"   # or EuroLLM-1.7B-Instruct
rev = "<pinned-commit-sha>"                        # pin the revision, don't float on main
tok = AutoTokenizer.from_pretrained(model_id, revision=rev)
model = AutoModelForCausalLM.from_pretrained(model_id, revision=rev)
# vLLM (OpenAI-compatible server)
vllm serve utter-project/EuroLLM-9B-Instruct --revision <sha>

# Ollama / llama.cpp (community GGUF)
ollama run alibayram/erurollm-9b-instruct
./llama-cli -m eurollm-9b-instruct.Q4_K_M.gguf -p "Bonjour"

A hosted NVIDIA NIM endpoint (utter-project/eurollm-9b-instruct) also exists as a managed API. Prefer safetensors and verify per-file checksums after download.

Hardware & VRAM requirements

EuroLLM-9B runs on a single modern 24 GB GPU: tight at full precision, comfortable with light quantization. It needs modest headroom for the KV cache, and the 4k context keeps this small. EuroLLM-1.7B runs on modest GPUs and is viable on CPU or edge via GGUF, which makes it a practical choice for local or low-resource multilingual deployments. Size to the largest checkpoint you intend to serve.

Serving stacks

The checkpoints are plain safetensors with a conventional architecture, so all mainstream runtimes load them with no custom code:

StackUse it for
vLLMHigh-throughput serving + OpenAI-compatible API
TGIHugging Face-native production serving
llama.cppCPU / edge / GGUF quantized inference
OllamaLocal single-command runs
transformersPrototyping and fine-tuning

A hosted NVIDIA NIM endpoint is also available. This breadth is why Operational Readiness scores 4. It stops short of 5 mainly on the short 4k context and the breadth of official day-0 tooling versus the largest ecosystems.

Safe-deployment controls & Deployment Ceiling

Apply the safe-deployment playbook. The model-specific gate rows are:

  • Supply chain: pin the exact utter-project revision hash and verify checksums; prefer safetensors (already the default, no pickle load).
  • Model layer: deploy the Instruct variant, never the base checkpoint, and set conservative decoding defaults.
  • Input/output layers: add guardrails and your own guard classifier for any customer-facing path, because EuroLLM ships no companion guard model. Add prompt-injection defences and treat retrieved and tool content as untrusted.
  • Language coverage: run your own per-language safety and quality evaluation for each target language before relying on it; coverage is uneven across the 35 languages.
  • Compliance: archive the technical-report-derived training-content summary and copyright posture in your AI-BOM.

Deployment Ceiling: T2 (customer-facing, human-reviewed), conditional. With the Instruct variant, input/output guardrails, prompt-injection defences and per-language evaluation, EuroLLM reaches customer-facing, human-reviewed use. Its fit is multilingual EU-facing applications under an EU-jurisdiction, Apache posture. T3+ (bounded autonomous) also needs a deterministic action-policy engine, per-action human approval for irreversible operations and external guard tooling beyond what the release provides.

Available quantizations

Community GGUF (QuantFactory, bartowski; via llama.cpp/Ollama), MLX 4-bit (Apple silicon) and GPTQ quantizations circulate and are acknowledged, and the safetensors base makes on-the-fly bitsandbytes 8-/4-bit loading simple. Coverage is partial because these are largely community efforts, not a broad first-class official quantization programme. Verify the source and test quality, especially per language, before relying on a third-party quant in production.

Fine-tuning & adaptation

Standard SFT/LoRA via transformers / TRL on the Apache-2.0 safetensors checkpoints is the practical path. Two things help. The technical report documents the recipe (Megatron-LM, data mixture, EuroFilter), and the team releases the EuroBlocks-Synthetic post-training dataset, which is directly useful for multilingual instruction adaptation. Unlike a fully-open model, the complete pre-training corpus and an end-to-end training repository are not available, so from-scratch reproduction is out of reach. Placing a derivative on the market carries EU AI Act provider implications (see Assess).

API / OpenAI-compatible integration

Serve EuroLLM behind vLLM's OpenAI-compatible /v1 server (or use the hosted NVIDIA NIM endpoint) for drop-in integration with existing OpenAI-client code:

vllm serve utter-project/EuroLLM-9B-Instruct --revision <sha> --port 8000
# then point any OpenAI SDK at http://localhost:8000/v1

No model-specific client is required. The chat-completions surface behaves like any other OpenAI-compatible endpoint, so routing, retries and gateways carry over unchanged. Mind the 4k context limit when composing prompts.

How this scores

The ownership factors this domain covers, drawn from the one entry record.

3

ReliabilityIs it reliable and good enough for the job?

Moderate

Runs dependably, but per-language safety coverage is thin and uneven, so you supply the safety layer.

How this scores (AOI sub-dimensions)
Operational4/5how practical it is to run, serve and maintain in productionStandard safetensors with a conventional architecture load on all mainstream stacks (vLLM, llama.cpp, Ollama, TGI, transformers).
Safety3/5whether misuse risks are evaluated and guardrails are providedThe Instruct variants are instruction-tuned on EuroBlocks and behave as ordinary safety-tuned assistants.
4

Doesn't extract your dataDoes running it keep your knowledge and data yours?

Strong

Self-hosted and EU-domiciled, the Apache weights run on your own infrastructure and nothing leaves, so your data and derived knowledge stay yours.

How this scores
Not a scored AOI dimension. For a self-hosted model, data-control is a structural property of running the weights yourself, strong by default unless the model phones home or the licence claws back rights. For a hosted API this factor is the retention + train-on-inputs + residency read, scored from the binding terms.
What this means for adoptionYou fully own the use of these Apache-2.0 weights, across 9B, 1.7B and 22B-Instruct-2512, with unconditional commercial use and no field-of-use limits. Self-hosted and EU-domiciled, you keep your data entirely. Ownership stays short of full because data openness is partial. The SFT set (EuroBlocks-SFT-2512) is released but the ~4T-token pre-training corpus is only described, so the recipe can be inspected but not reproduced from a released corpus as with a fully-open model. The 9B size, 4k context and uneven multilingual safety also cap reliability. Adopt it for multilingual EU-facing work that fits inside 4k, behind your own guardrails; look elsewhere for a long-context or frontier engine.

Sources

The same evidence records as the entry sheet. Read means the text was verified; unverified means it is known to exist but not yet read.

Vendor announcementread2026-11-19
The project site eurollm.io presents EuroLLM as a fully open source European multilingual LLM suite.
Model cardread2026-11-19
The EuroLLM-9B-Instruct model card on the verified utter-project org on Hugging Face shows safetensors under Apache-2.0, 4T training tokens, instruction tuning on EuroBlocks, a 4k context (Sequence Length 4,096) and a documented chat template (BOS id 1 / EOS id 4).
Model cardread2026-11-19
The EuroLLM-1.7B-Instruct model card states 1.7B parameters, a 4,096-token context, coverage of 35 languages and Apache-2.0, and is comparable to Gemma-7B on machine-translation benchmarks.
Technical_reportread2026-07-25
EuroLLM-9B: Technical Report (arXiv 2506.04079) says EuroLLM is trained from scratch to cover all 24 official EU languages plus 11 more.
Documentationread2026-11-19
The EuroLLM-22B-Instruct-2512 model card describes the ~4T-token pretraining mixture (web, parallel, Wikipedia, Arxiv, books, math, code, Apollo) and the EuroBlocks-SFT-2512 post-training set, and calls itself "the best EU-made fully open model" (marketing register).
Vendor announcementunverified2026-07-25
The EuroLLM team's release blog describes EuroLLM-9B, its EU consortium and EU funding (EuroHPC / Horizon Europe), multilingual coverage, Apache-2.0 licensing and the release of the models, filter and synthetic post-training data.
Licenceread2026-11-19
EuroLLM base and Instruct weights (9B, 1.7B and 22B-Instruct-2512) are distributed under OSI-approved Apache-2.0 with unconditional commercial use and no field-of-use limits.
Third-party analysisunverified2026-07-25
The European Commission's Open Source Observatory profiles EuroLLM as EU-funded pioneering European open-source AI released under an open licence.
Third-party analysisunverified2026-07-25
An independent review of the EuroLLM-9B technical report reports it on par with Gemma-2-9B on multilingual benchmarks, ahead on WMT24++ translation, and matching Mistral-7B on English.
Third-party analysisunverified2026-07-25
Independent coverage ranks EuroLLM among the leading European-developed open models for multilingual EU-language performance.
Third-party analysisunverified2026-07-25
EuroLLM safetensors checkpoints load on mainstream serving stacks (vLLM, llama.cpp, Ollama, TGI, transformers), with community GGUF/MLX/GPTQ quants and a hosted NVIDIA NIM endpoint available.
Technical_reportread2026-11-19
EuroLLM-22B: Technical Report (arXiv 2602.05879, submitted 2026-02-05) states "we release our base and instruction-tuned models, our multilingual web pretraining data and updated EuroBlocks instruction datasets, as well as our pre-training and evaluation codebases".