Update app.py

app.py

@@ -1,27 +1,20 @@
-"""qResearch v3.0: Dual-Agent Research System"""
+"""qResearch: Dual-Agent Research System"""
 
 import os
 import gradio as gr
-from dotenv import load_dotenv
 from smolagents import CodeAgent, HfApiModel, Tool
 
-# Initialize environment
-load_dotenv(override=True)
-
 class DuckDuckGoSearchTool(Tool):
-    """Web search tool for primary research"""
+    """Web search tool with proper input validation"""
     name = "web_search"
-    description = "Performs privacy-focused web searches using DuckDuckGo"
+    description = "Performs web searches using DuckDuckGo"
     inputs = {
-        "query": {
-            "type": "string", 
-            "description": "Research query"
-        },
+        "query": {"type": "string", "description": "Search query"},
         "max_results": {
             "type": "integer",
-            "description": "Number of results (3-10)",
+            "description": "Number of results (1-10)",
             "default": 5,
-            "nullable": True  # Critical fix here
+            "nullable": True
         }
     }
     output_type = "string"
@@ -29,132 +22,65 @@ 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))
-        return "\n".join([f"{idx+1}. {r['title']} ({r['href']}): {r['body']}" 
-                        for idx, r in enumerate(results)])
+            results = ddgs.text(query, max_results=max_results)
+        return "\n".join([f"{i+1}. {r['title']}: {r['body']} ({r['href']})" 
+                        for i, r in enumerate(results)])
 
 class ResearchSystem:
     def __init__(self):
         # Initialize model FIRST
         self.model = HfApiModel(
             model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
-            custom_role_conversions={"tool-call": "assistant", "tool-response": "user"},
+            custom_role_conversions={
+                "tool-call": "assistant",
+                "tool-response": "user"
+            },
             use_auth_token=False,
             trust_remote_code=True
         )
-    
-    def __init__(self):
-        # Initialize Researcher Agent
+
+        # Initialize agents AFTER model
         self.researcher = CodeAgent(
             tools=[DuckDuckGoSearchTool()],
             model=self.model,
-            system_message="""You are a Senior Research Analyst. Your tasks:  # Changed parameter name
-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"""
+            system_message="""Senior Research Analyst. Conduct comprehensive web research and compile raw findings."""
         )
         
-        # Initialize Formatter Agent 
         self.formatter = CodeAgent(
             tools=[],
             model=self.model,
-            system_message="""You are an MLA Formatting Specialist. Your tasks:  # Changed parameter name
-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"""
-        )
-
-    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
+            system_message="""MLA Formatting Specialist. Convert raw research into properly formatted MLA documents."""
         )
-        
-        return formatted_response
 
     def create_interface(self):
-        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():
-                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.Blocks(title="qResearch") as interface:
+            gr.Markdown("# qResearch\n*Research → Analysis → MLA Formatting*")
             
             with gr.Row():
-                input_box = gr.Textbox(
-                    placeholder="Enter research topic...",
-                    lines=2,
-                    label="Research Query"
-                )
+                chat = gr.Chatbot(label="Research Process", height=500)
+                input_box = gr.Textbox(label="Enter Query", placeholder="Research topic...")
                 submit_btn = gr.Button("Start Research", variant="primary")
             
             submit_btn.click(
-                self._handle_query,
+                self.process_query,
                 inputs=[input_box],
-                outputs=[chat_history, research_steps]
+                outputs=[chat]
             )
         
         return interface
 
-    def _handle_query(self, query: str):
+    def process_query(self, query: str):
         try:
-            # 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)
-            
+            raw_research = self.researcher.run(query)
+            formatted = self.formatter.run(f"Format this research:\n{raw_research}")
             return [
-                researcher_msg,
-                formatter_msg
-            ], {
-                "Completed Stages": ["Research Collection", "MLA Formatting"],
-                "Current Status": "Research Complete"
-            }
-            
+                gr.ChatMessage(role="user", content=query),
+                gr.ChatMessage(role="Researcher", content=raw_research),
+                gr.ChatMessage(role="Formatter", content=formatted)
+            ]
         except Exception as e:
-            error_msg = gr.ChatMessage(role="System", content=f"Error: {str(e)}")
-            return [error_msg], {"Error": str(e)}
+            return [gr.ChatMessage(role="Error", content=str(e))]
 
 if __name__ == "__main__":
-    research_system = ResearchSystem()
-    interface = research_system.create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+    system = ResearchSystem()
+    system.create_interface().launch(server_port=7860)