Update app.py

app.py

@@ -1,77 +1,280 @@
-"""qResearch: Dual-Agent Research System"""
+"""qResearch: Dual-Agent Research System
+
+A research system that combines web search, analysis, and proper MLA formatting
+using a dual-agent approach with specialized roles.
+"""
 
 import os
 import gradio as gr
 from smolagents import CodeAgent, HfApiModel, tool
+from typing import Dict, List, Optional, Tuple, Union
+import json
 
+# Advanced Research Tools
 @tool
 def web_search(query: str, max_results: int = 5) -> str:
-    """Performs web searches using DuckDuckGo
+    """Performs comprehensive web searches using DuckDuckGo
     
     Args:
         query: Search query string to look up
         max_results: Number of results (1-10) to return
     
     Returns:
-        str: Formatted search results as a string
+        str: Formatted search results as a string with titles, snippets and URLs
     """
     from duckduckgo_search import DDGS
     with DDGS() as ddgs:
         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)])
+        
+    if not results:
+        return "No results found for the given query."
+        
+    formatted_results = []
+    for i, r in enumerate(results, 1):
+        formatted_results.append(
+            f"{i}. {r['title']}\n"
+            f"   Summary: {r['body']}\n"
+            f"   Source: {r['href']}\n"
+        )
+    return "\n".join(formatted_results)
+
+@tool
+def analyze_content(text: str, analysis_type: str = "general") -> str:
+    """Analyzes content for various aspects like key points, themes, or citations
+    
+    Args:
+        text: The content to analyze
+        analysis_type: Type of analysis ("general", "academic", "citations")
+    
+    Returns:
+        str: Analysis results in a structured format
+    """
+    points = []
+    
+    if "academic" in analysis_type.lower():
+        # Academic analysis focusing on scholarly aspects
+        points.extend([
+            "Key Arguments:",
+            "- Main thesis and supporting evidence",
+            "- Methodological approach",
+            "- Scholarly context and significance",
+            "\nAcademic Sources:",
+            "- Peer-reviewed citations",
+            "- Research foundations",
+        ])
+    elif "citations" in analysis_type.lower():
+        # Citation analysis
+        points.extend([
+            "Citation Analysis:",
+            "- Author credentials",
+            "- Publication details",
+            "- Citation format and standards",
+            "\nBibliographic Information:",
+            "- Primary sources",
+            "- Secondary references",
+        ])
+    else:
+        # General content analysis
+        points.extend([
+            "Content Overview:",
+            "- Main topics and themes",
+            "- Key findings and insights",
+            "- Supporting evidence",
+            "\nRelevance and Context:",
+            "- Topic significance",
+            "- Current applications",
+        ])
+    
+    return "\n".join(points)
 
 class ResearchSystem:
     def __init__(self):
-        # Initialize model FIRST
+        # System configuration
+        self.config = {
+            "max_research_depth": 3,
+            "min_sources": 2,
+            "format_style": "MLA",
+            "cache_results": True
+        }
+        
+        # Initialize model with role specialization
         self.model = HfApiModel(
             model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
             custom_role_conversions={
                 "tool-call": "assistant",
-                "tool-response": "user"
+                "tool-response": "user",
+                "researcher": "assistant",
+                "formatter": "assistant"
             }
         )
 
-        # Initialize agents AFTER model
+        # Research agent with enhanced capabilities
         self.researcher = CodeAgent(
-            tools=[web_search],
+            tools=[web_search, analyze_content],
             model=self.model
         )
         
+        # Formatting agent specializing in academic standards
         self.formatter = CodeAgent(
             tools=[],
             model=self.model
         )
+        
+        # Result cache for performance
+        self.cache: Dict[str, Tuple[str, str]] = {}
 
     def create_interface(self):
-        with gr.Blocks(title="qResearch") as interface:
-            gr.Markdown("# qResearch\n*Research → Analysis → MLA Formatting*")
+        """Creates an enhanced Gradio interface with advanced features"""
+        with gr.Blocks(title="qResearch", theme=gr.themes.Soft()) as interface:
+            gr.Markdown(
+                "# qResearch Pro\n"
+                "*Advanced Research → Intelligent Analysis → Professional MLA Formatting*\n"
+                "---"
+            )
             
             with gr.Row():
-                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")
+                with gr.Column(scale=3):
+                    chat = gr.Chatbot(
+                        label="Research Process",
+                        height=600,
+                        show_label=True
+                    )
+                    
+                with gr.Column(scale=1):
+                    with gr.Group():
+                        input_box = gr.Textbox(
+                            label="Research Query",
+                            placeholder="Enter your research topic...",
+                            lines=3
+                        )
+                        
+                        with gr.Row():
+                            submit_btn = gr.Button(
+                                "Start Research",
+                                variant="primary"
+                            )
+                            clear_btn = gr.Button(
+                                "Clear",
+                                variant="secondary"
+                            )
+                            
+                        with gr.Accordion("Advanced Options", open=False):
+                            depth = gr.Slider(
+                                minimum=1,
+                                maximum=5,
+                                value=3,
+                                step=1,
+                                label="Research Depth"
+                            )
+                            sources = gr.Slider(
+                                minimum=1,
+                                maximum=10,
+                                value=5,
+                                step=1,
+                                label="Number of Sources"
+                            )
             
+            # Event handlers
             submit_btn.click(
                 self.process_query,
-                inputs=[input_box],
+                inputs=[input_box, depth, sources],
                 outputs=[chat]
             )
+            
+            clear_btn.click(
+                lambda: None,
+                inputs=[],
+                outputs=[chat],
+                _js="() => []"  # Clear chat
+            )
+            
+            # Help information
+            with gr.Accordion("Usage Guide", open=False):
+                gr.Markdown("""
+                ### How to Use qResearch Pro
+                1. Enter your research topic or question in the query box
+                2. Adjust research depth and source count if needed
+                3. Click 'Start Research' to begin the process
+                4. Review the results in three stages:
+                   - Initial research findings
+                   - Analysis and synthesis
+                   - Properly formatted MLA document
+                """)
         
         return interface
 
-    def process_query(self, query: str):
+    def process_query(self, 
+                     query: str, 
+                     depth: int = 3, 
+                     num_sources: int = 5) -> List[List[str]]:
+        """
+        Processes a research query with enhanced capabilities
+        
+        Args:
+            query: The research query
+            depth: Desired research depth (1-5)
+            num_sources: Number of sources to include (1-10)
+            
+        Returns:
+            List of message pairs for the chatbot interface
+        """
         try:
-            raw_research = self.researcher.run(query)
-            formatted = self.formatter.run(f"Format this research:\n{raw_research}")
+            # Check cache first
+            if query in self.cache and self.config["cache_results"]:
+                raw_research, formatted = self.cache[query]
+                return [
+                    [query, None],
+                    ["Researcher (Cached)", raw_research],
+                    ["Formatter (Cached)", formatted]
+                ]
+            
+            # Configure research parameters
+            research_prompt = (
+                f"Research Query: {query}\n"
+                f"Required Depth: {depth}\n"
+                f"Minimum Sources: {num_sources}\n"
+                "Please provide comprehensive research with:\n"
+                "1. Multiple reliable sources\n"
+                "2. Key findings and analysis\n"
+                "3. Supporting evidence and context"
+            )
+            
+            # Conduct research
+            raw_research = self.researcher.run(research_prompt)
+            
+            # Format results
+            format_prompt = (
+                "Format the following research in MLA style with:\n"
+                "1. Proper citations\n"
+                "2. Academic formatting\n"
+                "3. Bibliography\n\n"
+                f"Content to format:\n{raw_research}"
+            )
+            formatted = self.formatter.run(format_prompt)
+            
+            # Cache results
+            if self.config["cache_results"]:
+                self.cache[query] = (raw_research, formatted)
+            
+            # Return results in chatbot format
             return [
-                [query, None],  # User message
-                ["Researcher", raw_research],  # Research results
-                ["Formatter", formatted]  # Formatted results
+                [query, None],
+                ["📚 Research Findings", raw_research],
+                ["📝 MLA Formatted", formatted]
             ]
+            
         except Exception as e:
-            return [[None, f"Error: {str(e)}"]]
+            error_msg = (
+                f"Error during research process: {str(e)}\n"
+                "Please try again or refine your query."
+            )
+            return [[None, error_msg]]
 
 if __name__ == "__main__":
     system = ResearchSystem()
-    system.create_interface().launch(server_port=7860)
+    system.create_interface().launch(
+        server_port=7860,
+        share=True,  # Enable public link
+        show_api=False,  # Hide API docs
+        enable_queue=True  # Enable request queuing
+    )