llm_ticket3/agent_factory_llama.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Factory pour les agents LLM dédié exclusivement à Llama_vision.
Permet d'isoler les comportements spécifiques pour ce multimodal.
"""

import logging
import time
import os

from typing import Dict, Any, Optional, Union

from agents.llama_vision.agent_ticket_analyser import AgentTicketAnalyser
from agents.llama_vision.agent_image_sorter import AgentImageSorter
from agents.llama_vision.agent_image_analyser import AgentImageAnalyser
from agents.llama_vision.agent_report_generator import AgentReportGenerator
from agents.llama_vision.agent_vision_ocr import AgentVisionOCR

from llm_classes.llama_vision import LlamaVision

logger = logging.getLogger("AgentFactoryLlamaVision")

class AgentFactoryLlamaVision:
    """
    Factory pour les agents LLM dédié exclusivement à Llama_vision.
    Assure la cohérence d'utilisation du modèle pour tous les agents.
    """

    DEFAULT_MODEL_NAME = "llama3.2-vision:90b-instruct-q8_0"

    def __init__(self, model_name: str = DEFAULT_MODEL_NAME):
        self.model_name = model_name

    @staticmethod
    def create_llm(model_name: Optional[str] = None) -> LlamaVision:
        """
        Crée une nouvelle instance du modèle LlamaVision.
        Chaque instance est indépendante pour permettre des configurations spécifiques par agent.
        
        Args:
            model_name: Nom du modèle à utiliser (si None, utilise le modèle par défaut)
            
        Returns:
            Instance configurée de LlamaVision
        """
        actual_model = model_name if model_name else AgentFactoryLlamaVision.DEFAULT_MODEL_NAME
        logger.info(f"Initialisation du modèle llama_vision (modèle: {actual_model})")
        
        # Créer l'instance avec le nom exact du modèle
        model = LlamaVision(modele=actual_model)
        
        return model
    
    @staticmethod
    def create_ticket_analyser(llm: Optional[LlamaVision] = None) -> AgentTicketAnalyser:
        """
        Crée un agent d'analyse de tickets avec sa propre instance LLM.
        
        Args:
            llm: Instance LlamaVision existante (optionnel, une nouvelle instance sera créée si None)
            
        Returns:
            Agent d'analyse de tickets configuré
        """
        logger.info("Création de l'agent de tickets (llama_vision)")
        # Créer une nouvelle instance LLM spécifique à cet agent si aucune n'est fournie
        if llm is None:
            llm = AgentFactoryLlamaVision.create_llm()
        return AgentTicketAnalyser(llm)
    
    @staticmethod
    def create_image_sorter(llm: Optional[LlamaVision] = None) -> AgentImageSorter:
        """
        Crée un agent de tri d'images avec sa propre instance LLM.
        
        Args:
            llm: Instance LlamaVision existante (optionnel, une nouvelle instance sera créée si None)
            
        Returns:
            Agent de tri d'images configuré
        """
        logger.info("Création de l'agent de tri des images (llama_vision)")
        # Créer une nouvelle instance LLM spécifique à cet agent si aucune n'est fournie
        if llm is None:
            llm = AgentFactoryLlamaVision.create_llm()
        return AgentImageSorter(llm)
    
    @staticmethod
    def create_image_analyser(llm: Optional[LlamaVision] = None) -> AgentImageAnalyser:
        """
        Crée un agent d'analyse d'images avec sa propre instance LLM.
        
        Args:
            llm: Instance LlamaVision existante (optionnel, une nouvelle instance sera créée si None)
            
        Returns:
            Agent d'analyse d'images configuré
        """
        logger.info("Création de l'agent d'analyse des images (llama_vision)")
        # Créer une nouvelle instance LLM spécifique à cet agent si aucune n'est fournie
        if llm is None:
            llm = AgentFactoryLlamaVision.create_llm()
        return AgentImageAnalyser(llm)
    
    @staticmethod
    def create_report_generator(llm: Optional[LlamaVision] = None) -> AgentReportGenerator:
        """
        Crée un agent de génération de rapports avec sa propre instance LLM.
        
        Args:
            llm: Instance LlamaVision existante (optionnel, une nouvelle instance sera créée si None)
            
        Returns:
            Agent de génération de rapports configuré
        """
        logger.info("Création de l'agent de génération de rapports (llama_vision)")
        # Créer une nouvelle instance LLM spécifique à cet agent si aucune n'est fournie
        if llm is None:
            llm = AgentFactoryLlamaVision.create_llm()
        return AgentReportGenerator(llm)
    
    @staticmethod
    def create_vision_ocr(llm: Optional[LlamaVision] = None) -> AgentVisionOCR:
        """
        Crée un agent d'OCR visuel avec sa propre instance LLM.
        
        Args:
            llm: Instance LlamaVision existante (optionnel, une nouvelle instance sera créée si None)
            
        Returns:
            Agent d'OCR visuel configuré
        """
        logger.info("Création de l'agent d'OCR visuel (llama_vision)")
        # Créer une nouvelle instance LLM spécifique à cet agent si aucune n'est fournie
        if llm is None:
            llm = AgentFactoryLlamaVision.create_llm()
        return AgentVisionOCR(llm)
        
    @staticmethod
    def create_all_agents(model_name: Optional[str] = None) -> Dict[str, Any]:
        """
        Crée tous les agents nécessaires pour Llama_vision avec des instances LLM séparées.
        Chaque agent reçoit sa propre instance pour éviter les problèmes de configuration partagée.
        
        Args:
            model_name: Nom du modèle à utiliser (si None, utilise le modèle par défaut)
            
        Returns:
            Dictionnaire contenant tous les agents créés
        """
        # Utiliser un modèle explicite pour tous les agents
        logger.info(f"Création de tous les agents avec instances LLM indépendantes (modèle: {model_name or AgentFactoryLlamaVision.DEFAULT_MODEL_NAME})")
        
        # Créer une instance partagée du modèle LLM pour maintenir la cohérence
        llm = AgentFactoryLlamaVision.create_llm(model_name)
        
        # Vérifier que le modèle est bien une instance de LlamaVision
        if not isinstance(llm, LlamaVision):
            logger.error(f"Erreur: le modèle créé n'est pas une instance de LlamaVision")
            raise ValueError("Seul LlamaVision doit être utilisé avec cette factory")
        
        # Créer les agents avec la même instance LLM pour garantir la cohérence
        return {
            "ticket_analyser": AgentFactoryLlamaVision.create_ticket_analyser(llm),
            "image_sorter": AgentFactoryLlamaVision.create_image_sorter(llm),
            "image_analyser": AgentFactoryLlamaVision.create_image_analyser(llm),
            "report_generator": AgentFactoryLlamaVision.create_report_generator(llm),
            "vision_ocr": AgentFactoryLlamaVision.create_vision_ocr(llm)
        }