# LLM Lab

Un laboratoire pour tester et comparer différents modèles de langage (LLM) via Ollama.

## Fonctionnalités

- **Modèles intégrés** : Support pour Mistral 7B, CodeLlama 13B et Llama2 13B via Ollama
- **Agents spécialisés** : Agents configurés pour différentes tâches (code, documentation, gestion de projet...)
- **Interface graphique de chat** : Interface visuelle complète pour interagir avec les agents et personnaliser les paramètres
- **Moniteur système** : Interface graphique pour surveiller les ressources système, Ollama et GPU
- **Interface CLI** : Interface en ligne de commande simple pour interagir avec les agents

## Modèles disponibles

Ce projet prend en charge les modèles suivants :

- **Mistral 7B** : `mistral:latest` via Ollama - pour des tests rapides et la documentation
- **CodeLlama 13B Python** : `codellama:13b-python` via Ollama - pour le développement et le code
- **Llama2 13B** : `llama2:13b` via Ollama - pour la gestion de connaissances et de projet

## Agents spécialisés

- **cursor** : Agent de programmation (CodeLlama) pour Python, JavaScript et développement web
- **obsidian** : Agent de gestion de connaissances (Llama2) pour l'organisation d'informations
- **test** : Agent de test rapide (Mistral) pour vérifier rapidement les fonctionnalités
- **python** : Expert Python (CodeLlama)
- **webdev** : Expert développement web (CodeLlama)
- **projectmanager** : Chef de projet (Llama2)
- **documentaliste** : Spécialiste en documentation (Mistral)

## Installation

### Prérequis

