chnage

app/agents/agents.py

@@ -1,5 +1,11 @@
 from langchain_groq import ChatGroq
 from app.schemas.pydanticschema import ResumeExtract,JobDescriptionExtract,SkillGapAnalysis
+from app.core.config import settings
+from app.tools.tools import roadmap_planner_agent_tools
+import os
+
+if "GROQ_API_KEY" not in os.environ:
+    os.environ["GROQ_API_KEY"] = settings.GROQ_API_KEY
 
 resume_agent=ChatGroq(
     model="moonshotai/kimi-k2-instruct-0905",
@@ -14,6 +20,7 @@ resume_agent=resume_agent.with_structured_output(
     include_raw=True,
     strict=True
 )
+
 jd_agent=ChatGroq(
     model="meta-llama/llama-4-scout-17b-16e-instruct",
     temperature=0.2,
@@ -47,4 +54,6 @@ gap_analysis_agent=gap_analysis_agent.with_structured_output(
 roadmap_planner_agent=ChatGroq(
     model="moonshotai/kimi-k2-instruct-0905",
     temperature=0.2,
-)
+)
+
+roadmap_planner_agent=roadmap_planner_agent.bind_tools(roadmap_planner_agent_tools)

app/graph.py

@@ -0,0 +1,43 @@
+
+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
+
+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("skill_gap_analysis", skill_gap_node)
+builder.add_node("roadmap_planning_agent", roadmap_planning_node)
+builder.add_node("tools", tool_node) # Named 'tools' for tools_condition compatibility
+builder.add_node("finalize_state", finalize_state_node)
+
+# Define Entry Point and initial Extraction Parallelism
+builder.set_entry_point("input_node")
+builder.add_edge("input_node", "resume_data_extraction")
+builder.add_edge("input_node", "jd_data_extraction")
+
+# Join Extractions into Gap Analysis
+builder.add_edge("resume_data_extraction", "skill_gap_analysis")
+builder.add_edge("jd_data_extraction", "skill_gap_analysis")
+
+# Transition from Analysis to Planning Agent
+builder.add_edge("skill_gap_analysis", "roadmap_planning_agent")
+
+# Agentic ReAct Loop (Planning Agent <-> Tools)
+builder.add_conditional_edges(
+    "roadmap_planning_agent",
+    tools_condition,
+    {
+        "tools": "tools",            
+        "__end__": "finalize_state"  # tools_condition returns '__end__' when no tools are called
+    }
+)
+
+builder.add_edge("tools", "roadmap_planning_agent")
+builder.add_edge("finalize_state", END)
+
+graph = builder.compile()

app/nodes/graphnodes.py

@@ -1,4 +1,3 @@
-
 from app.state.state import OnboardingState
 from langchain_core.messages import SystemMessage, HumanMessage,ToolMessage,AIMessage
 from app.prompts.resume_agent_prompt import resume_agent_prompt
@@ -8,9 +7,9 @@ from app.agents.agents import resume_agent,jd_agent,roadmap_planner_agent,gap_an
 from app.prompts.gap_analysis_agent_prompt import gap_analysis_agent_prompt
 from app.schemas.pydanticschema import ResumeExtract,JobDescriptionExtract,SkillGapAnalysis
 import json
-
-
+from app.tools.tools import *
 from langchain_community.document_loaders import PyMuPDFLoader
+from langgraph.prebuilt import ToolNode ,tools_condition
 
 def input_node(state: OnboardingState):
 
@@ -194,4 +193,8 @@ def finalize_state_node(state: OnboardingState):
     return {
         "final_roadmap": final_roadmap,
         "mermaid_code": mermaid_code
-    }
+    }
+
+
+
+tool_node = ToolNode(roadmap_planner_agent_tools)

app/tools/tools.py

@@ -0,0 +1,132 @@
+from langchain_core.tools import tool
+from typing import Optional
+from app.utils.vectordatabase import retriever
+from app.schemas.pydanticschema import LearningRoadmap
+import json
+from typing import Dict, List,Any
+
+@tool
+def search_courses(query: str, level: str, category: str):
+    """
+    Search the course catalog for relevant modules based on a skill query, 
+    difficulty level, and technical category.
+    
+    Args:
+        query: The semantic search term (e.g., 'FastAPI', 'PostgreSQL', 'Docker').
+        level: The difficulty level required ('beginner', 'intermediate', or 'strong').
+        category: The technical domain ('Backend', 'Frontend', 'DevOps', 'Cybersecurity', 'Database', 'ML').
+    """
+    
+    # Using the hybrid search logic you perfected
+    # The '$and' ensures the agent gets EXACTLY what fits the candidate's level
+    results = retriever.invoke(
+        query, 
+        filter={
+            "$and": [
+                {"level": level},
+                {"category": category}
+            ]
+        }
+    )
+
+    if not results:
+        return f"No {level} level courses found in the {category} category for '{query}'."
+
+    # Format the output so the Agent can read the metadata easily
+    formatted_output = []
+    for doc in results:
+        course_info = (
+            f"ID: {doc.metadata.get('course_id')}\n"
+            f"Title: {doc.metadata.get('title')}\n"
+            f"Description: {doc.page_content}\n"
+            f"Prerequisites: {doc.metadata.get('prerequisites')}\n"
+            f"Duration: {doc.metadata.get('duration')} hours\n"
+            "---"
+        )
+        formatted_output.append(course_info)
+
+    return "\n".join(formatted_output)
+
+
+
+@tool(args_schema=LearningRoadmap)
+def submit_final_roadmap(candidate_name, target_role, roadmap, onboarding_summary):
+    """
+    STRICTLY call this tool to submit the final structured learning roadmap.
+    This saves the data to the global system and the graph state.
+    """
+    
+    result = {
+        "candidate_name": candidate_name,
+        "target_role": target_role,
+        "onboarding_summary": onboarding_summary,
+        "roadmap": [
+            step.model_dump() if hasattr(step, "model_dump") else step 
+            for step in roadmap
+        ]
+    }
+    
+    
+    
+    # Return to LangGraph (will be stored in state via a post-processing node)
+    return result
+
+
+@tool
+def submit_mermaid_visualization(mermaid_code: str):
+    """
+    STRICTLY call this tool to save the Mermaid.js visualization of the roadmap.
+    """
+    # 1. Tell Python to use the variable from the outer scope
+    
+    
+    # 2. Now this assignment updates the global variable
+    mermaid_roadmap_code = mermaid_code
+    
+    return "Mermaid visualization stored successfully."
+
+
+
+
+
+class CourseLookup:
+    def __init__(self, catalog_path: str = "course_catalog.json"):
+        self.catalog_path = catalog_path
+        self.courses_map = {}
+        self._load_catalog()
+
+    def _load_catalog(self):
+        """Loads the catalog into a dictionary for O(1) lookup speed."""
+        try:
+            with open(self.catalog_path, 'r') as f:
+                catalog = json.load(f)
+                # Key the dictionary by course_id for instant retrieval
+                self.courses_map = {course['course_id']: course for course in catalog}
+        except FileNotFoundError:
+            print(f"Error: {self.catalog_path} not found.")
+        except json.JSONDecodeError:
+            print(f"Error: Failed to decode {self.catalog_path}.")
+
+    def get_course_details(self, course_id: str) -> Optional[Dict[str, Any]]:
+        """Retrieves full details of a course by its ID."""
+        return self.courses_map.get(course_id)
+
+
+lookup_service = CourseLookup("Catalog.json")
+
+@tool
+def get_course_by_id(course_id: str) -> str:
+    """
+    Retrieves full details for a specific course using its unique course_id.
+    Use this tool when you find a prerequisite ID in another course and 
+    need to fetch its title, description, and duration to add to the roadmap.
+    """
+    details = lookup_service.get_course_details(course_id)
+    if not details:
+        return f"Error: Course with ID {course_id} not found in catalog."
+    
+    # Return a clean string for the agent to process
+    return json.dumps(details, indent=2)
+
+
+roadmap_planner_agent_tools=[search_courses, get_course_by_id,submit_final_roadmap,submit_mermaid_visualization]