- Ollama & OpenWebUI : IA gratuite en local

Ollama : architecture et fonctionnement

Ollama est un runtime open-source qui permet d'exécuter des modèles de langage (LLM) localement. Il gère le téléchargement, la quantification, l'inférence GPU/CPU et expose une API REST compatible OpenAI — permettant de remplacer des appels à GPT-4 avec zéro changement de code.

Installation Ollama (Windows/macOS/Linux)

Prérequis RAM : 8 Go minimum (modèles 7B quantifiés), 16 Go recommandé, 32 Go+ pour les modèles 13B-34B.

# macOS — Application native avec menu bar
# Télécharger le .dmg depuis ollama.com/download
# Ou via Homebrew :
brew install ollama

# Linux — Script officiel
curl -fsSL https://ollama.com/install.sh | sh

# Windows — Installateur .exe depuis ollama.com/download
# Ollama tourne en service en arrière-plan sur le port 11434

# Vérifier l'installation
ollama --version
# ollama version is 0.3.x

# Premier lancement du serveur (si pas automatique)
ollama serve  # démarre sur http://localhost:11434

Commandes CLI essentielles

# Télécharger et lancer un modèle en mode interactif
ollama run llama3.2
ollama run mistral
ollama run gemma2:9b         # variante 9B
ollama run deepseek-r1:8b    # modèle de raisonnement

# Lancer une requête directe sans mode interactif
ollama run llama3.2 "Explique les closures JavaScript en 3 lignes"

# Gérer les modèles installés
ollama list                  # modèles téléchargés
ollama ps                    # modèles chargés en mémoire
ollama rm mistral            # supprimer un modèle
ollama pull llama3.2:70b     # télécharger une variante

# Copier un modèle (base pour personnalisation)
ollama cp llama3.2 mon-assistant

# Informations sur un modèle
ollama show llama3.2 --modelfile  # affiche le Modelfile

Modèles 2024 : comparatif complet

API REST Ollama — intégration directe

Ollama expose deux APIs : son API native et une API compatible OpenAI — permettant de réutiliser les SDKs OpenAI sans modification.

# API native Ollama — génération simple
curl http://localhost:11434/api/generate -d '{
    "model": "llama3.1:8b",
    "prompt": "Explique les closures JavaScript",
    "stream": false
}'
# Réponse : { "model": "...", "response": "...", "done": true }

# API compatible OpenAI — chat completions
curl http://localhost:11434/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "llama3.1:8b",
        "messages": [
            { "role": "system", "content": "Tu es un expert Angular." },
            { "role": "user", "content": "Qu'est-ce que les Signals ?" }
        ],
        "stream": false
    }'

# Lister les modèles disponibles (compatible OpenAI)
curl http://localhost:11434/v1/models

Modelfile — personnaliser un modèle

Le Modelfile permet de créer un modèle personnalisé avec un système prompt fixe, des paramètres ajustés et un template de conversation custom.

# Modelfile — Créer un assistant Angular spécialisé
FROM llama3.1:8b

# Paramètres de génération
PARAMETER temperature 0.3     # Plus déterministe (0=strict, 1=créatif)
PARAMETER top_p 0.9
PARAMETER num_ctx 8192         # Taille du contexte (tokens)
PARAMETER num_predict 2048     # Longueur max de la réponse

# Système prompt — persona spécialisée
SYSTEM """
Tu es un expert en développement Angular 17+ avec 10 ans d'expérience.
Tu réponds toujours en français, avec des exemples de code TypeScript commentés.
Tu privilégies la syntaxe moderne : Signals, @if/@for, standalone components.
Tu n'inventes pas de fonctionnalités inexistantes — si tu n'es pas sûr, tu le dis.
"""

