Upload 7 files

README.md

@@ -1,13 +1,208 @@
+# 🚀 Production RAG Agent - Complete Setup
+
+## 🎯 What You Have
+
+I've created a complete, production-ready RAG (Retrieval-Augmented Generation) agent system with:
+
+### Core Files Created
+- ✅ `app.py` - Main Gradio application with professional UI
+- ✅ `config.py` - Centralized configuration management
+- ✅ `retriever.py` - Advanced document retrieval system
+- ✅ `tools.py` - Multiple custom tools for the agent
+- ✅ `requirements.txt` - All necessary dependencies
+- ✅ `setup.py` - Automated setup script
+- ✅ `knowledge_base/` - Folder for your documents
+- ✅ `vector_store/` - For AI embeddings storage
+- ✅ `logs/` - For system logs
+
+### Key Features
+🤖 **Agentic RAG** using Hugging Face's smolagents
+🔍 **Hybrid Search** (semantic + keyword)
+🌐 **Web Search** for current information
+📚 **Knowledge Base** support
+🛠️ **Multi-tool Support** (weather, math, time, etc.)
+💬 **Professional Chat Interface**
+
+## 🚀 Quick Start Options
+
+### Option 1: Local Testing (Recommended First)
+
+1. **Open Terminal/Command Prompt** in the project folder:
+   ```bash
+   cd "C:\Users\j_car\Desktop\Production_RAG_Agent"
+   ```
+
+2. **Run the setup script**:
+   ```bash
+   python setup.py
+   ```
+
+3. **Set your Hugging Face token**:
+   ```bash
+   # Windows Command Prompt:
+   set HF_TOKEN=your_hugging_face_token_here
+   
+   # Windows PowerShell:
+   $env:HF_TOKEN="your_hugging_face_token_here"
+   ```
+
+4. **Launch the application**:
+   ```bash
+   python app.py
+   ```
+
+5. **Open your browser** to `http://localhost:7860`
+
+### Option 2: Deploy to Hugging Face Spaces (Production)
+
+1. **Go to your space**: https://huggingface.co/spaces/JimmyBhoy/Production_RAG_Agent
+
+2. **Upload files** (drag and drop or use the file upload):
+   - `app.py`
+   - `config.py`
+   - `retriever.py`
+   - `tools.py`
+   - `requirements.txt`
+
+3. **Set environment variables** in Space Settings:
+   - `HF_TOKEN` = your_hugging_face_token
+
+4. **Upload documents** to `knowledge_base/` folder (optional)
+
+5. **Space will automatically build and deploy!**
+
+## 🔧 Configuration
+
+### Required Environment Variables
+```bash
+HF_TOKEN=your_hugging_face_token_here
+```
+
+### Optional API Keys (for enhanced features)
+```bash
+OPENWEATHER_API_KEY=your_weather_api_key
+SERPER_API_KEY=your_search_api_key
+```
+
+## 📚 Adding Your Knowledge Base
+
+1. **Add documents** to the `knowledge_base/` folder:
+   - Text files (`.txt`, `.md`)
+   - PDFs (`.pdf`)
+   - Data files (`.json`, `.csv`)
+
+2. **Restart the application** - it will automatically:
+   - Process your documents
+   - Create embeddings
+   - Build a searchable vector database
+
+## 🎯 Usage Examples
+
+### Basic Queries
+- "What is machine learning?"
+- "Tell me about recent AI developments"
+- "What's the weather in London?"
+
+### Knowledge Base Queries (after adding documents)
+- "Summarize our company policy document"
+- "What does the API documentation say about authentication?"
+
+### Complex Multi-step Queries
+- "Search for recent news about electric vehicles, then analyze it"
+- "What's the current weather and how might it affect operations?"
+
+## 🛠️ Customization
+
+### Adding More Tools
+Edit `tools.py` to add custom functions:
+```python
+@tool
+def my_custom_tool(parameter: str) -> str:
+    """Your custom tool description"""
+    # Your logic here
+    return "Tool result"
+```
+
+### Modifying the Interface
+Edit `app.py` to customize the Gradio interface:
+- Change themes and styling
+- Add more examples
+- Modify the layout
+
+### Adjusting AI Behavior
+Edit `config.py` to tune:
+- Model selection
+- Response length
+- Search parameters
+- Chunk sizes
+
+## 🔍 Troubleshooting
+
+### Common Issues & Solutions
+
+1. **Import Errors**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **No HF Token Error**:
+   - Get token from: https://huggingface.co/settings/tokens
+   - Set as environment variable
+
+3. **No Search Results**:
+   - Add documents to `knowledge_base/` folder
+   - Restart the application
+
+4. **Web Search Not Working**:
+   ```bash
+   pip install duckduckgo-search
+   ```
+
+### Performance Tips
+- **Faster responses**: Reduce `TOP_K_RETRIEVAL` in config
+- **Better accuracy**: Increase `CHUNK_SIZE` in config
+- **More context**: Increase `MAX_TOKENS` in config
+
+## 📈 Production Deployment
+
+### For Hugging Face Spaces
+- ✅ Automatic scaling
+- ✅ HTTPS enabled
+- ✅ Global CDN
+- ✅ Easy sharing
+- ✅ Version control
+
+### For Custom Deployment
+- Use Docker for containerization
+- Set up reverse proxy (nginx)
+- Configure SSL certificates
+- Monitor with logging
+
+## 🆘 Getting Help
+
+1. **Check the logs** in the `logs/` folder
+2. **Review error messages** in the terminal
+3. **Test individual components** with the setup script
+4. **Check Hugging Face Space discussions** for community help
+
+## 🎉 Next Steps
+
+1. **Test locally first** to understand the system
+2. **Add your own documents** to the knowledge base
+3. **Deploy to Hugging Face Spaces** for production use
+4. **Customize tools and interface** for your specific needs
+5. **Share with your team** and gather feedback
+
 ---
