Rename src/services/cv_service.py to src/services/graph_service.py

src/services/cv_service.py

@@ -1,91 +0,0 @@
-import json
-import logging
-import os
-from datetime import datetime
-from typing import Dict, Any, List
-from pymongo import MongoClient
-from src.config import load_pdf
-from src.agents.cv_agents import CVAgentOrchestrator
-from src.agents.scoring_agent import SimpleScoringAgent
-
-logger = logging.getLogger(__name__)
-
-class CVParsingService:
-    def __init__(self, models: Dict[str, Any]):
-        self.models = models
-        self.orchestrator = CVAgentOrchestrator(models.get("llm"))
-        self.scoring_agent = SimpleScoringAgent()
-        
-        # Initialisation MongoDB
-        try:
-            self.client = MongoClient(os.getenv("MONGO_URI"))
-            self.db = self.client[os.getenv("MONGO_DB_NAME")]
-            self.candidate_collection = self.db[os.getenv("MONGO_CV_COLLECTION")]
-        except:
-            self.client = None
-            self.candidate_collection = None
-
-    def parse_cv(self, pdf_path: str, user_id: str = None) -> Dict[str, Any]:
-        cv_text = load_pdf(pdf_path)
-        if not cv_text or not cv_text.strip():
-            return self._create_fallback_data()    
-        
-        logger.info(f"CV text loaded: {len(cv_text)} characters")
-        sections = self.orchestrator.split_cv_sections(cv_text)
-        logger.info(f"Sections extracted: {list(sections.keys())}")
-        cv_data = self.orchestrator.extract_all_sections(sections)
-        logger.info(f"CV data extracted: {cv_data is not None}")
-        
-        if not cv_data or not cv_data.get("candidat") or not self._is_valid_extraction(cv_data):
-            logger.warning("Agent extraction failed or incomplete, using fallback extraction")
-            return self._create_fallback_data()
-        
-        logger.info("Calculating skill levels...")
-        scores = self.scoring_agent.calculate_scores(cv_data["candidat"])
-        if scores and scores.get("analyse_competences"):
-            cv_data["candidat"].update(scores)
-            skills_count = len(scores.get("analyse_competences", []))
-            levels_summary = self._get_levels_summary(scores.get("analyse_competences", []))
-            logger.info(f"Skill levels calculated: {skills_count} skills - {levels_summary}")
-        else:
-            logger.warning("No skill levels calculated, adding empty analysis")
-            cv_data["candidat"]["analyse_competences"] = []
-        self._save_profile(cv_data, user_id)
-        
-        return cv_data
-
-    def _save_profile(self, cv_data: Dict[str, Any], user_id: str = None):
-        """
-        Sauvegarde le CV avec la structure complète incluant la clé 'candidat'
-        """
-        if self.candidate_collection is None or not isinstance(cv_data, dict):
-            return
-        
-        try:
-            # Garder la structure complète avec la clé 'candidat'
-            profile_data = cv_data.copy()
-            profile_data["created_at"] = datetime.utcnow()
-            profile_data["updated_at"] = datetime.utcnow()
-            
-            if user_id:
-                profile_data["user_id"] = user_id
-            
-            self.candidate_collection.insert_one(profile_data)
-            logger.info("CV stocké dans MongoDB avec succès")
-        except Exception as e:
-            logger.error(f"Erreur stockage CV: {e}")
-
-    def _get_levels_summary(self, competences: List[Dict[str, Any]]) -> str:
-        levels_count = {}
-        for comp in competences:
-            level = comp.get("level", "unknown")
-            levels_count[level] = levels_count.get(level, 0) + 1
-        return ", ".join([f"{count} {level}" for level, count in levels_count.items()])
-    
-    def _is_valid_extraction(self, cv_data: Dict[str, Any]) -> bool:
-        candidat = cv_data.get("candidat", {})
-        has_info = bool(candidat.get("informations_personnelles", {}).get("nom", "").strip())
-        has_skills = bool(candidat.get("compétences", {}).get("hard_skills", []) or 
-                         candidat.get("compétences", {}).get("soft_skills", []))
-        has_experience = bool(candidat.get("expériences", []))
-        return has_info or has_skills or has_experience

