LLM locaux

L’exécution de grands modèles de langage (LLM) protège localement la confidentialité des données, réduit les coûts des API et fournit des fonctionnalités d’inférence hors ligne. Ubuntu 26.04 offre un excellent environnement pour exécuter des LLM locaux. Cet article couvre les outils d’exécution de modèles locaux les plus populaires et les modèles recommandés.

Tip

Vous souhaitez créer une appliance « AI box » dédiée au lieu de l’exécuter sur votre bureau ? En juin 2026, Canonical a publié une référence officielle basée sur Ubuntu Core 26 + le snap gemma4, exposant une API compatible OpenAI (:8336/v1) et une WebUI (:8337). Le bootstrap minimum est documenté dans Post-release News.

Ollama

Ollama est actuellement le framework d’exécution de modèle local le plus populaire, offrant une expérience d’installation et d’utilisation extrêmement simple avec la prise en charge d’une large gamme de modèles open source.

Installer Ollama


# One-click installation (recommended)
curl -fsSL https://ollama.com/install.sh | bash
 
# Verify installation
ollama --version
 
# Check Ollama service status
systemctl status ollama


# Manual installation (if the auto script doesn't work)
# Download and extract the official tgz package to /usr
curl -L https://ollama.com/download/ollama-linux-amd64.tgz -o /tmp/ollama-linux-amd64.tgz
sudo tar -C /usr -xzf /tmp/ollama-linux-amd64.tgz
 
# Create Ollama user
sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama
 
# Create systemd service (use sudo tee to write a root-owned file)
sudo tee /etc/systemd/system/ollama.service > /dev/null << 'EOF'
[Unit]
Description=Ollama Service
After=network-online.target
 
[Service]
ExecStart=/usr/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="HOME=/usr/share/ollama"
 
[Install]
WantedBy=default.target
EOF
 
sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl start ollama

Modèles Pull and Run


# Pull a model (downloads the model file on first run)
ollama pull llama3.2
ollama pull qwen2.5:14b
ollama pull deepseek-r1:14b
 
# Run a model and start chatting
ollama run llama3.2
 
# Run a specific model size
ollama run qwen2.5:7b
ollama run qwen2.5:14b
ollama run qwen2.5:32b
 
# List downloaded models
ollama list
 
# View model details
ollama show qwen2.5:14b
 
# Delete a model
ollama rm llama3.2

Utilisation de l’API

Ollama fournit une API REST compatible avec le format OpenAI, en écoute par défaut sur http://localhost:11434.


# Generate text (Generate API)
curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5:14b",
  "prompt": "Explain Python decorators",
  "stream": false
}'
 
# Chat API (conversational format)
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:14b",
  "messages": [
    {"role": "system", "content": "You are a Linux expert"},
    {"role": "user", "content": "How do I check the Ubuntu system version?"}
  ],
  "stream": false
}'
 
# OpenAI-compatible API
curl http://localhost:11434/v1/chat/completions -d '{
  "model": "qwen2.5:14b",
  "messages": [
    {"role": "user", "content": "Hello"}
  ]
}'
 
# List available models
curl http://localhost:11434/api/tags

Python Exemple d’utilisation


# Ubuntu 26.04 blocks system-wide pip installs (PEP 668); install inside a virtual environment
python3 -m venv ~/ollama-env
source ~/ollama-env/bin/activate
 
# Install the ollama Python library
pip install ollama


import ollama
 
response = ollama.chat(model='qwen2.5:14b', messages=[
    {'role': 'user', 'content': 'Write a quicksort algorithm in Python'},
])
print(response['message']['content'])

Configurer Ollama


# Change model storage path (default: ~/.ollama/models)
sudo systemctl edit ollama
# Add the following:
# [Service]
# Environment="OLLAMA_MODELS=/data/ollama/models"
 
# Allow remote access (default is local only)
sudo systemctl edit ollama
# [Service]
# Environment="OLLAMA_HOST=0.0.0.0:11434"
 
