Initial commit with full functionality extend app req tools

Gradio_UI.py

@@ -1,29 +1,132 @@
 # Gradio_UI.py
 import gradio as gr
 from smolagents import CodeAgent
-from typing import Optional
+from typing import Optional, Dict, List, Tuple
+import re
+import logging
+from functools import lru_cache
+import json
+from datetime import datetime
+import time
+
+logger = logging.getLogger(__name__)
 
 class GradioUI:
     def __init__(self, agent: CodeAgent):
         self.agent = agent
+        self.cache = {}
+        self.rate_limit = {}
+
+    def validate_url(self, url: str) -> bool:
+        """Validate URL format."""
+        url_pattern = re.compile(
+            r'^https?://'
+            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'
+            r'localhost|'
+            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
+            r'(?::\d+)?'
+            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+        return bool(url_pattern.match(url))
+
+    def check_rate_limit(self, url: str) -> bool:
+        """Check if URL has been requested too frequently."""
+        current_time = time.time()
+        if url in self.rate_limit:
+            last_request = self.rate_limit[url]
+            if current_time - last_request < 60:  # 1 minute cooldown
+                return False
+        self.rate_limit[url] = current_time
+        return True
+
+    @lru_cache(maxsize=100)
+    def get_cached_analysis(self, url: str, analysis_types: tuple) -> Optional[Dict]:
+        """Get cached analysis results if available."""
+        cache_key = f"{url}_{','.join(analysis_types)}"
+        return self.cache.get(cache_key)
 
-    def process_query(self, query: str) -> str:
+    def store_cache(self, url: str, analysis_types: List[str], results: Dict):
+        """Store analysis results in cache."""
+        cache_key = f"{url}_{','.join(analysis_types)}"
+        self.cache[cache_key] = {
+            'results': results,
+            'timestamp': datetime.now().isoformat()
+        }
+
+    def process_query(self, url: str, analysis_types: List[str]) -> Tuple[str, str, str, str]:
+        """Process the analysis query and return results for all output tabs."""
         try:
-            response = self.agent.run(query)
-            return response
+            # Input validation
+            if not url:
+                raise ValueError("Please enter a URL")
+            if not self.validate_url(url):
+                raise ValueError("Invalid URL format")
+            if not self.check_rate_limit(url):
+                raise ValueError("Please wait before analyzing this URL again")
+
+            # Check cache
+            cached = self.get_cached_analysis(url, tuple(analysis_types))
+            if cached:
+                logger.info(f"Returning cached results for {url}")
+                results = cached['results']
+                return (
+                    results.get('clean_text', ''),
+                    results.get('summary', ''),
+                    results.get('sentiment', ''),
+                    results.get('topics', '')
+                )
+
+            # Create analysis prompt
+            prompt = self.create_analysis_prompt(url, analysis_types)
+            
+            # Run analysis
+            response = self.agent.run(prompt)
+            
+            # Parse response
+            try:
+                results = json.loads(response) if isinstance(response, str) else response
+            except json.JSONDecodeError:
+                results = {
+                    'clean_text': response,
+                    'summary': '',
+                    'sentiment': '',
+                    'topics': ''
+                }
+
+            # Cache results
+            self.store_cache(url, analysis_types, results)
+
+            return (
+                results.get('clean_text', ''),
+                results.get('summary', ''),
+                results.get('sentiment', ''),
+                results.get('topics', '')
+            )
+
         except Exception as e:
-            return f"Error processing query: {str(e)}"
+            logger.error(f"Error processing query: {str(e)}")
+            error_msg = f"⚠️ Error: {str(e)}"
+            return error_msg, error_msg, error_msg, error_msg
+
+    def create_analysis_prompt(self, url: str, types: List[str]) -> str:
+        """Create the analysis prompt based on selected types."""
+        if not types:
+            types = ["summarize"]  # Default analysis type
+        type_str = ", ".join(types)
+        return f"Analyze the content at {url} and provide the following analysis: {type_str}. Return results in JSON format with keys: clean_text, summary, sentiment, topics."
 
     def launch(self, 
                server_name: Optional[str] = None,
                server_port: Optional[int] = None,
                share: bool = False):
+        """Launch the Gradio interface."""
         
         # Create the interface
-        with gr.Blocks(title="Smart Web Analyzer Plus") as demo:
+        with gr.Blocks(title="Smart Web Analyzer Plus", theme=gr.themes.Soft()) as demo:
+            # Header
             gr.Markdown("# 🌐 Smart Web Analyzer Plus")
             gr.Markdown("Analyze web content using AI to extract summaries, determine sentiment, and identify topics.")
             
+            # Input section
             with gr.Row():
                 with gr.Column(scale=3):
                     url_input = gr.Textbox(
@@ -44,20 +147,20 @@ class GradioUI:
                         variant="primary"
                     )
             
-            # Output display
+            # Status indicator
+            status = gr.Markdown(visible=False)
+            
+            # Output tabs
             with gr.Tabs() as tabs:
-                with gr.Tab("📄 Clean Text"):
+                with gr.TabItem("📄 Clean Text"):
                     clean_text_output = gr.Markdown()
-                with gr.Tab("📝 Summary"):
+                with gr.TabItem("📝 Summary"):
                     summary_output = gr.Markdown()
-                with gr.Tab("🎭 Sentiment"):
+                with gr.TabItem("🎭 Sentiment"):
                     sentiment_output = gr.Markdown()
-                with gr.Tab("📊 Topics"):
+                with gr.TabItem("📊 Topics"):
                     topics_output = gr.Markdown()
             
-            # Loading indicator
-            status = gr.Markdown(visible=False)
-            
             # Examples
             gr.Examples(
                 examples=[
@@ -68,26 +171,23 @@ class GradioUI:
                 label="Try these examples"
             )
             
-            def create_analysis_prompt(url: str, types: list) -> str:
-                type_str = ", ".join(types)
-                return f"Analyze the content at {url} and provide {type_str} analysis."
-            
-            def on_analyze_start():
+            # Event handlers
+            def on_analyze_click():
                 return gr.update(value="⏳ Analysis in progress...", visible=True)
-            
-            def on_analyze_end():
+
+            def on_analyze_complete():
                 return gr.update(value="", visible=False)
-            
-            # Event handlers
+
             analyze_btn.click(
-                fn=on_analyze_start,
-                outputs=[status]
+                fn=on_analyze_click,
+                outputs=[status],
+                queue=False
             ).then(
-                fn=lambda url, types: self.process_query(create_analysis_prompt(url, types)),
+                fn=self.process_query,
                 inputs=[url_input, analysis_types],
-                outputs=[clean_text_output]  # The agent will format the output appropriately
+                outputs=[clean_text_output, summary_output, sentiment_output, topics_output]
             ).then(
-                fn=on_analyze_end,
+                fn=on_analyze_complete,
                 outputs=[status]
             )
         
@@ -96,4 +196,4 @@ class GradioUI:
             server_name=server_name,
             server_port=server_port,
             share=share
-        )
+        )

