Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,6 @@
+data/
+env/
+app.ipynb
+test.md
+__pycache__/
+.env

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,14 +1,6 @@
 ---
-title: Dahee AI
-emoji: 👁
-colorFrom: red
-colorTo: pink
+title: Dahee_AI
+app_file: gradio_app.py
 sdk: gradio
-sdk_version: 5.23.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: Math Question Preparer
+sdk_version: 5.22.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,474 @@
+from langgraph.graph import StateGraph, MessagesState, END, START
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_core.messages import SystemMessage
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_experimental.utilities.python import PythonREPL
+
+from pinecone import Pinecone
+
+from typing import List, Annotated
+from pydantic import BaseModel, Field
+from IPython.display import Image, display
+import operator
+import prompts
+
+# set environment variables
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+llm = ChatOpenAI(model="gpt-4o", temperature=0)
+weak_llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)
+
+
+class QuestionState(MessagesState):
+    topic: str  # topic of the question
+    subtopic: str  # subtopic of the question
+    difficulty: str  # difficulty of the question
+    description: str  # description of the subtopic
+    context: Annotated[list, operator.add]  # knowledge base of the subtopic
+    relevant_questions: List[dict]  # relevant questions
+    num_questions: int  # number of relevant questions to extract
+    human_feedback: str  # feedback from the human
+    question: str  # question to ask
+    steps: List[str]  # steps to solve the question
+    tool_requests: List[dict]  # tool requests to solve the question
+    tool_results: List[dict]  # tool results to solve the question
+    verified: bool  # if the solution is verified
+    solution: str  # solution to the question
+    answer: str  # answer to the question
+
+
+# -------------------------------
+# Node 1: Generate Description Node
+# -------------------------------
+def generate_description(state: QuestionState):
+    """
+    Generate a description for the subtopic
+    """
+    topic = state["topic"]
+    subtopic = state["subtopic"]
+
+    # generate description
+    system_message = prompts.DESCRIPTION_INSTRUCTION.format(
+        topic=topic, subtopic=subtopic
+    )
+    description = weak_llm.invoke(
+        [SystemMessage(content=system_message)], max_tokens=30
+    ).content
+
+    # write description to state
+    return {"description": description}
+
+
+# -------------------------------
+# Node 2: Search Wikipedia Node
+# -------------------------------
+def search_wikipedia(state: QuestionState):
+    """
+    Search wikipedia for the topic and subtopic
+    """
+
+    subtopic = state["subtopic"]
+
+    search_query = f"What is {subtopic}"
+
+    # search wikipedia
+    search_docs = WikipediaLoader(
+        query=search_query, load_max_docs=1, doc_content_chars_max=1500
+    ).load()
+
+    # Format
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+
+    return {"context": [formatted_search_docs]}
+
+
+# -------------------------------
+# Node 3: Search Document Node
+# -------------------------------
+def search_document(state: QuestionState):
+    """
+    Search the document for relevant context
+    """
+
+    topic = state["topic"]
+    subtopic = state["subtopic"]
+
+    # Initialize OpenAI Embeddings client
+    client = OpenAIEmbeddings(model="text-embedding-3-large")
+
+    query = f"Search about {topic} in area of {subtopic}"
+    embedded_query = client.embed_query(query)
+
+    # Initialize Pinecone client
+    api_key = os.environ.get("PINECONE_API_KEY")
+    pc = Pinecone(api_key=api_key)
+
+    # 2. Vector DB query with metadata filter
+    index_name = os.environ.get("PINECONE_INDEX_NAME")
+    index = pc.Index(index_name)
+
+    filters = {
+        "topic": {"$eq": topic},
+        "subtopic": {"$eq": subtopic},
+        "type": {"$eq": "description"},
+    }
+
+    # Execute similarity search
+    try:
+        results = index.query(
+            vector=embedded_query,
+            filter=filters,
+            top_k=1,  # Get top 5 similar questions
+            include_metadata=True,
+        )
+    except Exception as e:
+        raise ConnectionError(f"Vector DB query failed: {str(e)}")
+
+    # Get the context
+    if results and hasattr(results, "matches") and len(results.matches) > 0:
+        context = results.matches[0].metadata.get("context", "")
+        return {"context": [context]}
+    else:
+        return {"context": []}
+
+
+# -------------------------------
+# Node 4: Search Questions Node
+# -------------------------------
+def search_questions(state: QuestionState):
+    """
+    Search the document for relevant questions
+    """
+
+    topic = state["topic"]
+    subtopic = state["subtopic"]
+    num_questions = state["num_questions"]
+    difficulty = state["difficulty"]
+
+    # Initialize OpenAI Embeddings client
+    client = OpenAIEmbeddings(model="text-embedding-3-large")
+
+    query = f"Questions related to {topic} in area of {subtopic}"
+    embedded_query = client.embed_query(query)
+
+    # Initialize Pinecone client
+    api_key = os.environ.get("PINECONE_API_KEY")
+    pc = Pinecone(api_key=api_key)
+
+    # 2. Vector DB query with metadata filter
+    index_name = os.environ.get("PINECONE_INDEX_NAME")
+    index = pc.Index(index_name)
+
+    filters = {
+        "topic": {"$eq": topic},
+        "subtopic": {"$eq": subtopic},
+        "type": {"$eq": "question"},
+        "difficulty": {"$eq": difficulty},
+    }
+
+    # Execute similarity search
+    try:
+        results = index.query(
+            vector=embedded_query,
+            filter=filters,
+            top_k=num_questions,
+            include_metadata=True,
+        )
+    except Exception as e:
+        raise ConnectionError(f"Vector DB query failed: {str(e)}")
+
+    references = []
+    for match in results.matches:
+        metadata = match.metadata
+        references.append(
+            {
+                "question": metadata["question"],
+                "answer": metadata["answer"],
+                "difficulty": metadata["difficulty"],
+            }
+        )
+
+    return {"relevant_questions": references}
+
+
+# -------------------------------
+# Node 5: Generate Question Node
+# -------------------------------
+def generate_question(state: QuestionState):
+    """
+    Generate a question for the subtopic
+    """
+    topic = state["topic"]
+    subtopic = state["subtopic"]
+    difficulty = state["difficulty"]
+    context = state["context"]
+    relevant_questions = state["relevant_questions"]
+    human_feedback = state.get("human_feedback", "")
+
+    # generate question
+    query = prompts.QUESTION_INSTRUCTION.format(
+        topic=topic,
+        subtopic=subtopic,
+        difficulty=difficulty,
+        context=context,
+        relevant_questions=relevant_questions,
+        feedback=human_feedback,
+    )
+    question = llm.invoke([SystemMessage(content=query)], temperature=0.3).content
+
+    # Clean residual markdown formatting
+    question = question.strip().strip("`").replace("**Question:**", "").strip()
+
+    print("Generated Question: ", question)
+    # write question to state
+    return {"question": question}
+
+
+# -------------------------------
+# Node 6: Feedback Node
+# -------------------------------
+def human_feedback(state: QuestionState):
+    """No-op node that shoulds be interrupted on"""
+    print("Human Feedback Node: ", state)
+    pass
+
+
+def should_continue(state: QuestionState):
+    """Return the next node to execute"""
+    print("Should Continue: ", state)
+    # Check if human feedback
+    human_feedback = state.get("human_feedback", None)
+    if human_feedback:
+        return "generate_question"
+
+    # Otherwise end
+    return "llm_step_planner"
+
+
+# -------------------------------
+# Node 7: LLM Step Planner
+# -------------------------------
+class SolutionPlan(BaseModel):
+    solution_steps: List[str] = Field(description="List of steps to solve the problem")
+
+
+def llm_step_planner(state: QuestionState):
+    question = state["question"]
+    try:
+        prompt = prompts.STEP_INSTRUCTION.format(question=question)
+        structured_llm = llm.with_structured_output(SolutionPlan)
+        steps = structured_llm.invoke([SystemMessage(content=prompt)])
+        print("Steps", steps)
+
+        return {"steps": steps.solution_steps}
+
+    except Exception as e:
+        return {"error": f"LLM Parsing Error: {str(e)}"}
+
+
+# -------------------------------
+# Node 8: LLM Tool Decider
+# -------------------------------
+class ToolRequest(BaseModel):
+    code: str = Field(description="Python code to execute")
+    description: str = Field(description="Description of the code")
+
+
+class ToolRequestList(BaseModel):
+    tool_requests: List[ToolRequest] = Field(description="List of tool requests")
+
+
+def llm_tool_decider(state: QuestionState):
+    if "error" in state and state["error"]:
+        return state  # Pass through error
+
+    try:
+        question = state["question"]
+        steps = state.get("steps", [])
+
+        prompt = prompts.TOOL_INSTRUCTION.format(question=question, steps=steps)
+
+        structured_llm = llm.with_structured_output(ToolRequestList)
+        tool_requests = structured_llm.invoke(
+            [SystemMessage(content=prompt)], max_tokens=500, temperature=0.2
+        )
+        print("Tool Requests", tool_requests)
+        return {
+            "tool_requests": [req.model_dump() for req in tool_requests.tool_requests]
+        }
+    except Exception as e:
+        return {"error": f"LLM Tool Decider Error: {str(e)}"}
+
+
+# -------------------------------
+# Node 9: LLM Tool Executor
+# -------------------------------
+code_executor = PythonREPL()
+
+
+def tool_executor(state: QuestionState):
+    if "error" in state and state["error"]:
+        return state
+
+    try:
+        tool_results = []
+        for req in state.get("tool_requests", []):
+            print("Req", req)
+            if req.get("type", "sympy") == "sympy":  # default to sympy
+                try:
+                    output = code_executor.run(req["code"])  # Executes full code
+                    tool_results.append(
+                        {
+                            "description": req.get("description", ""),
+                            "result": output.strip(),
+                        }
+                    )
+                except Exception as e:
+                    tool_results.append(
+                        {
+                            "description": req.get("description", ""),
+                            "result": f"Execution Error: {str(e)}",
+                        }
+                    )
+            else:
+                tool_results.append(
+                    {
+                        "description": f"Unknown tool type: {req.get('type')}",
+                        "result": None,
+                    }
+                )
+        print("Tool Results", tool_results)
+        return {"tool_results": tool_results}
+    except Exception as e:
+        return {"error": f"Tool Execution Error: {str(e)}"}
+
+
+# -------------------------------
+# Node 10: LLM Verifier
+# -------------------------------
+class VerifierResponse(BaseModel):
+    verified: bool = Field(description="Whether the solution is verified")
+    explanation: str = Field(description="Explanation for verification decision")
+
+
+def llm_verifier(state: QuestionState):
+    if "error" in state and state["error"]:
+        return state
+
+    try:
+        question = state["question"]
+        steps = state.get("steps", [])
+        tool_results = state.get("tool_results", [])
+
+        prompt = prompts.VERIFICATION_INSTRUCTION.format(
+            question=question, steps=steps, tool_results=tool_results
+        )
+
+        structured_llm = weak_llm.with_structured_output(VerifierResponse)
+        verification_results = structured_llm.invoke(
+            [SystemMessage(content=prompt)], max_tokens=500
+        ).model_dump()
+        result = False
+        if verification_results.get("verified", False):
+            result = True
+        else:
+            result = False
+        return {
+            "verified": result,
+            "error": (
+                None
+                if result
+                else f"Verification Failed: {verification_results.get('explanation', 'No explanation')}"
+            ),
+        }
+    except Exception as e:
+        return {"error": f"LLM Verifier Error: {str(e)}"}
+
+
+# -------------------------------
+# Node 11: LLM Finalizer
+# -------------------------------
+class FinalizerResponse(BaseModel):
+    solution: str = Field(description="Markdown solution")
+    answer: str = Field(description="Final answer")
+
+
+def llm_finalizer(state: QuestionState):
+    if "error" in state and state["error"]:
+        state["solution"] = f"### Error\n{state['error']}"
+        state["answer"] = "N/A"
+        return state
+
+    try:
+        question = state["question"]
+        steps = state.get("steps", [])
+        tool_results = state.get("tool_results", [])
+        verified = state.get("verified", False)
+
+        prompt = prompts.FINALIZE_INSTRUCTION.format(
+            question=question,
+            steps=steps,
+            tool_results=tool_results,
+            verified=verified,
+        )
+        structured_llm = llm.with_structured_output(FinalizerResponse)
+        final_response = structured_llm.invoke(
+            [SystemMessage(content=prompt)], max_tokens=1000, temperature=0.2
+        )
+
+        return {"solution": final_response.solution, "answer": final_response.answer}
+    except Exception as e:
+        return {"solution": f"### Finalization Error\n{str(e)}", "answer": "N/A"}
+
+
+# -------------------------------
+# Graph Construction
+# -------------------------------
+builder = StateGraph(QuestionState)
+builder.add_node("generate_description", generate_description)
+# builder.add_node("search_wikipedia", search_wikipedia)
+builder.add_node("search_document", search_document)
+builder.add_node("search_questions", search_questions)
+builder.add_node("generate_question", generate_question)
+builder.add_node("feedback", human_feedback)
+builder.add_node("llm_step_planner", llm_step_planner)
+builder.add_node("llm_tool_decider", llm_tool_decider)
+builder.add_node("tool_executor", tool_executor)
+builder.add_node("llm_verifier", llm_verifier)
+builder.add_node("llm_finalizer", llm_finalizer)
+
+# Add edges
+builder.add_edge(START, "generate_description")
+# builder.add_edge("generate_description", "search_wikipedia")
+builder.add_edge("generate_description", "search_document")
+builder.add_edge("generate_description", "search_questions")
+# builder.add_edge("search_wikipedia", "generate_question")
+builder.add_edge("search_document", "generate_question")
+builder.add_edge("search_questions", "generate_question")
+builder.add_edge("generate_question", "feedback")
+builder.add_conditional_edges(
+    "feedback", should_continue, ["generate_question", "llm_step_planner"]
+)
+# builder.add_edge("generate_question", "llm_step_planner")
+builder.add_edge("llm_step_planner", "llm_tool_decider")
+builder.add_edge("llm_tool_decider", "tool_executor")
+builder.add_edge("tool_executor", "llm_verifier")
+builder.add_edge("llm_verifier", "llm_finalizer")
+builder.add_edge("llm_finalizer", END)
+
+# Compile
+memory = MemorySaver()
+question_graph = builder.compile(interrupt_before=["feedback"], checkpointer=memory)
+question_graph.name = "QuestionGenerationGraph"
+# question_graph = builder.compile(checkpointer=memory)
+
+# display(Image(question_graph.get_graph(xray=1).draw_mermaid_png()))