# Set GPU layers
# Environment="OLLAMA_NUM_GPU=999"
 
# Restart service to apply changes
sudo systemctl restart ollama

Modèles recommandés

Modèle	Paramètres	VRAM requise	Points forts
`qwen2.5:7b`	7B	6 Go	Forte maîtrise du chinois, bon pour le chat quotidien
`qwen2.5:14b`	14B	10 Go	Chinois complet, bon codage
`qwen2.5-coder:7b`	7B	6 Go	Axé sur la génération et la compréhension du code
`llama3.2:3b`	3B	3 Go	Léger, rapide
`llama3.1:8b`	8B	6 Go	Excellente maîtrise de l’anglais
`deepseek-r1:14b`	14B	10 Go	Un raisonnement fort
`mistral:7b`	7B	6 Go	Modèle européen, multilingue
`gemma2:9b`	9B	7 Go	Modèle open source de Google
`phi3:14b`	14B	10 Go	Modèle de recherche Microsoft
`nomic-embed-text`	-	1 Go	Modèle d’intégration de texte

Tip

Pour les utilisateurs de langue chinoise, la série Qwen 2.5 est fortement recommandée. La version 7B convient aux GPU avec 8 Go de VRAM, tandis que la version 14B fonctionne parfaitement avec 12 Go de VRAM. Pour les tâches de code uniquement, qwen2.5-coder est le meilleur choix.

LM Studio

LM Studio est un outil de gestion de modèles locaux graphique multiplateforme qui permet le téléchargement de modèles, le chat et un serveur API local.

Télécharger et installer


# Download LM Studio AppImage from the official site (get the latest link at https://lmstudio.ai/download)
# Replace the URL below with the actual download link from the official site
wget -O ~/LMStudio.AppImage "<latest AppImage download link from the official site>"
 
# Add execute permission
chmod +x ~/LMStudio.AppImage
 
# Move to application directory
mkdir -p ~/.local/bin
mv ~/LMStudio.AppImage ~/.local/bin/lmstudio
 
# Create desktop shortcut
# Note: .desktop Exec does not expand variables like $HOME; you must use an absolute path
# Replace YOUR_USER below with your username (the output of echo $USER)
cat > ~/.local/share/applications/lmstudio.desktop << 'EOF'
[Desktop Entry]
Name=LM Studio
Comment=Local LLM Management
Exec=/home/YOUR_USER/.local/bin/lmstudio --no-sandbox
Icon=lmstudio
Type=Application
Categories=Development;Science;
StartupNotify=true
EOF
 
# Launch LM Studio
~/.local/bin/lmstudio

Installer les dépendances


# LM Studio may require FUSE support (AppImage dependency)
sudo apt install -y libfuse2t64

Utilisation de l’interface graphique

Principales fonctionnalités de LM Studio :

Découvrir - Recherchez et téléchargez des modèles GGUF depuis Hugging Face
Chat – Chargez un modèle et discutez avec lui
Développeur — Démarrez un serveur API local, compatible avec le format API OpenAI

Démarrez le serveur API local :

Dans l’onglet Développeur, chargez un modèle, puis cliquez sur “Démarrer le serveur”. L’adresse par défaut est http://localhost:1234.


# Test LM Studio's local API
curl http://localhost:1234/v1/chat/completions -d '{
  "model": "loaded-model-name",
  "messages": [
    {"role": "user", "content": "Hello"}
  ]
}'

Note

LM Studio stocke les fichiers de modèle dans le répertoire ~/.lmstudio/models/. Les fichiers de modèles volumineux peuvent consommer des dizaines de Go, alors assurez-vous de disposer de suffisamment d’espace disque.

llama.cpp

llama.cpp est le moteur d’inférence locale de bas niveau, écrit en C/C++ pur, prenant en charge l’inférence CPU et GPU avec des performances extrêmement élevées. Le backend de Ollama utilise également llama.cpp.

