# Guide Complet : Intégration des Agents LLM Dynamiques dans Cursor avec Cline

---

## Objectif

- Lancer des modèles localement (codellama, mistral, etc.)
- Créer des **agents dynamiques spécialisés** pour coder, expliquer, corriger
- Utiliser et configurer **Cline** pour interagir visuellement avec tes agents

---

## I. Prérequis

- Avoir installé **Cursor** : [https://cursor.so](https://cursor.so/)
- Avoir installé **Ollama** : [[https://ollama.com](https://ollama.com/))
- Avoir Python 3.10+ installé

### Installer un modèle avec Ollama :

```bash
ollama pull codellama:13b-python
ollama pull mistral
```

Teste le bon fonctionnement :

```bash
ollama run mistral
```

---

## II. Intégrer Ollama à Cursor via `cursor-agent.json`

Crée ce fichier à la racine du projet :

```json
{
  "name": "LLM Local Agent",
  "entry": "main.py",
  "llm": {
    "provider": "custom",
    "completion_url": "http://localhost:11434/api/generate",
    "method": "POST",
    "headers": { "Content-Type": "application/json" },
    "input_key": "prompt",
    "output_key": "response"
  }
}
```

> Ce fichier connecte Cursor à ton modèle local via API HTTP.

---

## III. Cline dans Cursor : installation, configuration et usage

### Qu'est-ce que **Cline** ?

Cline est la **barre latérale interactive** dans Cursor. Elle te permet de :

- Créer des agents avec rôles personnalisés
- Interagir avec ton code sélectionné ou tout le fichier
- Voir la réponse du modèle directement à droite
- Ajouter des prompts, des messages système ou modifier des paramètres

### Comment l’activer ?

1. Sélectionne du code
2. Tape `//` pour activer un prompt (comme un commentaire)
3. Cline s’ouvre automatiquement à droite
4. Tu peux :
    - Choisir ton modèle (`cursor-agent.json` doit être actif)
    - Envoyer un prompt
    - Lire et copier la réponse

### Pourquoi c’est utile ?

Cline est **idéal pour le développement assisté par LLM**, car tu peux :

- Corriger le code sélectionné
- Générer automatiquement du code ou des tests
- Interagir avec différents agents en parallèle
- Comparer les retours selon les rôles

---

## IV. Créer un agent dynamique personnalisé (main.py)

```python
from base_agent import BaseAgent

agent = BaseAgent("CodeExplainer", model="mistral")
agent.set_role("Tu es un assistant Python expert. Tu expliques de manière claire le fonctionnement d’un code donné.")

prompt = input("Prompt utilisateur : ")
print(agent.process(prompt))
```

---

## V. Exemple de rôles d’agents Cursor

```python
explainer = BaseAgent("Explainer", model="mistral")
optimizer = BaseAgent("Optimizer", model="codellama:13b-python")
refactor = BaseAgent("Refactor", model="codellama:13b-python")

explainer.set_role("Explique ce que fait le code avec précision.")
optimizer.set_role("Optimise ce code Python pour la performance.")
refactor.set_role("Refactore le code pour qu’il soit plus lisible.")

code = '''
def process(x): return [i*2 for i in x if i > 0]'''

print(explainer.process(code))
```

---

## VI. Support multi-machine : Agents locaux ou distants (serveur)

Tu peux travailler avec un **Ollama local sur ton PC principal** ou utiliser un **serveur distant** qui héberge un modèle (par ex. Mistral 7B déjà actif sur ton site).

### 1. Classe RemoteLLMInterface

```python
import requests

class RemoteLLMInterface:
    def __init__(self, model, host="http://192.168.1.150:11434", **params):
        self.model = model
        self.api_url = f"{host}/api/generate"
        self.params = params

    def generate(self, prompt):
        payload = {"model": self.model, "prompt": prompt, **self.params}
        response = requests.post(self.api_url, json=payload)
        return response.json().get("response", "")
```

### 2. Créer un agent distant :

```python
from remote_llm_interface import RemoteLLMInterface

class RemoteAgent:
    def __init__(self, name, model="mistral", host="http://192.168.1.150:11434", **params):
        self.name = name
        self.interface = RemoteLLMInterface(model, host, **params)
        self.system_prompt = ""

    def set_role(self, prompt):
        self.system_prompt = prompt.strip()

    def process(self, user_input):
        full_prompt = f"{self.system_prompt}\n\n{user_input}" if self.system_prompt else user_input
        return self.interface.generate(full_prompt)
```

> Tu peux ainsi appeler le modèle Mistral 7B de ton site **depuis Cursor**, sans le réinstaller localement.

---

## VII. Changer d’agent facilement (CLI rapide)

```python
from base_agent import BaseAgent

name = input("Nom de l’agent : ")
model = input("Modèle Ollama (ex: mistral) : ")
role = input("Quel est le rôle de l’agent ? : ")
prompt = input("Quel est le prompt ? : ")

agent = BaseAgent(name=name, model=model)
agent.set_role(role)
print(agent.process(prompt))
```

---

## VIII. Exemples d'agents à utiliser dans Cursor

|Nom Agent|Modèle|Rôle assigné|
|---|---|---|
|`Optimizer`|`codellama:13b-python`|Optimise le code|
|`Explainer`|`mistral`|Explique le code|
|`BugFinder`|`codellama:13b-python`|Trouve des erreurs|
|`DocGen`|`mistral`|Génère des docstrings|
|`Formatter`|`codellama`|Reformate proprement le code|

---

## IX. Bonnes pratiques avec Cursor et Cline

- Utilise `//` pour poser des questions précises à ton agent
- Crée plusieurs agents avec des rôles spécialisés : rapide à réutiliser
- Utilise des raccourcis clavier pour alterner entre agents dans Cline
- Sauvegarde tes rôles les plus utiles dans un fichier JSON ou via script
- Combine les agents dans une chaîne pour effectuer plusieurs actions à la suite

---

## Conclusion

Tu maîtrises maintenant :

- L’installation d’Ollama et des modèles
- La configuration de Cursor et l’utilisation de `cursor-agent.json`
- L’interaction avancée avec Cline (prompts, agents multiples, feedback instantané)
- La création d’agents dynamiques **locaux ou distants**, selon ton architecture