llm_lab/docs/guide_utilisation.md

# Guide d'utilisation des agents et classes LLM

Ce guide fournit des instructions détaillées sur l'utilisation des différents agents et classes LLM disponibles dans le projet LLM Lab.

## Table des matières

1. [Utilisation des modèles LLM](#utilisation-des-modèles-llm)
   - [LlamaVision90B](#llamavision90b)
   - [MistralAPI](#mistralapi)
   
2. [Utilisation des agents](#utilisation-des-agents)
   - [Agent d'analyse d'images](#agent-danalyse-dimages)
   - [Agent d'analyse JSON](#agent-danalyse-json)
   - [Agent de questions-réponses](#agent-de-questions-réponses)
   
3. [Exemples de workflows complets](#exemples-de-workflows-complets)

## Utilisation des modèles LLM

Les modèles LLM sont accessibles via la factory `LLMFactory` pour garantir une instanciation cohérente et configurable.

### LlamaVision90B

Ce modèle est spécialisé dans l'analyse d'images avec des capacités multimodales (texte + image).

#### Configuration de base

```python
from core.factory import LLMFactory

# Création d'une instance via la factory
vision_llm = LLMFactory().create("llamavision")

# Configuration des paramètres
vision_llm.parametres_generation["temperature"] = 0.2
vision_llm.parametres_generation["max_tokens"] = 1000
vision_llm.parametres_avances["top_p"] = 0.9
```

#### Analyse d'une image

```python
# Définir le chemin de l'image
vision_llm.definir_image("chemin/vers/image.jpg")

# Générer une description de l'image
prompt = "Décris en détail ce que tu vois dans cette image."
description = vision_llm.generate(prompt)
print(description)
```

#### Analyse avec des données JSON complémentaires

```python
# Définir des données JSON complémentaires
donnees_complementaires = {
    "metadata": {
        "source": "caméra de surveillance",
        "timestamp": "2023-03-15T14:30:00",
        "location": "entrée principale"
    }
}

vision_llm.definir_donnees_json(donnees_complementaires)

# Générer une analyse avec contexte
prompt = "Analyse cette image en tenant compte des métadonnées fournies."
resultat = vision_llm.generate(prompt)
```

### MistralAPI

Cette classe permet d'accéder aux modèles de langage de Mistral AI via leur API.

#### Configuration de base

```python
from core.factory import LLMFactory
import os

# Définir la clé API (ou via variable d'environnement)
os.environ["MISTRAL_API_KEY"] = "votre_clé_api"

# Création d'une instance via la factory
mistral = LLMFactory().create("mistralapi")

# Configuration des paramètres
mistral.parametres_generation["temperature"] = 0.7
mistral.parametres_generation["max_tokens"] = 500
```

#### Génération de texte

```python
# Génération simple
prompt = "Explique le concept de l'intelligence artificielle en 3 paragraphes."
reponse = mistral.generate(prompt)
print(reponse)
```

#### Obtention de la liste des modèles disponibles

```python
modeles = mistral.obtenir_liste_modeles()
print("Modèles disponibles:")
for modele in modeles:
    print(f"- {modele}")
```

## Utilisation des agents

Les agents sont des composants de plus haut niveau qui encapsulent les modèles LLM avec des fonctionnalités spécifiques.

### Agent d'analyse d'images

Cet agent facilite l'analyse d'images en utilisant LlamaVision.

```python
from agents.analyse_image import AgentAnalyseImage

# Création de l'agent
agent = AgentAnalyseImage("AgentVision")

# Analyse simple d'une image
resultats = agent.executer(
    "chemin/vers/image.jpg",
    question="Que vois-tu dans cette image? Y a-t-il du texte visible?"
)

# Affichage des résultats
print(resultats["analyses"][0]["reponse"])

# Sauvegarde des résultats
agent.sauvegarder_resultats("resultats_analyse.json", resultats)
```

### Agent d'analyse JSON

Cet agent permet d'analyser et de manipuler des données JSON.

```python
from agents.analyse_json import AgentAnalyseJSON

# Création de l'agent
agent = AgentAnalyseJSON("AgentJSON")

# Données JSON à analyser
donnees = {
    "utilisateurs": [
        {"id": 1, "nom": "Dupont", "age": 32},
        {"id": 2, "nom": "Martin", "age": 45},
        {"id": 3, "nom": "Durand", "age": 28}
    ],
    "statistiques": {
        "moyenne_age": 35,
        "total_utilisateurs": 3
    }
}

# Analyse des données
resultats = agent.executer(
    donnees,
    question="Quelles informations importantes peux-tu extraire de ces données?"
)

print(resultats["analyse"])

# Extraction de la structure
structure = agent.extraire_structure(donnees)
print("Structure des données:", structure)
```

### Agent de questions-réponses

Cet agent utilise MistralAPI pour des interactions de type questions-réponses.

```python
from agents.agent_question_reponse import AgentQuestionReponse

# Création de l'agent avec le modèle souhaité
agent = AgentQuestionReponse("AgentQR", modele="mistral-large-latest")

# Poser une question simple
resultat = agent.executer("Comment fonctionne l'apprentissage par renforcement?")
print(resultat["reponse"])

# Poser une question avec contexte
contexte = {
    "sujet": "Intelligence artificielle",
    "domaine": "Apprentissage automatique",
    "concepts_cles": ["réseaux de neurones", "deep learning", "données d'entraînement"]
}

resultat_avec_contexte = agent.executer(
    "Quelles sont les différences entre l'apprentissage supervisé et non supervisé?",
    contexte=contexte
)
print(resultat_avec_contexte["reponse"])

# Générer des questions à partir d'un contexte
questions = agent.generer_questions(contexte, nombre=5)
for i, question in enumerate(questions, 1):
    print(f"{i}. {question}")

# Évaluer une réponse
evaluation = agent.evaluer_reponse(
    question="Qu'est-ce que le deep learning?",
    reponse="Le deep learning est une technique d'IA qui utilise des réseaux de neurones profonds."
)
print(evaluation["evaluation_detaillee"])
print("Scores:", evaluation["scores"])
```

## Exemples de workflows complets

### Workflow d'analyse d'image avec post-traitement

```python
from agents.analyse_image import AgentAnalyseImage
from agents.analyse_json import AgentAnalyseJSON
from agents.agent_question_reponse import AgentQuestionReponse
import json

# 1. Analyse de l'image
agent_image = AgentAnalyseImage("AgentVision")
resultats_image = agent_image.executer("chemin/vers/image.jpg")

# 2. Analyse des résultats JSON
agent_json = AgentAnalyseJSON("AgentJSON")
resultats_analyse = agent_json.executer(
    resultats_image,
    question="Extrais les éléments clés détectés dans l'image."
)

# 3. Génération de questions sur le contenu
agent_qr = AgentQuestionReponse("AgentQR")
questions = agent_qr.generer_questions(resultats_analyse, nombre=3)

# 4. Sauvegarde des résultats complets
workflow_results = {
    "analyse_image": resultats_image,
    "analyse_structure": resultats_analyse,
    "questions_potentielles": questions
}

with open("resultats_workflow.json", "w", encoding="utf-8") as f:
    json.dump(workflow_results, f, ensure_ascii=False, indent=2)
```

Ce workflow illustre comment combiner plusieurs agents pour créer une chaîne de traitement complète, de l'analyse d'image initiale jusqu'à la génération de questions pertinentes sur le contenu identifié.