Construire à partir de la source


# Install build dependencies
sudo apt install -y build-essential cmake git
 
# Clone the repository
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
 
# Method 1: CPU-only build
cmake -B build
cmake --build build --config Release -j$(nproc)
 
# Method 2: Enable CUDA GPU acceleration (recommended, requires CUDA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)
 
# Method 3: Enable Vulkan GPU acceleration (works with AMD/Intel/NVIDIA)
sudo apt install -y libvulkan-dev
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release -j$(nproc)

Télécharger des modèles


# llama.cpp uses GGUF format models
# Download from Hugging Face (Qwen 2.5 7B example)
mkdir -p ~/models
wget -O ~/models/qwen2.5-7b-q4_k_m.gguf \
  "https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf"

Inférence de ligne de commande


# Interactive chat
./build/bin/llama-cli \
  -m ~/models/qwen2.5-7b-q4_k_m.gguf \
  -ngl 999 \
  -c 4096 \
  --interactive \
  --color
 
# Start an OpenAI-compatible API server
./build/bin/llama-server \
  -m ~/models/qwen2.5-7b-q4_k_m.gguf \
  -ngl 999 \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080
 
# Parameter explanations:
# -m        Model file path
# -ngl 999  Use as many GPU layers as possible
# -c 4096   Context length
# --host    Listen address
# --port    Listen port


# Test the API server
curl http://localhost:8080/v1/chat/completions -d '{
  "model": "qwen2.5",
  "messages": [{"role": "user", "content": "Hello"}]
}'

Tip

Les fichiers de modèle GGUF sont disponibles dans différents niveaux de quantification. Q4_K_M offre un bon équilibre entre qualité et taille de fichier, Q5_K_M offre des fichiers de meilleure qualité mais plus volumineux, et Q8_0 est proche de la précision d’origine. Pour un usage quotidien, Q4_K_M ou Q5_K_M est recommandé.

Jan

Jan est un client de chat d’IA local open source avec une interface graphique conviviale, prenant en charge plusieurs modèles et inférences locales.

Installer Jan


# Download Jan deb package
wget -O /tmp/jan.deb "https://app.jan.ai/download/latest/linux-amd64-deb"
 
# Install
sudo dpkg -i /tmp/jan.deb
sudo apt install -f -y
 
# Launch Jan
jan


# Or install via AppImage
wget -O ~/jan.appimage "https://app.jan.ai/download/latest/linux-amd64-appimage"
chmod +x ~/jan.appimage
~/jan.appimage

Utilisation de l’interface

Principales caractéristiques de Jan :

Hub – Parcourir et télécharger les modèles recommandés (téléchargement en un clic)
Chat - Discutez avec des modèles, prend en charge plusieurs sessions
Paramètres - Configurez les paramètres du modèle, l’accélération GPU, etc.

Jan prend en charge l’importation de fichiers de modèle GGUF personnalisés. Placez les fichiers de modèle dans le répertoire ~/jan/models/.


# Jan default data directory
ls ~/jan/
 
# Manually import a model
mkdir -p ~/jan/models/my-custom-model
cp ~/models/qwen2.5-7b-q4_k_m.gguf ~/jan/models/my-custom-model/

Jan fournit également un serveur API local. Lorsqu’il est activé, il est compatible avec le format de l’API OpenAI, par défaut sur le port 1337.

Open WebUI

Open WebUI est une interface Web riche en fonctionnalités pour interagir avec les modèles locaux, prenant en charge les connexions à Ollama et aux API compatibles OpenAI.

Déploiement Docker


# Ensure Docker is installed
sudo apt install -y docker.io docker-compose-v2
sudo usermod -aG docker $USER
newgrp docker
 
# Method 1: Connect to local Ollama (most common)
docker run -d \
  --name open-webui \
  --network=host \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://127.0.0.1:11434 \
  --restart always \
  ghcr.io/open-webui/open-webui:main
 
# Method 2: Bundled Ollama version (all-in-one deployment)
docker run -d \
  --name open-webui \
  --gpus all \
  -p 3000:8080 \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:ollama

Accéder à Open WebUI


# After deployment, open your browser
# Method 1 (--network=host): http://localhost:8080
# Method 2 (-p 3000:8080): http://localhost:3000
 
# First visit requires creating an admin account

Connectez-vous à Ollama

Si Ollama et Open WebUI sont sur la même machine :


# Ensure Ollama is running
systemctl status ollama
 
# Open WebUI connects to http://localhost:11434 by default
# Confirm the Ollama URL in Open WebUI Settings > Connections

Docker Composer le déploiement


# Create project directory
mkdir -p ~/open-webui && cd ~/open-webui
 
# Create docker-compose.yml
cat > docker-compose.yml << 'EOF'
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
      - WEBUI_AUTH=true
    volumes:
      - open-webui-data:/app/backend/data
    extra_hosts:
      - "host.docker.internal:host-gateway"
    restart: always
 
volumes:
  open-webui-data:
EOF
 
# Start the service
docker compose up -d
 
# View logs
docker compose logs -f open-webui

Note

Open WebUI prend en charge les comptes multi-utilisateurs, l’historique des conversations, la gestion des modèles, RAG (Retrieval-Augmented Generation), la recherche sur le Web et d’autres fonctionnalités avancées. C’est l’une des meilleures interfaces Web pour les individus et les équipes utilisant des modèles locaux.

Tableau de comparaison des modèles

Voici une comparaison des modèles open source grand public actuels pour vous aider à choisir :

Série de modèles	Promoteur	Tailles disponibles	Chinois	Codage	Raisonnement	Licence
Lama 3.1/3.2	Méta	1B/3B/8B/70B/405B	Équitable	Bien	Bien	Lama 3
Qwen 2.5	Alibaba	0,5B-72B	Excellent	Excellent	Bien	Apache 2.0
Codeur Qwen 2.5	Alibaba	1,5B-32B	Bien	Remarquable	Bien	Apache 2.0
DeepSearch R1	Recherche profonde	1.5B-671B	Excellent	Excellent	Remarquable	MIT
DeepSearch V3	Recherche profonde	671B	Excellent	Excellent	Excellent	MIT
Mistral	Mistral	7B/8x7B/8x22B	Équitable	Bien	Bien	Apache 2.0
Gemme 2	Google	2B/9B/27B	Équitable	Bien	Bien	Gemme
Phi-3/4	Microsoft	3.8B-14B	Équitable	Bien	Bien	MIT
Oui	01.IA	6B/9B/34B	Excellent	Bien	Bien	Apache 2.0
GLM-4	IA Zhipu	9B	Excellent	Bien	Bien	Coutume

Recommandations de cas d’utilisation

Chat quotidien en chinois (8 Go de VRAM) :


ollama pull qwen2.5:7b
ollama run qwen2.5:7b

Aide à l’écriture de code (12 Go de VRAM) :


ollama pull qwen2.5-coder:14b
ollama run qwen2.5-coder:14b

Tâches de raisonnement complexes (16 Go+ VRAM) :


ollama pull deepseek-r1:14b
ollama run deepseek-r1:14b

CPU uniquement (pas de GPU) :


ollama pull qwen2.5:3b
ollama run qwen2.5:3b
 
# Or use an even smaller model
ollama pull llama3.2:1b
ollama run llama3.2:1b

Tip

Si vous ne savez pas quel modèle choisir, commencer par qwen2.5:7b est un bon pari. Il possède une forte maîtrise de la langue chinoise, une utilisation modérée des ressources et convient à la plupart des cas d’utilisation quotidienne. Pour les tâches de codage, qwen2.5-coder:14b est proche des modèles commerciaux.