Installation d'Ollama et de PHI ou mieux de Mistral sur un PC avec 8 Go ou 16 Go de RAM.

Voici mes commentaires et suggestions d'amélioration pour ce script et ma documentation :

Les points forts de cette approche

Détection automatique du GPU - excellent pour adapter l'installation
Structure claire du script avec émojis pour faciliter la lecture
Documentation complète sur les méthodes de démarrage/arrêt
Puis, suggestions d'amélioration des scripts.
Modèles recommandés selon la RAM

Ollama sur UBUNTU avec PHI.

La méthode pour relancer Ollama dépend de la façon dont vous l'avez arrêté, mais en général, la façon la plus simple sur Ubuntu est de le démarrer comme un service système.

Voici les deux principales méthodes pour relancer Ollama. Bien entendu cela demande des améliorations, mais ceci fonctionne.

1. Démarrage via `systemd` (Méthode Recommandée).

Si vous avez précédemment arrêté Ollama avec sudo systemctl stop ollama, ou si vous voulez qu'il fonctionne en arrière-plan comme un service, utilisez la commande suivante :

Démarrez le service Ollama :
Bash
sudo systemctl start ollama
Vérifiez le statut (Optionnel) :
Pour vous assurer qu'il est bien en cours d'exécution :
Bash
systemctl status ollama
Vous devriez voir Active: active (running).
Redémarrez le service (Si vous étiez en train de le modifier) :
Si Ollama était déjà en cours d'exécution, mais que vous voulez appliquer des changements de configuration (comme des variables d'environnement), utilisez restart :
Bash
sudo systemctl restart ollama

2. Démarrage en mode manuel

Si vous préférez exécuter Ollama dans votre terminal pour voir directement les logs, ou si vous ne l'avez pas installé en tant que service systemd :

Exécutez la commande serve :
Bash
ollama serve
Cette commande va lancer le serveur Ollama. Il restera actif tant que vous ne fermerez pas la fenêtre du terminal ou que vous n'appuyerez pas sur Ctrl+C.
Lancer en arrière-plan (Démon) :
Si vous voulez le lancer manuellement sans bloquer votre terminal, vous pouvez ajouter & à la fin de la commande :
Bash
ollama serve &
Vous pourrez ensuite utiliser votre terminal pour d'autres commandes. Vous devrez le tuer manuellement plus tard (par exemple avec pkill ollama) si vous voulez l'arrêter.

Astuce : Une fois qu'Ollama est démarré, vous pouvez tester sa disponibilité en exécutant un modèle :

Bash

ollama run llama3

Voici les lignes de commandes SUDO pour Ollama sur Ubuntu.

C'est MISTRAL.

Mes trois models sur Ollama.

Ollama.

Commandes pour Ollama.

Suggestions d'amélioration du script :

1. Gestion du redémarrage NVIDIA

bash

# Au lieu de forcer un reboot immédiat :
if [ "$GPU_TYPE" = "NVIDIA" ]; then
  echo "🚀 Installation driver NVIDIA + CUDA"
  sudo add-apt-repository ppa:graphics-drivers/ppa -y
  sudo apt update
  sudo apt install -y nvidia-driver-550 nvidia-cuda-toolkit
  
  echo "⚠️  Un redémarrage est nécessaire pour activer les drivers NVIDIA"
  echo "Appuyez sur [Entrée] pour redémarrer maintenant, ou Ctrl+C pour le faire plus tard"
  read
  sudo reboot
fi

2. Vérification préalable d'Ollama

bash

# Avant l'installation, vérifier si déjà installé
if command -v ollama &> /dev/null; then
  echo "⚠️  Ollama est déjà installé (version $(ollama --version))"
  echo "Voulez-vous réinstaller ? [o/N]"
  read -r response
  if [[ ! "$response" =~ ^[Oo]$ ]]; then
    exit 0
  fi
fi

3. Test plus robuste après installation

bash

# Au lieu de juste tester Mistral, proposer un choix
echo "📥 Modèles suggérés selon votre RAM :"
total_ram=$(free -g | awk '/^Mem:/{print $2}')

if [ "$total_ram" -ge 16 ]; then
  echo "  - mistral (7B) - Recommandé"
  echo "  - llama3.2 (3B) - Plus rapide"
else
  echo "  - phi (2.7B) - Recommandé pour 8GB RAM"
  echo "  - llama3.2 (3B)"
fi

echo "Entrez le nom du modèle à télécharger [mistral] :"
read -r model_choice
model_choice=${model_choice:-mistral}

ollama pull "$model_choice"
ollama run "$model_choice" "Bonjour, peux-tu te présenter en français ?"

4. Gestion des logs

bash

# Ajouter une fonction pour vérifier les logs en cas de problème
echo "📝 Pour consulter les logs d'Ollama :"
echo "   sudo journalctl -u ollama -f"
echo ""
echo "📊 Pour vérifier l'utilisation GPU :"
if [ "$GPU_TYPE" = "NVIDIA" ]; then
  echo "   watch -n 1 nvidia-smi"
fi

5. Configuration de la mémoire

bash

