changes

app/graph.py

@@ -2,15 +2,21 @@ from app.state.state import OnboardingState
 from app.nodes.graphnodes import *
 from langgraph.prebuilt import ToolNode ,tools_condition
 from langgraph.graph import StateGraph,END,START
+from langgraph.types import RetryPolicy
 
 
+node_retry = RetryPolicy(
+    max_attempts=3,
+    initial_interval=1.5,
+    retry_on=[ConnectionError]
+)
 
 builder = StateGraph(OnboardingState)
 
 # Define Nodes
 builder.add_node("input_node", input_node)
 builder.add_node("resume_data_extraction", extractResumeDataNode)
-builder.add_node("jd_data_extraction", extractJDDataNode)
+builder.add_node("jd_data_extraction", extractJDDataNode ,retry_policy=node_retry)
 builder.add_node("skill_gap_analysis", skill_gap_node)
 
 # The ReAct Agent Node

app/main.py

@@ -5,7 +5,6 @@ from app.utils.ui_payload_constructor import UIPayload
 from app.graph import graph
 from app.utils.cloudinary_utils import get_resume_url
  
- 
 app = FastAPI(title="Adaptive Onboarding Engine")
  
 app.add_middleware(
@@ -15,7 +14,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
  
- 
 @app.post("/analyze")
 async def analyze(
     user_id: str = Form(..., description="User ID — used to fetch resume from Cloudinary"),
@@ -68,6 +66,6 @@ def health():
     return {"status": "ok", "service": "Adaptive Onboarding Engine"}
  
  
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="127.0.0.1", port=8000)
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="127.0.0.1", port=8000)

app/nodes/graphnodes.py

@@ -1,22 +1,25 @@
 from app.state.state import OnboardingState
-from langchain_core.messages import SystemMessage, HumanMessage,ToolMessage,AIMessage
+from langchain_core.messages import SystemMessage, HumanMessage, ToolMessage, AIMessage
 from app.prompts.resume_agent_prompt import resume_agent_prompt
 from app.prompts.jd_agent_prompt import jd_agent_prompt
 from app.prompts.roadmap_planner_agent_prompt import roadmap_planner_agent_prompt
-from app.agents.agents import resume_agent,jd_agent,roadmap_planner_agent,gap_analysis_agent
+from app.agents.agents import resume_agent, jd_agent, roadmap_planner_agent, gap_analysis_agent, roadmap_planner_agent_tools
 from app.prompts.gap_analysis_agent_prompt import gap_analysis_agent_prompt
 import json
+import logging
 from app.tools.tools import *
 from langchain_community.document_loaders import PyMuPDFLoader
-from langgraph.prebuilt import ToolNode ,tools_condition
+from langgraph.prebuilt import ToolNode, tools_condition
 from app.schemas.jd_extract_schema import JobDescriptionExtract
 from app.schemas.resume_extract_schema import ResumeExtract
 from app.schemas.skill_gap_analysis_schema import SkillGapAnalysis
 
+logger = logging.getLogger(__name__)
 
-def input_node(state: OnboardingState):
 
-    file_path = state.get("file_path") 
+def input_node(state: OnboardingState):
+    """Load and extract text from resume PDF."""
+    file_path = state.get("file_path")
 
     if not file_path:
         return {"extraction_error": "Missing file_path in state"}
@@ -24,8 +27,6 @@ def input_node(state: OnboardingState):
     try:
         loader = PyMuPDFLoader(file_path)
         docs = loader.load()
-
-        
         resume_text = "\n".join([doc.page_content for doc in docs])
 
         return {
@@ -34,13 +35,14 @@ def input_node(state: OnboardingState):
         }
 
     except Exception as e:
+        logger.error(f"Failed to load resume: {str(e)}")
         return {
             "extraction_error": f"Failed to load resume: {str(e)}"
         }
-    
+
 
 def extractResumeDataNode(state: OnboardingState):
-    
+    """Extract structured resume data using resume agent."""
     resume_text = state["resume_text"]
 
     messages = [
@@ -48,105 +50,104 @@ def extractResumeDataNode(state: OnboardingState):
         HumanMessage(content=f"<resume_text>{resume_text}</resume_text>")
     ]
 
-    
     result = resume_agent.invoke(messages)
 
     return {"resume_data": result["parsed"]}
 
 
 def extractJDDataNode(state: OnboardingState):
-    # 1. Safety Check: Is the text even in the state?
+    """Extract structured job description data using JD agent."""
     jd_text = state.get("job_description", "")
-    
+
     if not jd_text or len(jd_text.strip()) < 5:
