llm_lab_perso/cursor_integration.md

# Intégration de LLM Lab avec Cursor

Ce guide détaille comment intégrer et utiliser LLM Lab spécifiquement avec l'éditeur de code [Cursor](https://cursor.sh/).

## Qu'est-ce que Cursor ?

Cursor est un éditeur de code moderne basé sur VS Code, enrichi par des capacités d'IA pour améliorer le développement. Par défaut, Cursor utilise des modèles cloud (comme Claude ou GPT-4), mais vous pouvez le configurer pour utiliser LLM Lab et ses modèles locaux via Ollama.

## Avantages de l'intégration

- **Confidentialité** : Votre code reste local, sans être envoyé à des serveurs externes
- **Personnalisation** : Contrôle total sur les modèles et leurs paramètres
- **Performance** : Exploitation directe de votre GPU local
- **Coût** : Aucun frais d'API ou d'abonnement

## Options d'intégration

### 1. Agent en ligne de commande + Copier-coller

La méthode la plus simple pour commencer :

1. **Ouvrir deux fenêtres** :
   - Cursor pour le développement
   - Terminal pour LLM Lab

2. **Lancer l'agent Cursor** :
   ```cmd
   # Windows
   run.bat chat cursor
   
   # Linux
   ./run.sh chat cursor
   ```

3. **Workflow** :
   - Copiez le code ou la question depuis Cursor
   - Collez dans le terminal LLM Lab
   - Copiez la réponse générée
   - Collez dans Cursor

### 2. Serveur API local pour Cursor

Pour une expérience plus intégrée, configurez un serveur API local :

1. **Créer un fichier `api_server.py`** dans le dossier racine de LLM Lab :

```python
#!/usr/bin/env python3
"""
Serveur API pour intégrer LLM Lab avec Cursor
"""
from flask import Flask, request, jsonify, Response
from flask_cors import CORS
import json
import os
from utils.agent_manager import AgentManager
import logging

# Configuration du logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler("logs/api_server.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger("api_server")

# Initialisation de l'application Flask
app = Flask(__name__)
CORS(app)  # Permet les requêtes cross-origin

@app.route('/v1/chat/completions', methods=['POST'])
def chat_completion():
    """
    Endpoint compatible avec l'API OpenAI Chat pour Cursor
    """
    try:
        data = request.json
        logger.info(f"Requête reçue: {json.dumps(data)}")
        
        # Extraire les messages et les paramètres
        messages = data.get('messages', [])
        model = data.get('model', 'codellama:13b-python')
        temperature = data.get('temperature', 0.7)
        
        # Construire le prompt à partir des messages
        system_message = next((msg['content'] for msg in messages if msg['role'] == 'system'), None)
        user_messages = [msg['content'] for msg in messages if msg['role'] == 'user']
        
        # Utiliser le dernier message utilisateur comme prompt
        prompt = user_messages[-1] if user_messages else ""
        
        # Détecter le type de tâche pour choisir l'agent approprié
        agent_name = "cursor"  # Par défaut
        if "javascript" in prompt.lower() or "js" in prompt.lower():
            agent_name = "webdev"
        elif "python" in prompt.lower():
            agent_name = "python"
        
        # Créer et configurer l'agent
        agent = AgentManager.create(agent_name)
        
        # Remplacer le system prompt si fourni
        if system_message:
            agent.system_prompt = system_message
        
        # Ajuster les paramètres
        agent.params["temperature"] = temperature
        
        # Générer la réponse
        response = agent.generate(prompt)
        logger.info(f"Réponse générée pour l'agent {agent_name}")
        
        # Formatage compatible avec l'API OpenAI
        return jsonify({
            "id": f"llmlab-{agent_name}-{hash(prompt) % 10000}",
            "object": "chat.completion",
            "created": int(__import__('time').time()),
            "model": agent.model,
            "choices": [
                {
                    "index": 0,
                    "message": {
                        "role": "assistant",
                        "content": response
                    },
                    "finish_reason": "stop"
                }
            ],
            "usage": {
                "prompt_tokens": len(prompt.split()),
                "completion_tokens": len(response.split()),
                "total_tokens": len(prompt.split()) + len(response.split())
            }
        })
    
    except Exception as e:
        logger.error(f"Erreur: {str(e)}", exc_info=True)
        return jsonify({
            "error": {
                "message": str(e),
                "type": "server_error",
                "code": 500
            }
        }), 500

@app.route('/models', methods=['GET'])
def list_models():
    """
    Liste les modèles disponibles
    """
    agents = AgentManager.list_agents()
    models = []
    
    for agent_name, info in agents.items():
        models.append({
            "id": info['model'],
            "object": "model",
            "owned_by": "llmlab",
            "permission": [{"id": agent_name, "object": "model_permission"}]
        })
    
    return jsonify({
        "object": "list",
        "data": models
    })

if __name__ == '__main__':
    # Créer le dossier logs s'il n'existe pas
    os.makedirs("logs", exist_ok=True)
    
    print("=== Serveur API LLM Lab pour Cursor ===")
    print("Serveur démarré sur http://localhost:8000")
    print("Utilisez cette URL dans les paramètres API de Cursor")
    print("Modèles disponibles:")
    for agent in AgentManager.list_agents():
        print(f"- {agent}")
    print("\nLog des requêtes dans logs/api_server.log")
    print("Appuyez sur Ctrl+C pour arrêter le serveur")
    
    app.run(host='0.0.0.0', port=8000, debug=False)
```

