# Guide complet : IA locale pour le code sur Windows WSL

Guide d'installation d'une IA locale performante orientée développement sur Windows avec WSL2 et GPU NVIDIA.

## Prérequis

- Windows 10/11 (version 21H2 ou supérieure)
- Carte graphique NVIDIA avec 8GB+ VRAM
- WSL2 installé
- Au moins 50GB d'espace disque libre

---

## Étape 1 : Configuration WSL2 avec support GPU

### 1.1 Installer/Mettre à jour WSL2

Ouvrir PowerShell en **administrateur** :

```powershell
# Installer WSL2 avec Ubuntu
wsl --install -d Ubuntu-22.04

# Ou mettre à jour WSL si déjà installé
wsl --update
```

Redémarrer si nécessaire, puis lancer Ubuntu depuis le menu démarrer.

### 1.2 Installer les drivers NVIDIA pour WSL

**Sur Windows** (pas dans WSL) :

1. Télécharger les derniers drivers NVIDIA : https://www.nvidia.com/Download/index.aspx
2. Installer normalement sur Windows
3. Les drivers WSL sont inclus automatiquement

**Vérification dans WSL** :

```bash
# Lancer WSL Ubuntu
wsl

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

Tu devrais voir ton GPU et la version CUDA.

### 1.3 Configurer WSL pour plus de RAM

Créer/éditer le fichier `.wslconfig` dans Windows :

**Sur Windows**, créer `C:\Users\VOTRE_NOM\.wslconfig` :

```ini
[wsl2]
memory=16GB
processors=8
swap=8GB
localhostForwarding=true

[experimental]
sparseVhd=true
```

Redémarrer WSL :

```powershell
wsl --shutdown
wsl
```

---

## Étape 2 : Installation de Docker dans WSL

```bash
# Mise à jour du système
sudo apt update && sudo apt upgrade -y

# Installer les dépendances
sudo apt install -y \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# Ajouter le repository Docker
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installer Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Ajouter votre user au groupe docker
sudo usermod -aG docker $USER

# Activer Docker au démarrage
sudo systemctl enable docker
sudo systemctl start docker

# IMPORTANT : Se déconnecter et reconnecter pour appliquer les permissions
exit
```

Relancer WSL et vérifier :

```bash
docker --version
docker run hello-world
```

### 2.1 Installer NVIDIA Container Toolkit

```bash
# Ajouter le repository NVIDIA
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

# Installer le toolkit
sudo apt update
sudo apt install -y nvidia-container-toolkit

# Configurer Docker pour utiliser le GPU
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Tester le GPU dans Docker
docker run --rm --gpus all nvidia/cuda:12.0.0-base-ubuntu22.04 nvidia-smi
```

---

## Étape 3 : Installer Ollama

```bash
# Télécharger et installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Démarrer le service Ollama
ollama serve &

# Attendre 5 secondes que le serveur démarre
sleep 5

# Vérifier que Ollama fonctionne
ollama list
```

### 3.1 Télécharger les modèles optimisés pour le code

```bash
# Qwen2.5 Coder - Le meilleur rapport qualité/vitesse
ollama pull qwen2.5-coder:7b

# DeepSeek Coder V2 - Excellente qualité (plus lourd)
ollama pull deepseek-coder-v2:16b

# Llama 3.1 - Bon généraliste
ollama pull llama3.1:8b

# Modèle d'embeddings pour le RAG
ollama pull nomic-embed-text
```

### 3.2 Tester un modèle

```bash
# Test simple
ollama run qwen2.5-coder:7b "Écris une fonction Python pour calculer Fibonacci"
```

---

## Étape 4 : Installer Open WebUI avec support GPU

```bash
# Lancer Open WebUI avec GPU NVIDIA
docker run -d \
  --gpus all \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:cuda

# Vérifier que le container tourne
docker ps

# Voir les logs
docker logs open-webui
```

**Accéder à l'interface** :
- Ouvrir navigateur Windows : `http://localhost:3000`
- Créer un compte (local, pas de cloud)
- Les modèles Ollama seront détectés automatiquement

---

## Étape 5 : Créer des modèles personnalisés pour le code

