Merge pull request #2 from serverdaun/codex/implement-chat-based-ui-with-system-messages

README.md

@@ -24,13 +24,13 @@ license: apache-2.0
 - **Planning**: Suggests up to five web searches to address the query.
 - **Web Search**: Summarizes web results for each planned search.
 - **Report Generation**: Produces a comprehensive markdown report with a summary and follow-up questions.
-- **Interactive UI**: Simple Gradio interface for end-to-end research.
+- **Interactive UI**: Chat-based Gradio interface for end-to-end research.
 
 ## Usage
 
-1. **Input your research topic** in the UI.
-2. **Answer clarifying questions** (if any).
-3. **Run the research** to receive a detailed report.
+1. **Send your research topic** in the chat box.
+2. **Answer the clarifying questions**.
+3. **Receive the detailed report** back in the same conversation.
 
 ## Tech Stack
 
@@ -55,13 +55,17 @@ license: apache-2.0
    ```sh
    pip install uv
    ```
-3. **Install dependencies:**
+3. **Create enviroment and install dependencies:**
    ```sh
-   uv pip install -r pyproject.toml
+   uv sync
+   ```
+4. **Activate the enviroment**
+   ```sh
+   source .venv/bin/activate #.venv/Scripts/activate on Win
    ```
 4. **Run the app:**
    ```sh
-   uv pip run python src/main.py
+   uv run src/main.py
    ```
 
-The app will launch a Gradio interface in your browser.
+The app will launch a Gradio interface that you can access in your browser.

src/main.py

@@ -5,74 +5,93 @@ from research_manager import ResearchManager
 
 load_dotenv()
 
+WELCOME_MESSAGE = (
+    "Welcome to **Deep Research**!\n"
+    "Send me a research topic and I will ask clarifying questions.\n"
+    "Answer them here to receive a detailed report."
+)
 
-async def ask_clarifications(query: str) -> tuple[str, list[str]]:
-    """Generate clarifying questions for *query* and return both a nicely formatted string and the raw list."""
-    manager = ResearchManager()
-    questions = await manager.get_clarifying_questions(query)
 
-    if not questions:
-        return (
-            "No clarifying questions were generated. You can proceed to run the research.",
-            [],
-        )
+def _format_clarifications(questions: list[str]) -> str:
+    return "\n".join(f"{idx + 1}. {q}" for idx, q in enumerate(questions))
 
-    formatted = "\n".join(f"{idx+1}. {q}" for idx, q in enumerate(questions))
-    return formatted, questions
 
+def _build_clarification_block(questions: list[str], answers: str) -> str:
+    lines = [line.strip() for line in answers.split("\n")]
+    while len(lines) < len(questions):
+        lines.append("")
+    return "\n".join(
+        f"Q{idx + 1}: {q}\nA{idx + 1}: {lines[idx]}" for idx, q in enumerate(questions)
+    )
 
-async def run_research(query: str, answers: str, questions: list[str]):
-    """Run the complete research pipeline and stream the markdown report."""
-    clarifications_block = ""
-
-    answer_lines = [line.strip() for line in answers.split("\n")]
-    while len(answer_lines) < len(questions):
-        answer_lines.append("")
-
-    q_and_a = []
-    for idx, question in enumerate(questions):
-        answer = answer_lines[idx]
-        q_and_a.append(f"Q{idx+1}: {question}\nA{idx+1}: {answer}")
-
-    clarifications_block = "\n".join(q_and_a)
 
-    async for chunk in ResearchManager().run(query, clarifications_block):
-        yield chunk
+async def respond(
+    message: str, history: list[dict], state: dict
+):
+    if not state:
+        state = {"stage": "awaiting_query", "query": "", "questions": []}
+
+    history.append({"role": "user", "content": message})
+
+    if state["stage"] == "awaiting_query":
+        state["query"] = message
+        manager = ResearchManager()
+        questions = await manager.get_clarifying_questions(message)
+        state["questions"] = questions
+        if questions:
+            state["stage"] = "awaiting_answers"
+            q_text = _format_clarifications(questions)
+            history.append(
+                {
+                    "role": "assistant",
+                    "content": f"Please answer the following questions, one per line:\n{q_text}",
+                }
+            )
+            yield history, state
+        else:
+            state["stage"] = "running"
+            history.append({"role": "assistant", "content": ""})
+            async for chunk in manager.run(message, ""):
+                history[-1]["content"] = (history[-1]["content"] or "") + chunk
+                yield history, state
+            state["stage"] = "awaiting_query"
+            yield history, state
+    elif state["stage"] == "awaiting_answers":
+        answers_block = _build_clarification_block(state["questions"], message)
+        manager = ResearchManager()
+        state["stage"] = "running"
+        history.append({"role": "assistant", "content": ""})
+        async for chunk in manager.run(state["query"], answers_block):
+            history[-1]["content"] = (history[-1]["content"] or "") + chunk
+            yield history, state
+        state["stage"] = "awaiting_query"
+        yield history, state
+    else:
+        history.append({"role": "assistant", "content": "Please wait for the current task to finish."})
+        yield history, state
+
+
+def reset():
+    return ([{"role": "assistant", "content": WELCOME_MESSAGE}], {
+        "stage": "awaiting_query",
+        "query": "",
+        "questions": [],
+    })
 
 
 with gr.Blocks(theme=gr.themes.Default(primary_hue="yellow")) as ui:
-    gr.Markdown("# Deep Research")
-
-    with gr.Row():
-        query_textbox = gr.Textbox(
-            label="What topic would you like to research?",
-            placeholder="e.g. How to create a Deep Research Agent?",
-        )
-        ask_button = gr.Button("Ask clarifying questions")
-
-    clarifying_questions_state = gr.State([])
-    clarifications_markdown = gr.Markdown(label="Clarifying questions will appear here")
-
-    clarification_answers_box = gr.Textbox(
-        label="Your answers to the clarifying questions (one per line)",
-        placeholder="Answer 1\nAnswer 2\n...",
-        lines=3,
+    chatbot = gr.Chatbot(
+        label="Deep Research",
+        height=500,
+        resizable=True,
+        show_copy_button=True,
+        type="messages",
     )
+    state = gr.State({})
+    msg = gr.Textbox(placeholder="Type your message and press Enter")
 
-    run_button = gr.Button("Run research", variant="primary")
-    report = gr.Markdown(label="Report")
-
-    ask_button.click(
-        fn=ask_clarifications,
-        inputs=query_textbox,
-        outputs=[clarifications_markdown, clarifying_questions_state],
-    )
-
-    run_button.click(
-        fn=run_research,
-        inputs=[query_textbox, clarification_answers_box, clarifying_questions_state],
-        outputs=report,
-    )
+    ui.load(fn=reset, outputs=[chatbot, state])
+    msg.submit(respond, inputs=[msg, chatbot, state], outputs=[chatbot, state])
 
 if __name__ == "__main__":
     ui.launch()