Ollama : installation et configuration avancée de LLM en local

## Linux et macOS
curl -fsSL https://ollama.com/install.sh | sh

## Windows PowerShell (administrateur)
irm https://ollama.com/install.ps1 | iex

## Téléchargement du binaire
OLLAMA_VERSION=$(curl -s https://api.github.com/repos/ollama/ollama/releases/latest | grep tag_name | cut -d'"' -f4)
curl -L "https://github.com/ollama/ollama/releases/download/${OLLAMA_VERSION}/ollama-linux-amd64" -o /usr/local/bin/ollama
chmod +x /usr/local/bin/ollama

## Création du service systemd
cat > /etc/systemd/system/ollama.service << 'EOF'
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/local/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="PATH=$PATH"

[Install]
WantedBy=default.target
EOF

## Création de l'utilisateur et démarrage
useradd -r -s /bin/false -U -m -d /usr/share/ollama ollama
usermod -aG ollama $(whoami)
systemctl daemon-reload
systemctl enable ollama
systemctl start ollama

## Exécution conteneurisée avec support GPU NVIDIA
docker run -d \
  —gpus all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  —name ollama \
  ollama/ollama

## Avec runtime ROCm pour AMD GPU
docker run -d \
  —device /dev/kfd \
  —device /dev/dri \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  —name ollama \
  ollama/ollama:rocm

## Pull d'un modèle spécifique avec quantification
ollama pull gemma3:4b
ollama pull gemma3:27b
ollama pull qwen2.5:14b-q5_K_M

## Lister les modèles locaux avec détails
ollama list
ollama show gemma3:4b —modelfile

## Modelfile - Assistant Code Review
FROM codellama:13b

## Paramètres d'inférence
PARAMETER temperature 0.2
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 4096
PARAMETER repeat_penalty 1.1

## Template de conversation
TEMPLATE """[INST] {{ if .System }}{{ .System }}\n\n{{ end }}{{ .Prompt }} [/INST]"""

## Message système
SYSTEM """Tu es un relecteur de code expérimenté. Analyse le code fourni selon ces critères :
1. Bugs potentiels et race conditions
2. Violations des principes SOLID
3. Problèmes de sécurité (injection, XSS, etc.)
4. Optimisations possibles
5. Conformité PEP8/style guide

Réponds avec une liste structurée et des suggestions de refactoring."""

## Construction et test
ollama create code-reviewer -f Modelfile
ollama run code-reviewer

## Fichier de configuration ~/.ollama/config.json ou variables d'environnement

## Spécifier le répertoire de modèles (utile pour NAS ou disque externe)
export OLLAMA_MODELS=/mnt/storage/ollama-models

## Hôte d'écoute (0.0.0.0 pour accès réseau, sécuriser avec firewall)
export OLLAMA_HOST=0.0.0.0:11434

## Nombre de couches GPU à déléguer (auto-détection si non spécifié)
export OLLAMA_GPU_LAYERS=35

## Limite de mémoire VRAM (Mo)
export OLLAMA_VRAM_SIZE=8192

## Nombre de threads CPU pour le calcul
export OLLAMA_NUM_THREADS=8

## Debug et logging
export OLLAMA_DEBUG=1
export OLLAMA_LOG_LEVEL=debug

## Requête de chat avec streaming
curl -X POST http://localhost:11434/api/chat \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma3",
    "messages": [
      {"role": "system", "content": "Tu réponds en français."},
      {"role": "user", "content": "Explique les transformers"}
    ],
    "stream": true,
    "options": {
      "temperature": 0.7,
      "num_predict": 512
    }
  }'

## Génération simple (non-streaming)
curl -X POST http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2",
    "prompt": "Définis l'optimisation LLM en 3 phrases",
    "stream": false,
    "format": "json"
  }'

## Génération d'embeddings
curl -X POST http://localhost:11434/api/embeddings \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nomic-embed-text",
    "prompt": "L'intelligence artificielle transforme l'industrie"
  }'

import ollama
from ollama import Client

## Client avec timeout et hôte personnalisé
client = Client(host='http://localhost:11434', timeout=120)

## Chat avec historique
response = client.chat(
    model='gemma3',
    messages=[
        {'role': 'user', 'content': 'Quelle est la capitale de la France ?'},
        {'role': 'assistant', 'content': 'La capitale de la France est Paris.'},
        {'role': 'user', 'content': 'Et sa population ?'}
    ],
    options={
        'temperature': 0.5,
        'top_p': 0.95,
        'num_ctx': 8192
    }
)