# Template de conversation (optionnel — format Llama 3)
TEMPLATE """
{{ if .System }}<|start_header_id|>system<|end_header_id|>
{{ .System }}<|eot_id|>{{ end }}
<|start_header_id|>user<|end_header_id|>
{{ .Prompt }}<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""

# Créer et utiliser le modèle personnalisé
ollama create angular-expert -f ./Modelfile
ollama run angular-expert
# > Quel est l'avantage des Signals vs RxJS ?

# Partager le modèle
ollama push ton-nom/angular-expert  # nécessite un compte ollama.com

OpenWebUI — interface ChatGPT-like

OpenWebUI est une interface web complète (conversations, historique, gestion de modèles, RAG, générations d'images) qui se connecte à Ollama via Docker.

# Lancer OpenWebUI avec Docker (recommandé)
docker run -d \
    --name open-webui \
    -p 3000:8080 \
    --add-host=host.docker.internal:host-gateway \
    -v open-webui:/app/backend/data \
    --restart always \
    ghcr.io/open-webui/open-webui:latest

# Accéder : http://localhost:3000
# Créer un compte admin au premier accès (100% local)

# docker-compose.yml — Configuration production locale
version: '3.8'
services:
    ollama:
        image: ollama/ollama:latest
        volumes:
            - ollama:/root/.ollama
        ports:
            - "11434:11434"
        restart: always
        # Pour GPU NVIDIA : décommenter
        # deploy:
        #   resources:
        #     reservations:
        #       devices:
        #         - driver: nvidia
        #           count: 1
        #           capabilities: [gpu]

    open-webui:
        image: ghcr.io/open-webui/open-webui:latest
        volumes:
            - open-webui:/app/backend/data
        ports:
            - "3000:8080"
        environment:
            - OLLAMA_BASE_URL=http://ollama:11434
            - WEBUI_SECRET_KEY=change_me_in_production
        depends_on:
            - ollama
        restart: always

volumes:
    ollama:
    open-webui:

Fonctionnalités clés d'OpenWebUI :

• Interface conversations multi-modèles avec historique persistant
• RAG natif — uploader des PDF/documents pour les interroger
• Arènes de comparaison — tester plusieurs modèles sur la même question
• Génération d'images via ComfyUI/AUTOMATIC1111
• Gestion multi-utilisateurs avec rôles
• Fonctions Python custom (tools/agents)

Intégration Node.js / Angular

Grâce à la compatibilité API OpenAI, intégrer Ollama dans une app existante ne nécessite que de changer l'URL de base et supprimer la clé API.

// ollama.service.ts — Client Ollama avec SDK OpenAI (Node.js/Express)
import OpenAI from 'openai';  // npm install openai

// Pointer vers Ollama local au lieu d'OpenAI
const ollama = new OpenAI({
    baseURL: 'http://localhost:11434/v1',
    apiKey: 'ollama', // valeur ignorée, juste requise par le SDK
});

// Appel identique à OpenAI — seul le modèle change
async function askOllama(question: string): Promise<string> {
    const response = await ollama.chat.completions.create({
        model: 'llama3.1:8b',  // modèle local Ollama
        messages: [
            { role: 'system', content: 'Tu es un assistant expert en Angular.' },
            { role: 'user', content: question }
        ],
        temperature: 0.3,
    });
    return response.choices[0].message.content ?? '';
}

// Streaming identique à OpenAI
async function streamOllama(question: string, onChunk: (text: string) => void) {
    const stream = await ollama.chat.completions.create({
        model: 'llama3.1:8b',
        messages: [{ role: 'user', content: question }],
        stream: true,
    });

    for await (const chunk of stream) {
        const delta = chunk.choices[0]?.delta?.content ?? '';
        if (delta) onChunk(delta);
    }
}

Service Angular avec Ollama

// ollama-chat.service.ts — Angular service (appel via proxy Express)
import { Injectable, signal } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class OllamaChatService {
    response = signal('');
    loading = signal(false);
    model = signal('llama3.1:8b');

    async chat(userMessage: string): Promise<void> {
        this.response.set('');
        this.loading.set(true);

        try {
            // Appel direct à Ollama (dev local uniquement)
            const res = await fetch('http://localhost:11434/api/chat', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    model: this.model(),
                    messages: [{ role: 'user', content: userMessage }],
                    stream: true,
                }),
            });

            if (!res.body) return;
            const reader = res.body.getReader();
            const decoder = new TextDecoder();

            while (true) {
                const { done, value } = await reader.read();
                if (done) break;

                const lines = decoder.decode(value).split('\n').filter(Boolean);
                for (const line of lines) {
                    const data = JSON.parse(line);
                    if (data.message?.content) {
                        this.response.update(r => r + data.message.content);
                    }
                }
            }
        } finally {
            this.loading.set(false);
        }
    }
}

Optimisation GPU et performance

# Variables d'environnement Ollama — optimisation
# Linux/macOS : ~/.bashrc ou /etc/systemd/system/ollama.service

# GPU NVIDIA CUDA
export CUDA_VISIBLE_DEVICES=0          # GPU à utiliser
export OLLAMA_GPU_OVERHEAD=1073741824  # 1GB réservé pour le système

# CPU uniquement
export OLLAMA_NUM_THREADS=8            # = nb cœurs physiques
export OLLAMA_MAX_LOADED_MODELS=2      # nb modèles en mémoire simultanément
export OLLAMA_KEEP_ALIVE=5m            # durée de vie modèle en mémoire (0 = toujours)

# Réseau
export OLLAMA_HOST=0.0.0.0:11434       # écouter sur toutes les interfaces
export OLLAMA_ORIGINS=*                # CORS pour les apps frontend locales

# macOS (Apple Silicon — très performant pour l'IA)
# llama3.1:8b tourne à 40-60 tokens/s sur M3 Pro
# Pas de configuration GPU nécessaire — métal natif automatique

Quantification et variantes de modèles

# Variantes de quantification — compromis taille/qualité
ollama pull llama3.1:8b        # Q4_0 par défaut (~4.7 Go)
ollama pull llama3.1:8b-q8_0   # Q8 — meilleure qualité, +taille (~8 Go)
ollama pull llama3.1:8b-fp16   # Précision complète (~16 Go, GPU recommandé)

# Recommandations :
# CPU lent     → Q4_0 (défaut) — bon compromis
# 16+ Go RAM   → Q5_K_M ou Q6_K — meilleure qualité
# GPU dédié    → Q8_0 ou fp16 — qualité maximale

• Apple Silicon (M1/M2/M3) : performances excellentes sans configuration — GPU unifié natif
• NVIDIA RTX 3080+ : charger les 40 couches en VRAM pour une vitesse maximale
• OLLAMA_KEEP_ALIVE=0 pour décharger le modèle immédiatement et libérer la RAM
• Utiliser ollama ps pour monitorer les modèles chargés et leur usage VRAM
• Les modèles quantifiés Q4 gardent 95% de la qualité avec 50% de la taille