Update app.py

app.py

@@ -1,32 +1,15 @@
-"""qResearch: Autonomous Research Assistant v2.1"""
+"""qResearch v3.0: Dual-Agent Research System"""
 
-import argparse
-import json
 import os
-import threading
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional
-
-import datasets
-import pandas as pd
-from dotenv import load_dotenv
 import gradio as gr
+from dotenv import load_dotenv
+from smolagents import CodeAgent, HfApiModel, Tool
 
-from smolagents import (
-    CodeAgent,
-    HfApiModel,
-    ToolCallingAgent,
-    Tool
-)
-from smolagents.agent_types import AgentText, AgentImage, AgentAudio
-
-# Configuration setup
+# Initialize environment
 load_dotenv(override=True)
 
 class DuckDuckGoSearchTool(Tool):
-    """Enhanced web search tool with MLA formatting"""
+    """Web search tool for primary research"""
     name = "web_search"
     description = "Performs privacy-focused web searches using DuckDuckGo"
     inputs = {
@@ -37,81 +20,132 @@ class DuckDuckGoSearchTool(Tool):
 
     def forward(self, query: str, max_results: int = 5) -> str:
         from duckduckgo_search import DDGS
-        
         with DDGS() as ddgs:
             results = list(ddgs.text(query, max_results=max_results))
-        
-        formatted_results = [
-            f"{idx+1}. {result['title']}\n"
-            f"   URL: {result['href']}\n"
-            f"   Summary: {result['body']}\n"
-            for idx, result in enumerate(results)
-        ]
-        return "## Web Research Results\n" + "\n".join(formatted_results)
+        return "\n".join([f"{idx+1}. {r['title']} ({r['href']}): {r['body']}" 
+                         for idx, r in enumerate(results)])
 
 class ResearchSystem:
     def __init__(self):
+        # Shared model configuration
         self.model = HfApiModel(
             model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
             custom_role_conversions={"tool-call": "assistant", "tool-response": "user"},
             use_auth_token=False,
             trust_remote_code=True
         )
-        self.agent = CodeAgent(
+        
+        # Initialize Researcher Agent
+        self.researcher = CodeAgent(
             tools=[DuckDuckGoSearchTool()],
-            model=self.model
+            model=self.model,
+            system_prompt="""You are a Senior Research Analyst. Your tasks:
+1. Conduct comprehensive web research using available tools
+2. Synthesize findings into a detailed draft report
+3. Include all relevant sources and data points
+4. Maintain raw factual accuracy without formatting"""
+        )
+        
+        # Initialize Formatter Agent
+        self.formatter = CodeAgent(
+            tools=[],
+            model=self.model,
+            system_prompt="""You are an MLA Formatting Specialist. Your tasks:
+1. Receive raw research content
+2. Apply proper MLA 9th edition formatting
+3. Verify citation integrity
+4. Structure content with: 
+   - Header block
+   - Title capitalization
+   - In-text citations
+   - Works Cited section
+5. Ensure academic tone and clarity"""
         )
-        self.file_storage = "research_documents"
-        os.makedirs(self.file_storage, exist_ok=True)
 
-    def _format_mla(self, content: str) -> str:
-        return f"{content}\n\n*Research conducted using qResearch AI system (qResearch, 2024)*"
+    def _process_research(self, query: str) -> str:
+        """Execute two-stage research process"""
+        # Stage 1: Initial research
+        raw_response = self.researcher.run(
+            task=f"Conduct research about: {query}",
+            temperature=0.7
+        )
+        
+        # Stage 2: MLA formatting
+        formatted_response = self.formatter.run(
+            task=f"Format this research into MLA:\n{raw_response}",
+            temperature=0.3
+        )
+        
+        return formatted_response
 
     def create_interface(self):
-        with gr.Blocks(theme=gr.themes.Default(), title="qResearch") as interface:
-            gr.Markdown("# qResearch\n*Open Source Intelligence Platform*")
+        with gr.Blocks(theme=gr.themes.Soft(), title="qResearch v3") as interface:
+            gr.Markdown("# qResearch Dual-Agent System\n*Research → Analysis → MLA Formatting*")
             
             with gr.Row():
-                chat_history = gr.Chatbot(
-                    label="Research Dialogue",
-                    avatar_images=(None, "/assets/logo.png"),
-                    height=600
-                )
-                research_output = gr.Markdown("# Analysis Results\n*Your findings will appear here*")
+                with gr.Column(scale=2):
+                    chat_history = gr.Chatbot(
+                        label="Agent Communication",
+                        avatar_images={
+                            "user": "👤",
+                            "assistant": "🤖",
+                            "Researcher": "🔍",
+                            "Formatter": "✒️"
+                        },
+                        height=500
+                    )
+                    
+                with gr.Column(scale=1):
+                    research_steps = gr.JSON(
+                        label="Processing Steps",
+                        value={"Current Stage": "Awaiting Input"}
+                    )
             
             with gr.Row():
                 input_box = gr.Textbox(
-                    placeholder="Enter your research question...",
-                    lines=3,
-                    max_lines=6,
+                    placeholder="Enter research topic...",
+                    lines=2,
                     label="Research Query"
                 )
-                submit_btn = gr.Button("Begin Analysis", variant="primary")
+                submit_btn = gr.Button("Start Research", variant="primary")
             
             submit_btn.click(
-                self.process_query,
+                self._handle_query,
                 inputs=[input_box],
-                outputs=[chat_history, research_output]
+                outputs=[chat_history, research_steps]
             )
         
         return interface
 
-    def process_query(self, query: str):
+    def _handle_query(self, query: str):
         try:
-            formatted_query = self._format_mla(query)
-            response = self.agent.run(task=formatted_query)
+            # Initial researcher agent processing
+            researcher_msg = gr.ChatMessage(role="Researcher", content=f"Beginning research: {query}")
+            
+            # Get formatted response
+            formatted_response = self._process_research(query)
+            
+            # Formatter agent response
+            formatter_msg = gr.ChatMessage(role="Formatter", content=formatted_response)
+            
             return [
-                gr.ChatMessage(role="user", content=query),
-                gr.ChatMessage(role="assistant", content=response)
-            ], self._format_mla(response)
+                researcher_msg,
+                formatter_msg
+            ], {
+                "Completed Stages": ["Research Collection", "MLA Formatting"],
+                "Current Status": "Research Complete"
+            }
+            
         except Exception as e:
-            error_msg = f"Research error: {str(e)}"
-            return [
-                gr.ChatMessage(role="user", content=query),
-                gr.ChatMessage(role="assistant", content=error_msg)
-            ], error_msg
+            error_msg = gr.ChatMessage(role="System", content=f"Error: {str(e)}")
+            return [error_msg], {"Error": str(e)}
 
 if __name__ == "__main__":
-    research_engine = ResearchSystem()
-    web_interface = research_engine.create_interface()
-    web_interface.launch(server_port=7860, share=False)
+    research_system = ResearchSystem()
+    interface = research_system.create_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )