Dans cette vidéo, nous explorons la nouvelle interface graphique de Ollama. En ce moment, son aspect et ses fonctionnalités sont assez basiques, mais il y aura probablement de l'amélioration dans le futur. Dans cette vidéo nous parlons aussi de gpt-oss.
Voici un résumé en français et un tableau synthétique des procédures et fonctionnalités de la nouvelle interface d’Ollama :
📝 Résumé
Ollama propose désormais une nouvelle interface plus ergonomique, intégrant un partenariat avec OpenAI.
Les principales nouveautés :
Téléchargement & installation simplifiés : mise à jour automatique ou téléchargement direct.
Interface unifiée : historique des discussions, choix de modèles, paramètres simplifiés.
Accès aux modèles OpenAI et open-source (ex. GPT-OSS-20B / 120B). Téléchargement automatique si un modèle n’est pas présent.
Possibilité d’exécution locale ou en ligne. GPT-OSS-20B permet d’effectuer des recherches web.
Mode Turbo : exécution sur les serveurs Ollama pour accélérer les réponses, utile pour les ordinateurs peu puissants. (⚠️ données hébergées aux USA).
Paramètres personnalisables :
Connexion au compte obligatoire pour certains modèles.
Exposition de l’API sur le réseau local (comme Open Web UI).
Choix de l’emplacement des modèles, taille du contexte (tokens).
Activation du mode avion pour garantir l’exécution 100 % locale.
Concours Open Model Hackathon : Ollama collabore avec OpenAI, Hugging Face, Nvidia, LM Studio pour développer de nouvelles applications open source, avec récompenses financières.
📊 Tableau des procédures et fonctionnalités
Étape / Fonction
Description
Points Clés
1. Installation / Mise à jour
Téléchargez via le site ou via la fenêtre de mise à jour intégrée.
Recherche « Ollama » dans vos applis après installation.
2. Ouverture de l’interface
Lancer l’application, interface avec historique de chat + sélection de modèles.
Interface simple, ergonomique, avec paramètres à droite.
3. Sélection du modèle
Choisissez parmi vos modèles locaux ou ceux d’OpenAI (GPT-OSS-20B/120B).
Téléchargement automatique si modèle absent.
4. Utilisation locale ou en ligne
GPT-OSS-20B permet recherche web, sinon fonctionnement hors ligne possible.
Idéal pour conserver la confidentialité.
5. Mode Turbo (Cloud)
Utilise les serveurs Ollama pour accélérer les réponses.
⚠️ Données hébergées aux USA → potentielle exposition légale.
6. Paramètres disponibles
- Connexion compte- Exposition API réseau- Gestion des modèles- Contexte (tokens)- Mode avion
Permet personnalisation avancée + exécution 100 % locale.
7. Sécurité / Confidentialité
Mode avion = aucune donnée sortante.
Turbo = données sur serveurs US, à prendre en compte.
8. Participation Hackathon
Créer des applis innovantes (catégories variées, prix jusqu’à 30 000 $).
Tu peux tester le modèle Apertus-8B-Instruct-2509 de Hugging Face de deux façons principales : localement avec Transformers, ou via l’interface web Hugging Face (si le modèle est déployé). Voici un guide complet pour chaque méthode :
🧪 1. Test local avec Transformers (Python) Prérequis : GPU avec au moins 24 Go de VRAM (type RTX 3090 ou A100), ou usage via bitsandbytes pour quantisation.
🌐 2. Interface web Hugging Face (si disponible)
Tu peux visiter la pour voir s’il propose une démo interactive. Si le bouton “Hosted inference API” ou “Try it out” est absent, cela signifie que le modèle n’est pas déployé pour test direct en ligne
Pour utiliser le modèle Apertus-8B-Instruct-2509 avec Azure, tu peux envisager deux approches selon ton architecture :
🧩 1. Déploiement local + Azure Container / VM
☁️ 2. Intégration dans Azure AI Foundry / OpenAI Evaluation
1️⃣ Installer l’outil huggingface-cli
Si ce n’est pas déjà fait, installe la bibliothèque huggingface_hub (qui contient huggingface-cli) :
pip install -U huggingface_hub
2️⃣ S’authentifier auprès de Hugging Face
Certains modèles (comme Apertus-8B-2509) nécessitent d’être connecté à ton compte Hugging Face et d’avoir accepté les conditions d’utilisation du modèle sur sa page.
Après téléchargement, tu devrais voir dans ./apertus-8b :
config.json
tokenizer.json / tokenizer.model
pytorch_model-*.bin ou model.safetensors
éventuellement des fichiers de configuration supplémentaires
Pour accélérer le téléchargement d’un gros modèle Hugging Face comme swiss-ai/Apertus-8B-2509, il faut jouer sur trois leviers : réseau, méthode de transfert et paramètres CLI.
Voici un plan d’optimisation concret que tu peux appliquer directement.
🚀 1. Préparer l’environnement
Connexion filaire : évite le Wi‑Fi si possible, surtout pour des fichiers de plusieurs dizaines de Go.
Serveur proche : Hugging Face utilise un CDN, donc un bon peering avec ton FAI aide.
Si tu es sur un serveur cloud (AWS, GCP, OVH…), choisis une région proche de l’Europe pour réduire la latence.
Limiter la concurrence réseau : ferme les autres téléchargements lourds pendant l’opération.
⚙️ 2. Optimiser la commande huggingface-cli
Par défaut, huggingface-cli download télécharge séquentiellement. Tu peux :
Inclure tous les fichiers d’un coup (évite les requêtes multiples) :
⚠️ Plus lourd que huggingface-cli si tu ne veux que les poids.
📋 5. Bonnes pratiques
Télécharger en heures creuses (nuit, tôt le matin) pour éviter la saturation réseau.
Vérifier l’espace disque avant (les modèles 8B peuvent dépasser 15–20 Go).
Utiliser un SSD pour éviter que l’écriture disque ne devienne le goulot d’étranglement.
Parfait, Erol — voici un script Bash complet qui combine huggingface-cli pour l’authentification et la récupération de la liste des fichiers, puis aria2c pour un téléchargement multi-connexion avec reprise automatique.
Il est pensé pour être robuste, reproductible et facile à maintenir.
📜 Script : download_apertus.sh
#!/usr/bin/env bash
set -euo pipefail
# === CONFIGURATION ===
REPO_ID="swiss-ai/Apertus-8B-2509"
LOCAL_DIR="./apertus-8b"
THREADS=16 # Connexions simultanées par fichier
SPLIT=16 # Segments par fichier
SEGMENT_SIZE="1M" # Taille des segments
HF_TOKEN="${HF_TOKEN:-}" # Peut être passé en variable d'env
# === PRÉREQUIS ===
command -v huggingface-cli >/dev/null || { echo "❌ huggingface-cli manquant. Installez-le avec : pip install -U huggingface_hub"; exit 1; }
command -v aria2c >/dev/null || { echo "❌ aria2c manquant. Installez-le avec : sudo apt install aria2 ou brew install aria2"; exit 1; }
# === AUTHENTIFICATION ===
if [[ -z "$HF_TOKEN" ]]; then
echo "🔑 Connexion à Hugging Face..."
huggingface-cli login
else
echo "🔑 Utilisation du token HF depuis la variable d'environnement."
huggingface-cli login --token "$HF_TOKEN" --add-to-git-credential
fi
# === CRÉATION DU DOSSIER LOCAL ===
mkdir -p "$LOCAL_DIR"
# === RÉCUPÉRATION DES URLS DIRECTES ===
echo "📥 Récupération de la liste des fichiers..."
FILE_LIST=$(huggingface-cli list-files "$REPO_ID" --include "*" | grep -v '/$')
# === TÉLÉCHARGEMENT AVEC aria2c ===
echo "🚀 Téléchargement parallèle avec aria2c..."
for FILE in $FILE_LIST; do
URL="https://huggingface.co/${REPO_ID}/resolve/main/${FILE}?download=true"
aria2c -x "$THREADS" -s "$SPLIT" -k "$SEGMENT_SIZE" \
-d "$LOCAL_DIR" -o "$(basename "$FILE")" \
--continue=true --max-connection-per-server="$THREADS" \
--min-split-size="$SEGMENT_SIZE" \
--header="Authorization: Bearer $HF_TOKEN" \
"$URL"
done
echo "✅ Téléchargement terminé dans : $LOCAL_DIR"
🔹 Points forts
Reprise automatique (--continue=true)
Multi-connexion (-x et -s) pour saturer ta bande passante
Token Hugging Face géré soit par login interactif, soit via variable d’environnement HF_TOKEN
Indépendant du cache HF → fichiers directement dans ./apertus-8b
Facile à adapter pour d’autres modèles
📦 Utilisation
Sauvegarde le script :
nano download_apertus.sh
# colle le contenu ci-dessus
chmod +x download_apertus.sh
💡 Astuce bonus :
Si tu veux vérifier l’intégrité après téléchargement, on peut ajouter un bloc qui calcule les SHA256 et les compare à ceux listés par huggingface-cli list-files --include "*".
Solution simplifiée en 3 étapes
1️⃣ Installer huggingface_hub
Ouvrez un terminal et installez l’outil officiel Hugging Face :
Cette commande télécharge tous les fichiers nécessaires dans le dossier ./apertus-8b.
Aucune option supplémentaire n’est requise pour un usage basique.
Pourquoi cette solution est plus simple ?
Pas besoin de gérer des options avancées comme --include "*" ou --local-dir-use-symlinks False (les valeurs par défaut fonctionnent bien pour la plupart des cas).
Pas de configuration complexe : juste une installation, une authentification et une commande de téléchargement.
Moins de risques d’erreurs : idéal pour les utilisateurs qui veulent juste récupérer le modèle sans optimisations poussées.
Vérification rapide
Après téléchargement, vérifiez que le dossier ./apertus-8b contient au moins :
config.json
tokenizer.json ou tokenizer.model
pytorch_model.bin ou model.safetensors
Alternative encore plus simple (si vous utilisez Python)
Si vous préférez éviter la ligne de commande, vous pouvez télécharger le modèle directement en Python avec la bibliothèque huggingface_hub :
Si vous n’avez pas besoin d’optimiser la vitesse de téléchargement.
Si vous voulez éviter les options CLI complexes.
Ce code est déjà correct sur le principe, mais pour le faire tourner, il faut surtout préparer l’environnement et respecter quelques points spécifiques au modèle Apertus-8B-Instruct-2509.
Voici la marche à suivre pas à pas pour exécuter cette commande en local ou sur un serveur GPU.
1️⃣ Préparer l’environnement Python
Installe Python 3.10+ et crée un environnement virtuel :
Enregistre ton code dans un fichier, par exemple apertus_test.py, puis exécute :
python apertus_test.py
5️⃣ Conseils pour éviter les erreurs
GPU obligatoire pour ce modèle en pleine précision (8B paramètres). Sur CPU, ça risque d’être très lent ou de planter par manque de RAM.
Si tu veux réduire la charge mémoire :
model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map="auto",
torch_dtype="auto",
load_in_8bit=True # ou load_in_4bit=True
)
max_new_tokens=32768 est énorme : commence plutôt avec max_new_tokens=512 pour tester.
Si tu veux un format conversationnel correct, apply_chat_template est bien, mais vérifie que le tokenizer du modèle supporte ce format.
💡 Astuce CI/CD (vu ton profil) :
Tu peux intégrer ce script dans un pipeline avec un test rapide (prompt court, génération limitée) pour valider que le modèle est accessible et fonctionnel avant de lancer des batchs plus lourds.
Voici un template complet de déploiement Azure pour exécuter le modèle Hugging Face Apertus-8B-Instruct-2509 dans un environnement sécurisé et scalable. Ce modèle n’est pas disponible via l’inférence managée Hugging Face, donc tu dois le déployer manuellement dans Azure Machine Learning ou AKS.
🚀 Déploiement via Azure Machine Learning (AML)
📦 1. Dockerfile (GPU)
FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04
RUN apt-get update && apt-get install -y \
python3-pip git curl && \
pip3 install --upgrade pip
RUN pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
RUN pip install transformers accelerate
WORKDIR /app
COPY . /app
CMD ["python3", "serve.py"]
✅ Le modèle Apertus-8B existe bien sur HuggingFace
❌ Le contexte n'est pas 65k tokens mais 65,536 tokens (valeur correcte)
❌ Le Modelfile proposé contient des erreurs de syntaxe
⚠️ Architecture xIELU + AdEMAMix : nécessite vérification de compatibilité avec llama.cpp
🎯 Approche POC Simplifiée
Option 1 : Import direct Safetensors (Recommandé pour POC)
# 1. Télécharger le modèle
huggingface-cli download swiss-ai/Apertus-8B-2509 --local-dir ./apertus-8b
# 2. Créer le Modelfile
echo "FROM ./apertus-8b" > Modelfile
# 3. Importer dans Ollama
ollama create apertus-8b -f Modelfile
# 4. Tester
ollama run apertus-8b
Option 2 : Via Hugging Face Hub (Plus simple)
# Import direct depuis HF (si disponible en GGUF)
ollama run hf.co/swiss-ai/Apertus-8B-2509
Option 3 : Conversion manuelle vers GGUF
# Installation des dépendances
pip install transformers torch sentencepiece
# Clone du repo llama.cpp
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
make
# Téléchargement du modèle
huggingface-cli download swiss-ai/Apertus-8B-2509 --local-dir ../apertus-8b
# Conversion vers GGUF
python convert_hf_to_gguf.py ../apertus-8b --outdir ../apertus-8b-gguf --outtype f16
# Création du Modelfile
echo "FROM ../apertus-8b-gguf/ggml-model-f16.gguf" > ../Modelfile
# Import dans Ollama
cd ..
ollama create apertus-8b -f Modelfile
🔧 Modelfile correct pour Ollama
# Modelfile corrigé
FROM /path/to/apertus-8b
# Paramètres recommandés pour Apertus
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 65536
# Template de chat (à adapter selon les besoins)
TEMPLATE """<|system|>
{{ .System }}</s>
<|user|>
{{ .Prompt }}</s>
<|assistant|>
"""
# Message système par défaut
SYSTEM """Vous êtes Apertus, un assistant IA multilingue développé par les institutions suisses EPFL, ETH Zurich et CSCS. Vous supportez plus de 1000 langues et êtes conçu pour être transparent, conforme et utile."""
⚠️ Points d'attention techniques
Architecture spécifique
xIELU activation : fonction d'activation custom
AdEMAMix optimizer : optimiseur spécialisé
Ces éléments pourraient nécessiter des adaptations dans llama.cpp
Vérifications de compatibilité
# Test de base après import
ollama run apertus-8b "Bonjour, peux-tu me parler en français ?"
# Test multilingue
ollama run apertus-8b "Can you respond in Swiss German?"
# Test de contexte long
ollama run apertus-8b "Résume ce long texte..." # (avec un texte de plusieurs milliers de tokens)
🚀 Script automatisé POC
#!/bin/bash
# poc_apertus_ollama.sh
set -e
echo "🚀 Déploiement POC Apertus-8B sur Ollama"
# Variables
MODEL_NAME="apertus-8b-poc"
HF_REPO="swiss-ai/Apertus-8B-2509"
WORK_DIR="./apertus_poc"
# Création du répertoire de travail
mkdir -p $WORK_DIR
cd $WORK_DIR
# Téléchargement du modèle
echo "📥 Téléchargement du modèle..."
huggingface-cli download $HF_REPO --local-dir ./model
# Création du Modelfile
echo "📝 Création du Modelfile..."
cat > Modelfile << EOF
FROM ./model
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 65536
SYSTEM """Vous êtes Apertus, un assistant IA multilingue développé par les institutions suisses. Vous supportez plus de 1000 langues."""
EOF
# Import dans Ollama
echo "🔧 Import dans Ollama..."
ollama create $MODEL_NAME -f Modelfile
# Tests basiques
echo "🧪 Tests de base..."
echo "Test français:"
ollama run $MODEL_NAME "Bonjour ! Peux-tu te présenter en français ?"
echo -e "\nTest multilingue:"
ollama run $MODEL_NAME "Please introduce yourself in English"
echo -e "\n✅ POC terminé ! Utilisez: ollama run $MODEL_NAME"
📊 Tests de validation
Tests fonctionnels
Réponse multilingue : vérifier le support des 1000+ langues
Contexte long : tester avec des prompts approchant 65k tokens
Performance : mesurer les temps de réponse
Cohérence : comparer avec le modèle original sur HF
Commandes de test
# Test de performance
time ollama run apertus-8b "Explain quantum computing"
# Test de mémoire
ollama run apertus-8b "Remember this: [long context]. Now answer: [question]"
# Test multilingue spécifique Suisse
ollama run apertus-8b "Chuchichäschtli" # Test en suisse-allemand
🎯 Résultats attendus
Si le POC fonctionne :
✅ Import réussi dans Ollama
✅ Réponses multilingues cohérentes
✅ Support du contexte long (65k tokens)
✅ Performance acceptable
Limitations potentielles :
⚠️ Architecture xIELU pourrait ne pas être totalement compatible
⚠️ Certaines optimisations AdEMAMix pourraient être perdues
⚠️ Performance variable selon le hardware
Note importante : Ce guide est optimisé pour un POC rapide. Pour une utilisation en production, une conversion GGUF native et des optimisations supplémentaires seraient recommandées.
Voici une explication claire et structurée des prompts Copilot dans Ollama, avec un aperçu de leur fonction et de leur utilité :
🧠 Qu’est-ce que les Prompts Copilot dans Ollama ?
Les prompts Copilot sont des modèles de requêtes prédéfinies que tu peux utiliser dans Ollama pour interagir avec un modèle de langage (comme moi) de manière ciblée et efficace. Chaque prompt sert un objectif précis — résumé, reformulation, traduction, etc. — et permet d’obtenir des réponses cohérentes et bien structurées selon le besoin.
📋 Détail des Prompts
TitreFonctionDescription
RésumerSynthèseRésume un texte en 3–4 phrases, en capturant les idées principales et les points clés.
ReformulerParaphraseRéécrit le texte avec un vocabulaire et une structure différents, tout en conservant le sens original.
TraduireTraductionTraduit le texte dans une autre langue (ici vers l’anglais), en respectant le ton et le style du texte source.
ExpliquerAnalyseFournit une explication détaillée du texte, en clarifiant les concepts, en ajoutant du contexte, et en illustrant avec des exemples.
PersonnaliséLibrePermet d’insérer n’importe quel texte ou instruction personnalisée, sans structure imposée.
🛠️ Exemple d’usage dans Ollama
Supposons que tu travailles sur un guide d’onboarding dans Figma et que tu veux :
• Résumer une documentation trop longue → utilise le prompt Résumer.
• Reformuler une section pour la rendre plus accessible → utilise Reformuler.
• Traduire ton contenu pour une équipe anglophone → utilise Traduire.
• Expliquer un concept complexe comme la hiérarchie des composants → utilise Expliquer.
• Personnaliser une requête pour générer un contenu spécifique → utilise Personnalisé.
🔍 Pourquoi c’est utile pour toi
En tant que systems architect, ces prompts t’aident à :
• Gagner du temps dans la documentation et la communication.
• Assurer la clarté et la cohérence dans tes livrables.
• Adapter ton contenu à différents publics (langues, niveaux de compréhension).
• Maintenir une modularité dans tes workflows textuels, comme tu le fais déjà dans Figma.
Pour activer et utiliser les prompts Copilot dans Ollama avec le modèle Mistral, voici une démarche claire et pratique adaptée à ton profil de systems architect 👇
⚙️ Étapes pour activer les prompts dans Ollama avec Mistral
1. Installer Ollama
Si ce n’est pas encore fait :
• Télécharge Ollama depuis le site officiel : ollama.com
• Installe-le sur ton PC (Windows, macOS ou Linux via WSL2)
• Vérifie que ta machine dispose d’une carte graphique suffisante pour faire tourner Mistral
2. Télécharger le modèle Mistral
Dans ton terminal, exécute :
ollama pull mistral
Cela télécharge le modèle Mistral 7B localement.
3. Utiliser un prompt Copilot
Tu peux lancer une session avec un prompt structuré directement via la ligne de commande :
ollama run mistral --prompt "Provide a concise summary of the following text: {ton texte ici}"
Tu peux remplacer "Provide a concise summary..." par n’importe quel prompt Copilot comme :
• Reformuler → "Rewrite the following text using alternative vocabulary..."
• Traduire → "Translate the following text into English..."
• Expliquer → "Explain the following text in detail..."
• Personnalisé → "Tu es un assistant de design system, aide-moi à structurer une nomenclature modulaire pour Figma..."
4. Créer des prompts personnalisés
Tu peux aussi créer tes propres prompts en ligne de commande :
ollama chat mistral --prompt "Explique la hiérarchie des composants dans un design system modulaire."
Ou automatiser des requêtes avec des scripts pour tes workflows de documentation ou d’onboarding.
🧩 Bonus : modèle optimisé pour prompts
Tu peux tester le modèle vokturz/mistral-7b-prompter, conçu pour améliorer les réponses aux prompts complexes :
ollama run vokturz/mistral-7b-prompter --prompt "###Knowledge: None\n\n###Initial_prompt: Résume ce texte : {texte}"
• Introduction à Ollama: téléchargement
Ollama et Page Assist
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)