gradio_app.py

@@ -0,0 +1,189 @@
+import gradio as gr
+from app import question_graph, MemorySaver
+import uuid
+
+
+# -----------------------------
+# In-Memory Storage for Feedback Flow
+# -----------------------------
+session_data = {}
+
+
+# -----------------------------
+# Graph Invocation Function
+# -----------------------------
+def run_graph(topic, subtopic, difficulty):
+    session_id = str(uuid.uuid4())  # Unique session per question
+    memory = MemorySaver()
+
+    inputs = {
+        "topic": topic,
+        "subtopic": subtopic,
+        "difficulty": difficulty,
+        "description": "",
+        "num_questions": 3,
+        "messages": [],
+        "context": [],
+        "relevant_questions": [],
+        "question": "",
+        "steps": [],
+        "tool_requests": [],
+        "tool_results": [],
+        "verified": False,
+        "solution": "",
+        "answer": "",
+        "error": "",
+        "human_feedback": "",
+    }
+
+    # Run up to feedback node (interrupt point)
+    partial_result = question_graph.invoke(
+        inputs, config={"configurable": {"thread_id": session_id}}
+    )
+    session_data[session_id] = {
+        "memory": memory,
+        "inputs": partial_result,  # Store intermediate state
+    }
+
+    generated_question = partial_result.get("question", "No question generated.")
+    return (
+        session_id,
+        generated_question,
+        "Enter feedback if needed, or click 'Solve Question'.",
+    )
+
+
+# -----------------------------
+# Handle Feedback and Rerun Graph
+# -----------------------------
+def handle_feedback(session_id, feedback_text):
+    data = session_data.get(session_id)
+    if not data:
+        return session_id, "Session expired or invalid.", ""
+
+    memory = data["memory"]
+    feedback_text = feedback_text.strip()
+    thread = {"configurable": {"thread_id": session_id}}
+
+    if feedback_text:
+        # Update state with feedback at node 'feedback'
+        question_graph.update_state(
+            thread, {"human_feedback": feedback_text}, as_node="feedback"
+        )
+
+        # Continue from feedback
+        final_result = question_graph.invoke(
+            None, config={"configurable": {"thread_id": session_id}}
+        )
+
+        new_question = final_result.get("question", "No question generated.")
+        session_data[session_id]["inputs"] = final_result
+
+        if final_result.get("steps"):
+            return session_id, new_question, "Proceeding to solve question..."
+        else:
+            return (
+                session_id,
+                new_question,
+                "Feedback applied. Refine again or click 'Solve Question'.",
+            )
+    else:
+        # No feedback provided, proceed immediately
+        question_graph.update_state(
+            thread,
+            {"human_feedback": None},
+            as_node="feedback",
+        )
+
+        final_result = question_graph.invoke(
+            None, config={"configurable": {"thread_id": session_id}}
+        )
+
+        solution_md = final_result.get("solution", "No solution generated.")
+        answer = final_result.get("answer", "No answer.")
+        return session_id, solution_md, answer
+
+
+# -----------------------------
+# Solve Question – Full Graph Run
+# -----------------------------
+def solve_question(session_id):
+    data = session_data.get(session_id)
+    thread = {"configurable": {"thread_id": session_id}}
+    if not data:
+        return "Session expired or invalid.", "", ""
+
+    state = data["inputs"]
+    memory = data["memory"]
+
+    question_graph.update_state(
+        thread,
+        {"human_feedback": None},
+        as_node="feedback",
+    )
+
+    final_result = question_graph.invoke(
+        None, config={"configurable": {"thread_id": session_id}}
+    )
+
+    print("Final Result", final_result)
+    solution_md = final_result.get("solution", "No solution generated.")
+    answer = final_result.get("answer", "No answer.")
+    return solution_md, answer
+
+
+# -----------------------------
+# Gradio UI Layout
+# -----------------------------
+with gr.Blocks(title="LangGraph Math Solver") as demo:
+    gr.Markdown(
+        "## 🧠 Dahee AI\nInput your topic and generate math questions, provide feedback, and get step-by-step solutions."
+    )
+
+    with gr.Row():
+        topic_input = gr.Textbox(label="Topic", placeholder="e.g., Combinatorics")
+        subtopic_input = gr.Textbox(
+            label="Subtopic", placeholder="e.g., Enumerative combinatorics"
+        )
+        difficulty_input = gr.Dropdown(
+            label="Difficulty", choices=["easy", "medium", "hard"], value="medium"
+        )
+
+    generate_btn = gr.Button("Generate Question")
+    question_output = gr.Markdown(label="Generated Question", render=True)
+    feedback_note = gr.Textbox(
+        label="Feedback (Optional)", placeholder="Enter feedback to refine question..."
+    )
+
+    with gr.Row():
+        feedback_btn = gr.Button("Submit Feedback")
+        solve_btn = gr.Button("Solve Question")
+
+    solution_output = gr.Markdown(label="Solution (Markdown)", render=True)
+    final_answer = gr.Markdown(label="Final Answer", render=True)
+
+    # Hidden session ID
+    session_state = gr.State()
+
+    # Events
+    generate_btn.click(
+        run_graph,
+        inputs=[topic_input, subtopic_input, difficulty_input],
+        outputs=[session_state, question_output, feedback_note],
+    )
+
+    feedback_btn.click(
+        handle_feedback,
+        inputs=[session_state, feedback_note],
+        outputs=[session_state, question_output, feedback_note],
+    )
+
+    solve_btn.click(
+        solve_question, inputs=[session_state], outputs=[solution_output, final_answer]
+    )
+
+# -----------------------------
+# Launch App
+# -----------------------------
+if __name__ == "__main__":
+    demo.launch()