- Python 3.8+ 
- [Ollama](https://ollama.ai/) installé et en cours d'exécution sur `localhost:11434`
- Les modèles correspondants installés dans Ollama

### Installation des modèles Ollama

```bash
# Installation des modèles
ollama pull mistral:latest
ollama pull codellama:13b-python
ollama pull llama2:13b
```

### Configuration de l'environnement sous Windows

Utilisez le script de configuration automatique pour Windows :

```cmd
# Exécuter le script de configuration
setup_env.bat
```

Ce script va :
1. Vérifier et installer les dépendances nécessaires
2. Créer un nouvel environnement virtuel Python
3. Installer toutes les dépendances requises (y compris les modules spécifiques à Windows)
4. Configurer les scripts pour une utilisation facile

### Configuration de l'environnement sous Linux

Utilisez le script de configuration automatique pour Linux :

```bash
# Exécuter le script de configuration
./setup_env.sh
```

### Installation manuelle (alternative)

Si vous préférez l'installation manuelle :

#### Sous Windows :
```cmd
# Créer un environnement virtuel
python -m venv llmlab

# Activer l'environnement virtuel
llmlab\Scripts\activate

# Installer les dépendances
pip install -r requirements.txt
pip install wmi psutil requests pillow
```

#### Sous Linux :
```bash
# Créer un environnement virtuel
python3 -m venv llmlab

# Activer l'environnement virtuel
source llmlab/bin/activate

# Installer les dépendances
pip install -r requirements.txt

# Installer tkinter si nécessaire (au niveau du système)
sudo apt install python3-tk
```

## Utilisation

### Utilisation avec le script de lancement sous Windows

```cmd
# Afficher l'aide
run.bat help

# Lister les agents disponibles
run.bat list

# Lancer l'interface graphique de chat
run.bat gui

# Lancer le chat en ligne de commande avec un agent spécifique
run.bat chat cursor    # Agent de programmation
run.bat chat obsidian  # Agent de gestion de connaissances
run.bat chat test      # Agent de test rapide

# Lancer le moniteur système
run.bat monitor
```

### Utilisation avec le script de lancement sous Linux

```bash
# Afficher l'aide
./run.sh help

# Lister les agents disponibles
./run.sh list

# Lancer l'interface graphique de chat
./run.sh gui

# Lancer le chat en ligne de commande avec un agent spécifique
./run.sh chat cursor    # Agent de programmation
./run.sh chat obsidian  # Agent de gestion de connaissances
./run.sh chat test      # Agent de test rapide

# Lancer le moniteur système
./run.sh monitor
```

### Utilisation directe

Si vous préférez utiliser directement les scripts Python après avoir activé l'environnement virtuel :

#### Sous Windows :
```cmd
# Activer l'environnement virtuel
llmlab\Scripts\activate

# Lancer l'interface graphique de chat
python chat_gui.py

# Lister les agents disponibles
python chat.py --list

# Lancer le chat en ligne de commande avec un agent
python chat.py cursor

# Lancer le moniteur système
python monitor.py
```

#### Sous Linux :
```bash
# Activer l'environnement virtuel
source llmlab/bin/activate

# Lancer l'interface graphique de chat
./chat_gui.py

# Lister les agents disponibles
./chat.py --list

# Lancer le chat en ligne de commande avec un agent
./chat.py cursor

# Lancer le moniteur système
./monitor.py
```

## Interface graphique de chat

L'interface graphique de chat offre de nombreuses fonctionnalités avancées :

- **Sélection d'agent** : Choisissez parmi tous les agents disponibles
- **Personnalisation des modèles** : Changez le modèle utilisé par un agent
- **Paramètres ajustables** : Modifiez tous les paramètres de génération (température, top-p, etc.)
- **Presets** : Appliquez des configurations prédéfinies (Créatif, Précis, Code, etc.)
- **Sauvegarde et chargement** : Enregistrez et chargez des conversations
- **Exportation** : Exportez vos conversations en markdown, texte ou JSON

Pour lancer l'interface graphique :

```bash
# Sous Linux
./run.sh gui

# Sous Windows
run.bat gui
```

## Moniteur système

Le moniteur système fournit une interface graphique pour surveiller :

- **Ressources système** : CPU, RAM, disque
- **Serveur Ollama** : État, modèles disponibles, tailles
- **GPU NVIDIA** (si disponible) : Utilisation, mémoire, température, processus
- **Journaux d'activité** : Logs en temps réel

Pour l'utiliser :

```bash
# Sous Linux
./run.sh monitor

# Sous Windows
run.bat monitor
```

## Structure du projet

- `core/` : Classes de base et implémentations des modèles
  - `base_llm.py` : Classe de base pour tous les modèles LLM
  - `factory.py` : Factory pour créer des instances de modèle
  - `mistral7b.py` : Implémentation du modèle Mistral 7B
  - `codellama13b_python.py` : Implémentation du modèle CodeLlama 13B Python
  - `llama2_13b.py` : Implémentation du modèle Llama2 13B
- `agents/` : Configuration des agents spécialisés
  - `roles.py` : Définition des différents agents et leurs paramètres
- `utils/` : Outils et utilitaires
  - `agent_manager.py` : Gestionnaire pour créer et configurer les agents
  - `system_monitor.py` : Moniteur de ressources système
  - `chat_ui.py` : Interface graphique de chat
- `tests/` : Tests unitaires et d'intégration
- `examples/` : Exemples d'utilisation
- `logs/` : Logs des résultats de génération (créé automatiquement)
- `chat_history/` : Historique des conversations (créé automatiquement)
- `saved_params/` : Paramètres personnalisés sauvegardés (créé automatiquement)

## Scripts spécifiques pour Windows

Le projet inclut plusieurs scripts batch optimisés pour Windows 11 Pro :

- **setup_env.bat** : Configure l'environnement virtuel Python et installe les dépendances
- **run.bat** : Script principal pour exécuter toutes les fonctionnalités du projet
- **optimize_ollama.bat** : Optimise Ollama pour de meilleures performances sur Windows
- **test_installation.bat** : Vérifie que l'installation est correcte et fonctionnelle

### Optimisation d'Ollama pour Windows

Pour maximiser les performances d'Ollama sur Windows, utilisez le script d'optimisation :

```cmd
# Exécuter en tant qu'administrateur
optimize_ollama.bat
```

Ce script va :
1. Détecter les ressources système disponibles (CPU, RAM, GPU)
2. Configurer Ollama avec des paramètres optimaux
3. Redémarrer le service Ollama pour appliquer les changements

## Personnalisation

### Ajouter un nouvel agent

Pour ajouter un nouvel agent, modifiez le fichier `agents/roles.py` et ajoutez une nouvelle entrée au dictionnaire `AGENTS` :

```python
"mon_agent": {
    "model": "mistral:latest",  # Modèle à utiliser
    "system_prompt": (
        "Description du rôle de l'agent..."
    ),
    "params": {
        "temperature": 0.7,
        "top_p": 0.9,
        # Autres paramètres...
    }
}
```

### Ajouter un nouveau modèle

Pour ajouter un nouveau modèle LLM :

1. Créez une nouvelle classe dans `core/` (par exemple `core/nouveau_modele.py`)
2. Ajoutez le modèle au registre dans `core/factory.py`
3. Mettez à jour la documentation et les tests