### 5.1 Créer un Modelfile pour assistant code

```bash
# Créer un dossier pour les modelfiles
mkdir -p ~/ollama-models
cd ~/ollama-models

# Créer le fichier
cat > CodeExpert.modelfile << 'EOF'
FROM qwen2.5-coder:7b

PARAMETER temperature 0.2
PARAMETER top_p 0.95
PARAMETER top_k 40
PARAMETER num_ctx 8192
PARAMETER repeat_penalty 1.1

SYSTEM """
Tu es un expert en développement logiciel avec 15 ans d'expérience.

RÈGLES :
- Écris du code propre, lisible et maintenable
- Inclus la gestion d'erreurs appropriée
- Ajoute des commentaires pour la logique complexe
- Suis les conventions du langage utilisé
- Propose des optimisations quand pertinent
- Utilise les design patterns appropriés
- Format : markdown avec syntax highlighting

LANGAGES MAÎTRISÉS :
Python, JavaScript/TypeScript, Java, C++, Go, Rust, SQL, Shell

SPÉCIALITÉS :
- Architecture logicielle
- Optimisation de performance
- Sécurité applicative
- Tests unitaires
- Clean Code
"""

TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
"""
EOF

# Créer le modèle custom
ollama create code-expert -f CodeExpert.modelfile

# Tester
ollama run code-expert "Crée une API REST avec FastAPI pour gérer des utilisateurs"
```

### 5.2 Modelfile pour code review

```bash
cat > CodeReviewer.modelfile << 'EOF'
FROM qwen2.5-coder:7b

PARAMETER temperature 0.1
PARAMETER top_p 0.9
PARAMETER num_ctx 8192

SYSTEM """
Tu es un expert en code review avec un œil pour les détails.

ANALYSE :
1. 🐛 BUGS : Erreurs logiques, edge cases non gérés
2. 🔒 SÉCURITÉ : Injections SQL, XSS, secrets exposés
3. ⚡ PERFORMANCE : Complexité algorithmique, optimisations
4. 📖 LISIBILITÉ : Nommage, structure, commentaires
5. ✅ BEST PRACTICES : Patterns, conventions, maintenabilité

FORMAT :
- Liste les problèmes par ordre de priorité
- Donne des suggestions concrètes
- Indique le niveau : CRITIQUE / IMPORTANT / SUGGESTION
"""
EOF

ollama create code-reviewer -f CodeReviewer.modelfile
```

### 5.3 Modelfile pour debugging

```bash
cat > Debugger.modelfile << 'EOF'
FROM deepseek-coder-v2:16b

PARAMETER temperature 0.1
PARAMETER top_p 0.95
PARAMETER num_ctx 16384

SYSTEM """
Tu es un expert en debugging et résolution de problèmes.

MÉTHODOLOGIE :
1. Analyse le code et l'erreur fournie
2. Identifie la cause racine
3. Explique pourquoi le bug se produit
4. Propose une correction avec explication
5. Suggère des tests pour éviter la régression

FOCUS :
- Stack traces
- Erreurs runtime
- Memory leaks
- Race conditions
- Edge cases
"""
EOF

ollama create debugger -f Debugger.modelfile
```

---

## Étape 6 : Configuration VS Code avec Continue.dev

### 6.1 Installer VS Code (si pas déjà fait)

Sur Windows, télécharger depuis : https://code.visualstudio.com/

### 6.2 Installer l'extension WSL

Dans VS Code :
1. Extensions (Ctrl+Shift+X)
2. Chercher "WSL"
3. Installer "WSL" par Microsoft

### 6.3 Se connecter à WSL

1. `Ctrl+Shift+P` → "WSL: Connect to WSL"
2. Ou cliquer sur le bouton vert en bas à gauche → "Connect to WSL"

### 6.4 Installer Continue.dev

Dans VS Code (connecté à WSL) :
1. Extensions → Chercher "Continue"
2. Installer "Continue - Codestral, Claude, and more"

### 6.5 Configurer Continue

Créer le fichier de config :