app.py

@@ -3,34 +3,59 @@ from smolagents import CodeAgent, HfApiModel
 from tools.final_answer import FinalAnswerTool
 import yaml
 from Gradio_UI import GradioUI
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 def create_agent():
-    # Initialize the final answer tool
-    final_answer = FinalAnswerTool()
-    # Load prompt templates
-    with open("prompts.yaml", 'r') as stream:
-        prompt_templates = yaml.safe_load(stream)
-    
-    # Create the model
-    model = HfApiModel(
-        model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-        max_tokens=2096,
-        temperature=0.5
-    )
-    
-    # Create and return the agent
-    return CodeAgent(
-        model=model,
-        tools=[final_answer],
-        max_steps=6,
-        verbosity_level=1,
-        prompt_templates=prompt_templates
-    )
+    try:
+        # Initialize the final answer tool
+        final_answer = FinalAnswerTool()
+        
+        # Load prompt templates
+        with open("prompts.yaml", 'r', encoding='utf-8') as stream:
+            prompt_templates = yaml.safe_load(stream)
+        
+        # Create the model
+        model = HfApiModel(
+            model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+            max_tokens=2096,
+            temperature=0.5
+        )
+        
+        # Create and return the agent
+        return CodeAgent(
+            model=model,
+            tools=[final_answer],
+            max_steps=6,
+            verbosity_level=1,
+            prompt_templates=prompt_templates
+        )
+    except Exception as e:
+        logger.error(f"Error creating agent: {str(e)}")
+        raise
+
+def main():
+    try:
+        # Create and launch the agent
+        logger.info("Initializing Smart Web Analyzer Plus...")
+        agent = create_agent()
+        
+        # Initialize and launch UI
+        ui = GradioUI(agent)
+        ui.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False  # Set to True if you want to share publicly
+        )
+    except Exception as e:
+        logger.error(f"Application startup failed: {str(e)}")
+        raise
 
 if __name__ == "__main__":
