llm_lab/migration_windows_guide.md

# Guide de migration de LLM Lab vers Windows natif

Ce guide vous aidera à migrer le projet LLM Lab de WSL vers Windows natif pour profiter pleinement des ressources matérielles de votre machine.

## Avantages de la migration vers Windows natif

- Accès direct à toute la RAM (64 Go) sans limitations de WSL
- Meilleures performances GPU grâce à l'accès direct aux pilotes NVIDIA
- Latence réduite (pas de couche de virtualisation WSL)
- Meilleure intégration avec l'environnement de bureau Windows

## Plan de migration

1. Installer les prérequis sur Windows
2. Configurer l'environnement Python
3. Installer Ollama pour Windows
4. Transférer les fichiers du projet
5. Adapter les scripts
6. Tester et optimiser

## 1. Installation des prérequis

### Python
1. Téléchargez Python 3.10+ depuis [python.org](https://www.python.org/downloads/)
2. Cochez "Add Python to PATH" lors de l'installation
3. Ouvrez un terminal et vérifiez l'installation:
   ```cmd
   python --version
   pip --version
   ```

### Git
1. Téléchargez Git depuis [git-scm.com](https://git-scm.com/download/win)
2. Installez avec les options par défaut
3. Vérifiez l'installation:
   ```cmd
   git --version
   ```

### Pilotes NVIDIA
1. Assurez-vous d'avoir les derniers pilotes NVIDIA: [nvidia.com/Download](https://www.nvidia.com/Download/index.aspx)
2. Installez CUDA Toolkit 12.x: [developer.nvidia.com/cuda-downloads](https://developer.nvidia.com/cuda-downloads)
3. Vérifiez l'installation:
   ```cmd
   nvidia-smi
   nvcc --version
   ```

## 2. Configuration de l'environnement Python

Créez un environnement virtuel pour le projet:

```cmd
mkdir C:\LLM_Lab
cd C:\LLM_Lab
python -m venv venv
venv\Scripts\activate
```

## 3. Installation d'Ollama pour Windows

1. Téléchargez Ollama depuis [ollama.com](https://ollama.com/download/windows)
2. Installez en suivant les instructions
3. Vérifiez que le service est bien lancé:
   ```cmd
   curl http://localhost:11434/api/tags
   ```

## 4. Transfert des fichiers du projet

### Option 1: Via Git (recommandé)
Si vous avez un dépôt Git:
```cmd
cd C:\LLM_Lab
git clone <URL_DE_VOTRE_DÉPÔT>
```

### Option 2: Copie directe
1. Naviguez vers votre projet WSL: `\\wsl$\Ubuntu\home\fgras-ca\llm_lab`
2. Copiez tous les fichiers vers `C:\LLM_Lab`

## 5. Installation des dépendances

```cmd
cd C:\LLM_Lab
venv\Scripts\activate
pip install -r requirements.txt
```

## 6. Adaptation des scripts

### Créer un script d'activation pour Windows (run.bat)

Créez un fichier `run.bat` à la racine du projet:

```batch
@echo off
setlocal

REM Activer l'environnement virtuel
call venv\Scripts\activate

REM Vérifier les arguments
if "%1"=="" (
    echo Usage: run.bat [command]
    echo Commands:
    echo   chat       - Lance l'interface de chat en ligne de commande
    echo   gui        - Lance l'interface graphique de chat
    echo   server     - Démarre le serveur d'API
    echo   monitor    - Lance le moniteur système
    echo   agent      - Lance un agent spécifique
    goto :eof
)

if "%1"=="chat" (
    python chat.py %2 %3 %4 %5 %6 %7 %8 %9
) else if "%1"=="gui" (
    python chat_gui.py
) else if "%1"=="server" (
    python server.py
) else if "%1"=="monitor" (
    python monitor.py
) else if "%1"=="agent" (
    python agents\%2.py %3 %4 %5 %6 %7 %8 %9
) else (
    echo Commande inconnue: %1
    echo Utilisez run.bat sans arguments pour voir les commandes disponibles
)

endlocal
```

### Modifications du code

#### 1. Adapter les chemins dans le code

Remplacez les chemins style Unix par des chemins Windows:

```python
# Avant
os.path.join('/home/fgras-ca/llm_lab', 'data')

# Après
os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')
```

#### 2. Adapter system_monitor.py

```python
# Modifier la détection du système d'exploitation
if platform.system() == "Windows":
    # Utiliser WMI pour une meilleure détection des ressources
    import wmi
    computer = wmi.WMI()
    
    # Récupérer les informations sur la RAM
    for os_info in computer.Win32_OperatingSystem():
        total_ram = float(os_info.TotalVisibleMemorySize) / (1024 * 1024)  # en GB
```

#### 3. Optimiser les paramètres Ollama

Créez un fichier `ollama_config.json` à la racine:

```json
{
  "gpu_layers": -1,
  "num_ctx": 8192,
  "num_thread": 12,
  "num_batch": 512
}
```

## 7. Optimisations pour Windows

### Activez le mode de haute performance

1. Panneau de configuration → Options d'alimentation
2. Sélectionnez "Performances optimales" ou créez un plan personnalisé

### Optimisez CUDA pour Ollama

Créez un script `optimize_ollama.bat`:

```batch
@echo off
setlocal

echo Optimisation des performances d'Ollama sur Windows...

REM Configurer les variables d'environnement pour CUDA
set CUDA_VISIBLE_DEVICES=0
set OMP_NUM_THREADS=8

REM Redémarrer le service Ollama pour appliquer ces paramètres
net stop Ollama
net start Ollama

echo Ollama optimisé pour de meilleures performances!
endlocal
```

## 8. Gestion des modèles

Sous Windows, les modèles Ollama seront stockés dans:
```
C:\Users\VotreNom\.ollama\models
```

Pour importer vos modèles existants depuis WSL:
1. Copiez les fichiers de `\\wsl$\Ubuntu\home\fgras-ca\.ollama\models` vers ce dossier
2. Redémarrez le service Ollama

## 9. Tests et vérification

Lancez le moniteur système pour vérifier l'utilisation des ressources:

```cmd
cd C:\LLM_Lab
run.bat monitor
```

Lancez l'interface graphique:

```cmd
run.bat gui
```

## Dépannage

### Si l'interface graphique ne démarre pas

1. Vérifiez que tkinter est installé:
   ```cmd
   python -c "import tkinter; tkinter._test()"
   ```

2. Assurez-vous que les chemins dans le code sont corrects:
   ```cmd
   set PYTHONPATH=C:\LLM_Lab
   ```

### Si Ollama n'utilise pas le GPU

1. Vérifiez que CUDA est correctement détecté:
   ```cmd
   nvidia-smi
   ```

2. Réinstallez Ollama en mode administrateur
3. Exécutez `optimize_ollama.bat` en mode administrateur

## Conclusion

Cette migration vers Windows natif devrait significativement améliorer les performances de votre projet LLM Lab en utilisant pleinement les 64 Go de RAM et les capacités GPU de votre système. Le retrait de la couche de virtualisation WSL réduira la latence et permettra une meilleure allocation des ressources.

Si vous rencontrez des problèmes pendant la migration, n'hésitez pas à consulter les logs d'Ollama dans:
```
C:\Users\VotreNom\.ollama\logs
```