-        print("DEBUGGER ERROR: job_description text is MISSING from state!")
+        logger.warning("job_description text is missing from state")
         return {"JobDescriptionExtract_data": JobDescriptionExtract()}
 
-    print(f"DEBUGGER: Sending {len(jd_text)} characters to JD Agent...")
+    logger.info(f"Extracting JD from {len(jd_text)} characters")
 
     messages = [
         SystemMessage(content=jd_agent_prompt),
-        HumanMessage(content=f"EXTRACT FROM THIS TEXT:\n\n{jd_text}")
+        HumanMessage(content=f"<job_description>{jd_text}</job_description>")
     ]
 
     try:
-        # 2. Invoke the agent
         result = jd_agent.invoke(messages)
-        
-        # 3. Handle the 'parsed' key (ensure your chain is configured correctly)
-        # If result is already the Pydantic object, use it directly.
-        # If result is a dict with 'parsed', use result['parsed'].
         parsed_data = result.get("parsed") if isinstance(result, dict) else result
 
-        # 4. Critical Check: Did it actually find anything?
         if parsed_data.job_title is None and parsed_data.tools_technologies is None:
-            print("DEBUGGER WARNING: LLM returned empty schema! Checking prompt...")
+            logger.warning("JD extraction returned empty schema")
         else:
-            print(f"DEBUGGER SUCCESS: Extracted {parsed_data.job_title}")
+            logger.info(f"Successfully extracted job title: {parsed_data.job_title}")
 
         return {"JobDescriptionExtract_data": parsed_data}
-        
+
     except Exception as e:
-        print(f"DEBUGGER CRITICAL: Invoke failed: {str(e)}")
+        logger.error(f"JD extraction failed: {str(e)}")
         return {"JobDescriptionExtract_data": JobDescriptionExtract()}
-    
-
 
 
 def skill_gap_node(state: OnboardingState):
-    
-    resume_data = state["resume_data"] 
-    candidate_name = state["candidate_name"]
-    
-    # To remove noise and reduce size  of the prompt.
-    lean_resume_dict = resume_data.model_dump(
-       exclude_none=True # Bonus: Automatically drops any fields that are None/null!
-    )
-
-    raw_jd = state["JobDescriptionExtract_data"]
-    
-    # Strip the HR noise and text bloat
-    lean_jd_dict = raw_jd.model_dump(
-       exclude_none=True # Drops any null fields
-    )
-    
-    lean_resume_json = json.dumps(lean_resume_dict, indent=2)
+    """Analyze skill gaps between resume and job description."""
+    resume_data = state["resume_data"]
+    candidate_name = state.get("candidate_name", "Candidate")
 
+    # Convert Pydantic models to lean dicts (exclude None values)
+    lean_resume_dict = resume_data.model_dump(exclude_none=True)
+    lean_jd_dict = state["JobDescriptionExtract_data"].model_dump(exclude_none=True)
 
+    # Serialize to JSON
+    lean_resume_json = json.dumps(lean_resume_dict, indent=2)
     lean_jd_json = json.dumps(lean_jd_dict, indent=2)
 
+    # Clean prompt with proper formatting
+    prompt_text = f"""Analyze the skill gaps for the following candidate:
+
+Candidate Name: {candidate_name}
+
+Resume:
+{lean_resume_json}
+
+Job Description:
+{lean_jd_json}
+
+Please provide a detailed skill gap analysis."""
+
     messages = [
         SystemMessage(content=gap_analysis_agent_prompt),
-        HumanMessage(content=f"Users Resume:UserName:<candidate_name>{candidate_name}</candidate_name> Resume:<lean_resume_json>{lean_resume_json}</lean_resume_json> Job Description:<lean_jd_json>{lean_jd_json}</lean_jd_json>"),
-        
+        HumanMessage(content=prompt_text)
     ]
 
-    
-    result = gap_analysis_agent.invoke(messages)
-
-    return {"skill_gap_analysis_data": result["parsed"]}
-
+    try:
+        result = gap_analysis_agent.invoke(messages)
+        return {"skill_gap_analysis_data": result["parsed"]}
 
+    except Exception as e:
+        logger.error(f"Skill gap analysis failed: {str(e)}")
+        return {"skill_gap_analysis_data": SkillGapAnalysis()}
 
 
 def roadmap_planning_node(state: OnboardingState):
     """
-    The agent's 'thinking' node. It looks at the Skill Gaps and 
-    decides which tool to call next.
+    Plan learning roadmap based on skill gaps.
+    This node decides which tools to call next based on the analysis.
     """
     skill_gap_data = state["skill_gap_analysis_data"]
 