2. **Ajouter les dépendances Flask** :
   Modifiez `requirements.txt` pour ajouter :
   ```
   flask>=2.0.0
   flask-cors>=3.0.10
   ```

3. **Mettre à jour `run.bat`** pour inclure la commande API :
   ```batch
   ) else if "%1"=="api" (
       python api_server.py
   ```

4. **Lancer le serveur API** :
   ```cmd
   # Windows
   run.bat api
   
   # Linux
   ./run.sh api
   ```

5. **Configurer Cursor** :
   - Ouvrez Cursor
   - Allez dans Paramètres > AI
   - Sélectionnez "Custom endpoint"
   - Entrez l'URL : `http://localhost:8000/v1`
   - Activez l'option "Use custom endpoint for all AI features"

### 3. Extension Cursor (Avancé)

Pour les développeurs avancés, vous pouvez créer une extension Cursor dédiée :

1. **Initialiser un projet d'extension** :
   ```cmd
   mkdir cursor-llmlab-extension
   cd cursor-llmlab-extension
   npm init
   ```

2. **Créer la structure du projet** conformément à la documentation de Cursor

3. **Implémenter l'intégration** avec LLM Lab via l'API locale

## Conseils d'utilisation

### Commandes utiles dans Cursor

- `Ctrl+I` : Invoquer l'IA pour une requête
- `Ctrl+L` : Chat avec l'IA
- `/edit` : Demander une édition de code
- `/doc` : Générer de la documentation
- `/test` : Générer des tests unitaires

### Invites (prompts) efficaces pour CodeLlama

- **Être spécifique** : "Refactor cette fonction pour utiliser des list comprehensions au lieu des boucles for"
- **Fournir le contexte** : "J'utilise Flask avec SQLAlchemy dans une application REST"
- **Demander des explications** : "Explique comment ce code fonctionne ligne par ligne"
- **Indiquer les contraintes** : "Utilise uniquement des bibliothèques standard, sans dépendances externes"

### Exemples pratiques

#### 1. Complétion de fonction

**Prompt** : "Complète cette fonction qui doit convertir des dates au format ISO en timestamp Unix"

```python
def iso_to_timestamp(iso_date):
    # À compléter
    pass
```

#### 2. Débogage

**Prompt** : "Ce code lève une IndexError. Identifie le problème et propose une correction"

#### 3. Refactoring

**Prompt** : "Refactorise ce code pour améliorer sa lisibilité et ses performances"

## Développement avancé

### Personnaliser l'agent Cursor

Vous pouvez personnaliser l'agent Cursor dans `agents/roles.py` :

```python
"cursor": {
    "model": "codellama:13b-python",
    "description": "Agent de programmation optimisé pour Cursor",
    "system_prompt": (
        "Tu es un expert en programmation spécialisé dans l'écriture et la révision de code. "
        "Pour répondre à des questions de programmation, tu dois : "
        "1. Fournir du code complet, fonctionnel et bien structuré "
        "2. Suivre les meilleures pratiques du langage demandé "
        "3. Privilégier la lisibilité et la maintenabilité "
        "4. Expliquer brièvement les concepts importants "
        "Quand on te demande de déboguer, d'améliorer ou de refactoriser du code, "
        "tu dois analyser en détail le code fourni et proposer des solutions concrètes. "
        "Tes réponses doivent être précises et contenir du code prêt à l'emploi."
    ),
    "params": {
        "temperature": 0.2,  # Valeur basse pour du code précis
        "top_p": 0.95,
        "num_ctx": 4096
    }
}
```

### Créer des agents spécialisés

Vous pouvez créer des agents spécialisés pour différents langages ou tâches :

```python
"python": {
    "model": "codellama:13b-python",
    "description": "Expert Python pour le développement et la résolution de problèmes",
    "system_prompt": (
        "Tu es un expert Python avec une connaissance approfondie de l'écosystème Python, "
        "des bibliothèques standard et des frameworks populaires comme Django, Flask, "
        "Pandas, NumPy et TensorFlow. Ton objectif est d'aider à écrire du code Python "
        "élégant, performant et idiomatique, en suivant les principes PEP 8 et les "
        "bonnes pratiques Python. Tu dois favoriser les approches pythoniques comme "
        "les compréhensions de liste, les générateurs et les fonctions de haut niveau."
    ),
    "params": {
        "temperature": 0.2,
        "top_p": 0.95,
        "num_ctx": 4096
    }
}
```

## Dépannage

### Problèmes courants

1. **Erreur de connexion à l'API** :
   - Vérifiez que le serveur API est bien en cours d'exécution
   - Confirmez que l'URL dans Cursor est correcte (http://localhost:8000/v1)
   - Vérifiez les logs dans `logs/api_server.log`

2. **Réponses trop lentes** :
   - Optimisez les paramètres d'Ollama avec `optimize_ollama.bat`
   - Réduisez la taille du contexte ou utilisez un modèle plus petit

3. **Qualité de code insuffisante** :
   - Ajustez la température (valeurs plus basses pour plus de précision)
   - Améliorez le prompt système de l'agent
   - Essayez un modèle plus performant (comme Mixtral ou Llama3)

### Support

Pour obtenir de l'aide supplémentaire :
- Consultez les logs dans le dossier `logs/`
- Vérifiez les issues connues sur le dépôt GitHub du projet
- Posez vos questions sur le forum de la communauté