## Streaming
for chunk in client.chat(
    model='mistral',
    messages=[{'role': 'user', 'content': 'Raconte une histoire'}],
    stream=True
):
    print(chunk['message']['content'], end='', flush=True)

## Gestion des modèles
client.pull('deepseek-coder:6.7b')
client.delete('ancien-modele')

import ollama from 'ollama';

// Chat avec gestion d'erreurs
async function generateResponse(prompt: string) {
  try {
    const response = await ollama.chat({
      model: 'qwen2.5',
      messages: [{ role: 'user', content: prompt }],
      options: {
        temperature: 0.3,
        num_predict: 1024
      }
    });
    return response.message.content;
  } catch (error) {
    if (error.statusCode === 404) {
      console.error('Modèle non trouvé, exécutez : ollama pull qwen2.5');
    }
    throw error;
  }
}

// Embeddings pour相似ité sémantique
const embedding = await ollama.embeddings({
  model: 'nomic-embed-text',
  prompt: 'Texte à vectoriser'
});

## Surveillance de l'utilisation GPU
watch -n 1 nvidia-smi

## Monitoring du serveur Ollama
curl http://localhost:11434/api/ps

## Logs en temps réel
journalctl -u ollama -f

## Préchargement d'un modèle en mémoire
curl -X POST http://localhost:11434/api/generate \
  -d '{"model": "gemma3", "prompt": "", "keep_alive": "24h"}'

## Garder le modèle chargé entre les requêtes
export OLLAMA_KEEP_ALIVE=24h

## Réduire le contexte pour les modèles massifs
options = {
    'num_ctx': 2048,      # Limite la fenêtre de contexte
    'num_gpu': 20,        # Couches offload GPU
    'num_thread': 4,      # Threads CPU
    'batch_size': 512     # Taille de batch
}

## UFW - Autoriser uniquement le réseau local
ufw allow from 192.168.1.0/24 to any port 11434
ufw deny 11434

## Nginx reverse proxy avec authentification
location /ollama/ {
    auth_basic "Ollama API";
    auth_basic_user_file /etc/nginx/.htpasswd;
    proxy_pass http://localhost:11434/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
}

## Exécution dans un namespace réseau isolé
unshare —net —fork /usr/local/bin/ollama serve

## systemd hardening (extrait)
[Service]
PrivateTmp=yes
PrivateDevices=yes
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes

## Réduire les couches GPU
export OLLAMA_GPU_LAYERS=20

## Ou utiliser uniquement le CPU
export OLLAMA_GPU_LAYERS=0
ollama serve

## Vérifier la compatibilité AVX
cat /proc/cpuinfo | grep flags | head -1

## Si pas d'AVX2, compiler llama.cpp avec flags adaptés
## ou utiliser les builds spécifiques ollama-legacy

## Activer le mode debug
OLLAMA_DEBUG=1 ollama serve 2>&1 | tee ollama.log

## Test avec verbose
curl -v -X POST http://localhost:11434/api/generate \
  -d '{"model": "gemma3", "prompt": "test"}'

#!/bin/bash
## warm-up-models.sh - Préchargement des modèles fréquents

MODELS=("gemma3:4b" "nomic-embed-text" "deepseek-coder:6.7b")

for model in "${MODELS[@]}"; do
    echo "Préchauffage de $model..."
    ollama pull "$model"
    curl -s -X POST http://localhost:11434/api/generate \
        -d "{\"model\": \"$model\", \"prompt\": \"\", \"keep_alive\": \"1h\"}" > /dev/null
done

echo "Modèles prêts"

#!/usr/bin/env python3
## benchmark.py - Évaluation des performances

import time
import ollama
import statistics

def benchmark_model(model_name, prompt, iterations=5):
    times = []
    tokens = []
    
    for _ in range(iterations):
        start = time.time()
        response = ollama.generate(
            model=model_name,
            prompt=prompt,
            options={'num_predict': 256}
        )
        elapsed = time.time() - start
        times.append(elapsed)
        tokens.append(response['eval_count'])
    
    avg_time = statistics.mean(times)
    avg_tokens = statistics.mean(tokens)
    tps = avg_tokens / avg_time
    
    print(f"{model_name}: {avg_time:.2f}s, {tps:.1f} tokens/s")
    return tps

benchmark_model('gemma3:4b', 'Explique la récursivité')