src/services/graph_service.py

@@ -0,0 +1,193 @@
+import os
+import logging
+import json
+from typing import TypedDict, Annotated, Sequence, Dict, Any, List
+
+from langchain_openai import ChatOpenAI
+from langchain_core.runnables import Runnable
+from langchain_core.messages import BaseMessage, AIMessage, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langgraph.graph import StateGraph, END
+from langgraph.prebuilt import ToolNode
+
+from tools.analysis_tools import trigger_interview_analysis
+
+class AgentState(TypedDict):
+    messages: Annotated[Sequence[BaseMessage], lambda x, y: x + y]
+    user_id: str
+    job_offer_id: str
+    job_description: str
+
+class GraphInterviewProcessor:
+    """
+    Cette classe encapsule la logique d'un entretien en utilisant LangGraph.
+    Elle prépare toutes les données nécessaires à l'initialisation.
+    """
+    def __init__(self, payload: Dict[str, Any]):
+        logging.info("Initialisation de GraphInterviewProcessor...")
+        
+        self.user_id = payload["user_id"]
+        self.job_offer_id = payload["job_offer_id"]
+        self.job_offer = payload["job_offer"]
+        self.cv_data = payload.get("cv_document", {}).get('candidat', {})
+
+        if not self.cv_data:
+            raise ValueError("Données du candidat non trouvées dans le payload.")
+
+        self.system_prompt_template = self._load_prompt_template('prompts/rag_prompt_old.txt')
+        self.formatted_cv_str = self._format_cv_for_prompt()
+        self.skills_summary = self._extract_skills_summary()
+        self.reconversion_info = self._extract_reconversion_info()
+        
+        self.agent_runnable = self._create_agent_runnable()
+        self.graph = self._build_graph()
+        logging.info("GraphInterviewProcessor initialisé avec succès.")
+
+    def _load_prompt_template(self, file_path: str) -> str:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        except FileNotFoundError:
+            logging.error(f"Fichier prompt introuvable: {file_path}")
+            return "Vous êtes un assistant RH."
+
+    def _format_cv_for_prompt(self) -> str:
+        return json.dumps(self.cv_data, indent=2, ensure_ascii=False)
+
+    def _extract_skills_summary(self) -> str:
+        competences = self.cv_data.get('analyse_competences', [])
+        if not competences: return "Aucune analyse de compétences disponible."
+        summary = [f"{comp.get('skill', '')}: {comp.get('level', 'débutant')}" for comp in competences]
+        return "Niveaux de compétences du candidat: " + " | ".join(summary)
+
+    def _extract_reconversion_info(self) -> str:
+        reconversion = self.cv_data.get('reconversion', {})
+        if reconversion.get('is_reconversion'):
+            return f"CANDIDAT EN RECONVERSION: {reconversion.get('analysis', '')}"
+        return "Le candidat n'est pas identifié comme étant en reconversion."
+
+    def _create_agent_runnable(self) -> Runnable:
+        """Crée une chaîne (runnable) qui agit comme notre agent."""
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "{system_prompt_content}"),
+            MessagesPlaceholder(variable_name="messages"),
+        ])
+        llm = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4o-mini", temperature=0.7)
+        tools = [trigger_interview_analysis]
+        llm_with_tools = llm.bind_tools(tools)
+        return prompt | llm_with_tools
+
+    def _agent_node(self, state: AgentState):
+        """Prépare le prompt et appelle le runnable de l'agent."""
+        job_description_str = json.dumps(self.job_offer, ensure_ascii=False)
+        
+        system_prompt_content = self.system_prompt_template.format(
+            user_id=state['user_id'],
+            job_offer_id=state['job_offer_id'],
+            entreprise=self.job_offer.get('entreprise', 'notre entreprise'),
+            poste=self.job_offer.get('poste', 'ce poste'),
+            mission=self.job_offer.get('mission', 'Non spécifiée'),
+            profil_recherche=self.job_offer.get('profil_recherche', 'Non spécifié'),
+            competences=self.job_offer.get('competences', 'Non spécifiées'),
+            pole=self.job_offer.get('pole', 'Non spécifié'),
+            cv=self.formatted_cv_str,
+            skills_analysis=self.skills_summary,
+            reconversion_analysis=self.reconversion_info,
+            job_description=job_description_str
+        )
+        
+        response = self.agent_runnable.invoke({
+            "system_prompt_content": system_prompt_content,
+            "messages": state["messages"]
+        })
+
+        return {"messages": [response]}
+
+    def _router(self, state: AgentState) -> str:
+        """Route le flux du graphe en fonction de la dernière réponse de l'agent."""
+        last_message = state["messages"][-1]
+        if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
+            if any(tool_call.get('name') == 'trigger_interview_analysis' for tool_call in last_message.tool_calls):
+                return "call_final_tool"
+            return "call_tool"
+        return "end_turn"
+
+    def _final_analysis_node(self, state: AgentState):
+        """
+        Appelle l'outil d'analyse finale. Construit les arguments manuellement
+        à partir de l'état du graphe pour garantir la fiabilité.
+        """
+        conversation_history = []
+        for msg in state["messages"]:
+            if isinstance(msg, HumanMessage):
+                role = "user"
+            elif isinstance(msg, AIMessage):
+                role = "assistant"
+            else:
+                continue
+            conversation_history.append({"role": role, "content": msg.content})
+
+        tool_input = {
+            "user_id": state['user_id'],
+            "job_offer_id": state['job_offer_id'],
+            "job_description": state['job_description'],
+            "conversation_history": conversation_history
+        }
+        
+        trigger_interview_analysis.invoke(tool_input)
+        return {}
+
+    def _build_graph(self) -> any:
+        """Construit et compile le graphe d'états."""
+        tool_node = ToolNode([trigger_interview_analysis])
+        
+        graph = StateGraph(AgentState)
+        graph.add_node("agent", self._agent_node)
+        graph.add_node("tools", tool_node)
+        graph.add_node("final_tool_node", self._final_analysis_node) 
+        
+        graph.set_entry_point("agent")
+        
+        graph.add_conditional_edges(
+            "agent",
+            self._router,
+            {
+                "call_tool": "tools",
+                "call_final_tool": "final_tool_node",
+                "end_turn": END
+            }
+        )
+        
+        graph.add_edge("tools", "agent")
+        graph.add_edge("final_tool_node", END)
+        
+        return graph.compile()
+
+    def invoke(self, messages: List[Dict[str, Any]]):
+        """Point d'entrée pour lancer une conversation dans le graphe."""
+        langchain_messages = [HumanMessage(content=m["content"]) if m["role"] == "user" else AIMessage(content=m["content"]) for m in messages]
+        
+        if not langchain_messages:
+            logging.info("Historique de conversation vide. Ajout d'un message de démarrage interne.")
+            langchain_messages.append(HumanMessage(content="Bonjour, je suis prêt à commencer l'entretien."))
+            
+        initial_state = {
+            "user_id": self.user_id,
+            "job_offer_id": self.job_offer_id,
+            "messages": langchain_messages,
+            "job_description": json.dumps(self.job_offer, ensure_ascii=False),
+        }
+        
+        final_state = self.graph.invoke(initial_state)
+        
+        if not final_state or not final_state.get('messages'):
+            logging.error("L'état final est vide ou ne contient pas de messages.")
+            return {"response": "Erreur: Impossible de générer une réponse.", "status": "finished"}
+        last_message = final_state['messages'][-1]
+        status = "finished" if hasattr(last_message, 'tool_calls') and last_message.tool_calls else "interviewing"
+        response_content = last_message.content
+        
+        return {
+            "response": response_content,
+            "status": status
+        }