coffreobsidian/inbox/Pipeline de mon programme.md

1. Schéma de mon pipeline

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

{
    "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é:

sorting_result = self.image_sorter.executer(img_path)

Ce sorting_result correspond exactement à la sortie de AgentImageSorter.executer(...), qui contien:

{
    "is_relevant": True/False,
    "reason": "Explication du LLM",
    "raw_response": "...",
    "error": False,
    "metadata": {
        "image_path": "...",
        ...
    }
}

Ensuite il est stocké dans cette ligne:

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

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:

json_path, md_path = self.report_generator.executer(rapport_data, model_reports_dir)

Résumé flux de l'information

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:

ticket_analysis = self.ticket_agent.executer(ticket_data)

transmission à l'agent analyse d'image:

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:

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:

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]