prompts.py

@@ -0,0 +1,108 @@
+"""Default prompts"""
+
+DESCRIPTION_INSTRUCTION = """Generate a short description for the topic {subtopic} in the area of {topic}. 
+
+Your goal is to generate a short, concise, well-structured description to the topic.
+
+It will be used to used as query in retrieval and / or web-search
+
+Keep the description concise and limited to one or two sentences.
+"""
+
+QUESTION_INSTRUCTION = """As a teacher creating a quiz question on the topic of {subtopic} within the field of {topic}, your task is to analyze the context, review relevant questions, and craft a question that meets the following criteria:
+
+Type: The question should be conceptual and/or technical question, not a factual question.
+Relevance: The question must be related to the specified topic and subtopic.
+Similarity: If relevant questions are provided, your question should be similar to them.
+Difficulty: Ensure that the question aligns with the stated difficulty level and is of similar complexity to the provided questions.
+Clarity: The question should be straightforward and concise.
+Uniqueness: Your question should be distinctive and not a direct replica of the relevant questions, although you can modify parameters and numbers from them.
+
+Examine any feedback provided and adjust your question accordingly.
+{feedback}
+
+List of relevant questions:
+{relevant_questions}
+
+Difficulty Level: {difficulty}
+
+Format your question in markdown syntax (e.g., **bold**, `code`, or *italic* for emphasis). 
+**Do NOT include:** 
+- Backticks (```) or code blocks 
+- Prefixes like "Question:" 
+- Any extra text beyond the question itself.
+
+Example of valid formatting:
+What is value $x$ if $\sqrt{{3x-1}} + (1+x)^2 = 13$ 
+"""
+
+
+STEP_INSTRUCTION = """
+You are a helpful math tutor. Given the following math question, break it down into clear, logical steps needed to solve it. 
+
+Guidelines:
+- Write each step as a **concise string** in a numbered list.
+- If a step requires a **precise calculation** (e.g., solving an equation, evaluating an expression), end the step with: **(Calculation needed)**
+- Do **not perform any calculations** or write code.
+
+Example Output:
+[
+"Step 1: Step 1: Define variables",
+"Step 2: Simplify the equation.",
+"Step 3: Solve the simplified equation for x. (Calculation needed)",
+"Step 4: Verify the solution."
+]
+
+Question: {question}
+
+Respond with a Python list of strings.
+"""
+
+
+TOOL_INSTRUCTION = """
+You are a math assistant. Given the problem and the step-by-step plan, review each step to determine if it needs an exact calculation.
+
+For steps needing calculation:
+- Generate Python code using **SymPy**.
+- Always assign the final value to a variable named `result`.
+- Always include **print(result)** at the end.
+- Provide a clear description of what the code does.
+
+Only generate code **aligned with the step** requiring it.
+
+Problem: {question}
+Steps: {steps}
+
+Respond in JSON with key 'tool_requests' as a list of objects:
+[
+{{"code": "Python code here", "description": "What it calculates"}}
+]
+
+If no step needs calculation, return an empty list.
+"""
+
+VERIFICATION_INSTRUCTION = """
+You are a math tutor. Review the following problem-solving steps and the results of calculations.
+
+Question: {question}
+Steps: {steps}
+Tool Results: {tool_results}
+
+Check if the steps and results are mathematically correct and consistent.
+"""
+
+
+FINALIZE_INSTRUCTION = """
+You are a math tutor. Given the problem, steps, and calculation results, write a clear and concise Markdown solution.
+
+Include:
+- Step-by-step solution
+- Final answer (boxed or highlighted)
+
+Question: {question}
+Steps: {steps}
+Tool Results: {tool_results}
+Verified: {verified}
+
+Respond in markdown format. ALWAYS write mathematical equations in between dollar signs (e.g., $x^2$).
+"""