## 1. Schéma de mon pipeline
```scss
Ticket brut (JSON / Markdown) + images
    ↓
[TicketDataLoader]
    ↓
[ticket_agent] → Analyse texte du ticket
    ↓
[image_sorter] → Trie les images pertinentes
    ↓
[image_analyser] → Analyse chaque image pertinente avec contexte
    ↓
[report_generator] → Génère un rapport JSON + Markdown
    ↓
Output final (JSON + .md dans /output et /reports)
```

## 2. Rôle de AgentImageSorter dans le pipeline

#### Mission: déterminer si une image jointe est pertinent
- Analyse de type binaire ("oui" ou "non") avec une explication succincte.
- Utilise le modèle PixtralLarge, qui lui-même encode l'image en base64.
L'encodage base64 est fait uniquement dans la classe PixtralLarge(voir pour supprimer cette fonctionnalité dans l'agent)
- Entrée : image_path: str
- Traitement principal:
	1. Vérifier si l'image existe et est lisible
	2. Génère um prompt
	3. Apelle PixtralLarge.interroger_avec_image(image_path, prompt)
		1. Ce LLM encode lui_même en base64
		2. Envoie une requête vers l'API MIstral
	4. Analyse la réponse:
		1. Explicite ? ("oui", "non")
		2. Sinon, heuristique par mots-clés
	5. Produit une sortie détaillée
```python
{
    "is_relevant": True / False,
    "reason": "Explication du modèle",
    "raw_response": "...",
    "error": False,
    "metadata": {...}
}
```

#### Utilisation par l'orchestrateur
Dans orchestratoe.triter_ticket():
1. Pour chaque image dans attchments/:
2. Appelle image_sorter.executer(image_path)
3. Si is_relevant == True, ajoute à la liste des images pertinentes
4. Ces images seront analysées plus tard dans image_analyser avec contexte texte

#### Localisation du résultat du tri d'image
Dans orchestrator.traiter_ticket() -> bloc principal du tri d'images:
Passage clé:
```python
sorting_result = self.image_sorter.executer(img_path)
```
Ce sorting_result correspond exactement à la sortie de AgentImageSorter.executer(...), qui contien:
```python
{
    "is_relevant": True/False,
    "reason": "Explication du LLM",
    "raw_response": "...",
    "error": False,
    "metadata": {
        "image_path": "...",
        ...
    }
}
```
Ensuite il est stocké dans cette ligne:
```python
images_analyses[img_path] = {
    "sorting": sorting_result,
    "analysis": None  # sera complété plus tard
}
```
images_analyses est un dictionnaire qui regroupe toutes les images traitées dans un ticket, qu'elles soient pertinentes ou non.
Il est ensuite injecté dans la structure de rapport que l'orchestrateut transmet à l'agent de génération de rapport(report_generator):
```python
rapport_data = {
    "ticket_data": ticket_data,
    "ticket_id": ticket_id,
    "ticket_analyse": ticket_analysis,
    "analyse_images": images_analyses,  # ← ici
    "metadata": {
        ...
    }
}
```
Et ce rapport est transmis ici:
```python
json_path, md_path = self.report_generator.executer(rapport_data, model_reports_dir)
```

**Résumé flux de l'information**
```text
AgentImageSorter.executer(image_path) 
     ↓
  → renvoie sorting_result = { is_relevant, reason, ... }
     ↓
Orchestrator.traiter_ticket()
     ↓
Stocke le résultat dans images_analyses[image_path] = { sorting: ..., analysis: None }
     ↓
Ajoute à rapport_data["analyse_images"]
     ↓
Transmis à report_generator.executer(rapport_data)
```

## 3. Agent d'analyse de ticket

#### Objectif:
Analyser les tickets de support (au format JSON) pour:
- Reconstituer le contexte tecnique du tcket
- Nettoyer et structurer le fil de discussion
- Identifier les éléments visuels clés (pour aider analyse des images pertinentes)
- Injecter les données nettoyées dans le pipeline