-    # Create and launch the agent
-    agent = create_agent()
-    GradioUI(agent).launch(
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+    main()

prompts.yaml

@@ -1,42 +1,50 @@
 # prompts.yaml
 system_prompt: |
-  You are a helpful AI assistant that can analyze web content. You have access to several tools:
-  - Text extraction to get content from URLs
-  - Sentiment analysis to determine the emotional tone
-  - Summarization to create concise summaries
-  - Topic detection to identify main themes
-  - Web search for additional context
-  - Time zone checking for temporal context
+  You are a sophisticated AI assistant specialized in web content analysis. You have access to these capabilities:
+  - Text extraction: Clean and extract meaningful content from URLs
+  - Sentiment analysis: Determine emotional tone and context
+  - Summarization: Create concise, informative summaries
+  - Topic detection: Identify main themes and subjects
+  - Web search: Gather additional context when needed
+  - Temporal analysis: Consider time-based context
   
-  Always think step by step and use the most appropriate tools for the task.
+  Always structure your responses in JSON format with these keys:
+  - clean_text: The extracted and cleaned content
+  - summary: A concise summary if requested
+  - sentiment: Sentiment analysis if requested
+  - topics: Main topics if requested
+  
+  Think step by step and use the most appropriate tools for each task.
 
 user: |
   User query: {input}
   
-  Think through this step-by-step:
-  1. Understand what analysis is being requested
-  2. Plan which tools to use
-  3. Execute the analysis in a logical order
-  4. Provide a clear, formatted response
+  Analysis process:
+  1. Validate and process the URL
+  2. Determine required analysis types
+  3. Execute analysis in order: extraction → summary → sentiment → topics
+  4. Format results in JSON structure
   
   Available tools: {tools}
 
-assistant: |
-  I'll help analyze that content. Let me think about this step by step:
+A: |
+  I'll analyze the content systematically:
 
   {thoughts}
 
-  Let me take action using the appropriate tools.
+  Executing analysis with appropriate tools...
 
 observation: |
   Tool response: {output}
 
 final: |
-  Based on the analysis, here is the final answer:
+  Analysis complete. Results formatted in JSON:
 
   {response}
 
 error: |
-  I encountered an error: {error}
+  An error occurred: {error}
+  
+  Technical details: {error_details}
   
-  Let me try a different approach or tool to help you.
+  I'll attempt an alternative approach or provide partial results if possible.

requirements.txt

@@ -1,6 +1,20 @@
-smolagents
-gradio
-requests
-pytz
-pyyaml
-duckduckgo-search
+# requirements.txt
+smolagents>=0.2.0
+gradio>=4.0.0
+requests>=2.31.0
+pytz>=2023.3
+pyyaml>=6.0.1
+python-dotenv>=1.0.0
+beautifulsoup4>=4.12.2
+numpy>=1.24.3
+pandas>=2.0.3
+scikit-learn>=1.3.0
+nltk>=3.8.1
+spacy>=3.7.2
+transformers>=4.35.0
+torch>=2.0.1
+tqdm>=4.65.0
+validators>=0.22.0
+aiohttp>=3.8.5
+cachetools>=5.3.1
+python-dateutil>=2.8.2

tools/final_answer.py

@@ -1,38 +1,91 @@
 # tools/final_answer.py
 from smolagents import Tool
 from typing import Optional, Dict, Any
+import json
+import logging
+
+logger = logging.getLogger(__name__)
 
 class FinalAnswerTool(Tool):
-    """Tool for providing final answers to user queries."""
+    """Tool for providing final answers to user queries with improved error handling and validation."""
     
     name = "final_answer"
-    description = "Tool for providing the final answer to the agent's task"
+    description = "Tool for providing the final answer to the agent's task with structured output"
     
-    # Define inputs with the correct type string
     inputs: Dict[str, Any] = {
         "answer": {
             "type": "string",
-            "description": "The final answer to be returned"
+            "description": "The final answer to be returned in JSON format"
         }
     }
     
-    # Specify output type with correct string
     output_type = "string"
     
     def __init__(self, description: Optional[str] = None):
         super().__init__()
         self.description = description or self.description
     
+    def validate_json(self, answer: str) -> bool:
+        """Validate if the answer is proper JSON format."""
+        try:
+            if isinstance(answer, str):
+                json.loads(answer)
+            return True
+        except json.JSONDecodeError:
+            return False
+    
+    def format_response(self, answer: str) -> str:
+        """Format the response to ensure consistent structure."""
+        try:
+            if isinstance(answer, str):
+                # Try to parse as JSON first
+                if self.validate_json(answer):
+                    return answer
+                
+                # If not JSON, create a structured response
+                return json.dumps({
+                    'clean_text': answer,
+                    'summary': '',
+                    'sentiment': '',
+                    'topics': ''
+                })
+            
+            # If answer is already a dict, convert to JSON
+            if isinstance(answer, dict):
+                return json.dumps(answer)
+            
+            raise ValueError("Invalid answer format")
+            
+        except Exception as e:
+            logger.error(f"Error formatting response: {str(e)}")
+            return json.dumps({
+                'error': str(e),
+                'clean_text': str(answer),
+                'summary': '',
+                'sentiment': '',
+                'topics': ''
+            })
+    
     def forward(self, answer: str) -> str:
-        """Process and return the final answer.
+        """Process and return the final answer with improved error handling.
         
         Args:
             answer: The answer text to be returned
         
         Returns:
-            str: The processed answer
+            str: The processed answer in JSON format
         """
-        return answer
+        try:
+            return self.format_response(answer)
+        except Exception as e:
+            logger.error(f"Error in forward method: {str(e)}")
+            return json.dumps({
+                'error': str(e),
+                'clean_text': 'An error occurred while processing the response',
+                'summary': '',
+                'sentiment': '',
+                'topics': ''
+            })
 
     def __call__(self, answer: str) -> str:
         """Alias for forward method to maintain compatibility"""