```bash
mkdir -p ~/.continue
cat > ~/.continue/config.json << 'EOF'
{
  "models": [
    {
      "title": "Code Expert",
      "provider": "ollama",
      "model": "code-expert",
      "apiBase": "http://localhost:11434"
    },
    {
      "title": "Qwen Coder",
      "provider": "ollama",
      "model": "qwen2.5-coder:7b",
      "apiBase": "http://localhost:11434"
    },
    {
      "title": "DeepSeek Coder",
      "provider": "ollama",
      "model": "deepseek-coder-v2:16b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen Fast Autocomplete",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b",
    "apiBase": "http://localhost:11434"
  },
  "embeddingsProvider": {
    "provider": "ollama",
    "model": "nomic-embed-text",
    "apiBase": "http://localhost:11434"
  },
  "contextProviders": [
    {
      "name": "code",
      "params": {}
    },
    {
      "name": "docs",
      "params": {}
    },
    {
      "name": "diff",
      "params": {}
    },
    {
      "name": "terminal",
      "params": {}
    },
    {
      "name": "problems",
      "params": {}
    },
    {
      "name": "folder",
      "params": {}
    },
    {
      "name": "codebase",
      "params": {}
    }
  ],
  "slashCommands": [
    {
      "name": "edit",
      "description": "Edit selected code"
    },
    {
      "name": "comment",
      "description": "Write comments for selected code"
    },
    {
      "name": "share",
      "description": "Export conversation to markdown"
    },
    {
      "name": "cmd",
      "description": "Generate shell command"
    }
  ]
}
EOF
```

### 6.6 Utiliser Continue dans VS Code

**Raccourcis clavier** :
- `Ctrl+L` : Ouvrir le chat Continue
- `Ctrl+I` : Edit inline (modifier le code sélectionné)
- `Ctrl+Shift+L` : Nouveau chat

**Commandes slash** :
- `/edit` : Modifier le code sélectionné
- `/comment` : Ajouter des commentaires
- `/fix` : Corriger les erreurs
- `/test` : Générer des tests

---

## Étape 7 : Optimisations avancées

### 7.1 Script de démarrage automatique

```bash
cat > ~/start-ai-stack.sh << 'EOF'
#!/bin/bash

echo "🚀 Démarrage de la stack IA..."

# Démarrer Ollama en arrière-plan
echo "📦 Démarrage Ollama..."
ollama serve > /dev/null 2>&1 &
sleep 3

# Vérifier que Ollama tourne
if curl -s http://localhost:11434/api/tags > /dev/null; then
    echo "✅ Ollama démarré"
else
    echo "❌ Erreur : Ollama n'a pas démarré"
    exit 1
fi

# Démarrer Open WebUI si pas déjà lancé
if ! docker ps | grep -q open-webui; then
    echo "🌐 Démarrage Open WebUI..."
    docker start open-webui 2>/dev/null || \
    docker run -d \
      --gpus all \
      -p 3000:8080 \
      --add-host=host.docker.internal:host-gateway \
      -v open-webui:/app/backend/data \
      --name open-webui \
      --restart always \
      ghcr.io/open-webui/open-webui:cuda
    echo "✅ Open WebUI démarré sur http://localhost:3000"
else
    echo "✅ Open WebUI déjà actif"
fi

echo ""
echo "🎉 Stack IA prête !"
echo "📊 GPU Status:"
nvidia-smi --query-gpu=name,memory.total,memory.used --format=csv,noheader,nounits
echo ""
echo "🔗 Accès:"
echo "   - Open WebUI: http://localhost:3000"
echo "   - Ollama API: http://localhost:11434"
echo ""
echo "📝 Modèles disponibles:"
ollama list
EOF

chmod +x ~/start-ai-stack.sh
```

Utilisation :
```bash
~/start-ai-stack.sh
```

### 7.2 Créer un alias dans .bashrc

```bash
echo "alias ai='~/start-ai-stack.sh'" >> ~/.bashrc
echo "alias ai-stop='docker stop open-webui && pkill ollama'" >> ~/.bashrc
source ~/.bashrc
```

Maintenant tu peux juste taper `ai` pour tout lancer.

### 7.3 Monitoring GPU en temps réel

```bash
# Installer nvtop pour monitoring GPU
sudo apt install -y nvtop

# Lancer
nvtop
```