##### Entrée:
- Un dictionnaire python extrait du fichier TXXXX_rapport.json
- Ce rapport contient les champs "name", "description", "messages", etc ...
##### Sortie:
- Une chaîne de texte contenant un résumé structuré du ticket (avec consignes pour rester fidèle au texte original)
- Cette réponse est transmise:
	- Au prochain agent analyse image sous forme de contexte et analyse à l'agetn report
	- Sauvegarde le résultat en JSON avec sauvegarder_donnees(...)

#### Fonctionnement dans le pipeline (orchestrator.py)

Méthode:
```python
ticket_analysis = self.ticket_agent.executer(ticket_data)
```
transmission à l'agent analyse d'image:
```python
contexte_ticket = ticket_analysis
analysis_result = self.image_analyser.executer(image_path, contexte=contexte_ticket)
```

transmission à l'agent report generator:
Tout est rassemblé dans un dictionnaire rapport_data:
```python
rapport_data = {
    "ticket_data": ticket_data,
    "ticket_id": ticket_id,
    "ticket_analyse": ticket_analysis,
    "analyse_images": images_analyses,
    "metadata": {
        "timestamp_debut": self._get_timestamp(),
        "ticket_id": ticket_id,
        "images_analysees": images_count,
        "images_pertinentes": len(relevant_images)
    }
}
```
Puis transmis à report_generator:
```python
if self.report_generator:
    json_path, md_path = self.report_generator.executer(rapport_data, model_reports_dir)
```

## 4. Agent analyser d'image (AgentImageAnalyser)

#### Objectifs:
Cet agent a pour but d'analyser chaque image jugée pertinente, en s'appuyant sur:
- Le contexte textuel du ticket produit par AgentTicketAnalyser
- L'accès à l'image (via chemin fichier) analysée visuellement via un LLM multimodal
Il ne fournit pas de de diagnostic, ne propose aucune solutiol, et se limite à des observations factuelles et tehcniques issues des captures.

#### Fonctionnement gnéral
- __init__
	- Initialise le prompt système à envoyer au LLM.
	- Définit les instructions factuelles pour analyser une image (menus visibles, éléments grisés, erreurs affichées, etc).
	- Applique la configuration au LLM: température, top_p,...

- _verifier_image(image_path)
	- Vérifie que l'image existe, est lisible, et a des dimensions valides.
	- Important pour éviter les erreurs en aval

- _generer_prompt_analyse(contexte, prefix)
	- Génère un prompt personnalisé pour le LLM.
	- Combine un préfix("Analyse cette image...") avec le contexte textuel du ticket, puis les instructions factuelles.
	- Sert à encadrer et orienter la génération du modèle.

- executer(image_path, contexte)
C'est la fonction principale de l'agent. Elle:
- Vérifie l'image
- Génère le prompt avec le contexte du ticket
- Appelle le modèle multimodal(interroger_avec_image) ou fallback avec base64 si nécessaire
- Vérifie les erreurs de réponse (si le modèle dit qu'il ne peut pas analyser l'image)
- Structure un dictionnaire result avec:
	- L'analyse textuelle(analyse)
	- La réponse brut(raw_response)
	- Des métadonnées (modèle utilisé, timestamp, nom image, etc...)
- Appelle sauvegarder_donnees() pour enregistrer l'analyse dans reports/
- Ajoute l'analyse à l'historique avec ajouter_historique(...)

#### Intégration dans le pipeline (orchestrator.py)
Dans le fichier orchestrateur:
- L'agent est appelé une fois que les images pertinentes ont éé détectées (ImageSorter)
- Pour chaque image pertinente :
	- Le chemin de l'image est passé à AgentTicketAnalyser
	- Le contexte du ticket est récupéré depuis AgentTicketAnalyser
	- Le résultat est stocké dans images_analyses[image_path]["analysis]