Update app.py

app.py

@@ -105,136 +105,154 @@ for subject in incomplete_task_list_json["subjects"]:
 
 # 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="""Very short overview of the main topics and concepts to be covered in this section.""",
-    )
+# 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="""Very short 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.",
-    )
+# 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)
+# # 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
-            **Do not generate more than 5 sections**
-            """),
-            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"""
+# 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
+
 
-    # 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.Make sure that a task is completed only when the "task_completed" key is true and the "time" key tells about how much
+# # 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
+#             **Do not generate more than 5 sections**
+#             """),
+#             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.Make sure that a task is completed only when the "task_completed" key is true and the "time" key tells about how much
+#             tentative that task can take time
+#                  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
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+response = client.chat.completions.create(
+    model="gpt-4o-mini",
+    messages=[
+            {"role": "system", "content": """You will be given a JEE student's previous_day_roadmap and then you have to create
+            a completely interactive and useful report for the user. 
+            The report should include a table for task completion rates and data
+            The student's study pattern
+            The student's weaknesses and tips to improve.
+            Make sure that a task is completed only when the "task_completed" key is true and the "time" key tells about how much
             tentative that task can take time
-                 Use markdown formatting."""
-            ),
-            HumanMessage(
-                content=f"Here is the section name: {state['section'].name} and description: {state['section'].description}"
-            ),
+            Use markdown formatting.
+            """},
+            {"role": "user", "content": f"""Here is the user's previous day roadmap in json : {previous_day_roadmap_str}"""}
         ]
     )
-
-    # 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
+output = response.choices[0].message.content
+final_report = output                                                                                   #-->display 2
 
 #Evaluator-optimizer approach
 def remove_the_first_day(roadmap):