Ou utiliser :
```bash
watch -n 1 nvidia-smi
```

### 7.4 Script pour tester les performances

```bash
cat > ~/benchmark-models.sh << 'EOF'
#!/bin/bash

echo "🎯 Benchmark des modèles..."

PROMPT="Écris une fonction Python qui implémente QuickSort avec commentaires"

for MODEL in "qwen2.5-coder:7b" "code-expert" "deepseek-coder-v2:16b"; do
    echo ""
    echo "⏱️  Testing $MODEL..."
    
    START=$(date +%s)
    ollama run $MODEL "$PROMPT" > /dev/null 2>&1
    END=$(date +%s)
    
    DURATION=$((END - START))
    echo "✅ $MODEL: ${DURATION}s"
done
EOF

chmod +x ~/benchmark-models.sh
```

---

## Étape 8 : Utilisation avancée avec API

### 8.1 Script Python pour interagir avec Ollama

```bash
# Installer les dépendances Python
pip install ollama requests rich
```

```python
# Créer ~/ai_assistant.py
cat > ~/ai_assistant.py << 'EOF'
#!/usr/bin/env python3
import ollama
from rich.console import Console
from rich.markdown import Markdown

console = Console()

def code_review(code: str, language: str = "python"):
    """Effectue une review de code."""
    response = ollama.chat(
        model='code-reviewer',
        messages=[{
            'role': 'user',
            'content': f'Review ce code {language}:\n\n```{language}\n{code}\n```'
        }]
    )
    
    md = Markdown(response['message']['content'])
    console.print(md)

def debug_error(code: str, error: str, language: str = "python"):
    """Debug une erreur."""
    response = ollama.chat(
        model='debugger',
        messages=[{
            'role': 'user',
            'content': f'''
Code {language}:
```{language}
{code}
```

Erreur:
```
{error}
```

Trouve et corrige le bug.
'''
        }]
    )
    
    md = Markdown(response['message']['content'])
    console.print(md)

def generate_code(description: str, language: str = "python"):
    """Génère du code."""
    response = ollama.chat(
        model='code-expert',
        messages=[{
            'role': 'user',
            'content': f'Génère du code {language} pour: {description}'
        }]
    )
    
    md = Markdown(response['message']['content'])
    console.print(md)

if __name__ == "__main__":
    import sys
    
    if len(sys.argv) < 2:
        print("Usage:")
        print("  python ai_assistant.py review <fichier>")
        print("  python ai_assistant.py debug <fichier> <erreur>")
        print("  python ai_assistant.py generate '<description>'")
        sys.exit(1)
    
    command = sys.argv[1]
    
    if command == "review" and len(sys.argv) >= 3:
        with open(sys.argv[2]) as f:
            code = f.read()
        code_review(code)
    
    elif command == "generate" and len(sys.argv) >= 3:
        generate_code(sys.argv[2])
    
    else:
        print("Commande invalide")
EOF

chmod +x ~/ai_assistant.py
```

Utilisation :
```bash
# Review de code
python ~/ai_assistant.py review mon_script.py

# Génération de code
python ~/ai_assistant.py generate "API REST avec authentification JWT"
```

### 8.2 API REST custom avec FastAPI

```bash
pip install fastapi uvicorn
```

```python
# Créer ~/code_api.py
cat > ~/code_api.py << 'EOF'
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import ollama

app = FastAPI(title="Code AI API")

class CodeRequest(BaseModel):
    code: str
    language: str = "python"

class PromptRequest(BaseModel):
    prompt: str
    model: str = "code-expert"

@app.post("/review")
async def review_code(request: CodeRequest):
    """Review du code."""
    try:
        response = ollama.chat(
            model='code-reviewer',
            messages=[{
                'role': 'user',
                'content': f'Review ce code {request.language}:\n\n```{request.language}\n{request.code}\n```'
            }]
        )
        return {"review": response['message']['content']}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/generate")
async def generate_code(request: PromptRequest):
    """Génération de code."""
    try:
        response = ollama.chat(
            model=request.model,
            messages=[{
                'role': 'user',
                'content': request.prompt
            }]
        )
        return {"code": response['message']['content']}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/models")
async def list_models():
    """Liste les modèles disponibles."""
    try:
        models = ollama.list()
        return {"models": [m['name'] for m in models['models']]}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF
```

