Робочий варіант, але потребує суттєвого доопрацювання

Gradio_UI.py

@@ -1,7 +1,8 @@
 import gradio as gr
 import logging
 from pathlib import Path
-import os
+from config import ModelConfig
+from typing import Tuple, List
 
 logger = logging.getLogger(__name__)
 
@@ -10,9 +11,20 @@ class GradioUI:
         self.agent = agent
         self.file_upload_folder = Path(file_upload_folder)
         self.file_upload_folder.mkdir(exist_ok=True)
+        self.model_config = ModelConfig()
         
     def build_interface(self):
         with gr.Blocks(theme=gr.themes.Soft()) as interface:
+            # Model selection dropdown
+            with gr.Row():
+                model_choices = self.model_config.get_available_models()
+                model_dropdown = gr.Dropdown(
+                    choices=[f"{key} - {desc}" for key, desc in model_choices],
+                    value=f"{self.model_config.get_default_model()} - {dict(model_choices)[self.model_config.get_default_model()]}",
+                    label="Оберіть модель",
+                    info="Оберіть модель для обробки запитів"
+                )
+
             with gr.Row():
                 chatbot = gr.Chatbot(
                     label="Research Assistant",
@@ -20,7 +32,6 @@ class GradioUI:
                     show_copy_button=True
                 )
             