-    skill_gap_data= skill_gap_data.model_dump()
+    # Convert Pydantic model to dict, then to JSON
+    skill_gap_dict = skill_gap_data.model_dump()
+    skill_gap_json = json.dumps(skill_gap_dict, indent=2)
 
     system_prompt = SystemMessage(content=roadmap_planner_agent_prompt)
-    input_msg = HumanMessage(content=f"<skill_gap_data> {skill_gap_data} </skill_gap_data>")
-    
-    response = roadmap_planner_agent.invoke([system_prompt, input_msg] + state["messages"])
+    input_msg = HumanMessage(content=f"<skill_gap_analysis>\n{skill_gap_json}\n</skill_gap_analysis>")
 
-    
-    
-    return {"messages": [response]}
+    try:
+        response = roadmap_planner_agent.invoke([system_prompt, input_msg] + state.get("messages", []))
+        return {"messages": [response]}
 
+    except Exception as e:
+        logger.error(f"Roadmap planning failed: {str(e)}")
+        return {"messages": [AIMessage(content=f"Error in roadmap planning: {str(e)}")]}
 
 
-tool_node = ToolNode(roadmap_planner_agent_tools)
+# Initialize tool node for roadmap planner
+tool_node = ToolNode(roadmap_planner_agent_tools)

app/schemas/resume_extract_schema.py

@@ -8,22 +8,6 @@ class Skill(BaseModel):
     )
 
 
-class ExperienceItem(BaseModel):
-    job_title: str = Field(
-        ...,
-        description="Role title of the candidate. Example: 'Backend Intern', 'Software Engineer'"
-    )
-
-    technologies: Optional[List[str]] = Field(
-        default_factory=list,
-        description="Technologies, tools, or frameworks used in this role"
-    )
-
-    responsibilities: Optional[List[str]] = Field(
-        default_factory=list,
-        description="Key responsibilities, tasks, or learnings in concise bullet points keep it summarised detail *not* required"
-    )
-
 class ProjectItem(BaseModel):
     name: str = Field(..., description="Project name")
     technologies: List[str] = Field(
@@ -52,32 +36,14 @@ class ResumeExtract(BaseModel):
        )
     )
 
-  
-
-   
     skills: List[Skill] = Field(
         default_factory=list,
         description="Skills explicitly listed by the candidate"
     )
-    experience: List[ExperienceItem] = Field(
-        default_factory=list,
-        description=(
-            "Each role as a separate entry. "
-            "No company name needed — focus on what was done and learned."
-        )
-    )
+
     projects: List[ProjectItem] = Field(
         default_factory=list,
         description="Projects with technologies used and what was built"
     )
 
 
-
-    is_fresher: bool = Field(
-    ...,
-    description=(
-        "Set to True if the candidate lacks full-time professional employment. "
-        "Academic projects, certifications, and internships are considered "
-        "part of the learning phase and do not qualify a candidate as 'non-fresher' hence is_."
-    )
-)

app/schemas/skill_gap_analysis_schema.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Literal
 class SkillGap(BaseModel):
     skill_name: str = Field(
         ..., 
-        description="The specific technology or tool missing or requiring an upgrade (e.g., 'PostgreSQL')"
+        description="The specific  tool missing or requiring an upgrade (e.g., 'Docker')"
     )
     
     gap_type: Literal["missing_foundation", "needs_advanced_upgrade"] = Field(
@@ -24,7 +24,6 @@ class SkillGap(BaseModel):
     reasoning: str = Field(
         ...,
         description=(
-            "The 'Reasoning Trace'. This MUST be provided for every skill gap identified. "
             "Explain exactly WHY this gap was flagged based on the resume vs JD comparison. "
             "Example: 'JD requires FastAPI; candidate has Python experience but no record of using FastAPI framework.'"
         )

app/{graph_trial.py → test.py}

@@ -33,9 +33,7 @@ initial_input = {
     "resume_data": None,
     "extraction_error": None,
     "JobDescriptionExtract_data": None,
-    "skill_gap_analysis_data": None
-    
-    
+    "skill_gap_analysis_data": None   
 }
 
 
@@ -47,7 +45,21 @@ config = {"configurable": {"thread_id": THREAD_ID}}
 # final_result = graph.invoke(initial_input, config=config)
 
 
-# print(final_result)
+# print(final_result['resume_data'])
+
+# print()
+
+# print(final_result['JobDescriptionExtract_data'])
+
+# print()
+
+# print(final_result['skill_gap_analysis_data'])
+
+
+# print()
+
+
+# print(final_result['final_roadmap'])