Lancer l'API :
```bash
python ~/code_api.py
```

Tester :
```bash
# Review de code
curl -X POST http://localhost:8000/review \
  -H "Content-Type: application/json" \
  -d '{"code": "def add(a,b):\n  return a+b", "language": "python"}'

# Générer du code
curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Fonction pour valider un email", "model": "code-expert"}'
```

---

## Étape 9 : Intégration RAG (Retrieval Augmented Generation)

Pour que l'IA utilise ta documentation/codebase :

```bash
pip install chromadb langchain
```

```python
# Créer ~/rag_codebase.py
cat > ~/rag_codebase.py << 'EOF'
#!/usr/bin/env python3
import chromadb
from chromadb.config import Settings
import ollama
import os
from pathlib import Path

class CodebaseRAG:
    def __init__(self, codebase_path: str):
        self.client = chromadb.Client(Settings(
            chroma_db_impl="duckdb+parquet",
            persist_directory="./chroma_db"
        ))
        self.collection = self.client.get_or_create_collection("codebase")
        self.codebase_path = Path(codebase_path)
        
    def index_codebase(self):
        """Indexe tous les fichiers de code."""
        extensions = ['.py', '.js', '.ts', '.java', '.cpp', '.go', '.rs']
        
        for ext in extensions:
            for file_path in self.codebase_path.rglob(f'*{ext}'):
                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        content = f.read()
                    
                    # Générer l'embedding avec Ollama
                    embedding_response = ollama.embeddings(
                        model='nomic-embed-text',
                        prompt=content
                    )
                    
                    self.collection.add(
                        ids=[str(file_path)],
                        embeddings=[embedding_response['embedding']],
                        documents=[content],
                        metadatas=[{"path": str(file_path), "ext": ext}]
                    )
                    print(f"✅ Indexé: {file_path}")
                except Exception as e:
                    print(f"❌ Erreur {file_path}: {e}")
    
    def query_codebase(self, question: str, n_results: int = 3):
        """Recherche dans la codebase."""
        # Générer l'embedding de la question
        query_embedding = ollama.embeddings(
            model='nomic-embed-text',
            prompt=question
        )
        
        # Chercher les documents similaires
        results = self.collection.query(
            query_embeddings=[query_embedding['embedding']],
            n_results=n_results
        )
        
        return results
    
    def ask(self, question: str):
        """Pose une question sur la codebase."""
        # Récupérer les documents pertinents
        results = self.query_codebase(question)
        
        # Construire le contexte
        context = "\n\n".join([
            f"Fichier: {meta['path']}\n```\n{doc}\n```"
            for doc, meta in zip(results['documents'][0], results['metadatas'][0])
        ])
        
        # Générer la réponse avec le contexte
        response = ollama.chat(
            model='code-expert',
            messages=[{
                'role': 'system',
                'content': 'Tu es un expert qui répond aux questions sur une codebase. Utilise le contexte fourni.'
            }, {
                'role': 'user',
                'content': f'''Contexte:\n{context}\n\nQuestion: {question}'''
            }]
        )
        
        return response['message']['content']

if __name__ == "__main__":
    import sys
    
    if len(sys.argv) < 3:
        print("Usage:")
        print("  python rag_codebase.py index <chemin_projet>")
        print("  python rag_codebase.py ask '<question>'")
        sys.exit(1)
    
    rag = CodebaseRAG("./chroma_db")
    
    if sys.argv[1] == "index":
        rag.codebase_path = Path(sys.argv[2])
        rag.index_codebase()
        print("✅ Indexation terminée")
    
    elif sys.argv[1] == "ask":
        answer = rag.ask(sys.argv[2])
        print(answer)
EOF

chmod +x ~/rag_codebase.py
```

Utilisation :
```bash
# Indexer un projet
python ~/rag_codebase.py index /chemin/vers/projet

# Poser une question
python ~/rag_codebase.py ask "Comment fonctionne l'authentification dans ce projet ?"
```