-            # Hidden by default file upload section
             with gr.Row(visible=False) as file_upload_row:
                 upload_file = gr.File(
                     label="Upload File",
@@ -34,21 +45,33 @@ class GradioUI:
 
             with gr.Row():
                 text_input = gr.Textbox(
-                    label="Enter your research query",
-                    placeholder="Enter your query here...",
+                    label="Введіть ваш запит",
+                    placeholder="Введіть ваш запит тут...",
                     lines=2
                 )
                 
             with gr.Row():
-                submit_btn = gr.Button("Submit", variant="primary")
-                clear_btn = gr.Button("Clear")
-                toggle_upload_btn = gr.Button("Toggle File Upload")
+                submit_btn = gr.Button("Надіслати", variant="primary")
+                clear_btn = gr.Button("Очистити")
+                toggle_upload_btn = gr.Button("Завантажити файл")
 
             # Store conversation state
             state = gr.State([])
             file_history = gr.State([])
+            current_model = gr.State(self.model_config.get_default_model())
+
+            def change_model(choice):
+                model_key = choice.split(" - ")[0]
+                model_config = self.model_config.get_model_config(model_key)
+                self.agent.update_model(model_config)
+                return model_key
+
+            model_dropdown.change(
+                fn=change_model,
+                inputs=[model_dropdown],
+                outputs=[current_model]
+            )
 
-            # Event handlers
             def toggle_upload(visible):
                 return not visible
             
@@ -62,15 +85,14 @@ class GradioUI:
                 if file:
                     try:
                         file_path = self.file_upload_folder / file.name
-                        # Save file
                         with open(file_path, 'wb') as f:
                             f.write(file.read())
                         history.append(str(file_path))
-                        return gr.update(value=f"File uploaded: {file.name}"), history
+                        return gr.update(value=f"Файл завантажено: {file.name}"), history
                     except Exception as e:
-                        logger.error(f"Upload error: {e}")
-                        return gr.update(value=f"Upload failed: {str(e)}"), history
-                return gr.update(value="No file selected"), history
+                        logger.error(f"Помилка завантаження: {e}")
+                        return gr.update(value=f"Помилка завантаження: {str(e)}"), history
+                return gr.update(value="Файл не вибрано"), history
 
             upload_file.change(
                 fn=process_upload,
@@ -80,7 +102,7 @@ class GradioUI:
 
             def user_message(message, chat_history, files):
                 if files:
-                    message += f"\nAvailable files for analysis: {', '.join(files)}"
+                    message += f"\nДоступні файли для аналізу: {', '.join(files)}"
                 chat_history.append((message, None))
                 return "", chat_history
 
@@ -93,11 +115,10 @@ class GradioUI:
                     chat_history[-1] = (chat_history[-1][0], response)
                     return chat_history
                 except Exception as e:
-                    logger.error(f"Error in bot response: {e}")
-                    chat_history[-1] = (chat_history[-1][0], f"Error: {str(e)}")
+                    logger.error(f"Помилка відповіді: {e}")
+                    chat_history[-1] = (chat_history[-1][0], f"Помилка: {str(e)}")
                     return chat_history
 
-            # Submit handling
             submit_btn.click(
                 user_message,
                 [text_input, state, file_history],
@@ -108,7 +129,6 @@ class GradioUI:
                 [chatbot]
             )
 
-            # Clear handling
             def clear_chat():
                 return [], []
             
@@ -123,11 +143,4 @@ class GradioUI:
 
     def launch(self, **kwargs):
         interface = self.build_interface()
-        interface.launch(**kwargs)
-
-if __name__ == "__main__":
-    # Example usage
-    from agent import ResearchAgent
-    agent = ResearchAgent()
-    ui = GradioUI(agent)
-    ui.launch(share=True)
+        interface.launch(**kwargs)

agent.py

@@ -2,6 +2,7 @@ from smolagents import CodeAgent
 import logging
 from typing import Optional, List, Dict, Any
 from datetime import datetime
+import os
 
 logger = logging.getLogger(__name__)
 
@@ -67,54 +68,19 @@ class ResearchAgent(CodeAgent):
             logger.error(f"Error formatting research report: {e}")
             return str(content)  # Return raw content if formatting fails
 
-    def prepare_query_context(self, query: str, available_files: Optional[List[str]] = None) -> str:
-        """
-        Prepare the context for the research query.
-        
-        Args:
-            query (str): Original research query
-            available_files (Optional[List[str]]): List of available files
-            
-        Returns:
-            str: Prepared query context
-        """
-        context_parts = [
-            query,
-            "\nІнструкції для виконання:",
-            "1. Використовуйте web_search для пошуку актуальної наукової інформації",
-            "2. Аналізуйте знайдені джерела та підсумовуйте ключові висновки",
-            "3. Формуйте структурований звіт з усіма необхідними розділами",
-            "4. Обов'язково вказуйте посилання на використані джерела"
-        ]
-        
-        if available_files:
-            context_parts.append(f"\nДоступні файли для аналізу: {', '.join(available_files)}")
-        
-        return "\n".join(context_parts)
-
-    def validate_search_results(self, results: str) -> bool:
-        """
-        Validate that search results are meaningful.
-        
-        Args:
-            results (str): Search results to validate
-            
-        Returns:
-            bool: True if results are valid, False otherwise
-        """
-        if not results or len(results.strip()) < 100:
-            return False
-        
-        # Check for common error indicators
-        error_indicators = [
-            "no results found",
-            "error",
-            "failed",
-            "unauthorized",
-            "invalid"
-        ]
-        
-        return not any(indicator in results.lower() for indicator in error_indicators)
+    def update_model(self, model_config):
+        """Update the model configuration"""
+        try:
+            from smolagents import HfApiModel
+            self.model = HfApiModel(
+                model_id=model_config['model_id'],
+                token=os.getenv('HF_API_TOKEN'),
+                temperature=model_config['parameters'].get('temperature', 0.7)
+            )
+            logger.info(f"Model updated to: {model_config['model_id']}")
+        except Exception as e:
+            logger.error(f"Error updating model: {e}")
+            raise
 
     def process_query(self, query: str, available_files: Optional[List[str]] = None) -> str:
         """
@@ -130,12 +96,9 @@ class ResearchAgent(CodeAgent):
         try:
             logger.info(f"Processing research query: {query}")
             
-            # Prepare context
-            context = self.prepare_query_context(query, available_files)
-            
             # Execute query
             result = self.run(
-                task=context,
+                task=query,
                 stream=False,  # We want complete results
                 reset=True     # Fresh start for each query
             )
@@ -158,39 +121,4 @@ class ResearchAgent(CodeAgent):
         except Exception as e:
             error_msg = f"Помилка при обробці запиту: {str(e)}"
             logger.error(error_msg)
-            return error_msg
-
-    def add_tool(self, tool) -> None:
-        """
-        Add a new tool to the agent's toolkit.
-        
-        Args:
-            tool: Tool instance to add
-        """
-        try:
-            self.available_tools[tool.name] = tool
-            self.tools.append(tool)
-            logger.info(f"Added new tool: {tool.name}")
-        except Exception as e:
-            logger.error(f"Error adding tool: {e}")
-            raise
-
-    def remove_tool(self, tool_name: str) -> None:
-        """
-        Remove a tool from the agent's toolkit.
-        
-        Args:
-            tool_name (str): Name of the tool to remove
-        """
-        try:
-            if tool_name in self.available_tools:
-                tool = self.available_tools.pop(tool_name)
-                self.tools.remove(tool)
-                logger.info(f"Removed tool: {tool_name}")
-        except Exception as e:
-            logger.error(f"Error removing tool: {e}")
-            raise
-
-    def __str__(self) -> str:
-        """String representation of the agent"""
-        return f"ResearchAgent(tools={list(self.available_tools.keys())})"
+            return error_msg

app.py

@@ -7,6 +7,7 @@ from agent import ResearchAgent
 import os
 from dotenv import load_dotenv
 import logging
+from config import ModelConfig
 
 # Configure logging
 logging.basicConfig(
@@ -43,12 +44,16 @@ def initialize_model():
     """Initialize the language model"""
     logger.info("Initializing language model...")
     try:
+        model_config = ModelConfig()
+        default_model = model_config.get_model_config()
+        
         model = HfApiModel(
-            model_id=os.getenv('MODEL_ID', "mistralai/Mistral-7B-Instruct-v0.2"),
+            model_id=default_model['model_id'],
             token=os.getenv('HF_API_TOKEN'),
-            temperature=float(os.getenv('TEMPERATURE', 0.3))
+            temperature=default_model['parameters'].get('temperature', 0.7),
+            max_tokens=default_model['parameters'].get('max_tokens', 2048)
         )
-        logger.info(f"Model initialized: {model.model_id}")
+        logger.info(f"Model initialized: {default_model['model_id']}")
         return model
     except Exception as e:
         logger.error(f"Error initializing model: {e}")
@@ -63,11 +68,11 @@ def main():
         tools = initialize_tools()
         model = initialize_model()
         
-        # Initialize research agent
+        # Initialize research agent with increased max_steps
         agent = ResearchAgent(
             model=model,
             tools=tools,
-            max_steps=int(os.getenv('MAX_STEPS', 6)),
+            max_steps=int(os.getenv('MAX_STEPS', 10)),  # Increased from 6 to 10
             verbosity_level=int(os.getenv('VERBOSITY_LEVEL', 1))
         )
         

config.py

@@ -0,0 +1,112 @@
+import json
+from pathlib import Path
+
+class ModelConfig:
+    def __init__(self, config_path='models_config.json'):  # Changed path
+        self.config_path = Path(config_path)
+        self.ensure_config_exists()
+        self.load_config()
+
+    def ensure_config_exists(self):
+        """Ensure config file exists"""
+        if not self.config_path.exists():
+            default_config = {
+                "models": {
+                    "deepseek-r1": {
+                        "model_id": "deepseek-ai/DeepSeek-R1",
+                        "description": "Найбільш рейтингова модель за кількістю лайків",
+                        "likes": 8659,
+                        "downloads": 3468420,
+                        "parameters": {
+                            "max_tokens": 2048,
+                            "temperature": 0.7,
+                            "top_p": 0.95,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0
+                        },
+                        "recommended_use": ["складні дослідницькі завдання", "аналітика", "генерація тексту"]
+                    },
+                    "llama-3-instruct": {
+                        "model_id": "meta-llama/Llama-3.1-8B-Instruct",
+                        "description": "Потужна інструктивна модель від Meta",
+                        "likes": 3612,
+                        "downloads": 6035070,
+                        "parameters": {
+                            "max_tokens": 4096,
+                            "temperature": 0.8,
+                            "top_p": 0.9,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0
+                        },
+                        "recommended_use": ["діалоги", "інструкції", "навчальні матеріали"]
+                    },
+                    "mistral-instruct": {
+                        "model_id": "mistralai/Mistral-7B-Instruct-v0.2",
+                        "description": "Оптимізована інструктивна модель",
+                        "likes": 2650,
+                        "downloads": 3415777,
+                        "parameters": {
+                            "max_tokens": 2048,
+                            "temperature": 0.3,
+                            "top_p": 0.9,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0
+                        },
+                        "recommended_use": ["наукові дослідження", "структуровані відповіді"]
+                    },
+                    "gpt2": {
+                        "model_id": "openai-community/gpt2",
+                        "description": "Найбільш завантажувана модель",
+                        "likes": 2565,
+                        "downloads": 18299067,
+                        "parameters": {
+                            "max_tokens": 1024,
+                            "temperature": 0.9,
+                            "top_p": 0.9,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0
+                        },
+                        "recommended_use": ["базова генерація тексту", "прості завдання"]
+                    },
+                    "llama-3-1b": {
+                        "model_id": "meta-llama/Llama-3.2-1B",
+                        "description": "Легка версія Llama 3",
+                        "likes": 1559,
+                        "downloads": 8244484,
+                        "parameters": {
+                            "max_tokens": 2048,
+                            "temperature": 0.8,
+                            "top_p": 0.9,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0
+                        },
+                        "recommended_use": ["швидкі відповіді", "базова генерація"]
+                    }
+                },
+                "default_model": "mistral-instruct",
+                "model_selection_criteria": {
+                    "research": ["deepseek-r1", "mistral-instruct", "llama-3-instruct"],
+                    "general": ["gpt2", "llama-3-1b"],
+                    "instruction": ["mistral-instruct", "llama-3-instruct"]
+                }
+            }
+            self.config_path.write_text(json.dumps(default_config, indent=4, ensure_ascii=False))
+
+    def load_config(self):
+        """Load configuration from file"""
+        self.config = json.loads(self.config_path.read_text())
+
+    def get_model_config(self, model_key=None):
+        """Get configuration for specific model or default model"""
+        if model_key is None:
+            model_key = self.config['default_model']
+        return self.config['models'].get(model_key)
+
+    def get_available_models(self):
+        """Get list of available models"""
+        return [(key, model['description']) 
+                for key, model in self.config['models'].items()]
+
+    def get_default_model(self):
+        """Get default model key"""
+        return self.config['default_model']

models_config.json

@@ -0,0 +1,80 @@
+{
+    "models": {
+        "deepseek-r1": {
+            "model_id": "deepseek-ai/DeepSeek-R1",
+            "description": "Найбільш рейтингова модель за кількістю лайків",
+            "likes": 8659,
+            "downloads": 3468420,
+            "parameters": {
+                "max_tokens": 2048,
+                "temperature": 0.7,
+                "top_p": 0.95,
+                "frequency_penalty": 0.0,
+                "presence_penalty": 0.0
+            },
+            "recommended_use": ["складні дослідницькі завдання", "аналітика", "генерація тексту"]
+        },
+        "llama-3-instruct": {
+            "model_id": "meta-llama/Llama-3.1-8B-Instruct",
+            "description": "Потужна інструктивна модель від Meta",
+            "likes": 3612,
+            "downloads": 6035070,
+            "parameters": {
+                "max_tokens": 4096,
+                "temperature": 0.8,
+                "top_p": 0.9,
+                "frequency_penalty": 0.0,
+                "presence_penalty": 0.0
+            },
+            "recommended_use": ["діалоги", "інструкції", "навчальні матеріали"]
+        },
+        "mistral-instruct": {
+            "model_id": "mistralai/Mistral-7B-Instruct-v0.2",
+            "description": "Оптимізована інструктивна модель",
+            "likes": 2650,
+            "downloads": 3415777,
+            "parameters": {
+                "max_tokens": 2048,
+                "temperature": 0.3,
+                "top_p": 0.9,
+                "frequency_penalty": 0.0,
+                "presence_penalty": 0.0
+            },
+            "recommended_use": ["наукові дослідження", "структуровані відповіді"]
+        },
+        "gpt2": {
+            "model_id": "openai-community/gpt2",
+            "description": "Найбільш завантажувана модель",
+            "likes": 2565,
+            "downloads": 18299067,
+            "parameters": {
+                "max_tokens": 1024,
+                "temperature": 0.9,
+                "top_p": 0.9,
+                "frequency_penalty": 0.0,
+                "presence_penalty": 0.0
+            },
+            "recommended_use": ["базова генерація тексту", "прості завдання"]
+        },
+        "llama-3-1b": {
+            "model_id": "meta-llama/Llama-3.2-1B",
+            "description": "Легка версія Llama 3",
+            "likes": 1559,
+            "downloads": 8244484,
+            "parameters": {
+                "max_tokens": 2048,
+                "temperature": 0.8,
+                "top_p": 0.9,
+                "frequency_penalty": 0.0,
+                "presence_penalty": 0.0
+            },
+            "recommended_use": ["швидкі відповіді", "базова генерація"]
+        }
+    },
+    "default_model": "mistral-instruct",
+    "model_selection_criteria": {
+        "research": ["deepseek-r1", "mistral-instruct", "llama-3-instruct"],
+        "general": ["gpt2", "llama-3-1b"],
+        "instruction": ["mistral-instruct", "llama-3-instruct"]
+    }
+}

requirements.txt

@@ -1,5 +1,10 @@
-markdownify
-smolagents
-requests
-duckduckgo_search
-pandas
+smolagents==0.1.0
+gradio>=4.0.0
+python-dotenv>=0.19.0
+huggingface-hub>=0.19.0
+duckduckgo-search>=3.0.0
+markdownify>=0.11.0
+requests>=2.28.0
+logging>=0.5.1.2
+pandas>=1.3.0
+numpy>=1.21.0

tools/__init__.py

@@ -0,0 +1,11 @@
+from .web_search import DuckDuckGoSearchTool
+from .final_answer import FinalAnswerTool
+from .healthcare_llm_visualizer import HealthcareLLMVisualizerTool
+from .visit_webpage import VisitWebpageTool
+
+__all__ = [
+    'DuckDuckGoSearchTool', 
+    'FinalAnswerTool', 
+    'HealthcareLLMVisualizerTool',
+    'VisitWebpageTool'
+]

tools/final_answer.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Dict, Union, List
 from smolagents.tools import Tool
 import logging
 from datetime import datetime
@@ -14,14 +14,11 @@ class FinalAnswerTool(Tool):
             'description': 'The final research report content'
         }
     }
-    output_type = "any"
+    output_type = "string"  # Changed from 'str' to 'string'
 
-    def _format_report(self, content: Union[str, Dict]) -> str:
-        """Format content as a proper research report"""
-        if isinstance(content, str):
-            return content
-
-        required_sections = [
+    def __init__(self):
+        super().__init__()
+        self.sections = [
             "Executive Summary",
             "Introduction",
             "Methodology",
@@ -31,28 +28,55 @@ class FinalAnswerTool(Tool):
             "References"
         ]
 
-        # Ensure all required sections are present
-        for section in required_sections:
-            if section not in content:
-                content[section] = f"{section} section was not provided"
-
-        # Create formatted report
-        report = [
-            f"# Research Report",
-            f"*Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*\n",
-        ]
+    def _format_list_content(self, content: List) -> str:
+        """Format list content into readable text"""
+        try:
+            return "\n".join([f"- {item}" for item in content])
+        except Exception as e:
+            logger.error(f"Error formatting list content: {e}")
+            return str(content)
 
-        # Add each section
-        for section in required_sections:
-            report.extend([
+    def _format_dict_content(self, content: Dict) -> str:
+        """Format dictionary content into sections"""
+        formatted_sections = []
+        
+        for section in self.sections:
+            section_content = content.get(section, f"{section} section was not provided")
+            if isinstance(section_content, list):
+                section_content = self._format_list_content(section_content)
+            formatted_sections.extend([
                 f"## {section}",
-                content[section],
+                str(section_content),
                 ""  # Empty line for better readability
             ])
+        
+        return "\n".join(formatted_sections)
+
+    def _format_report(self, content: Any) -> str:
+        """Format content as a proper research report"""
+        try:
+            # Create report header
+            report_parts = [
+                "# Науковий звіт",
+                f"*Згенеровано: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*\n"
+            ]
 
-        return "\n".join(report)
+            # Handle different content types
+            if isinstance(content, dict):
+                report_parts.append(self._format_dict_content(content))
+            elif isinstance(content, list):
+                report_parts.append(self._format_list_content(content))
+            else:
+                report_parts.append(str(content))
 
-    def forward(self, answer: Any) -> Any:
+            return "\n".join(report_parts)
+
+        except Exception as e:
+            error_msg = f"Error formatting report: {str(e)}"
+            logger.error(error_msg)
+            return f"# Error in Report Generation\n\n{error_msg}\n\nRaw content:\n{str(content)}"
+
+    def forward(self, answer: Any) -> str:
         """Process and return the final answer"""
         logger.info("Formatting final research report")
         try:
@@ -62,8 +86,4 @@ class FinalAnswerTool(Tool):
         except Exception as e:
             error_msg = f"Error formatting research report: {str(e)}"
             logger.error(error_msg)
-            return error_msg
-
-    def __init__(self, *args, **kwargs):
-        self.is_initialized = False
-        super().__init__(*args, **kwargs)
+            return error_msg

tools/healthcare_llm_visualizer.py

@@ -6,13 +6,13 @@ class HealthcareLLMVisualizerTool(Tool):
     description = "Creates interactive visualizations for analyzing LLM applications in Healthcare"
     inputs = {
         'data': {
-            'type': 'object',
+            'type': 'object',  # Using 'object' for dictionary input
             'description': 'Data for visualization in format: {"items": [{"category": "name", "value": number}]}'
         }
     }
-    output_type = "string"
+    output_type = "string"  # Changed from 'str' to 'string'
 
-    def prepare_data(self, raw_data: Dict) -> List[Dict[str, Any]]:
+    def prepare_data(self, raw_data: Dict) -> Dict[str, List[Dict[str, Any]]]:
         """Convert raw data into format suitable for visualization"""
         categories = {}
         

tools/visit_webpage.py

@@ -1,13 +1,19 @@
 from typing import Any, Optional
 from smolagents.tools import Tool
 import requests
+import re
 import markdownify
 import smolagents
 
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
     description = "Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages."
-    inputs = {'url': {'type': 'string', 'description': 'The url of the webpage to visit.'}}
+    inputs = {
+        'url': {
+            'type': 'string',
+            'description': 'The url of the webpage to visit.'
+        }
+    }
     output_type = "string"
 
     def forward(self, url: str) -> str:
@@ -15,7 +21,6 @@ class VisitWebpageTool(Tool):
             import requests
             from markdownify import markdownify
             from requests.exceptions import RequestException
-
             from smolagents.utils import truncate_content
         except ImportError as e:
             raise ImportError(
@@ -42,4 +47,4 @@ class VisitWebpageTool(Tool):
             return f"An unexpected error occurred: {str(e)}"
 
     def __init__(self, *args, **kwargs):
-        self.is_initialized = False
+        self.is_initialized = False

tools/web_search.py

@@ -1,20 +1,14 @@
-from typing import Any, Optional, List, Dict
+from typing import Any, Optional
 from smolagents.tools import Tool
 import duckduckgo_search
-import logging
-import re
-from datetime import datetime
-from collections import defaultdict
-
-logger = logging.getLogger(__name__)
 
 class DuckDuckGoSearchTool(Tool):
     name = "web_search"
-    description = "Performs comprehensive web searches with focus on academic and scientific sources"
+    description = "Performs a duckduckgo web search based on your query (think a Google search) then returns the top search results."
     inputs = {
         'query': {
             'type': 'string',
-            'description': 'The search query to perform'
+            'description': 'The search query to perform.'
         }
     }
     output_type = "string"
@@ -26,95 +20,24 @@ class DuckDuckGoSearchTool(Tool):
             from duckduckgo_search import DDGS
         except ImportError as e:
             raise ImportError(
-                "Required package `duckduckgo_search` not found. Install with: pip install duckduckgo-search"
+                "You must install package `duckduckgo_search` to run this tool: for instance run `pip install duckduckgo-search`."
             ) from e
         self.ddgs = DDGS(**kwargs)
 
-    def _extract_date(self, text: str) -> Optional[str]:
-        """Extract publication date from text if available"""
-        try:
-            # Common date patterns
-            patterns = [
-                r'\b(20\d{2})\b',  # Year pattern
-                r'\b(19\d{2})\b',  # Year pattern for older papers
-                r'\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]* \d{1,2},? 20\d{2}\b'
-            ]
-            
-            for pattern in patterns:
-                match = re.search(pattern, text)
-                if match:
-                    return match.group(0)
-            return None
-        except Exception as e:
-            logger.error(f"Error extracting date: {e}")
-            return None
-
-    def _parse_search_result(self, result: Dict[str, str]) -> Dict[str, Any]:
-        """Parse a single search result safely"""
-        try:
-            title = result.get('title', '').strip()
-            url = result.get('link', '')
-            description = result.get('body', '').strip()
-            date = self._extract_date(description) or 'Date not found'
-            
-            return {
-                'title': title,
-                'url': url,
-                'description': description,
-                'date': date
-            }
-        except Exception as e:
-            logger.error(f"Error parsing search result: {e}")
-            return {}
-
-    def _format_results(self, results: List[Dict[str, str]]) -> str:
-        """Format search results with academic focus"""
-        if not results:
-            return "No results found. Consider refining your search terms."
-
-        formatted_output = ["## Search Results\n"]
+    def forward(self, query: str) -> str:
+        results = list(self.ddgs.text(query, max_results=self.max_results))
+        if len(results) == 0:
+            raise Exception("No results found! Try a less restrictive/shorter query.")
+        
+        # Print result structure for debugging
+        if results:
+            print("Result keys:", results[0].keys())
         
+        postprocessed_results = []
         for result in results:
-            parsed = self._parse_search_result(result)
-            if parsed and parsed.get('title'):
-                formatted_output.extend([
-                    f"### {parsed['title']}",
-                    f"**Source:** [{parsed['url']}]({parsed['url']})",
-                    f"**Date:** {parsed['date']}",
-                    f"**Summary:** {parsed['description']}\n"
-                ])
-
-        return "\n".join(formatted_output)
-
-    def forward(self, query: str) -> str:
-        """Execute search and return formatted results"""
-        logger.info(f"Performing web search for query: {query}")
-        try:
-            # Add academic focus to search if not present
-            academic_terms = ['research', 'study', 'journal', 'paper']
-            if not any(term in query.lower() for term in academic_terms):
-                query = f"{query} research study"
-
-            # Execute search with error handling
-            try:
-                results = list(self.ddgs.text(query, max_results=self.max_results))
-                if not results:
-                    return "No results found. Try modifying your search terms."
-            except Exception as e:
-                logger.error(f"Search execution error: {e}")
-                return f"Error performing search: {str(e)}"
-
-            # Format results
-            formatted_output = self._format_results(results)
-            logger.info("Search completed successfully")
-            return formatted_output
-            
-        except Exception as e:
-            error_msg = f"Error during web search: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
-
-    def __del__(self):
-        """Cleanup when object is destroyed"""
-        if hasattr(self, 'ddgs'):
-            self.ddgs = None
+            title = result.get('title', '')
+            url = result.get('link', '') or result.get('href', '')
+            body = result.get('body', '') or result.get('snippet', '')
+            postprocessed_results.append(f"[{title}]({url})\n{body}")
+        
+        return "## Search Results\n\n" + "\n\n".join(postprocessed_results)