# Créer un fichier de configuration pour optimiser selon la RAM
sudo mkdir -p /etc/systemd/system/ollama.service.d/
cat <<EOF | sudo tee /etc/systemd/system/ollama.service.d/override.conf
[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"
Environment="OLLAMA_KEEP_ALIVE=5m"
EOF

sudo systemctl daemon-reload

Suggestions pour la documentation

Ajouter une section dépannage

markdown

## Dépannage

### Ollama ne démarre pas
```bash
# Vérifier les logs
sudo journalctl -u ollama -n 50

# Vérifier le port
sudo netstat -tlnp | grep 11434
```

### Modèle trop lent
- Pour 8GB RAM : utilisez phi, gemma:2b, ou llama3.2:1b
- Pour 16GB RAM : mistral, llama3.2, phi3
- Arrêtez les autres applications gourmandes en RAM

### Erreur "out of memory"
```bash
# Limiter le nombre de couches GPU
OLLAMA_NUM_GPU_LAYERS=20 ollama run mistral
```

Script de test rapide

Créez un fichier test-ollama.sh :

bash

#!/bin/bash
echo "🧪 Test d'Ollama..."

# Vérifier le service
if systemctl is-active --quiet ollama; then
  echo "✅ Service actif"
else
  echo "❌ Service inactif - Démarrage..."
  sudo systemctl start ollama
  sleep 3
fi

# Lister les modèles
echo -e "\n📦 Modèles installés :"
ollama list

# Test de performance
echo -e "\n⚡ Test de vitesse :"
time ollama run phi "Compte de 1 à 10" --verbose

Modèles recommandés selon la RAM

Pour 8 GB RAM :

phi (2.7B) - Équilibré
gemma:2b - Très rapide
qwen2.5:3b - Bon en code

Pour 16 GB RAM :

mistral (7B) - Excellent polyvalent
llama3.2 (3B) - Rapide et performant
deepseek-coder:6.7b - Spécialisé code

OLLAMA - AIDE-MÉMOIRE RAPIDE

🚀 INSTALLATION (PREMIÈRE FOIS)

1. Installation d'Ollama

$ chmod +x ollama-install-optimized.sh

$ ./ollama-install-optimized.sh

2. Configuration optimale

$ chmod +x configure-ollama.sh

$ ./configure-ollama.sh

💻 UTILISATION QUOTIDIENNE

Lancer une conversation

$ ollama run mistral

Question rapide

$ ollama run qwen2.5:3b "Explique-moi les listes en Python"

Utiliser un fichier

$ cat script.py | ollama run qwen2.5:3b "Explique ce code"

📦 GESTION DES MODÈLES

Lister les modèles installés

$ ollama list

Télécharger un modèle

$ ollama pull llama3.2:3b

Supprimer un modèle

$ ollama rm nom-du-modele

Voir les modèles actifs

$ ollama ps

🔧 SERVICE OLLAMA

Démarrer

$ sudo systemctl start ollama

Arrêter

$ sudo systemctl stop ollama

Redémarrer

$ sudo systemctl restart ollama

Voir l'état

$ systemctl status ollama

Voir les logs

$ sudo journalctl -u ollama -f

🛠️ SCRIPTS UTILITAIRES

État complet du système

$ ~/ollama-status.sh

Test de performance

$ ~/test-vitesse.sh mistral

Nettoyer la RAM (8GB seulement)

$ ~/prepare-ollama.sh

🎯 MODÈLES RECOMMANDÉS

8GB RAM - Code

$ ollama pull qwen2.5:3b

8GB RAM - Conversation

$ ollama pull llama3.2:3b

8GB RAM - Ultra-rapide

$ ollama pull gemma:2b

16GB RAM - Polyvalent

$ ollama pull mistral:7b

16GB RAM - Code spécialisé

$ ollama pull deepseek-coder:6.7b

16GB RAM - Multilingue

$ ollama pull qwen2.5:7b

🐛 DÉPANNAGE RAPIDE

Modèle trop lent (8GB) ?

→ Utilisez qwen2.5:3b ou gemma:2b au lieu de mistral:7b

Out of memory ?

→ sudo sync && echo 3 | sudo tee /proc/sys/vm/drop_caches

→ sudo systemctl restart ollama

Service ne démarre pas ?

→ sudo journalctl -u ollama -n 50

→ sudo pkill ollama

→ sudo systemctl restart ollama

Réponses en anglais ?

→ Utilisez qwen2.5:3b (meilleur en français)

→ Forcez : "Réponds en français : [question]"

💡 ASTUCES

Réduire l'utilisation RAM

$ ollama run mistral --num-ctx 2048

Mode verbeux (voir les stats)

$ ollama run mistral --verbose "Test"

Sauvegarder une réponse

$ ollama run mistral "Question" > reponse.txt

Utiliser le GPU (si NVIDIA)

→ Automatique, surveillez avec : watch -n 1 nvidia-smi

Forcer CPU uniquement

$ OLLAMA_NUM_GPU_LAYERS=0 ollama run mistral

📚 DOCUMENTATION │

README.md → Guide complet d'installation

GUIDE-OLLAMA-COMPLET.md → Dépannage et optimisations

CHOIX-MODELE-RAPIDE.md → Aide au choix du modèle

🔗 LIENS UTILES

Site officiel : https://ollama.com

Liste modèles : https://ollama.com/library

GitHub : https://github.com/ollama/ollama

💾 RAPPEL RAM

8GB → Modèles 3B uniquement (qwen2.5:3b, llama3.2:3b, gemma:2b)

16GB → Modèles 7B-8B utilisables (mistral, deepseek-coder, etc.)

⚠️ RÈGLE D'OR 8GB

• UN SEUL modèle actif à la fois

• NE PAS utiliser mistral:7b (trop lent)

• Fermez les applications gourmandes avant utilisation

GUIDE COMPLET OLLAMA - OPTIMISATION & DÉPANNAGE

📋 TABLE DES MATIÈRES

🔧 PROBLÈMES COURANTS ET SOLUTIONS {#problèmes-courants}

Problème 1 : Mistral bloque ou est très lent sur 8GB RAM

Cause : Mistral (7B) nécessite ~5-6GB de RAM, ce qui laisse peu de marge sur un système 8GB

Solutions :

# Solution 1 : Utilisez une version quantifiée plus légère
ollama pull mistral:7b-instruct-q4_0  # Version compressée

# Solution 2 : Limitez la mémoire du contexte
ollama run mistral --num-ctx 2048  # Au lieu de 4096 par défaut

# Solution 3 : Passez à un modèle 3B plus adapté
ollama pull llama3.2:3b
ollama run llama3.2:3b

# Solution 4 : Forcez l'utilisation du CPU avec moins de couches
OLLAMA_NUM_GPU_LAYERS=0 ollama run mistral

Problème 2 : Phi est lent sur 8GB

Cause : Phi (2.7B) devrait être rapide. Si c'est lent, c'est probablement dû à :

Swap excessif (RAM saturée)
CPU surchargé par d'autres processus

Solutions :

# Vérifier l'utilisation de la RAM
free -h
# Si le swap est utilisé, fermez des applications

# Vérifier les processus gourmands
top -o %MEM
# Tuez les processus inutiles

# Essayez un modèle encore plus léger
ollama pull gemma:2b        # Google, très rapide
ollama pull qwen2.5:1.5b    # Ultra-rapide, bon en code

# Redémarrez Ollama pour vider le cache
sudo systemctl restart ollama

Problème 3 : Service Ollama ne démarre pas

# Vérifier l'état détaillé
sudo systemctl status ollama

# Voir les logs d'erreur
sudo journalctl -u ollama -n 50 --no-pager

# Vérifier si le port est déjà utilisé
sudo ss -tlnp | grep 11434

# Si le port est occupé, tuez le processus
sudo pkill ollama
sudo systemctl restart ollama

# Vérifier les permissions
sudo chown -R $USER:$USER ~/.ollama

Problème 4 : "Out of memory" ou crashes

# Vérifier la RAM disponible
free -h

# Réduire le nombre de modèles chargés simultanément
# Éditer la configuration
sudo nano /etc/systemd/system/ollama.service.d/override.conf

# Ajouter/modifier :
[Service]
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_NUM_PARALLEL=1"

# Recharger et redémarrer
sudo systemctl daemon-reload
sudo systemctl restart ollama

# Utiliser des modèles quantifiés (plus compacts)
ollama pull llama3.2:3b-instruct-q4_0

Problème 5 : Réponses en anglais alors que vous parlez français

# Forcez le français dans votre prompt
ollama run mistral "Réponds UNIQUEMENT en français : Comment ça va ?"

# Ou utilisez un modèle multilingue
ollama pull qwen2.5:3b      # Excellent en français
ollama pull aya:8b          # 101 langues dont français

⚙️ OPTIMISATION SELON VOTRE MATÉRIEL {#optimisation-matériel}

Configuration 8GB RAM - CPU uniquement

Modèles recommandés par usage :

Pour CODE :

# Le meilleur : Qwen2.5 (excellent ratio performance/taille)
ollama pull qwen2.5:3b
ollama run qwen2.5:3b "Écris une fonction Python pour trier une liste"

# Alternative ultra-rapide :
ollama pull qwen2.5:1.5b

Pour CONVERSATION GÉNÉRALE :

# Le meilleur équilibre :
ollama pull llama3.2:3b

# Le plus rapide :
ollama pull gemma:2b

Pour TRADUCTION :

# Excellent multilingue :
ollama pull qwen2.5:3b

# Spécialisé traduction :
ollama pull aya:8b  # Attention : proche de la limite 8GB

Configuration système optimale 8GB :

# Créer/éditer la config
sudo nano /etc/systemd/system/ollama.service.d/override.conf

[Service]
# Un seul modèle en mémoire
Environment="OLLAMA_MAX_LOADED_MODELS=1"

# Pas de parallélisme
Environment="OLLAMA_NUM_PARALLEL=1"

# Garder en mémoire 5 minutes après utilisation
Environment="OLLAMA_KEEP_ALIVE=5m"

# Limiter le contexte (économise la RAM)
Environment="OLLAMA_NUM_CTX=2048"

# Recharger
sudo systemctl daemon-reload
sudo systemctl restart ollama

Script pour libérer la RAM avant d'utiliser Ollama :

#!/bin/bash
# Sauvegarder comme ~/prepare-ollama.sh

echo "🧹 Nettoyage de la RAM..."

# Vider le cache système
sudo sync
echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null

# Fermer les applications gourmandes (exemples)
killall -9 chrome chromium firefox 2>/dev/null

# Afficher la RAM disponible
echo ""
echo "💾 RAM disponible :"
free -h | grep Mem

echo ""
echo "✅ Prêt pour Ollama"
ollama list

Configuration 16GB RAM - CPU ou GPU

Modèles recommandés par usage :

Pour CODE :

# Spécialiste code :
ollama pull deepseek-coder:6.7b
ollama run deepseek-coder:6.7b "Écris un serveur web en Python avec Flask"

# Alternative excellent code + multilingue :
ollama pull qwen2.5-coder:7b

# Si vous avez un GPU NVIDIA :
ollama pull codellama:13b  # Encore plus puissant

Pour CONVERSATION + POLYVALENCE :

# Le meilleur général :
ollama pull mistral:7b

# Alternative Meta :
ollama pull llama3.1:8b

# Pour français + multilingue :
ollama pull qwen2.5:7b

Pour TRADUCTION :

# Excellent multilingue :
ollama pull qwen2.5:7b

# Spécialiste 101 langues :
ollama pull aya:8b

Configuration système optimale 16GB :

sudo nano /etc/systemd/system/ollama.service.d/override.conf

[Service]
# Deux modèles simultanés possibles
Environment="OLLAMA_MAX_LOADED_MODELS=2"

# Deux requêtes parallèles
Environment="OLLAMA_NUM_PARALLEL=2"

# Garder en mémoire 10 minutes
Environment="OLLAMA_KEEP_ALIVE=10m"

# Contexte complet
Environment="OLLAMA_NUM_CTX=4096"

sudo systemctl daemon-reload
sudo systemctl restart ollama

Optimisation GPU NVIDIA

# Vérifier que le GPU est détecté
nvidia-smi

# Ollama utilise automatiquement le GPU si disponible
# Pour vérifier pendant l'utilisation :
watch -n 1 nvidia-smi

# Forcer un nombre de couches sur GPU (si problème)
OLLAMA_NUM_GPU_LAYERS=32 ollama run mistral

# Pour ne PAS utiliser le GPU (test CPU)
OLLAMA_NUM_GPU_LAYERS=0 ollama run mistral

# Optimisation GPU dans la config
sudo nano /etc/systemd/system/ollama.service.d/override.conf

[Service]
Environment="OLLAMA_NUM_GPU_LAYERS=999"  # Tout sur GPU
Environment="CUDA_VISIBLE_DEVICES=0"      # GPU 0 uniquement

sudo systemctl daemon-reload
sudo systemctl restart ollama

📊 COMPARATIF DES MODÈLES {#comparatif-modèles}

Tableau de performance (8GB RAM - CPU)

Modèle	Taille	Vitesse	Code	Conversation	Traduction	RAM
qwen2.5:1.5b	1.5B	⚡⚡⚡⚡⚡	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	2GB
gemma:2b	2B	⚡⚡⚡⚡⚡	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	2GB
llama3.2:3b	3B	⚡⚡⚡⚡	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐	3GB
qwen2.5:3b	3B	⚡⚡⚡⚡	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	3GB
phi3:3.8b	3.8B	⚡⚡⚡	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	4GB
mistral:7b	7B	⚡⚡	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	5-6GB

🎯 Recommandation 8GB : qwen2.5:3b ou llama3.2:3b

Tableau de performance (16GB RAM)

Modèle	Taille	Code	Conversation	Traduction	GPU	RAM
mistral:7b	7B	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	✅	5-6GB
llama3.1:8b	8B	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐	✅	6GB
qwen2.5:7b	7B	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	✅	5GB
deepseek-coder:6.7b	6.7B	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	✅	5GB
codellama:7b	7B	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐	✅	5GB
aya:8b	8B	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	✅	6GB

🎯 Recommandation 16GB : mistral:7b (polyvalent) ou qwen2.5:7b (code+multilingue)

Tests de vitesse comparatifs

#!/bin/bash
# Script de benchmark comparatif
# Sauvegarder comme ~/compare-models.sh

PROMPT="Écris une fonction Python qui calcule les nombres premiers jusqu'à N"

echo "🧪 TEST DE VITESSE - CODE"
echo "=========================="
echo ""

for MODEL in qwen2.5:1.5b gemma:2b llama3.2:3b qwen2.5:3b mistral:7b; do
    echo "Test de $MODEL..."
    echo "---"
    
    # Vérifier si le modèle est installé
    if ! ollama list | grep -q "$MODEL"; then
        echo "⏭️  $MODEL non installé, skip"
        echo ""
        continue
    fi
    
    # Mesurer le temps
    TIME_START=$(date +%s)
    ollama run "$MODEL" "$PROMPT" > /tmp/ollama_test_output.txt
    TIME_END=$(date +%s)
    DURATION=$((TIME_END - TIME_START))
    
    # Compter les tokens (approximation)
    CHARS=$(wc -c < /tmp/ollama_test_output.txt)
    TOKENS=$((CHARS / 4))  # Approximation : 1 token ≈ 4 caractères
    
    echo "⏱️  Temps : ${DURATION}s"
    echo "📝 Tokens : ~${TOKENS}"
    echo "⚡ Vitesse : ~$((TOKENS / DURATION)) tokens/s"
    echo ""
done

rm /tmp/ollama_test_output.txt

🚀 COMMANDES AVANCÉES {#commandes-avancées}

Gestion des modèles

# Lister TOUS les modèles disponibles en ligne
curl https://ollama.com/api/tags | jq '.models[].name'

# Télécharger une version spécifique
ollama pull llama3.2:3b-instruct-q4_0  # Version quantifiée 4-bit

# Voir les détails d'un modèle installé
ollama show mistral

# Voir la taille des modèles installés
du -sh ~/.ollama/models/*

# Supprimer TOUS les modèles (gain d'espace)
rm -rf ~/.ollama/models/*
ollama pull llama3.2:3b  # Réinstaller celui que vous voulez

# Copier un modèle avec un nouveau nom
ollama cp mistral mon-assistant
ollama run mon-assistant

Personnalisation des modèles (Modelfile)

# Créer un modèle personnalisé avec des instructions
cat > Modelfile-Assistant-Code <<EOF
FROM qwen2.5:3b

SYSTEM """
Tu es un assistant spécialisé en programmation Python.
Tu réponds TOUJOURS en français.
Tu donnes des exemples de code commentés.
Tu expliques ta logique.
"""

PARAMETER temperature 0.7
PARAMETER num_ctx 4096
EOF

# Créer le modèle personnalisé
ollama create assistant-code -f Modelfile-Assistant-Code

# Utiliser votre modèle personnalisé
ollama run assistant-code "Comment créer une API REST ?"

Exemple : Modèle pour traduction

cat > Modelfile-Traducteur <<EOF
FROM qwen2.5:3b

SYSTEM """
Tu es un traducteur professionnel.
Traduis le texte fourni avec précision.
Préserve le ton et le style.
Indique la langue source et cible.
"""

PARAMETER temperature 0.3
PARAMETER top_p 0.9
EOF

ollama create traducteur -f Modelfile-Traducteur
ollama run traducteur "Translate to English: Bonjour le monde"

Utilisation en ligne de commande

# Conversation simple
ollama run mistral "Explique-moi les classes en Python"

# Avec contexte limité (plus rapide)
ollama run mistral --num-ctx 2048 "Question courte"

# Mode verbeux (voir les stats)
ollama run mistral --verbose "Test"

# Sans streaming (attendre la réponse complète)
ollama run mistral --no-stream "Question"

# Sauvegarder la sortie
ollama run mistral "Liste les types de données Python" > reponse.txt

# Utiliser un fichier comme input
ollama run mistral "Résume ce code:" < script.py

# Pipeline avec d'autres commandes
cat code.py | ollama run deepseek-coder "Explique ce code"

API REST locale

# Ollama expose une API REST sur le port 11434

# Envoyer une requête (exemple avec curl)
curl http://localhost:11434/api/generate -d '{
  "model": "mistral",
  "prompt": "Pourquoi le ciel est bleu ?",
  "stream": false
}'

# Avec Python
cat > test_ollama_api.py <<EOF
import requests
import json

def ask_ollama(prompt, model="mistral"):
    url = "http://localhost:11434/api/generate"
    data = {
        "model": model,
        "prompt": prompt,
        "stream": False
    }
    
    response = requests.post(url, json=data)
    result = response.json()
    return result['response']

# Utilisation
reponse = ask_ollama("Qu'est-ce que Python ?")
print(reponse)
EOF

python3 test_ollama_api.py

Intégration dans scripts Bash

#!/bin/bash
# Script d'assistant de code

echo "🤖 Assistant Code Ollama"
echo "========================"
echo ""
echo "Décrivez ce que vous voulez coder :"
read -r user_input

echo ""
echo "🔄 Génération du code..."
echo ""

ollama run qwen2.5:3b <<PROMPT
Génère du code Python propre et commenté pour : $user_input

Fournis :
1. Le code complet
2. Des commentaires explicatifs
3. Un exemple d'utilisation

Réponds uniquement en français.
PROMPT

echo ""
echo "✅ Terminé !"

📜 SCRIPTS D'AUTOMATISATION {#scripts}

Script 1 : Assistant conversationnel persistant

#!/bin/bash
# Sauvegarder comme ~/ollama-chat.sh

MODEL=${1:-llama3.2:3b}
HISTORY_FILE=~/.ollama_chat_history

echo "💬 Chat avec $MODEL (tapez 'exit' pour quitter)"
echo "================================================"
echo ""

# Charger l'historique si existe
if [ -f "$HISTORY_FILE" ]; then
    echo "📜 Historique chargé"
fi

while true; do
    echo -n "Vous: "
    read -r user_input
    
    # Quitter
    if [ "$user_input" = "exit" ]; then
        echo "👋 Au revoir !"
        break
    fi
    
    # Sauvegarder dans l'historique
    echo "USER: $user_input" >> "$HISTORY_FILE"
    
    echo ""
    echo "$MODEL: "
    
    # Obtenir la réponse
    response=$(ollama run "$MODEL" "$user_input")
    echo "$response"
    
    # Sauvegarder la réponse
    echo "AI: $response" >> "$HISTORY_FILE"
    echo ""
done

Script 2 : Traducteur automatique

#!/bin/bash
# Sauvegarder comme ~/translate.sh

SOURCE_LANG=${1:-""}
TARGET_LANG=${2:-"anglais"}
TEXT=${3:-""}

if [ -z "$TEXT" ]; then
    echo "Usage: ./translate.sh [langue_source] langue_cible \"texte\""
    echo "Exemple: ./translate.sh français anglais \"Bonjour le monde\""
    exit 1
fi

if [ -z "$SOURCE_LANG" ]; then
    PROMPT="Traduis en $TARGET_LANG : $TEXT"
else
    PROMPT="Traduis de $SOURCE_LANG vers $TARGET_LANG : $TEXT"
fi

ollama run qwen2.5:3b "$PROMPT"

Script 3 : Revue de code automatique

#!/bin/bash
# Sauvegarder comme ~/code-review.sh

FILE=${1:-""}

if [ -z "$FILE" ] || [ ! -f "$FILE" ]; then
    echo "Usage: ./code-review.sh fichier.py"
    exit 1
fi

CODE=$(cat "$FILE")

ollama run deepseek-coder:6.7b <<PROMPT
Analyse ce code et fournis une revue détaillée :

\`\`\`
$CODE
\`\`\`

Fournis :
1. Points positifs
2. Points à améliorer
3. Bugs potentiels
4. Suggestions d'optimisation
5. Score de qualité /10

Réponds en français.
PROMPT

Script 4 : Générateur de documentation

#!/bin/bash
# Sauvegarder comme ~/gen-docs.sh

FILE=${1:-""}

if [ -z "$FILE" ] || [ ! -f "$FILE" ]; then
    echo "Usage: ./gen-docs.sh script.py"
    exit 1
fi

CODE=$(cat "$FILE")
FILENAME=$(basename "$FILE")
DOCFILE="${FILENAME%.py}_documentation.md"

echo "📝 Génération de la documentation pour $FILENAME..."

ollama run qwen2.5:7b <<PROMPT > "$DOCFILE"
Génère une documentation complète en markdown pour ce code :

\`\`\`python
$CODE
\`\`\`

La documentation doit inclure :
1. Titre et description
2. Prérequis et dépendances
3. Installation
4. Utilisation avec exemples
5. Description des fonctions/classes
6. Paramètres et retours
7. Exemples de code
8. Notes et avertissements

Format markdown professionnel en français.
PROMPT

echo "✅ Documentation générée : $DOCFILE"
cat "$DOCFILE"

Script 5 : Moniteur de ressources Ollama

#!/bin/bash
# Sauvegarder comme ~/ollama-watch.sh

while true; do
    clear
    echo "=== OLLAMA MONITOR ==="
    date
    echo ""
    
    echo "📊 SERVICE"
    systemctl is-active ollama && echo "✅ ACTIF" || echo "❌ INACTIF"
    echo ""
    
    echo "💾 RAM SYSTÈME"
    free -h | grep -E "Mem:|Swap:"
    echo ""
    
    echo "📦 MODÈLES CHARGÉS"
    ollama ps 2>/dev/null || echo "Aucun modèle actif"
    echo ""
    
    echo "🎮 GPU (si disponible)"
    nvidia-smi --query-gpu=utilization.gpu,utilization.memory,memory.used --format=csv,noheader 2>/dev/null || echo "N/A"
    echo ""
    
    echo "🔄 Actualisation dans 2s... (Ctrl+C pour quitter)"
    sleep 2
done

🎯 WORKFLOWS RECOMMANDÉS

Workflow 1 : Développement avec assistance IA (8GB)

# 1. Préparer le système
~/prepare-ollama.sh

# 2. Charger le modèle de code
ollama run qwen2.5:3b

# 3. Demander de l'aide
# >>> Écris une classe Python pour gérer une base de données SQLite

# 4. Sauvegarder le code généré
# (copier-coller dans votre éditeur)

# 5. Demander une revue
cat moncode.py | ollama run qwen2.5:3b "Revois ce code et suggère des améliorations"

Workflow 2 : Traduction de documents (16GB)

# 1. Charger le modèle multilingue
ollama pull qwen2.5:7b

# 2. Traduction interactive
ollama run qwen2.5:7b
# >>> Traduis en anglais le texte suivant : [votre texte]

# 3. Traduction de fichiers
cat document_fr.txt | ollama run qwen2.5:7b "Traduis ce texte en anglais, conserve la mise en forme"

✅ CHECKLIST DE PERFORMANCE

Cochez pour optimiser :

Configuration 8GB :

[ ] Un seul modèle 3B installé (llama3.2:3b ou qwen2.5:3b)
[ ] Applications gourmandes fermées avant utilisation
[ ] Swap non utilisé (vérifier avec free -h)
[ ] OLLAMA_MAX_LOADED_MODELS=1 dans la config
[ ] Script de nettoyage RAM créé

Configuration 16GB :

[ ] Modèles 7B-8B installés selon vos besoins
[ ] GPU NVIDIA détecté et actif (si disponible)
[ ] OLLAMA_MAX_LOADED_MODELS=2 dans la config
[ ] Scripts de monitoring installés

Pour tous :

[ ] Service Ollama démarré au boot
[ ] Scripts utilitaires dans ~/
[ ] Modèles testés avec benchmark
[ ] Documentation sauvegardée

Besoin d'aide ? Exécutez ~/ollama-diagnostic.sh pour identifier les problèmes.

A tester :

#!/usr/bin/env bash

# Script de configuration intelligente Ollama

# Détecte automatiquement RAM et propose la meilleure configuration

set -e

RED='\033[0;31m'

GREEN='\033[0;32m'

YELLOW='\033[1;33m'

BLUE='\033[0;34m'

CYAN='\033[0;36m'

NC='\033[0m'

info() { echo -e "${BLUE}ℹ${NC} $1"; }

success() { echo -e "${GREEN}✅${NC} $1"; }

warning() { echo -e "${YELLOW}⚠️${NC} $1"; }

error() { echo -e "${RED}❌${NC} $1"; }

question() { echo -e "${CYAN}❓${NC} $1"; }

clear

echo "╔════════════════════════════════════════════╗"

echo "║ CONFIGURATION INTELLIGENTE OLLAMA ║"

echo "║ Optimisation automatique ║"

echo "╚════════════════════════════════════════════╝"

echo ""

# Vérifier qu'Ollama est installé

if ! command -v ollama &> /dev/null; then

error "Ollama n'est pas installé !"

info "Lancez d'abord : ./ollama-install-optimized.sh"

exit 1

# Détecter la RAM

TOTAL_RAM_GB=$(free -g | awk '/^Mem:/{print $2}')

info "RAM détectée : ${TOTAL_RAM_GB}GB"

# Détecter le GPU

GPU_TYPE="CPU"

if lspci | grep -qi nvidia && command -v nvidia-smi &> /dev/null; then

GPU_TYPE="NVIDIA"

elif lspci | grep -qi amd; then

GPU_TYPE="AMD"

info "GPU détecté : $GPU_TYPE"

echo ""

echo "════════════════════════════════════════════"

echo ""

# Déterminer le profil d'usage

question "Quel est votre usage principal ?"

echo ""

echo " 1) 💻 Code (Python, JavaScript, etc.)"

echo " 2) 💬 Conversation générale"

echo " 3) 🌍 Traduction multilingue"

echo " 4) 🔄 Usage mixte (code + conversation + traduction)"

echo ""

echo -n "Votre choix [1-4] : "

read -r usage_choice

# Recommandations selon RAM et usage

echo ""

echo "════════════════════════════════════════════"

echo " ANALYSE ET RECOMMANDATIONS"

echo "════════════════════════════════════════════"

echo ""

RECOMMENDED_MODELS=()

SECONDARY_MODELS=()

if [ "$TOTAL_RAM_GB" -le 8 ]; then

warning "Configuration 8GB RAM - Modèles légers recommandés"

echo ""

case $usage_choice in

info "Usage : CODE"

RECOMMENDED_MODELS=("qwen2.5:3b")

SECONDARY_MODELS=("qwen2.5:1.5b")

echo " 🎯 Modèle principal : qwen2.5:3b"

echo " • Excellent en code"

echo " • Rapide sur CPU"

echo " • ~3GB RAM"

echo ""

echo " ⚡ Alternative rapide : qwen2.5:1.5b"

echo " • Ultra-rapide"

echo " • Pour code simple"

;;

info "Usage : CONVERSATION"

RECOMMENDED_MODELS=("llama3.2:3b")

SECONDARY_MODELS=("gemma:2b")

echo " 🎯 Modèle principal : llama3.2:3b"

echo " • Excellent conversationnel"

echo " • Bon en français"

echo " • ~3GB RAM"

echo ""

echo " ⚡ Alternative rapide : gemma:2b"

echo " • Très rapide"

echo " • Google model"

;;

info "Usage : TRADUCTION"

RECOMMENDED_MODELS=("qwen2.5:3b")

SECONDARY_MODELS=()

echo " 🎯 Modèle principal : qwen2.5:3b"

echo " • Excellent multilingue"

echo " • 29 langues"

echo " • ~3GB RAM"

;;

info "Usage : MIXTE"

RECOMMENDED_MODELS=("qwen2.5:3b")

SECONDARY_MODELS=()

echo " 🎯 Modèle polyvalent : qwen2.5:3b"

echo " • Bon en code"

echo " • Bon en conversation"

echo " • Bon en traduction"

echo " • ~3GB RAM"

;;

esac

echo ""

warning "⚠️ Avec 8GB, installez UN SEUL modèle à la fois"

warning "⚠️ mistral:7b sera TROP LENT sur votre configuration"

else

success "Configuration 16GB+ RAM - Tous les modèles supportés"

echo ""

case $usage_choice in

info "Usage : CODE"

RECOMMENDED_MODELS=("deepseek-coder:6.7b" "qwen2.5-coder:7b")

SECONDARY_MODELS=("mistral:7b")

echo " 🎯 Modèle spécialisé code : deepseek-coder:6.7b"

echo " • Expert en code"

echo " • Explications claires"

echo " • ~5GB RAM"

echo ""

echo " 🔄 Alternative : qwen2.5-coder:7b"

echo " • Code + multilingue"

echo " • ~5GB RAM"

echo ""

echo " 💬 Modèle général : mistral:7b"

echo " • Pour conversation"

echo " • Complément"

;;

info "Usage : CONVERSATION"

RECOMMENDED_MODELS=("mistral:7b")

SECONDARY_MODELS=("llama3.1:8b")

echo " 🎯 Modèle principal : mistral:7b"

echo " • Excellent conversationnel"

echo " • Naturel en français"

echo " • ~5-6GB RAM"

echo ""

echo " 🔄 Alternative : llama3.1:8b"

echo " • Très puissant"

if [ "$GPU_TYPE" = "NVIDIA" ]; then

echo " • Excellent sur GPU"

;;

info "Usage : TRADUCTION"

RECOMMENDED_MODELS=("qwen2.5:7b")

SECONDARY_MODELS=("aya:8b")

echo " 🎯 Modèle principal : qwen2.5:7b"

echo " • Excellent multilingue"

echo " • 29 langues"

echo " • ~5GB RAM"

echo ""

echo " 🌍 Spécialisé : aya:8b"

echo " • 101 langues"

echo " • Expert traduction"

;;

info "Usage : MIXTE"

RECOMMENDED_MODELS=("mistral:7b" "qwen2.5:7b")

SECONDARY_MODELS=("deepseek-coder:6.7b")

echo " 🎯 Modèle polyvalent : mistral:7b"

echo " • Excellent pour tout"

echo " • ~5-6GB RAM"

echo ""

echo " 💻 Pour le code : qwen2.5:7b ou deepseek-coder:6.7b"

echo " • Complément code"

echo " • ~5GB RAM"

;;

esac

echo ""

if [ "$GPU_TYPE" = "NVIDIA" ]; then

success "🎮 GPU NVIDIA détecté - Les modèles seront accélérés"

echo ""

echo "════════════════════════════════════════════"

echo ""

# Installation des modèles

question "Voulez-vous installer les modèles recommandés maintenant ? [O/n]"

read -r install_choice

if [[ "$install_choice" =~ ^[Oo]$ ]] || [ -z "$install_choice" ]; then

echo ""

info "Installation des modèles recommandés..."

echo ""

for model in "${RECOMMENDED_MODELS[@]}"; do

echo "📥 Téléchargement de $model..."

if ollama pull "$model"; then

success "$model installé"

else

error "Échec de l'installation de $model"

echo ""

done

if [ ${#SECONDARY_MODELS[@]} -gt 0 ]; then

question "Voulez-vous aussi installer les modèles alternatifs ? [o/N]"

read -r install_secondary

if [[ "$install_secondary" =~ ^[Oo]$ ]]; then

for model in "${SECONDARY_MODELS[@]}"; do

echo "📥 Téléchargement de $model..."

if ollama pull "$model"; then

success "$model installé"

else

error "Échec de l'installation de $model"

echo ""

done

# Configuration système

echo ""

echo "════════════════════════════════════════════"

echo " OPTIMISATION SYSTÈME"

echo "════════════════════════════════════════════"

echo ""

question "Voulez-vous optimiser la configuration système ? [O/n]"

read -r optimize_choice

if [[ "$optimize_choice" =~ ^[Oo]$ ]] || [ -z "$optimize_choice" ]; then

info "Création de la configuration optimisée..."

sudo mkdir -p /etc/systemd/system/ollama.service.d/

if [ "$TOTAL_RAM_GB" -le 8 ]; then

# Configuration 8GB

cat <<EOF | sudo tee /etc/systemd/system/ollama.service.d/override.conf > /dev/null

[Service]

Environment="OLLAMA_HOST=127.0.0.1:11434"

Environment="OLLAMA_KEEP_ALIVE=5m"

Environment="OLLAMA_MAX_LOADED_MODELS=1"

Environment="OLLAMA_NUM_PARALLEL=1"

Environment="OLLAMA_NUM_CTX=2048"

EOF

success "Configuration optimisée pour 8GB RAM"

else

# Configuration 16GB+

cat <<EOF | sudo tee /etc/systemd/system/ollama.service.d/override.conf > /dev/null

[Service]

Environment="OLLAMA_HOST=127.0.0.1:11434"

Environment="OLLAMA_KEEP_ALIVE=10m"

Environment="OLLAMA_MAX_LOADED_MODELS=2"

Environment="OLLAMA_NUM_PARALLEL=2"

Environment="OLLAMA_NUM_CTX=4096"

EOF

success "Configuration optimisée pour 16GB+ RAM"

if [ "$GPU_TYPE" = "NVIDIA" ]; then

info "Ajout de la configuration GPU NVIDIA..."

sudo bash -c "cat >> /etc/systemd/system/ollama.service.d/override.conf" <<EOF

Environment="OLLAMA_NUM_GPU_LAYERS=999"

Environment="CUDA_VISIBLE_DEVICES=0"

EOF

success "Configuration GPU ajoutée"

# Recharger systemd

sudo systemctl daemon-reload

sudo systemctl restart ollama

success "Service Ollama redémarré avec la nouvelle configuration"

# Création des scripts utilitaires

echo ""

echo "════════════════════════════════════════════"

echo " SCRIPTS UTILITAIRES"

echo "════════════════════════════════════════════"

echo ""

question "Voulez-vous créer les scripts utilitaires ? [O/n]"

read -r scripts_choice

if [[ "$scripts_choice" =~ ^[Oo]$ ]] || [ -z "$scripts_choice" ]; then

# Script de nettoyage RAM (pour 8GB)

if [ "$TOTAL_RAM_GB" -le 8 ]; then

cat > ~/prepare-ollama.sh <<'PREP_EOF'

#!/bin/bash

echo "🧹 Nettoyage de la RAM..."

sudo sync

echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null

killall -9 chrome chromium firefox thunderbird 2>/dev/null

echo ""

echo "💾 RAM disponible :"

free -h | grep Mem

echo ""

echo "✅ Prêt pour Ollama"

PREP_EOF

chmod +x ~/prepare-ollama.sh

success "Script ~/prepare-ollama.sh créé"

# Script de benchmark

cat > ~/test-vitesse.sh <<'TEST_EOF'

#!/bin/bash

MODEL=${1:-$(ollama list | tail -n +2 | head -n1 | awk '{print $1}')}

echo "⚡ Test de vitesse : $MODEL"

echo ""

echo "Test 1 : Réponse courte"

time ollama run $MODEL "Bonjour" --verbose 2>&1 | tail -n 3

echo ""

echo "Test 2 : Code simple"

time ollama run $MODEL "Fonction Python pour additionner 2 nombres" --verbose 2>&1 | tail -n 3

TEST_EOF

chmod +x ~/test-vitesse.sh

success "Script ~/test-vitesse.sh créé"

# Script de monitoring

cat > ~/ollama-status.sh <<'STATUS_EOF'

#!/bin/bash

clear

echo "╔════════════════════════════════════════════╗"

echo "║ ÉTAT OLLAMA ║"

echo "╚════════════════════════════════════════════╝"

echo ""

echo "📊 Service :"

systemctl is-active ollama && echo " ✅ Actif" || echo " ❌ Inactif"

echo ""

echo "📦 Modèles installés :"

ollama list | tail -n +2 | while read line; do

echo " • $line"

done

echo ""

echo "💾 RAM :"

free -h | grep Mem | awk '{print " Total: "$2" | Utilisé: "$3" | Libre: "$4}'

echo ""

if command -v nvidia-smi &> /dev/null; then

echo "🎮 GPU :"

nvidia-smi --query-gpu=name,memory.used,memory.total --format=csv,noheader | awk -F, '{print " "$1" | "$2"/"$3}'

echo ""

echo "🔧 Configuration :"

if [ -f /etc/systemd/system/ollama.service.d/override.conf ]; then

grep Environment /etc/systemd/system/ollama.service.d/override.conf | sed 's/Environment=/ • /'

else

echo " Configuration par défaut"

STATUS_EOF

chmod +x ~/ollama-status.sh

success "Script ~/ollama-status.sh créé"

# Test du modèle installé

echo ""

echo "════════════════════════════════════════════"

echo " TEST DU MODÈLE"

echo "════════════════════════════════════════════"

echo ""

FIRST_MODEL="${RECOMMENDED_MODELS[0]}"

if ollama list | grep -q "$FIRST_MODEL"; then

question "Voulez-vous tester $FIRST_MODEL ? [O/n]"

read -r test_choice

if [[ "$test_choice" =~ ^[Oo]$ ]] || [ -z "$test_choice" ]; then

echo ""

info "Test de $FIRST_MODEL..."

echo ""

echo ">>> Question : Présente-toi brièvement en français"

echo ""

ollama run "$FIRST_MODEL" "Présente-toi brièvement en français (3 phrases max)" --verbose

echo ""

success "Test terminé !"

# Résumé final

echo ""

echo "╔════════════════════════════════════════════╗"

echo "║ CONFIGURATION TERMINÉE ║"

echo "╚════════════════════════════════════════════╝"

echo ""

success "Configuration optimale pour votre système !"

echo ""

info "Configuration :"

echo " • RAM : ${TOTAL_RAM_GB}GB"

echo " • GPU : $GPU_TYPE"

echo " • Usage : $(case $usage_choice in 1) echo 'Code';; 2) echo 'Conversation';; 3) echo 'Traduction';; 4) echo 'Mixte';; esac)"

echo ""

info "Modèles installés :"

for model in "${RECOMMENDED_MODELS[@]}"; do

if ollama list | grep -q "$model"; then

echo " ✅ $model"

done

echo ""

info "Scripts créés :"

[ -f ~/prepare-ollama.sh ] && echo " • ~/prepare-ollama.sh - Nettoyer la RAM"

[ -f ~/test-vitesse.sh ] && echo " • ~/test-vitesse.sh - Tester les performances"

[ -f ~/ollama-status.sh ] && echo " • ~/ollama-status.sh - Voir l'état du système"

echo ""

info "Commandes utiles :"

echo ""

echo " # Utiliser le modèle"

echo " ollama run $FIRST_MODEL"

echo ""

echo " # Voir l'état du système"

echo " ~/ollama-status.sh"

echo ""

if [ "$TOTAL_RAM_GB" -le 8 ]; then

echo " # Préparer le système (8GB)"

echo " ~/prepare-ollama.sh"

echo ""

echo " # Tester les performances"

echo " ~/test-vitesse.sh $FIRST_MODEL"

echo ""

echo " # Voir tous les modèles"

echo " ollama list"

echo ""

echo "════════════════════════════════════════════"

echo ""

success "🎉 Ollama est prêt à l'emploi !"

echo ""

Voici les commandes pour créer des raccourcis clavier pour Ollama sur Ubuntu/GNOME :

🎯 Méthode via Interface Graphique

Paramètres → Clavier → Raccourcis personnalisés

Exemples de raccourcis à créer :

Nom	Commande	Raccourci suggéré
Lancer Ollama (Phi)	`gnome-terminal -- ollama run phi:latest`	`Ctrl+Alt+O`
Lancer Mistral	`gnome-terminal -- ollama run mistral:latest`	`Ctrl+Alt+1`
Lancer Mistral Small	`gnome-terminal -- ollama run mistral-small:latest`	`Ctrl+Alt+2`
Liste modèles	`gnome-terminal -- bash -c "ollama list; read -p 'Appuyez sur Entrée...'"`	`Ctrl+Alt+L`
État Ollama	`gnome-terminal -- bash -c "systemctl status ollama; read -p 'Appuyez sur Entrée...'"`	`Ctrl+Alt+S`

💻 Méthode via Terminal (plus rapide)

# Créer un raccourci pour lancer Phi (Ctrl+Alt+O)
gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-phi/ name 'Ollama Phi'
gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-phi/ command 'gnome-terminal -- ollama run phi:latest'
gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-phi/ binding '<Primary><Alt>o'

# Créer un raccourci pour Mistral (Ctrl+Alt+1)
gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-mistral/ name 'Ollama Mistral'
gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-mistral/ command 'gnome-terminal -- ollama run mistral:latest'
gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-mistral/ binding '<Primary><Alt>1'

# Activer tous les raccourcis créés
gsettings set org.gnome.settings-daemon.plugins.media-keys custom-keybindings "['/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-phi/', '/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-mistral/']"

📝 Script Automatique Complet

#!/bin/bash
# Sauvegarder comme ~/create-ollama-shortcuts.sh

# Liste des raccourcis
SHORTCUTS_PATH="org.gnome.settings-daemon.plugins.media-keys"

# Réinitialiser les raccourcis personnalisés
gsettings set $SHORTCUTS_PATH custom-keybindings "[]"

# Fonction pour créer un raccourci
create_shortcut() {
    local name="$1"
    local command="$2"
    local binding="$3"
    local path="/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/$name/"
    
    gsettings set $SHORTCUTS_PATH.custom-keybinding:$path name "$name"
    gsettings set $SHORTCUTS_PATH.custom-keybinding:$path command "$command"
    gsettings set $SHORTCUTS_PATH.custom-keybinding:$path binding "$binding"
}

# Créer les raccourcis
create_shortcut "ollama-phi" "gnome-terminal -- ollama run phi:latest" "<Primary><Alt>o"
create_shortcut "ollama-mistral" "gnome-terminal -- ollama run mistral:latest" "<Primary><Alt>1"
create_shortcut "ollama-mistral-small" "gnome-terminal -- ollama run mistral-small:latest" "<Primary><Alt>2"
create_shortcut "ollama-list" "gnome-terminal -- bash -c 'ollama list; read -p Entrée...'" "<Primary><Alt>l"
create_shortcut "ollama-status" "gnome-terminal -- bash -c 'systemctl status ollama; read -p Entrée...'" "<Primary><Alt>s"

# Activer tous les raccourcis
gsettings set $SHORTCUTS_PATH custom-keybindings "[
    '/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-phi/',
    '/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-mistral/',
    '/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-mistral-small/',
    '/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-list/',
    '/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/ollama-status/'
]"

echo "✅ Raccourcis créés avec succès !"

Pour l'utiliser :

chmod +x ~/create-ollama-shortcuts.sh
~/create-ollama-shortcuts.sh

🎹 Raccourcis créés :

Ctrl+Alt+O → Lancer Phi
Ctrl+Alt+1 → Lancer Mistral
Ctrl+Alt+2 → Lancer Mistral Small
Ctrl+Alt+L → Voir la liste des modèles
Ctrl+Alt+S → Voir l'état du service

Vous pouvez les tester immédiatement après avoir exécuté le script ! 🚀

dimanche 14 décembre 2025

Installation d'Ollama et de PHI sur UBUNTU

Installation d'Ollama et de PHI ou mieux de Mistral sur un PC avec 8 Go ou 16 Go de RAM.

Voici mes commentaires et suggestions d'amélioration pour ce script et ma documentation :

Les points forts de cette approche

1. Démarrage via systemd (Méthode Recommandée).

2. Démarrage en mode manuel

Suggestions d'amélioration du script :

1. Gestion du redémarrage NVIDIA

2. Vérification préalable d'Ollama

3. Test plus robuste après installation

4. Gestion des logs

5. Configuration de la mémoire

Suggestions pour la documentation

Ajouter une section dépannage

Script de test rapide

Modèles recommandés selon la RAM

OLLAMA - AIDE-MÉMOIRE RAPIDE

🚀 INSTALLATION (PREMIÈRE FOIS)

💻 UTILISATION QUOTIDIENNE

📦 GESTION DES MODÈLES

🔧 SERVICE OLLAMA

🛠️ SCRIPTS UTILITAIRES

🎯 MODÈLES RECOMMANDÉS

🐛 DÉPANNAGE RAPIDE

💡 ASTUCES

📚 DOCUMENTATION │

🔗 LIENS UTILES

💾 RAPPEL RAM

⚠️ RÈGLE D'OR 8GB

GUIDE COMPLET OLLAMA - OPTIMISATION & DÉPANNAGE

📋 TABLE DES MATIÈRES

🔧 PROBLÈMES COURANTS ET SOLUTIONS {#problèmes-courants}

Problème 1 : Mistral bloque ou est très lent sur 8GB RAM

Problème 2 : Phi est lent sur 8GB

Problème 3 : Service Ollama ne démarre pas

Problème 4 : "Out of memory" ou crashes

Problème 5 : Réponses en anglais alors que vous parlez français

⚙️ OPTIMISATION SELON VOTRE MATÉRIEL {#optimisation-matériel}

Configuration 8GB RAM - CPU uniquement

Pour CODE :

Pour CONVERSATION GÉNÉRALE :

Pour TRADUCTION :

Configuration 16GB RAM - CPU ou GPU

Pour CODE :

Pour CONVERSATION + POLYVALENCE :

Pour TRADUCTION :

Optimisation GPU NVIDIA

📊 COMPARATIF DES MODÈLES {#comparatif-modèles}

Tableau de performance (8GB RAM - CPU)

Tableau de performance (16GB RAM)

Tests de vitesse comparatifs

🚀 COMMANDES AVANCÉES {#commandes-avancées}

Gestion des modèles

Personnalisation des modèles (Modelfile)

Utilisation en ligne de commande

API REST locale

Intégration dans scripts Bash

📜 SCRIPTS D'AUTOMATISATION {#scripts}

Script 1 : Assistant conversationnel persistant

Script 2 : Traducteur automatique

Script 3 : Revue de code automatique

Script 4 : Générateur de documentation

Script 5 : Moniteur de ressources Ollama

🎯 WORKFLOWS RECOMMANDÉS

Workflow 1 : Développement avec assistance IA (8GB)

Workflow 2 : Traduction de documents (16GB)

✅ CHECKLIST DE PERFORMANCE

A tester :

Voici les commandes pour créer des raccourcis clavier pour Ollama sur Ubuntu/GNOME :

🎯 Méthode via Interface Graphique

Exemples de raccourcis à créer :

💻 Méthode via Terminal (plus rapide)

📝 Script Automatique Complet

🎹 Raccourcis créés :

Aucun commentaire:

Enregistrer un commentaire

1. Démarrage via `systemd` (Méthode Recommandée).