llm_ticket3/agents/agent_base.py

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

"""
Module définissant la classe abstraite Agent qui servira de base pour tous les agents
spécialisés du système d'analyse de tickets.
"""

import os
import json
from abc import ABC, abstractmethod
from datetime import datetime
from typing import Dict, List, Any, Optional

class Agent(ABC):
    """
    Classe abstraite définissant l'interface commune de tous les agents.
    """
    def __init__(self, nom: str):
        """
        Initialise un agent avec son nom et son historique d'actions.
        
        Args:
            nom: Nom de l'agent
        """
        self.nom: str = nom
        self.historique: List[Dict[str, Any]] = []
        self.llm_params: Dict[str, Any] = {}
        self.llm = None
        
    def ajouter_historique(self, action: str, input_data: Any, output_data: Any) -> None:
        """
        Ajoute une entrée dans l'historique de l'agent.
        
        Args:
            action: Type d'action réalisée
            input_data: Données d'entrée (limitées pour économiser l'espace)
            output_data: Données de sortie (limitées pour économiser l'espace)
        """
        self.historique.append({
            "timestamp": datetime.now().isoformat(),
            "action": action,
            "input": str(input_data)[:500],  # Limitation pour éviter des historiques trop volumineux
            "output": str(output_data)[:500]  # Limitation pour éviter des historiques trop volumineux
        })
    
    def obtenir_historique(self) -> List[Dict[str, Any]]:
        """
        Retourne l'historique complet de l'agent.
        
        Returns:
            Liste d'actions avec leurs timestamp et données
        """
        return self.historique
    
    def sauvegarder_historique(self, chemin_fichier: str) -> bool:
        """
        Sauvegarde l'historique de l'agent dans un fichier JSON.
        
        Args:
            chemin_fichier: Chemin où sauvegarder le fichier JSON
            
        Returns:
            True si la sauvegarde a réussi, False sinon
        """
        try:
            # Créer le répertoire parent si nécessaire
            os.makedirs(os.path.dirname(chemin_fichier), exist_ok=True)
            
            with open(chemin_fichier, 'w', encoding='utf-8') as f:
                json.dump(self.historique, f, ensure_ascii=False, indent=2)
            return True
        except Exception as e:
            print(f"Erreur lors de la sauvegarde de l'historique: {e}")
            return False
    
    def configurer_llm(self, **parametres: Any) -> None:
        """
        Configure les paramètres du LLM associé à l'agent.
        
        Args:
            **parametres: Paramètres à configurer (température, modèle, etc.)
        """
        if self.llm is None:
            raise ValueError("Aucun LLM associé à cet agent")
        
        # Enregistrer les paramètres modifiés
        self.llm_params.update(parametres)
        
        # Appliquer les paramètres au LLM
        for param, valeur in parametres.items():
            if hasattr(self.llm, param):
                setattr(self.llm, param, valeur)
            else:
                print(f"Avertissement: Le paramètre '{param}' n'existe pas dans le LLM")
        
        # Ajouter à l'historique
        self.ajouter_historique("configuration_llm", 
                               f"Paramètres: {parametres}", 
                               f"Paramètres actuels: {self.obtenir_parametres_llm()}")
    
    def obtenir_parametres_llm(self) -> Dict[str, Any]:
        """
        Obtient les paramètres actuels du LLM associé à l'agent.
        
        Returns:
            Dictionnaire des paramètres actuels du LLM
        """
        if self.llm is None:
            return {}
        
        # Paramètres à récupérer (étendre selon vos besoins)
        params_keys = [
            "model", "temperature", "max_tokens", "top_p", 
            "frequency_penalty", "presence_penalty", "system_prompt"
        ]
        
        # Extraire les valeurs des paramètres
        params = {}
        for key in params_keys:
            if hasattr(self.llm, key):
                params[key] = getattr(self.llm, key)
        
        return params
    
    def generer_rapport_parametres(self) -> Dict[str, Any]:
        """
        Génère un rapport des paramètres utilisés par l'agent.
        
        Returns:
            Dictionnaire contenant les informations sur les paramètres
        """
        return {
            "agent": self.nom,
            "llm_type": self.llm.__class__.__name__ if self.llm else "Aucun",
            "parametres": self.obtenir_parametres_llm(),
            "parametres_modifies": self.llm_params
        }
    
    def appliquer_parametres_globaux(self, params_globaux: Dict[str, Any]) -> None:
        """
        Applique des paramètres globaux au LLM de l'agent.
        Les paramètres spécifiques déjà définis ont priorité sur les globaux.
        
        Args:
            params_globaux: Dictionnaire de paramètres globaux à appliquer
        """
        if self.llm is None:
            return
            
        # Filtrer les paramètres applicables
        params_a_appliquer = {}
        for param, valeur in params_globaux.items():
            # Ne pas écraser les paramètres déjà définis spécifiquement pour cet agent
            if param not in self.llm_params and hasattr(self.llm, param):
                params_a_appliquer[param] = valeur
                
        # Appliquer les paramètres filtrés
        if params_a_appliquer:
            self.configurer_llm(**params_a_appliquer)
            self.ajouter_historique("application_params_globaux", 
                                 f"Paramètres globaux appliqués: {params_a_appliquer}", 
                                 f"Paramètres actuels: {self.obtenir_parametres_llm()}")
    
    @abstractmethod
    def executer(self, *args, **kwargs) -> Dict[str, Any]:
        """
        Méthode abstraite que chaque agent concret doit implémenter.
        Cette méthode exécute la fonction principale de l'agent.
        
        Returns:
            Dictionnaire contenant les résultats de l'exécution
        """
        pass