Update services/graph_service.py

services/graph_service.py

@@ -1,99 +1,143 @@
 import os
-from typing import TypedDict, Annotated, Sequence
+import logging
+import json
+from typing import TypedDict, Annotated, Sequence, Dict, Any, List
+
 from langchain_openai import ChatOpenAI
-from langchain_core.messages import BaseMessage, AIMessage, HumanMessage
+from langchain_core.messages import BaseMessage, AIMessage, HumanMessage, SystemMessage
 from langchain.agents import create_openai_tools_agent, AgentExecutor
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langgraph.graph import StateGraph, END
 from tools.analysis_tools import trigger_interview_analysis
 
-# --- 1. Définition de l'état du graphe ---
 class AgentState(TypedDict):
+    messages: Annotated[Sequence[BaseMessage], lambda x, y: x + y]
     user_id: str
     job_offer_id: str
-    cv_document: dict
-    job_offer: dict
-    messages: Annotated[Sequence[BaseMessage], lambda x, y: x + y]
 
-# --- 2. Configuration de l'agent ---
-def create_agent_executor():
-    # Le prompt instruit l'agent sur son rôle et quand utiliser l'outil
-    prompt = ChatPromptTemplate.from_messages([
-        ("system", """You are a friendly and professional HR recruiter named AIrh.
-        Your role is to conduct a job interview based on the provided resume (cv_document) and the job description (job_offer).
-        Engage with the user, ask relevant questions, and respond to their answers.
-        When you feel the interview is complete, you MUST use the 'trigger_interview_analysis' tool to end the conversation.
-        After calling the tool, say a final goodbye to the user."""),
-        MessagesPlaceholder(variable_name="messages"),
-    ])
-    
-    llm = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4-turbo", temperature=0.7)
-    tools = [trigger_interview_analysis]
-    agent = create_openai_tools_agent(llm, tools, prompt)
-    return AgentExecutor(agent=agent, tools=tools, verbose=True)
-
-# --- 3. Définition des nœuds du graphe ---
-agent_executor = create_agent_executor()
-
-def agent_node(state: AgentState):
-    """Le nœud principal qui appelle l'agent pour répondre ou utiliser un outil."""
-    response = agent_executor.invoke({
-        "user_id": state["user_id"],
-        "job_offer_id": state["job_offer_id"],
-        "cv_document": state["cv_document"],
-        "job_offer": state["job_offer"],
-        "messages": state["messages"],
-        "conversation_history": state["messages"] # Pour la compatibilité si l'outil en a besoin
-    })
-    return {"messages": [AIMessage(content=response["output"])]}
-
-# --- 4. Définition du routeur (Conditional Edge) ---
-def router(state: AgentState):
-    """Décide du chemin à suivre après la réponse de l'agent."""
-    last_message = state["messages"][-1]
-    if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
-        # Si l'agent a décidé d'appeler l'outil, on termine le graphe
-        return "end"
-    else:
-        # Sinon, on continue la conversation
+class GraphInterviewProcessor:
+    """
+    Cette classe encapsule la logique d'un entretien en utilisant LangGraph.
+    Elle prépare toutes les données nécessaires à l'initialisation, comme dans votre code original.
+    """
+    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_executor = self._create_agent_executor()
+        self.graph = self._build_graph()
+        logging.info("GraphInterviewProcessor initialisé avec succès.")
+
+    def _load_prompt_template(self, file_path: str) -> str:
+        """Charge le template du prompt depuis un fichier."""
+        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:
+        """Formate le CV pour l'injecter dans le prompt."""
+        return json.dumps(self.cv_data, indent=2, ensure_ascii=False)
+
+    def _extract_skills_summary(self) -> str:
+        """Extrait un résumé des compétences avec niveaux."""
+        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:
+        """Extrait les informations de reconversion."""
+        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_executor(self) -> AgentExecutor:
+        """Crée l'agent executor avec un prompt minimaliste."""
+        prompt = ChatPromptTemplate.from_messages([
+            SystemMessage(content="{system_prompt_content}"),
+            MessagesPlaceholder(variable_name="messages"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ])
+        llm = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4o-mini", temperature=0.7)
+        tools = [trigger_interview_analysis]
+        agent = create_openai_tools_agent(llm, tools, prompt)
+        return AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+    def _agent_node(self, state: AgentState):
+        """Prépare le prompt système dynamiquement et appelle l'agent."""
+        system_prompt_content = self.system_prompt_template.format(
+            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
+        )
+        
+        response = self.agent_executor.invoke({
+            "system_prompt_content": system_prompt_content,
+            "messages": state["messages"],
+            "user_id": state["user_id"],
+            "job_offer_id": state["job_offer_id"],
+            "conversation_history": state["messages"]
+        })
+        return {"messages": [response['output']]}
+
+    def _router(self, state: AgentState):
+        """Décide du chemin à suivre après la réponse de l'agent."""
+        last_message = state["messages"][-1]
+        if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
+            return "end"
         return "continue"
 
-# --- 5. Construction du graphe ---
-def build_graph():
-    graph = StateGraph(AgentState)
-    graph.add_node("agent", agent_node)
-    graph.add_conditional_edges(
-        "agent",
-        router,
-        {"continue": "agent", "end": END}
-    )
-    graph.set_entry_point("agent")
-    return graph.compile()
-
-# --- Service principal à appeler depuis l'API ---
-class GraphConversationManager:
-    def __init__(self):
-        self.graph = build_graph()
-
-    def invoke(self, payload: dict):
-        # Prépare les messages pour le format LangChain
-        messages = [HumanMessage(content=m["content"]) if m["role"] == "user" else AIMessage(content=m["content"]) for m in payload["messages"]]
+    def _build_graph(self) -> any:
+        """Construit et compile le graphe d'états."""
+        graph = StateGraph(AgentState)
+        graph.add_node("agent", self._agent_node)
+        graph.add_conditional_edges(
+            "agent",
+            self._router,
+            {"continue": "agent", "end": END}
+        )
+        graph.set_entry_point("agent")
+        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]
         
-        state = {
-            "user_id": payload["user_id"],
-            "job_offer_id": payload["job_offer_id"],
-            "cv_document": payload["cv_document"],
-            "job_offer": payload["job_offer"],
-            "messages": messages,
+        initial_state = {
+            "user_id": self.user_id,
+            "job_offer_id": self.job_offer_id,
+            "messages": langchain_messages,
         }
         
-        final_state = self.graph.invoke(state)
+        final_state = self.graph.invoke(initial_state)
         
-        # Détermine le statut final pour le front-end
         last_message = final_state['messages'][-1]
-        status = "finished" if hasattr(last_message, 'tool_calls') and last_message.tool_calls else "interviewing"
+        status = "finished" if self._router(final_state) == 'end' else "interviewing"
         
         return {
             "response": last_message.content,
             "status": status
-        }
+        }