Update services/graph_service.py

services/graph_service.py

@@ -5,12 +5,12 @@ 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, SystemMessage
+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, _final_analysis_node
+from tools.analysis_tools import trigger_interview_analysis
 
 class AgentState(TypedDict):
     messages: Annotated[Sequence[BaseMessage], lambda x, y: x + y]
@@ -38,7 +38,7 @@ class GraphInterviewProcessor:
         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.")
@@ -75,34 +75,15 @@ class GraphInterviewProcessor:
         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 _should_continue(self, state: AgentState) -> str:
-        """
-        Détermine si l'entretien doit continuer ou se terminer.
-        """
-        messages = state.get('messages', [])
-        last_message = messages[-1]
-        if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
-            for tool_call in last_message.tool_calls:
-                if tool_call.get('name') == 'trigger_interview_analysis':
-                    print("Condition de fin détectée : appel à trigger_interview_analysis.")
-                    return "end" 
-        return "continue"
-
     def _agent_node(self, state: AgentState):
         """Prépare le prompt et appelle le runnable de l'agent."""
-
-        context_header = (
-            f"--- CONTEXTE TECHNIQUE POUR L'AGENT (ne pas mentionner à l'utilisateur) ---\n"
-            f"L'ID de l'utilisateur actuel est : {state['user_id']}\n"
-            f"L'ID de l'offre d'emploi actuelle est : {state['job_offer_id']}\n"
-            f"Quand tu appelleras l'outil 'trigger_interview_analysis', tu devras OBLIGATOIREMENT utiliser ces IDs exacts.\n"
-            f"--- FIN DU CONTEXTE TECHNIQUE ---\n\n"
-        )
         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'),
@@ -112,60 +93,50 @@ class GraphInterviewProcessor:
             cv=self.formatted_cv_str,
             skills_analysis=self.skills_summary,
             reconversion_analysis=self.reconversion_info,
-            job_description=job_description_str,
-            user_id=state['user_id'],
-            job_offer_id=state['job_offer_id'],
+            job_description=job_description_str
         )
         
-        final_system_prompt = context_header + system_prompt_content
-        job_description = json.dumps(self.job_offer)
-
         response = self.agent_runnable.invoke({
-            "system_prompt_content": final_system_prompt,
-            "messages": state["messages"],
-            "job_description": job_description 
+            "system_prompt_content": system_prompt_content,
+            "messages": state["messages"]
         })
-        return {
-            "messages": [response],
-            "job_description": job_description_str
-        }
+
+        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.
-        - Si un outil d'analyse final est appelé, termine le graphe.
-        - Si un autre outil est appelé, va au noeud d'outils.
-        - Sinon, termine le tour de conversation.
-        """
+        """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):
-                print(">>> Routeur : Appel à l'outil final détecté. Terminaison du graphe.")
                 return "call_final_tool"
             return "call_tool"
         return "end_turn"
-'''
-    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", tool_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 _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])
@@ -199,7 +170,7 @@ class GraphInterviewProcessor:
         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,
@@ -212,7 +183,6 @@ class GraphInterviewProcessor:
         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