# 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

Utilisez le script de configuration automatique :

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

Ce script va :
1. Vérifier et installer les dépendances système nécessaires (venv, tkinter)
2. Créer un nouvel environnement virtuel Python
3. Installer toutes les dépendances requises
4. Configurer les scripts pour une utilisation facile

### Installation manuelle (alternative)

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

```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

Le moyen le plus simple d'utiliser LLM Lab est d'utiliser le script de lancement `run.sh` :

```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 :

```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
./run.sh 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
./run.sh 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)

## 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