-title: Production RAG Agent
-emoji: 📉
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 5.43.1
-app_file: app.py
-pinned: false
-short_description: Production-ready Agentic RAG system based on Unit_3_Agentic_
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**You now have a complete, production-ready RAG system!** 🚀
+
+This system combines the latest AI techniques with practical deployment options. Whether you use it locally or deploy to Hugging Face Spaces, you'll have a powerful AI assistant that can:
+
+- Answer questions using multiple information sources
+- Search the web for current information
+- Process your own documents and data
+- Perform complex multi-step reasoning
+- Provide cited, accurate responses
+
+**Happy RAGging!** 🤖✨

app.py

@@ -0,0 +1,115 @@
+        
+        **Model**: {self.config.MODEL_NAME}
+        **Available Tools**: {', '.join(tool_names)}
+        **Max Iterations**: {self.config.MAX_ITERATIONS}
+        **Status**: ✅ Ready
+        
+        **Capabilities**:
+        - Web search for current information
+        - Document retrieval from knowledge base
+        - Weather information
+        - Multi-step reasoning and planning
+        - Source attribution
+        """
+
+# Initialize the RAG agent
+rag_agent = ProductionRAGAgent()
+
+def chat_interface(message: str, history: List) -> str:
+    """Gradio chat interface function"""
+    return rag_agent.query(message, history)
+
+def get_info() -> str:
+    """Get agent information"""
+    return rag_agent.get_agent_info()
+
+# Create Gradio interface
+def create_interface():
+    """Create the Gradio web interface"""
+    
+    with gr.Blocks(
+        title="Production RAG Agent",
+        theme=gr.themes.Soft(),
+        css="""
+        .container { max-width: 1200px; margin: auto; }
+        .header { text-align: center; margin-bottom: 30px; }
+        .info-box { background: #f8f9fa; padding: 20px; border-radius: 10px; margin: 10px 0; }
+        """
+    ) as demo:
+        
+        # Header
+        with gr.Row():
+            gr.HTML("""
+            <div class="header">
+                <h1>🚀 Production RAG Agent</h1>
+                <p>Advanced Retrieval-Augmented Generation with Multi-Tool Support</p>
+            </div>
+            """)
+        
+        # Main interface
+        with gr.Row():
+            with gr.Column(scale=3):
+                # Chat interface
+                chatbot = gr.ChatInterface(
+                    fn=chat_interface,
+                    title="💬 Chat with RAG Agent",
+                    description="Ask questions and get answers from multiple information sources",
+                    examples=[
+                        "What are the latest developments in AI?",
+                        "Explain how transformer models work",
+                        "What's the weather like today?",
+                        "Compare different machine learning algorithms",
+                        "Tell me about recent research in computer vision"
+                    ],
+                    retry_btn="🔄 Retry",
+                    undo_btn="↶ Undo",
+                    clear_btn="🗑️ Clear",
+                    submit_btn="📤 Send"
+                )
+            
+            with gr.Column(scale=1):
+                # Agent information panel
+                with gr.Group():
+                    gr.Markdown("### 🤖 Agent Status")
+                    info_display = gr.Markdown(value=get_info())
+                    refresh_btn = gr.Button("🔄 Refresh Status", size="sm")
+                    refresh_btn.click(fn=get_info, outputs=info_display)
+                
+                # Usage tips
+                with gr.Group():
+                    gr.Markdown("""
+                    ### 💡 Usage Tips
+                    
+                    **Best Practices:**
+                    - Be specific in your questions
+                    - Ask for sources when needed
+                    - Use follow-up questions for clarification
+                    
+                    **Available Features:**
+                    - 🌐 Web search for current info
+                    - 📚 Document knowledge retrieval
+                    - 🌤️ Weather information
+                    - 🧠 Multi-step reasoning
+                    """)
+        
+        # Footer
+        with gr.Row():
+            gr.HTML("""
+            <div style="text-align: center; margin-top: 30px; padding: 20px; background: #f1f3f4; border-radius: 10px;">
+                <p><strong>Production RAG Agent</strong> - Powered by Hugging Face 🤗</p>
+                <p>Built with smolagents, Gradio, and advanced retrieval techniques</p>
+            </div>
+            """)
+    
+    return demo
+
+# Create and launch the interface
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.queue()
+    demo.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )

config.py

@@ -0,0 +1,139 @@
+import os
+from pathlib import Path
+
+class RAGConfig:
+    """Configuration settings for the RAG Agent"""
+    
+    # Model settings
+    MODEL_NAME = "microsoft/DialoGPT-medium"  # Default model, can be changed
+    EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+    
+    # Agent settings
+    MAX_ITERATIONS = 5
+    TEMPERATURE = 0.7
+    MAX_TOKENS = 2048
+    
+    # Retrieval settings
+    CHUNK_SIZE = 512
+    CHUNK_OVERLAP = 50
+    TOP_K_RETRIEVAL = 5
+    SIMILARITY_THRESHOLD = 0.7
+    
+    # Paths
+    BASE_DIR = Path(__file__).parent
+    KNOWLEDGE_BASE_PATH = BASE_DIR / "knowledge_base"
+    VECTOR_STORE_PATH = BASE_DIR / "vector_store"
+    LOGS_PATH = BASE_DIR / "logs"
+    
+    # API Keys (set as environment variables)
+    HF_TOKEN = os.getenv("HF_TOKEN")
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+    
+    # Web search settings
+    MAX_SEARCH_RESULTS = 5
+    SEARCH_TIMEOUT = 10
+    
+    # Vector database settings
+    VECTOR_DB_TYPE = "faiss"  # Options: faiss, chroma, pinecone
+    PERSIST_DIRECTORY = str(VECTOR_STORE_PATH)
+    
+    # Gradio settings
+    GRADIO_SHARE = True
+    GRADIO_PORT = 7860
+    GRADIO_HOST = "0.0.0.0"
+    
+    # Supported file types for knowledge base
+    SUPPORTED_EXTENSIONS = ['.txt', '.md', '.pdf', '.docx', '.json', '.csv']
+    
+    # Advanced settings
+    USE_RERANKING = True
+    RERANKER_MODEL = "cross-encoder/ms-marco-MiniLM-L-2-v2"
+    
+    # Logging
+    LOG_LEVEL = "INFO"
+    LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    
+    def __init__(self):
+        """Initialize configuration and create necessary directories"""
+        self._create_directories()
+        self._validate_config()
+    
+    def _create_directories(self):
+        """Create necessary directories if they don't exist"""
+        directories = [
+            self.KNOWLEDGE_BASE_PATH,
+            self.VECTOR_STORE_PATH,
+            self.LOGS_PATH
+        ]
+        
+        for directory in directories:
+            directory.mkdir(parents=True, exist_ok=True)
+    
+    def _validate_config(self):
+        """Validate configuration settings"""
+        # Check if HF token is available
+        if not self.HF_TOKEN:
+            print("⚠️ Warning: HF_TOKEN not set. Some features may not work.")
+        
+        # Validate paths
+        if not self.BASE_DIR.exists():
+            raise ValueError(f"Base directory does not exist: {self.BASE_DIR}")
+    
+    def get_model_config(self) -> dict:
+        """Get model configuration dictionary"""
+        return {
+            "model_name": self.MODEL_NAME,
+            "temperature": self.TEMPERATURE,
+            "max_tokens": self.MAX_TOKENS,
+            "token": self.HF_TOKEN
+        }
+    
+    def get_retrieval_config(self) -> dict:
+        """Get retrieval configuration dictionary"""
+        return {
+            "chunk_size": self.CHUNK_SIZE,
+            "chunk_overlap": self.CHUNK_OVERLAP,
+            "top_k": self.TOP_K_RETRIEVAL,
+            "similarity_threshold": self.SIMILARITY_THRESHOLD,
+            "embedding_model": self.EMBEDDING_MODEL,
+            "reranker_model": self.RERANKER_MODEL if self.USE_RERANKING else None
+        }
+    
+    def get_gradio_config(self) -> dict:
+        """Get Gradio configuration dictionary"""
+        return {
+            "share": self.GRADIO_SHARE,
+            "server_port": self.GRADIO_PORT,
+            "server_name": self.GRADIO_HOST
+        }
+    
+    @classmethod
+    def from_env(cls):
+        """Create configuration from environment variables"""
+        instance = cls()
+        
+        # Override with environment variables if available
+        env_mappings = {
+            "RAG_MODEL_NAME": "MODEL_NAME",
+            "RAG_MAX_ITERATIONS": "MAX_ITERATIONS",
+            "RAG_TEMPERATURE": "TEMPERATURE",
+            "RAG_CHUNK_SIZE": "CHUNK_SIZE",
+            "RAG_TOP_K": "TOP_K_RETRIEVAL"
+        }
+        
+        for env_var, attr_name in env_mappings.items():
+            env_value = os.getenv(env_var)
+            if env_value:
+                # Convert to appropriate type
+                if attr_name in ["MAX_ITERATIONS", "CHUNK_SIZE", "TOP_K_RETRIEVAL"]:
+                    setattr(instance, attr_name, int(env_value))
+                elif attr_name in ["TEMPERATURE"]:
+                    setattr(instance, attr_name, float(env_value))
+                else:
+                    setattr(instance, attr_name, env_value)
+        
+        return instance
+
+# Global config instance
+config = RAGConfig.from_env()

requirements.txt

@@ -0,0 +1,44 @@
+# Core dependencies
+gradio>=4.0.0
+smolagents>=0.1.0
+transformers>=4.35.0
+torch>=2.0.0
+huggingface_hub>=0.20.0
+
+# RAG and retrieval
+langchain>=0.1.0
+langchain-community>=0.0.10
+langchain-huggingface>=0.0.3
+sentence-transformers>=2.2.2
+faiss-cpu>=1.7.4
+
+# Document processing
+pypdf>=3.17.0
+python-docx>=1.1.0
+openpyxl>=3.1.0
+
+# Data processing
+pandas>=2.0.0
+numpy>=1.24.0
+
+# Web search and APIs
+duckduckgo-search>=3.9.0
+requests>=2.31.0
+beautifulsoup4>=4.12.0
+
+# Time and timezone handling
+pytz>=2023.3
+
+# Logging and utilities
+python-dotenv>=1.0.0
+pydantic>=2.5.0
+
+# Optional: Advanced features
+# rank_bm25>=0.2.2
+# chromadb>=0.4.0
+# openai>=1.0.0
+
+# Development (optional)
+# black>=23.0.0
+# pytest>=7.0.0
+# jupyter>=1.0.0

retriever.py

@@ -0,0 +1,117 @@
+    
+    def add_document(self, content: str, metadata: Dict[str, Any] = None) -> bool:
+        """Add a new document to the knowledge base"""
+        try:
+            # Create document
+            doc = Document(page_content=content, metadata=metadata or {})
+            
+            # Add to documents list
+            self.documents.append(doc)
+            
+            # Update vector store if it exists
+            if self.vector_store and self.embeddings:
+                chunks = self.text_splitter.split_documents([doc])
+                self.vector_store.add_documents(chunks)
+                
+                # Save updated vector store
+                vector_store_path = self.config.VECTOR_STORE_PATH / "faiss_index"
+                self.vector_store.save_local(str(vector_store_path))
+            
+            logger.info("Successfully added document to knowledge base")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error adding document: {e}")
+            return False
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about the knowledge base"""
+        return {
+            'total_documents': len(self.documents),
+            'vector_store_available': self.vector_store is not None,
+            'embedding_model': self.config.EMBEDDING_MODEL,
+            'knowledge_base_path': str(self.knowledge_base_path),
+            'supported_extensions': self.config.SUPPORTED_EXTENSIONS
+        }
+
+@tool
+def search_knowledge_base(query: str, search_type: str = "hybrid", max_results: int = 5) -> str:
+    """
+    Search the knowledge base for relevant information.
+    
+    Args:
+        query: The search query
+        search_type: Type of search ('similarity', 'keyword', or 'hybrid')
+        max_results: Maximum number of results to return
+    
+    Returns:
+        Formatted search results with sources
+    """
+    try:
+        # Initialize retriever (global instance would be better in production)
+        retriever = DocumentRetriever()
+        
+        # Perform search based on type
+        if search_type == "similarity":
+            results = retriever.similarity_search(query, max_results)
+        elif search_type == "keyword":
+            results = retriever.keyword_search(query, max_results)
+        else:  # hybrid
+            results = retriever.hybrid_search(query, max_results)
+        
+        if not results:
+            return f"No relevant information found for query: '{query}'"
+        
+        # Format results
+        formatted_results = []
+        for i, result in enumerate(results, 1):
+            content = result['content'][:500] + "..." if len(result['content']) > 500 else result['content']
+            source = result.get('source', 'Unknown source')
+            score = result.get('similarity_score', result.get('keyword_score', result.get('combined_score', 0)))
+            
+            formatted_results.append(f"""
+**Result {i}** (Score: {score:.3f})
+Source: {source}
+Content: {content}
+""")
+        
+        return "\n".join(formatted_results)
+        
+    except Exception as e:
+        return f"Error searching knowledge base: {str(e)}"
+
+def create_retriever_tool(retriever: DocumentRetriever):
+    """Create a tool function for the retriever"""
+    
+    @tool
+    def retriever_tool(query: str) -> str:
+        """
+        Retrieve relevant information from the knowledge base.
+        
+        Args:
+            query: The search query
+        
+        Returns:
+            Relevant information from the knowledge base
+        """
+        try:
+            results = retriever.hybrid_search(query)
+            
+            if not results:
+                return f"No relevant information found for: {query}"
+            
+            # Format results for the agent
+            formatted_output = []
+            for result in results:
+                content = result['content'][:800] + "..." if len(result['content']) > 800 else result['content']
+                source = Path(result.get('source', 'unknown')).name
+                
+                formatted_output.append(f"Source: {source}\n{content}")
+            
+            return "\n\n---\n\n".join(formatted_output)
+            
+        except Exception as e:
+            logger.error(f"Retriever tool error: {e}")
+            return f"Error retrieving information: {str(e)}"
+    
+    return retriever_tool

setup.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Setup script for Production RAG Agent
+Run this script to install dependencies and set up the environment
+"""
+
+import subprocess
+import sys
+import os
+from pathlib import Path
+
+def run_command(command):
+    """Run a shell command and return the result"""
+    try:
+        result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+        return True, result.stdout
+    except subprocess.CalledProcessError as e:
+        return False, e.stderr
+
+def main():
+    print("🚀 Setting up Production RAG Agent...")
+    print("=" * 50)
+    
+    # Check Python version
+    print(f"✓ Python version: {sys.version}")
+    
+    # Install dependencies
+    print("\n📦 Installing dependencies...")
+    success, output = run_command("pip install -r requirements.txt")
+    
+    if success:
+        print("✓ Dependencies installed successfully")
+    else:
+        print(f"❌ Error installing dependencies: {output}")
+        return
+    
+    # Check environment variables
+    print("\n🔑 Checking environment variables...")
+    
+    required_vars = ["HF_TOKEN"]
+    optional_vars = ["OPENWEATHER_API_KEY", "SERPER_API_KEY"]
+    
+    for var in required_vars:
+        if os.getenv(var):
+            print(f"✓ {var} is set")
+        else:
+            print(f"⚠️ {var} is not set (required for full functionality)")
+    
+    for var in optional_vars:
+        if os.getenv(var):
+            print(f"✓ {var} is set")
+        else:
+            print(f"ℹ️ {var} is not set (optional)")
+    
+    # Check directories
+    print("\n📁 Checking directories...")
+    base_dir = Path(__file__).parent
+    
+    directories = [
+        base_dir / "knowledge_base",
+        base_dir / "vector_store", 
+        base_dir / "logs"
+    ]
+    
+    for directory in directories:
+        if directory.exists():
+            print(f"✓ {directory.name} directory exists")
+        else:
+            directory.mkdir(parents=True, exist_ok=True)
+            print(f"✓ Created {directory.name} directory")
+    
+    # Test imports
+    print("\n🧪 Testing imports...")
+    
+    test_imports = [
+        "gradio",
+        "transformers", 
+        "torch",
+        "sentence_transformers",
+        "langchain"
+    ]
+    
+    for module in test_imports:
+        try:
+            __import__(module)
+            print(f"✓ {module}")
+        except ImportError:
+            print(f"❌ {module} (install failed)")
+    
+    print("\n" + "=" * 50)
+    print("🎉 Setup complete!")
+    print("\nNext steps:")
+    print("1. Set your HF_TOKEN environment variable")
+    print("2. Add documents to the knowledge_base folder")
+    print("3. Run: python app.py")
+    print("\nFor Hugging Face Spaces:")
+    print("1. Upload all files to your space")
+    print("2. Set HF_TOKEN in space settings")
+    print("3. Your space will automatically deploy!")
+
+if __name__ == "__main__":
+    main()

tools.py

@@ -0,0 +1,219 @@
+
+@tool
+def get_weather_info(location: str = "New York") -> str:
+    """
+    Get current weather information for a location.
+    
+    Args:
+        location: Location to get weather for (default: New York)
+    
+    Returns:
+        Current weather information
+    """
+    try:
+        # Using a free weather API (OpenWeatherMap)
+        api_key = os.getenv('OPENWEATHER_API_KEY')
+        
+        if not api_key:
+            # Fallback to mock data for demo
+            return f"""
+🌤️ **Weather for {location}** (Demo Data)
+Temperature: 22°C (72°F)
+Condition: Partly Cloudy
+Humidity: 65%
+Wind: 8 mph NW
+
+*Note: This is demo data. Set OPENWEATHER_API_KEY for real weather data.*
+"""
+        
+        # Real API call
+        base_url = "https://api.openweathermap.org/data/2.5/weather"
+        params = {
+            'q': location,
+            'appid': api_key,
+            'units': 'metric'
+        }
+        
+        response = requests.get(base_url, params=params, timeout=5)
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        weather_info = f"""
+🌤️ **Weather for {data['name']}, {data['sys']['country']}**
+Temperature: {data['main']['temp']:.1f}°C ({data['main']['temp'] * 9/5 + 32:.1f}°F)
+Feels like: {data['main']['feels_like']:.1f}°C
+Condition: {data['weather'][0]['description'].title()}
+Humidity: {data['main']['humidity']}%
+Pressure: {data['main']['pressure']} hPa
+Wind: {data['wind']['speed']} m/s
+
+Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+        return weather_info
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Weather API error: {e}")
+        return f"Unable to fetch weather data for {location}. API error: {str(e)}"
+    except Exception as e:
+        logger.error(f"Weather tool error: {e}")
+        return f"Error getting weather information: {str(e)}"
+
+@tool
+def calculate_math(expression: str) -> str:
+    """
+    Safely evaluate mathematical expressions.
+    
+    Args:
+        expression: Mathematical expression to evaluate (e.g., "2 + 2 * 3")
+    
+    Returns:
+        Result of the mathematical calculation
+    """
+    try:
+        # Simple evaluation for basic math operations
+        # In production, you might want to use a more sophisticated math parser
+        
+        # Remove any potentially dangerous characters
+        allowed_chars = "0123456789+-*/()., "
+        cleaned_expression = ''.join(c for c in expression if c in allowed_chars)
+        
+        if cleaned_expression != expression:
+            return f"Expression contains invalid characters. Cleaned: {cleaned_expression}"
+        
+        # Evaluate the expression
+        result = eval(cleaned_expression)
+        
+        return f"""
+🧮 **Mathematical Calculation**
+Expression: {expression}
+Result: {result}
+
+Calculated at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+    except ZeroDivisionError:
+        return "Error: Division by zero is not allowed."
+    except Exception as e:
+        logger.error(f"Math calculation error: {e}")
+        return f"Error calculating expression '{expression}': {str(e)}"
+
+@tool
+def get_current_time(timezone: str = "UTC") -> str:
+    """
+    Get current time for a specific timezone.
+    
+    Args:
+        timezone: Timezone (default: UTC)
+    
+    Returns:
+        Current date and time information
+    """
+    try:
+        from datetime import datetime
+        try:
+            import pytz
+            
+            if timezone == "UTC":
+                current_time = datetime.utcnow()
+                tz_info = "UTC"
+            else:
+                try:
+                    tz = pytz.timezone(timezone)
+                    current_time = datetime.now(tz)
+                    tz_info = timezone
+                except:
+                    # Fallback to UTC
+                    current_time = datetime.utcnow()
+                    tz_info = "UTC (fallback - invalid timezone provided)"
+        except ImportError:
+            # Fallback without pytz
+            current_time = datetime.now()
+            tz_info = "Local System Time"
+        
+        time_info = f"""
+🕒 **Current Time Information**
+Date: {current_time.strftime('%A, %B %d, %Y')}
+Time: {current_time.strftime('%H:%M:%S')}
+Timezone: {tz_info}
+ISO Format: {current_time.isoformat()}
+"""
+        
+        return time_info
+        
+    except Exception as e:
+        logger.error(f"Time tool error: {e}")
+        return f"Error getting current time: {str(e)}"
+
+@tool
+def text_summarizer(text: str, max_sentences: int = 3) -> str:
+    """
+    Summarize a given text to specified number of sentences.
+    
+    Args:
+        text: Text to summarize
+        max_sentences: Maximum number of sentences in summary (default: 3)
+    
+    Returns:
+        Summarized text
+    """
+    try:
+        import re
+        
+        if not text.strip():
+            return "No text provided to summarize."
+        
+        # Simple extractive summarization
+        # Split into sentences
+        sentences = re.split(r'[.!?]+', text.strip())
+        sentences = [s.strip() for s in sentences if s.strip()]
+        
+        if len(sentences) <= max_sentences:
+            return f"**Summary:** {text[:500]}..." if len(text) > 500 else text
+        
+        # Simple scoring based on sentence length and position
+        scored_sentences = []
+        for i, sentence in enumerate(sentences):
+            # Prefer sentences of medium length and earlier position
+            length_score = min(len(sentence.split()) / 15, 1.0)  # Normalize to words
+            position_score = 1.0 - (i / len(sentences))  # Earlier sentences get higher score
+            
+            total_score = length_score * 0.7 + position_score * 0.3
+            scored_sentences.append((sentence, total_score))
+        
+        # Sort by score and take top sentences
+        scored_sentences.sort(key=lambda x: x[1], reverse=True)
+        summary_sentences = [s[0] for s in scored_sentences[:max_sentences]]
+        
+        # Maintain original order
+        final_summary = []
+        for sentence in sentences:
+            if sentence in summary_sentences:
+                final_summary.append(sentence)
+                if len(final_summary) == max_sentences:
+                    break
+        
+        summary = '. '.join(final_summary) + '.'
+        
+        return f"""
+📄 **Text Summary**
+Original length: {len(text)} characters
+Summary length: {len(summary)} characters
+Sentences: {max_sentences}
+
+**Summary:** {summary}
+"""
+        
+    except Exception as e:
+        logger.error(f"Text summarization error: {e}")
+        return f"Error summarizing text: {str(e)}"
+
+# List of all available tools for easy import
+AVAILABLE_TOOLS = [
+    web_search,
+    get_weather_info,
+    calculate_math,
+    get_current_time,
+    text_summarizer
+]