---

## Étape 10 : Dépannage et optimisations

### 10.1 Problèmes courants

**Ollama ne démarre pas** :
```bash
# Vérifier les processus
ps aux | grep ollama

# Tuer et relancer
pkill ollama
ollama serve &
```

**GPU non détecté** :
```bash
# Vérifier CUDA
nvidia-smi

# Réinstaller nvidia-container-toolkit
sudo apt remove --purge nvidia-container-toolkit
sudo apt install nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

**Open WebUI ne charge pas** :
```bash
# Voir les logs
docker logs open-webui

# Redémarrer
docker restart open-webui

# Si problème persistant, recréer
docker rm -f open-webui
# Puis relancer la commande docker run de l'étape 4
```

**Manque de mémoire GPU** :
```bash
# Lister les processus GPU
nvidia-smi

# Utiliser des modèles plus petits ou quantizés
ollama pull qwen2.5-coder:7b-q4_0  # Version plus légère
```

### 10.2 Optimiser les performances

**Ajuster les paramètres Ollama** :

```bash
# Créer un fichier de config Ollama
mkdir -p ~/.ollama
cat > ~/.ollama/config.json << 'EOF'
{
  "num_gpu": 1,
  "gpu_layers": 35,
  "num_thread": 8,
  "num_ctx": 8192,
  "batch_size": 512
}
EOF
```

**Utiliser la quantization appropriée** :

```bash
# Pour 8GB VRAM
ollama pull qwen2.5-coder:7b-q5_K_M   # Meilleure qualité
ollama pull qwen2.5-coder:7b-q4_K_M   # Équilibré
ollama pull qwen2.5-coder:7b-q3_K_M   # Plus rapide, moins précis
```

### 10.3 Surveillance et monitoring

```bash
# Script de monitoring
cat > ~/monitor-ai.sh << 'EOF'
#!/bin/bash

echo "📊 Monitoring de l'IA"
echo "===================="
echo ""

echo "🖥️  GPU:"
nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu --format=csv,noheader,nounits

echo ""
echo "🐳 Docker Containers:"
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

echo ""
echo "📦 Ollama Service:"
if curl -s http://localhost:11434/api/tags > /dev/null; then
    echo "✅ Running"
    echo "Modèles chargés:"
    curl -s http://localhost:11434/api/tags | python3 -m json.tool | grep '"name"'
else
    echo "❌ Not running"
fi

echo ""
echo "💾 Espace disque WSL:"
df -h / | tail -1
EOF

chmod +x ~/monitor-ai.sh
```

---

## Récapitulatif des commandes essentielles

```bash
# Démarrer tout
ai  # (alias créé précédemment)

# Ou manuellement
ollama serve &
docker start open-webui

# Arrêter tout
ai-stop  # (alias créé précédemment)

# Ou manuellement
docker stop open-webui
pkill ollama

# Lister les modèles
ollama list

# Utiliser un modèle en CLI
ollama run code-expert "ton prompt ici"

# Monitoring
~/monitor-ai.sh
watch -n 1 nvidia-smi

# Nettoyer l'espace disque
docker system prune -a
ollama rm <model-name>  # Supprimer un modèle non utilisé
```

---

## Accès et URLs

- **Open WebUI** : http://localhost:3000
- **Ollama API** : http://localhost:11434
- **API REST custom** : http://localhost:8000 (si lancée)

---

## Prochaines étapes recommandées

1. **Personnaliser les modèles** avec tes propres Modelfiles
2. **Indexer ta codebase** avec le RAG
3. **Créer des prompts** spécialisés pour tes langages favoris
4. **Intégrer avec Git** pour des commits auto-générés
5. **Automatiser les tests** avec l'IA

---

## Ressources

- Documentation Ollama : https://ollama.ai/docs
- Open WebUI : https://docs.openwebui.com
- Continue.dev : https://continue.dev/docs
- Modèles Ollama : https://ollama.ai/library

---

**🎉 Félicitations ! Ton IA locale est prête.**

Teste-la avec :
```bash
ollama run code-expert "Crée une API REST complète avec FastAPI pour gérer des tâches avec authentification JWT"
```