Update app.py

app.py

@@ -1,431 +1,430 @@
-import json
-import operator
-import os
-import getpass
-from langchain_anthropic import ChatAnthropic
-from langchain_openai import ChatOpenAI
-from typing import Annotated, List
-from pydantic import BaseModel, Field
-from typing_extensions import TypedDict
-from langgraph.graph import StateGraph, START, END
-from IPython.display import Image, display
-from langchain_core.messages import HumanMessage, SystemMessage, ToolMessage
-from langgraph.graph import MessagesState
-from typing_extensions import Literal
-from langchain_core.tools import tool
-import json
-from datetime import datetime, timedelta
-import streamlit as st
-
-st.set_page_config(layout="wide")
-
-st.title("RoadMap Test")
-
-
-# # setting LLM
-# def _set_env(var: str):
-#     if not os.environ.get(var):
-#         os.environ[var] = getpass.getpass(f"{var}: ")
-
-
-# _set_env("ANTHROPIC_API_KEY")
-
-os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
-
-llm = ChatOpenAI(model="gpt-4o-mini")
-
-
-with open('fourdayRoadmap.json', 'r') as file:
-    data = json.load(file)  # Load JSON content into a Python dictionary                                                   -->display 1
-
-
-data_old = data            # Added for stramlit app,not the part of actual code 
-
-#Intermediate Step : Add variables task_completed as false and completion_timestamp as null
-for day in data["schedule"]:
-    for subject in day["subjects"]:
-        for task in subject["tasks"]:
-            task["task_completed"] = False
-            task["completion_timestamp"] = None
-
-# Step 2 : Extract The previous day from the extracted roadmap
-previous_day = data["schedule"][0]
-previous_day_roadmap_str = str(previous_day)
-
-#Step 3 : Extract the incompleted tasks
-# Extract incomplete tasks
-incomplete_tasks = {
-    "dayNumber": previous_day["dayNumber"],
-    "date": previous_day["date"],
-    "subjects": []
-}
-
-for subject in previous_day["subjects"]:
-    incomplete_subject_tasks = [
-        {
-            "ChapterName": task["ChapterName"],
-            "type": task["type"],
-            "subtopic": task["subtopic"],
-            "time": task["time"],
-            "task_completed": False,
-            "completion_timestamp": None
-        }
-        for task in subject["tasks"] if not task["task_completed"]
-    ]
-
-    if incomplete_subject_tasks:
-        incomplete_tasks["subjects"].append({
-            "name": subject["name"],
-            "tasks": incomplete_subject_tasks
-        })
-
-# Convert to JSON format
-incomplete_tasks_json = json.dumps(incomplete_tasks, indent=4)
-
-#Generate a incomplete_tasks_list for the the agent 2
-# Extract incomplete tasks
-incomplete_task_list = []
-incomplete_task_list_json = json.loads(incomplete_tasks_json)
-for subject in incomplete_task_list_json["subjects"]:
-    for task in subject["tasks"]:
-        if not task["task_completed"]:
-            incomplete_task = {
-                "subject": subject["name"],
-                "ChapterName": task["ChapterName"],
-                "type": task["type"],
-                "subtopic": task["subtopic"],
-                "time": task["time"],
-                "task_completed": task["task_completed"],
-                "completion_timestamp": task["completion_timestamp"]
-            }
-            incomplete_task_list.append(incomplete_task)
-
-#Now we have to make an Orchestrator - worker workflow which generates a report on the roadmap data and defining sections which are most relevant and so giving a report
-
-
-# Schema for structured output to use in planning
-
-class Section(BaseModel):  # This part defines the structure of a single section of the report, saying that it should return a field name and a description
-    name: str = Field(
-        description="Name for this section of the report.",
-    )
-    description: str = Field(
-        description="Brief overview of the main topics and concepts to be covered in this section.",
-    )
-
-
-class Sections(BaseModel): # This part defines what has to be the output of the llm
-    sections: List[Section] = Field(
-        description="Sections of the report.",
-    )
-
-
-# Augment the LLM with schema for structured output
-planner = llm.with_structured_output(Sections)
-
-from langgraph.constants import Send
-
-# This is a state which defines all params that we need to collect in this WF
-# Graph state
-class State(TypedDict):
-    previous_day_roadmap: str  # Report topic
-    sections: list[Section]  # List of report sections
-    completed_sections: Annotated[
-        list, operator.add
-    ]  # All workers write to this key in parallel
-    final_report: str  # Final report
-
-
-# Worker state
-class WorkerState(TypedDict):
-    section: Section
-    completed_sections: Annotated[list, operator.add]
-
-
-# Nodes
-def orchestrator(state: State):
-    """Orchestrator that generates a plan for the report"""
-
-    # Generate queries
-    report_sections = planner.invoke(
-        [
-            SystemMessage(content="""Generate a plan for the report. The report is a review and analysis output, which tells us about
-            the study pattern, studying hours, non studying hours and future action plan for the user based on
-            performance of task completion on a day of the user. We only want to understand about how the student studies nothing apart from that
-            Dont halucinate the data, just keep focus on provided data, no need for data out of the box.
-            I want a very short report to understand how many tasks student completed and then what is the studying pattern of the user
-            """),
-            HumanMessage(content=f"Here is the Previous day roadmap of the user: {state['previous_day_roadmap']}"),
-        ]
-    )
-
-    return {"sections": report_sections.sections}
-
-
-def llm_call(state: WorkerState):
-    """Worker writes a section of the report"""
-
-    # Generate section
-    section = llm.invoke(
-        [
-            SystemMessage(
-                content="""Write a report section following the provided name and description. Make this report userful for parents, teachers
-                 and students himself, also try to motivate the student.This report is for a Joint Entrance Examination aspirant.
-                 Keep the report very short but will all clear parameter and make sure the report is not so big but contains all the necessary
-                 details of the student's day. Keep the report very short and avoid texts and focus on numbers
-                 Include no preamble for each section.
-                 Use markdown formatting."""
-            ),
-            HumanMessage(
-                content=f"Here is the section name: {state['section'].name} and description: {state['section'].description}"
-            ),
-        ]
-    )
-
-    # Write the updated section to completed sections
-    return {"completed_sections": [section.content]}
-
-
-def synthesizer(state: State):
-    """Synthesize full report from sections"""
-
-    # List of completed sections
-    completed_sections = state["completed_sections"]
-
-    # Format completed section to str to use as context for final sections
-    completed_report_sections = "\n\n---\n\n".join(completed_sections)
-
-    return {"final_report": completed_report_sections}
-
-
-# Conditional edge function to create llm_call workers that each write a section of the report
-def assign_workers(state: State):
-    """Assign a worker to each section in the plan"""
-
-    # Kick off section writing in parallel via Send() API
-    return [Send("llm_call", {"section": s}) for s in state["sections"]]
-
-
-# Build workflow
-orchestrator_worker_builder = StateGraph(State)
-
-# Add the nodes
-orchestrator_worker_builder.add_node("orchestrator", orchestrator)
-orchestrator_worker_builder.add_node("llm_call", llm_call)
-orchestrator_worker_builder.add_node("synthesizer", synthesizer)
-
-# Add edges to connect nodes
-orchestrator_worker_builder.add_edge(START, "orchestrator")
-orchestrator_worker_builder.add_conditional_edges(
-    "orchestrator", assign_workers, ["llm_call"]
-)
-orchestrator_worker_builder.add_edge("llm_call", "synthesizer")
-orchestrator_worker_builder.add_edge("synthesizer", END)
-
-# Compile the workflow
-orchestrator_worker = orchestrator_worker_builder.compile()
-
-# # Show the workflow
-# display(Image(orchestrator_worker.get_graph().draw_mermaid_png()))
-
-# Invoke
-state = orchestrator_worker.invoke({"previous_day_roadmap": f"{previous_day_roadmap_str}"})
-
-from IPython.display import Markdown
-final_report = state["final_report"]                                                                                    #-->display 2
-
-#Evaluator-optimizer approach
-def remove_the_first_day(roadmap):
-  new_roadmap={
-      "schedule":[
-
-      ]
-  }
-  for day in roadmap['schedule']:
-    if day['dayNumber']!=1:
-      new_roadmap['schedule'].append(day)
-  return new_roadmap
-
-roadmap = remove_the_first_day(data)
-
-available_dates = []
-for day in roadmap['schedule']:
-  available_dates.append(day['date'])
-print(available_dates)
-
-# Graph state
-class State(TypedDict):
-    roadmap: dict
-    student_report: str
-    available_dates: dict
-    incomplete_task_list: list
-    feedback: str
-    added_or_not: str
-
-
-# Schema for structured output to use in evaluation
-class Feedback(BaseModel):
-    grade: Literal["added", "not added"] = Field(
-        description="Check if all the incomplete tasks are added to the roadmap or not",
-    )
-    feedback: str = Field(
-        description="If some tasks are not not added, give feedback to add those tasks also",
-    )
-
-
-# Augment the LLM with schema for structured output
-evaluator = llm.with_structured_output(Feedback)
-
-
-# Nodes
-def llm_call_generator(state: State):
-    """The function which addes the roadmap and incomplete tasks list to the state"""
-    roadmap_str = """
-    {
-      'roadmap':[
-        'date':'YYYY-MM-DD',
-        'tasks':[
-          <List of tasks>
-        ]
-      ]
-    }
-    """
-    if state.get("feedback"):
-        msg = llm.invoke(
-            f"""Add the following incomplete_tasks {state['incomplete_task_list']} to the roadmap key and take into account the feedback {state['feedback']}
-            and make sure that we dyanamically add the tasks not increasing the load on just one day, also we have to add the tasks on
-            following dates only {state['available_dates']} only also we need to focus on student's performance report while adding tasks {state['student_report']}
-            Make sure you only give roadmap json as output and nothing else, strictly follow the output structure {roadmap_str}
-            """
-        )
-    else:
-      ## In this case we have to just add the roadmap and incomplete tasks list to the state
-      msg = llm.invoke(f"""Add the following incomplete_tasks {state['incomplete_task_list']} to the roadmap key
-            and make sure that we dyanamically add the tasks not increasing the load on just one day, also we have to add the tasks on
-            following dates only {state['available_dates']} only also we need to focus on student's performance report while adding tasks {state['student_report']}\
-            Make sure you only give roadmap json as output and nothing else, strictly follow the output structure {roadmap_str}
-            """)
-    return {"roadmap": msg.content}
-
-
-def llm_call_evaluator(state: State):
-    """This the evaluator that checks where all the tasks are added to the roadmap or not"""
-    grade = evaluator.invoke(f"Grade the roadmap {state['roadmap']} by checking the {state['incomplete_task_list']} as all added or not and make sure that we dyanamically add the tasks not increasing the load on just one day, also we need to make sure that we return an roadmap with proper json format as the roadmap was")
-    return {"added_or_not": grade.grade, "feedback": grade.feedback}
-
-
-# Conditional edge function to route back to joke generator or end based upon feedback from the evaluator
-def route_roadmap(state: State):
-    """Route back to the generator if  roadmap does not have all the incomplete tasks"""
-    if state["added_or_not"] == "added":
-        return "Accepted"
-    elif state["added_or_not"] == "not added":
-        return "Rejected + Feedback"
-
-
-# Build workflow
-optimizer_builder = StateGraph(State)
-
-# Add the nodes
-optimizer_builder.add_node("llm_call_generator", llm_call_generator)
-optimizer_builder.add_node("llm_call_evaluator", llm_call_evaluator)
-
-# Add edges to connect nodes
-optimizer_builder.add_edge(START, "llm_call_generator")
-optimizer_builder.add_edge("llm_call_generator", "llm_call_evaluator")
-optimizer_builder.add_conditional_edges(
-    "llm_call_evaluator",
-    route_roadmap,
-    {  # Name returned by route_roadmap : Name of next node to visit
-        "Accepted": END,
-        "Rejected + Feedback": "llm_call_generator",
-    },
-)
-
-# Compile the workflow
-optimizer_workflow = optimizer_builder.compile()
-
-# # Show the workflow
-# display(Image(optimizer_workflow.get_graph().draw_mermaid_png()))
-
-# Invoke
-state = optimizer_workflow.invoke({"student_report":final_report,"available_dates": available_dates, "incomplete_task_list":incomplete_task_list})
-shifted_tasks_roadmap = state["roadmap"]    
-shifted_tasks_roadmap = shifted_tasks_roadmap.split("json")[1].split("```")[0]                                                                    
-print(shifted_tasks_roadmap)
-
-
-#Now we merge the shifted roadmap
-def add_task(roadmap, task, date_task_to_be_added):
-    subject_name = task["subject"]  # Extract subject
-    chapter_name = task["ChapterName"]
-    topic_name = task["subtopic"]
-    type_name = task["type"]
-
-    # Check if the date exists
-    for day in roadmap['schedule']:
-        if day['date'] == date_task_to_be_added:
-            for subject in day['subjects']:
-                if subject['name'] == subject_name:
-                    # Check if task already exists
-                    for existing_task in subject['tasks']:
-                        if existing_task['ChapterName'] == chapter_name and existing_task['type'] == type_name and existing_task['subtopic'] == topic_name:
-                            return roadmap  # Task already exists, return unchanged roadmap
-
-                    # Add task
-                    temp_task = {
-                        "ChapterName": chapter_name,
-                        "type": type_name,
-                        "topic": topic_name,
-                        "time": task["time"],
-                        "task_completed": False,
-                        "completion_timestamp": None
-                    }
-                    subject['tasks'].append(temp_task)
-                    return roadmap  # Return updated roadmap
-                
-for day in json.loads(shifted_tasks_roadmap)["roadmap"]:
-  date = day['date']
-  tasks = day['tasks']
-  for task in tasks:
-    add_task(data,task,date)
-
-
-
-
-#stramlit section 
-
-# Initialize session state for page navigation if it doesn't exist
-if "page" not in st.session_state:
-    st.session_state["page"] = 1
-
-def show_page_1():
-    st.title("Roadmaps")
-
-    col1, col2 = st.columns([1, 1])  
-
-    with col1:
-        st.subheader("Original Roadmap")
-        st.json(data_old)
-
-    with col2:
-        st.subheader("Roadmap with Shifted Task")
-        st.json(data)
-
-
-def show_page_2():
-    st.title("Report")
-    st.markdown(final_report)
-
-# Navigation
-st.sidebar.title("Navigation")
-if st.sidebar.button("Roadmaps Page"):
-    st.session_state["page"] = 1
-if st.sidebar.button("Report Page"):
-    st.session_state["page"] = 2
-
-# Display content based on the current page
-if st.session_state["page"] == 1:
-    show_page_1()
-elif st.session_state["page"] == 2:
+import json
+import operator
+import os
+import getpass
+from langchain_openai import ChatOpenAI
+from typing import Annotated, List
+from pydantic import BaseModel, Field
+from typing_extensions import TypedDict
+from langgraph.graph import StateGraph, START, END
+from IPython.display import Image, display
+from langchain_core.messages import HumanMessage, SystemMessage, ToolMessage
+from langgraph.graph import MessagesState
+from typing_extensions import Literal
+from langchain_core.tools import tool
+import json
+from datetime import datetime, timedelta
+import streamlit as st
+
+st.set_page_config(layout="wide")
+
+st.title("RoadMap Test")
+
+
+# # setting LLM
+# def _set_env(var: str):
+#     if not os.environ.get(var):
+#         os.environ[var] = getpass.getpass(f"{var}: ")
+
+
+# _set_env("ANTHROPIC_API_KEY")
+
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
+
+llm = ChatOpenAI(model="gpt-4o-mini")
+
+
+with open('fourdayRoadmap.json', 'r') as file:
+    data = json.load(file)  # Load JSON content into a Python dictionary                                                   -->display 1
+
+
+data_old = data            # Added for stramlit app,not the part of actual code 
+
+#Intermediate Step : Add variables task_completed as false and completion_timestamp as null
+for day in data["schedule"]:
+    for subject in day["subjects"]:
+        for task in subject["tasks"]:
+            task["task_completed"] = False
+            task["completion_timestamp"] = None
+
+# Step 2 : Extract The previous day from the extracted roadmap
+previous_day = data["schedule"][0]
+previous_day_roadmap_str = str(previous_day)
+
+#Step 3 : Extract the incompleted tasks
+# Extract incomplete tasks
+incomplete_tasks = {
+    "dayNumber": previous_day["dayNumber"],
+    "date": previous_day["date"],
+    "subjects": []
+}
+
+for subject in previous_day["subjects"]:
+    incomplete_subject_tasks = [
+        {
+            "ChapterName": task["ChapterName"],
+            "type": task["type"],
+            "subtopic": task["subtopic"],
+            "time": task["time"],
+            "task_completed": False,
+            "completion_timestamp": None
+        }
+        for task in subject["tasks"] if not task["task_completed"]
+    ]
+
+    if incomplete_subject_tasks:
+        incomplete_tasks["subjects"].append({
+            "name": subject["name"],
+            "tasks": incomplete_subject_tasks
+        })
+
+# Convert to JSON format
+incomplete_tasks_json = json.dumps(incomplete_tasks, indent=4)
+
+#Generate a incomplete_tasks_list for the the agent 2
+# Extract incomplete tasks
+incomplete_task_list = []
+incomplete_task_list_json = json.loads(incomplete_tasks_json)
+for subject in incomplete_task_list_json["subjects"]:
+    for task in subject["tasks"]:
+        if not task["task_completed"]:
+            incomplete_task = {
+                "subject": subject["name"],
+                "ChapterName": task["ChapterName"],
+                "type": task["type"],
+                "subtopic": task["subtopic"],
+                "time": task["time"],
+                "task_completed": task["task_completed"],
+                "completion_timestamp": task["completion_timestamp"]
+            }
+            incomplete_task_list.append(incomplete_task)
+
+#Now we have to make an Orchestrator - worker workflow which generates a report on the roadmap data and defining sections which are most relevant and so giving a report
+
+
+# Schema for structured output to use in planning
+
+class Section(BaseModel):  # This part defines the structure of a single section of the report, saying that it should return a field name and a description
+    name: str = Field(
+        description="Name for this section of the report.",
+    )
+    description: str = Field(
+        description="Brief overview of the main topics and concepts to be covered in this section.",
+    )
+
+
+class Sections(BaseModel): # This part defines what has to be the output of the llm
+    sections: List[Section] = Field(
+        description="Sections of the report.",
+    )
+
+
+# Augment the LLM with schema for structured output
+planner = llm.with_structured_output(Sections)
+
+from langgraph.constants import Send
+
+# This is a state which defines all params that we need to collect in this WF
+# Graph state
+class State(TypedDict):
+    previous_day_roadmap: str  # Report topic
+    sections: list[Section]  # List of report sections
+    completed_sections: Annotated[
+        list, operator.add
+    ]  # All workers write to this key in parallel
+    final_report: str  # Final report
+
+
+# Worker state
+class WorkerState(TypedDict):
+    section: Section
+    completed_sections: Annotated[list, operator.add]
+
+
+# Nodes
+def orchestrator(state: State):
+    """Orchestrator that generates a plan for the report"""
+
+    # Generate queries
+    report_sections = planner.invoke(
+        [
+            SystemMessage(content="""Generate a plan for the report. The report is a review and analysis output, which tells us about
+            the study pattern, studying hours, non studying hours and future action plan for the user based on
+            performance of task completion on a day of the user. We only want to understand about how the student studies nothing apart from that
+            Dont halucinate the data, just keep focus on provided data, no need for data out of the box.
+            I want a very short report to understand how many tasks student completed and then what is the studying pattern of the user
+            """),
+            HumanMessage(content=f"Here is the Previous day roadmap of the user: {state['previous_day_roadmap']}"),
+        ]
+    )
+
+    return {"sections": report_sections.sections}
+
+
+def llm_call(state: WorkerState):
+    """Worker writes a section of the report"""
+
+    # Generate section
+    section = llm.invoke(
+        [
+            SystemMessage(
+                content="""Write a report section following the provided name and description. Make this report userful for parents, teachers
+                 and students himself, also try to motivate the student.This report is for a Joint Entrance Examination aspirant.
+                 Keep the report very short but will all clear parameter and make sure the report is not so big but contains all the necessary
+                 details of the student's day. Keep the report very short and avoid texts and focus on numbers
+                 Include no preamble for each section.
+                 Use markdown formatting."""
+            ),
+            HumanMessage(
+                content=f"Here is the section name: {state['section'].name} and description: {state['section'].description}"
+            ),
+        ]
+    )
+
+    # Write the updated section to completed sections
+    return {"completed_sections": [section.content]}
+
+
+def synthesizer(state: State):
+    """Synthesize full report from sections"""
+
+    # List of completed sections
+    completed_sections = state["completed_sections"]
+
+    # Format completed section to str to use as context for final sections
+    completed_report_sections = "\n\n---\n\n".join(completed_sections)
+
+    return {"final_report": completed_report_sections}
+
+
+# Conditional edge function to create llm_call workers that each write a section of the report
+def assign_workers(state: State):
+    """Assign a worker to each section in the plan"""
+
+    # Kick off section writing in parallel via Send() API
+    return [Send("llm_call", {"section": s}) for s in state["sections"]]
+
+
+# Build workflow
+orchestrator_worker_builder = StateGraph(State)
+
+# Add the nodes
+orchestrator_worker_builder.add_node("orchestrator", orchestrator)
+orchestrator_worker_builder.add_node("llm_call", llm_call)
+orchestrator_worker_builder.add_node("synthesizer", synthesizer)
+
+# Add edges to connect nodes
+orchestrator_worker_builder.add_edge(START, "orchestrator")
+orchestrator_worker_builder.add_conditional_edges(
+    "orchestrator", assign_workers, ["llm_call"]
+)
+orchestrator_worker_builder.add_edge("llm_call", "synthesizer")
+orchestrator_worker_builder.add_edge("synthesizer", END)
+
+# Compile the workflow
+orchestrator_worker = orchestrator_worker_builder.compile()
+
+# # Show the workflow
+# display(Image(orchestrator_worker.get_graph().draw_mermaid_png()))
+
+# Invoke
+state = orchestrator_worker.invoke({"previous_day_roadmap": f"{previous_day_roadmap_str}"})
+
+from IPython.display import Markdown
+final_report = state["final_report"]                                                                                    #-->display 2
+
+#Evaluator-optimizer approach
+def remove_the_first_day(roadmap):
+  new_roadmap={
+      "schedule":[
+
+      ]
+  }
+  for day in roadmap['schedule']:
+    if day['dayNumber']!=1:
+      new_roadmap['schedule'].append(day)
+  return new_roadmap
+
+roadmap = remove_the_first_day(data)
+
+available_dates = []
+for day in roadmap['schedule']:
+  available_dates.append(day['date'])
+print(available_dates)
+
+# Graph state
+class State(TypedDict):
+    roadmap: dict
+    student_report: str
+    available_dates: dict
+    incomplete_task_list: list
+    feedback: str
+    added_or_not: str
+
+
+# Schema for structured output to use in evaluation
+class Feedback(BaseModel):
+    grade: Literal["added", "not added"] = Field(
+        description="Check if all the incomplete tasks are added to the roadmap or not",
+    )
+    feedback: str = Field(
+        description="If some tasks are not not added, give feedback to add those tasks also",
+    )
+
+
+# Augment the LLM with schema for structured output
+evaluator = llm.with_structured_output(Feedback)
+
+
+# Nodes
+def llm_call_generator(state: State):
+    """The function which addes the roadmap and incomplete tasks list to the state"""
+    roadmap_str = """
+    {
+      'roadmap':[
+        'date':'YYYY-MM-DD',
+        'tasks':[
+          <List of tasks>
+        ]
+      ]
+    }
+    """
+    if state.get("feedback"):
+        msg = llm.invoke(
+            f"""Add the following incomplete_tasks {state['incomplete_task_list']} to the roadmap key and take into account the feedback {state['feedback']}
+            and make sure that we dyanamically add the tasks not increasing the load on just one day, also we have to add the tasks on
+            following dates only {state['available_dates']} only also we need to focus on student's performance report while adding tasks {state['student_report']}
+            Make sure you only give roadmap json as output and nothing else, strictly follow the output structure {roadmap_str}
+            """
+        )
+    else:
+      ## In this case we have to just add the roadmap and incomplete tasks list to the state
+      msg = llm.invoke(f"""Add the following incomplete_tasks {state['incomplete_task_list']} to the roadmap key
+            and make sure that we dyanamically add the tasks not increasing the load on just one day, also we have to add the tasks on
+            following dates only {state['available_dates']} only also we need to focus on student's performance report while adding tasks {state['student_report']}\
+            Make sure you only give roadmap json as output and nothing else, strictly follow the output structure {roadmap_str}
+            """)
+    return {"roadmap": msg.content}
+
+
+def llm_call_evaluator(state: State):
+    """This the evaluator that checks where all the tasks are added to the roadmap or not"""
+    grade = evaluator.invoke(f"Grade the roadmap {state['roadmap']} by checking the {state['incomplete_task_list']} as all added or not and make sure that we dyanamically add the tasks not increasing the load on just one day, also we need to make sure that we return an roadmap with proper json format as the roadmap was")
+    return {"added_or_not": grade.grade, "feedback": grade.feedback}
+
+
+# Conditional edge function to route back to joke generator or end based upon feedback from the evaluator
+def route_roadmap(state: State):
+    """Route back to the generator if  roadmap does not have all the incomplete tasks"""
+    if state["added_or_not"] == "added":
+        return "Accepted"
+    elif state["added_or_not"] == "not added":
+        return "Rejected + Feedback"
+
+
+# Build workflow
+optimizer_builder = StateGraph(State)
+
+# Add the nodes
+optimizer_builder.add_node("llm_call_generator", llm_call_generator)
+optimizer_builder.add_node("llm_call_evaluator", llm_call_evaluator)
+
+# Add edges to connect nodes
+optimizer_builder.add_edge(START, "llm_call_generator")
+optimizer_builder.add_edge("llm_call_generator", "llm_call_evaluator")
+optimizer_builder.add_conditional_edges(
+    "llm_call_evaluator",
+    route_roadmap,
+    {  # Name returned by route_roadmap : Name of next node to visit
+        "Accepted": END,
+        "Rejected + Feedback": "llm_call_generator",
+    },
+)
+
+# Compile the workflow
+optimizer_workflow = optimizer_builder.compile()
+
+# # Show the workflow
+# display(Image(optimizer_workflow.get_graph().draw_mermaid_png()))
+
+# Invoke
+state = optimizer_workflow.invoke({"student_report":final_report,"available_dates": available_dates, "incomplete_task_list":incomplete_task_list})
+shifted_tasks_roadmap = state["roadmap"]    
+shifted_tasks_roadmap = shifted_tasks_roadmap.split("json")[1].split("```")[0]                                                                    
+print(shifted_tasks_roadmap)
+
+
+#Now we merge the shifted roadmap
+def add_task(roadmap, task, date_task_to_be_added):
+    subject_name = task["subject"]  # Extract subject
+    chapter_name = task["ChapterName"]
+    topic_name = task["subtopic"]
+    type_name = task["type"]
+
+    # Check if the date exists
+    for day in roadmap['schedule']:
+        if day['date'] == date_task_to_be_added:
+            for subject in day['subjects']:
+                if subject['name'] == subject_name:
+                    # Check if task already exists
+                    for existing_task in subject['tasks']:
+                        if existing_task['ChapterName'] == chapter_name and existing_task['type'] == type_name and existing_task['subtopic'] == topic_name:
+                            return roadmap  # Task already exists, return unchanged roadmap
+
+                    # Add task
+                    temp_task = {
+                        "ChapterName": chapter_name,
+                        "type": type_name,
+                        "topic": topic_name,
+                        "time": task["time"],
+                        "task_completed": False,
+                        "completion_timestamp": None
+                    }
+                    subject['tasks'].append(temp_task)
+                    return roadmap  # Return updated roadmap
+                
+for day in json.loads(shifted_tasks_roadmap)["roadmap"]:
+  date = day['date']
+  tasks = day['tasks']
+  for task in tasks:
+    add_task(data,task,date)
+
+
+
+
+#stramlit section 
+
+# Initialize session state for page navigation if it doesn't exist
+if "page" not in st.session_state:
+    st.session_state["page"] = 1
+
+def show_page_1():
+    st.title("Roadmaps")
+
+    col1, col2 = st.columns([1, 1])  
+
+    with col1:
+        st.subheader("Original Roadmap")
+        st.json(data_old)
+
+    with col2:
+        st.subheader("Roadmap with Shifted Task")
+        st.json(data)
+
+
+def show_page_2():
+    st.title("Report")
+    st.markdown(final_report)
+
+# Navigation
+st.sidebar.title("Navigation")
+if st.sidebar.button("Roadmaps Page"):
+    st.session_state["page"] = 1
+if st.sidebar.button("Report Page"):
+    st.session_state["page"] = 2
+
+# Display content based on the current page
+if st.session_state["page"] == 1:
+    show_page_1()
+elif st.session_state["page"] == 2:
     show_page_2()