Upload 33 files

README.md

@@ -1,12 +1,526 @@
----
-title: 8 Tools
-emoji: 🏢
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+tags:
+- building-mcp-track-enterprise
+- mcp
+- anthropic
+- enterprise-automation
+- gradio-hackathon
+- ai-agents
+- mcp-server
+---
+
+# 🚀 MissionControlMCP
+
+**Enterprise Automation MCP Server for Document Analysis, Data Processing & Business Intelligence**
+
+A fully functional Model Context Protocol (MCP) server providing 8 powerful enterprise automation tools for document processing, web scraping, semantic search, data visualization, and business analytics.
+
+Built for the **MCP 1st Birthday Hackathon – Winter 2025** (Track 1: Building MCP - Enterprise Category).
+
+🏆 **Hackathon Submission** | 🔧 **Track 1: Building MCP** | 🏢 **Enterprise Category**
+
+---
+
+## 📋 Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Tools](#tools)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Tool Examples](#tool-examples)
+- [Claude Desktop Integration](#claude-desktop-integration)
+- [Development](#development)
+- [Testing](#testing)
+- [Architecture](#architecture)
+- [Hackathon Submission](#hackathon-submission)
+
+---
+
+## 🎯 Overview
+
+**MissionControlMCP** is an enterprise-grade MCP server that provides intelligent automation capabilities through 8 specialized tools. It enables AI assistants like Claude to perform complex document processing, data analysis, web research, and business intelligence tasks.
+
+### Key Capabilities
+
+- **📄 Document Processing**: Extract text from PDFs, process and summarize content
+- **🌐 Web Intelligence**: Fetch and parse web content with clean text extraction
+- **🔍 Semantic Search**: RAG-based vector search using FAISS and sentence transformers
+- **📊 Data Visualization**: Generate charts from CSV/JSON data
+- **🔄 File Conversion**: Convert between PDF, TXT, and CSV formats
+- **📧 Email Classification**: Classify email intents using NLP
+- **📈 KPI Generation**: Calculate business metrics and generate insights
+
+---
+
+## 🧪 Quick Test
+
+```bash
+# Test all tools with sample files
+python test_samples.py
+```
+
+**See [TESTING.md](TESTING.md) for complete testing guide with examples!**
+
+---
+
+## ✨ Features
+
+- ✅ **8 Production-Ready Tools** for enterprise automation
+- ✅ **MCP Compliant** - Works with Claude Desktop and any MCP client
+- ✅ **Type-Safe** - Built with Python 3.11+ and type hints
+- ✅ **Modular Architecture** - Clean separation of concerns
+- ✅ **Comprehensive Testing** - Test suite included
+- ✅ **Well Documented** - Clear schemas and examples
+- ✅ **Vector Search** - RAG implementation with FAISS
+- ✅ **Data Visualization** - Base64 encoded chart generation
+- ✅ **NLP Classification** - Rule-based intent detection
+
+---
+
+## 🛠️ Tools
+
+### 1. **pdf_reader**
+Extract text and metadata from PDF files.
+
+**Input:**
+- `file_path`: Path to PDF file
+
+**Output:**
+- Extracted text from all pages
+- Page count
+- Document metadata (author, title, dates)
+
+---
+
+### 2. **text_extractor**
+Process and extract information from text.
+
+**Input:**
+- `text`: Raw text to process
+- `operation`: 'clean', 'summarize', 'chunk', or 'keywords'
+- `max_length`: Max length for summaries (default: 500)
+
+**Output:**
+- Processed text
+- Word count
+- Operation metadata
+
+---
+
+### 3. **web_fetcher**
+Fetch and extract content from web URLs.
+
+**Input:**
+- `url`: URL to fetch
+- `extract_text_only`: Extract text only (default: true)
+
+**Output:**
+- Clean text content or HTML
+- HTTP status code
+- Response metadata
+
+---
+
+### 4. **rag_search**
+Semantic search using RAG (Retrieval Augmented Generation).
+
+**Input:**
+- `query`: Search query
+- `documents`: List of documents to search
+- `top_k`: Number of results (default: 3)
+
+**Output:**
+- Ranked search results with similarity scores
+- Document snippets
+- Relevance rankings
+
+---
+
+### 5. **data_visualizer**
+Create data visualizations and charts.
+
+**Input:**
+- `data`: JSON or CSV string data
+- `chart_type`: 'bar', 'line', 'pie', or 'scatter'
+- `x_column`, `y_column`: Column names
+- `title`: Chart title
+
+**Output:**
+- Base64 encoded PNG image
+- Chart dimensions
+- Column information
+
+---
+
+### 6. **file_converter**
+Convert files between formats.
+
+**Input:**
+- `input_path`: Path to input file
+- `output_format`: 'txt', 'csv', or 'pdf'
+- `output_path`: Optional output path
+
+**Output:**
+- Output file path
+- Conversion status
+- File size
+
+**Supported Conversions:**
+- PDF → TXT
+- TXT → CSV
+- CSV → TXT
+
+---
+
+### 7. **email_intent_classifier**
+Classify email intent using NLP.
+
+**Input:**
+- `email_text`: Email content to classify
+
+**Output:**
+- Primary intent (inquiry, complaint, request, feedback, meeting, order, urgent, follow_up, thank_you, application)
+- Confidence score
+- Secondary intents
+
+---
+
+### 8. **kpi_generator**
+Generate business KPIs and insights.
+
+**Input:**
+- `data`: JSON string with business data
+- `metrics`: List of metrics - 'revenue', 'growth', 'efficiency', 'customer', 'operational'
+
+**Output:**
+- Calculated KPIs
+- Executive summary
+- Key trends and insights
+
+---
+
+## 📦 Installation
+
+### Prerequisites
+
+- Python 3.11 or higher
+- pip or uv package manager
+
+### Setup
+
+1. **Clone or download the repository:**
+
+```bash
+cd mission_control_mcp
+```
+
+2. **Install dependencies:**
+
+```bash
+pip install -r requirements.txt
+```
+
+Or using `uv`:
+
+```bash
+uv pip install -r requirements.txt
+```
+
+### Dependencies
+
+- `mcp` - Model Context Protocol SDK
+- `pypdf2` - PDF processing
+- `requests` + `beautifulsoup4` - Web scraping
+- `pandas` + `numpy` - Data processing
+- `faiss-cpu` + `sentence-transformers` - Vector search
+- `matplotlib` + `seaborn` - Data visualization
+- `scikit-learn` + `nltk` - NLP and ML
+
+---
+
+## 🚀 Usage
+
+### Running the Server
+
+#### For Development/Testing:
+
+```bash
+uvx mcp dev mission_control_mcp/mcp_server.py
+```
+
+Or with Python directly:
+
+```bash
+python mcp_server.py
+```
+
+#### For Production:
+
+The server runs via stdio and is designed to be integrated with MCP clients like Claude Desktop.
+
+---
+
+## 💡 Tool Examples
+
+### Example 1: Text Extraction & Summarization
+
+```json
+{
+  "tool": "text_extractor",
+  "arguments": {
+    "text": "Your long document text here...",
+    "operation": "summarize",
+    "max_length": 200
+  }
+}
+```
+
+### Example 2: Web Content Fetching
+
+```json
+{
+  "tool": "web_fetcher",
+  "arguments": {
+    "url": "https://example.com/article",
+    "extract_text_only": true
+  }
+}
+```
+
+### Example 3: Semantic Search
+
+```json
+{
+  "tool": "rag_search",
+  "arguments": {
+    "query": "machine learning algorithms",
+    "documents": [
+      "Document 1 about neural networks...",
+      "Document 2 about decision trees...",
+      "Document 3 about clustering..."
+    ],
+    "top_k": 3
+  }
+}
+```
+
+### Example 4: Data Visualization
+
+```json
+{
+  "tool": "data_visualizer",
+  "arguments": {
+    "data": "{\"month\": [\"Jan\", \"Feb\", \"Mar\"], \"sales\": [1000, 1500, 1200]}",
+    "chart_type": "bar",
+    "x_column": "month",
+    "y_column": "sales",
+    "title": "Q1 Sales Report"
+  }
+}
+```
+
+### Example 5: Email Intent Classification
+
+```json
+{
+  "tool": "email_intent_classifier",
+  "arguments": {
+    "email_text": "Hi, I need help with my recent order. It hasn't arrived yet and I'm wondering about the tracking status."
+  }
+}
+```
+
+### Example 6: KPI Generation
+
+```json
+{
+  "tool": "kpi_generator",
+  "arguments": {
+    "data": "{\"revenue\": 1000000, \"costs\": 600000, \"customers\": 500, \"current_revenue\": 1000000, \"previous_revenue\": 800000}",
+    "metrics": ["revenue", "growth", "efficiency"]
+  }
+}
+```
+
+---
+
+## 🖥️ Claude Desktop Integration
+
+### Configuration
+
+Add to your Claude Desktop config file (`claude_desktop_config.json`):
+
+**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "mission-control": {
+      "command": "python",
+      "args": [
+        "C:/Users/YourUser/path/to/mission_control_mcp/mcp_server.py"
+      ]
+    }
+  }
+}
+```
+
+Or with `uvx`:
+
+```json
+{
+  "mcpServers": {
+    "mission-control": {
+      "command": "uvx",
+      "args": [
+        "mcp",
+        "run",
+        "C:/Users/YourUser/path/to/mission_control_mcp/mcp_server.py"
+      ]
+    }
+  }
+}
+```
+
+### Usage in Claude
+
+After configuration, restart Claude Desktop. You can then ask Claude to:
+
+- "Extract text from this PDF file"
+- "Fetch content from this website and summarize it"
+- "Search these documents for information about X"
+- "Create a bar chart from this sales data"
+- "Classify the intent of this email"
+- "Generate KPIs from this business data"
+
+---
+
+## 🧪 Testing
+
+Run the comprehensive test suite:
+
+```bash
+python test_server.py
+```
+
+The test suite includes:
+- Text extraction and processing tests
+- Web fetching tests
+- RAG search demonstrations
+- Data visualization generation
+- Email classification examples
+- KPI calculation tests
+- Example JSON inputs for all tools
+
+---
+
+## 🏗️ Architecture
+
+```
+mission_control_mcp/
+├── mcp_server.py              # Main MCP server
+├── requirements.txt           # Dependencies
+├── test_server.py            # Test suite
+├── README.md                 # Documentation
+│
+├── tools/                    # Tool implementations
+│   ├── pdf_reader.py
+│   ├── text_extractor.py
+│   ├── web_fetcher.py
+│   ├── rag_search.py
+│   ├── data_visualizer.py
+│   ├── file_converter.py
+│   ├── email_intent_classifier.py
+│   └── kpi_generator.py
+│
+├── models/                   # Data schemas
+│   └── schemas.py
+│
+└── utils/                    # Utilities
+    ├── helpers.py            # Helper functions
+    └── rag_utils.py          # RAG/vector search utilities
+```
+
+### Design Principles
+
+- **Modularity**: Each tool is independently implemented
+- **Type Safety**: Pydantic schemas for validation
+- **Error Handling**: Comprehensive error catching and logging
+- **Clean Code**: Well-documented with docstrings
+- **Testability**: Easy to test individual components
+
+---
+
+## 🎖️ Hackathon Submission
+
+### Track 1: MCP Server
+
+**Server Name:** MissionControlMCP
+
+**Description:** Enterprise automation MCP server providing 8 specialized tools for document processing, web intelligence, semantic search, data visualization, and business analytics.
+
+### Key Features for Judges
+
+1. **Production-Ready**: All 8 tools are fully implemented and tested
+2. **MCP Compliant**: Follows MCP specification precisely
+3. **Real-World Value**: Solves actual enterprise automation needs
+4. **Clean Architecture**: Modular, maintainable, well-documented code
+5. **Advanced Features**: RAG search with FAISS, data visualization, NLP classification
+6. **Comprehensive Testing**: Full test suite with examples
+7. **Easy Integration**: Works seamlessly with Claude Desktop
+
+### Technical Highlights
+
+- **Vector Search**: FAISS-based semantic search with sentence transformers
+- **NLP Classification**: Rule-based email intent classifier with confidence scoring
+- **Data Visualization**: Dynamic chart generation with matplotlib
+- **File Processing**: Multi-format support (PDF, TXT, CSV)
+- **Web Intelligence**: Smart web scraping with clean text extraction
+- **Business Intelligence**: KPI calculation with trend analysis
+
+---
+
+## � Documentation & Examples
+
+- **[EXAMPLES.md](EXAMPLES.md)** - Real-world use cases, workflows, and ROI examples
+- **[HACKATHON_SUBMISSION.md](HACKATHON_SUBMISSION.md)** - Judge evaluation guide
+- **[VIDEO_SCRIPT.md](VIDEO_SCRIPT.md)** - Demo video script and talking points
+- **[examples/](examples/)** - Sample files for testing all tools:
+  - `sample_report.txt` - Business report for text extraction
+  - `business_data.csv` - Financial data for visualization & KPIs
+  - `sample_email_*.txt` - Email samples for intent classification
+  - `sample_documents.txt` - Documents for RAG search testing
+
+---
+
+## �📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Created for the MCP 1st Birthday Hackathon – Winter 2025.
+
+---
+
+## 🤝 Contributing
+
+This project was built for the hackathon, but improvements and suggestions are welcome! Check out [EXAMPLES.md](EXAMPLES.md) for usage patterns and best practices.
+
+---
+
+## 📧 Contact
+
+For questions about this MCP server, please reach out through the hackathon channels.
+
+---
+
+## 🌟 Acknowledgments
+
+- Built with the [Model Context Protocol SDK](https://github.com/modelcontextprotocol)
+- Powered by sentence-transformers, FAISS, and other open-source libraries
+- Created for the MCP 1st Birthday Hackathon 2025
+
+---
+
+**Happy Automating! 🚀**

app.py

@@ -0,0 +1,553 @@
+"""
+🚀 MissionControlMCP - Gradio Web Interface
+Beautiful GUI demo for all 8 tools!
+
+Run: python demo_gui.py
+Then share the public URL on LinkedIn!
+"""
+
+import gradio as gr
+import sys
+import os
+import json
+import base64
+from io import BytesIO
+from PIL import Image
+
+# Setup paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(SCRIPT_DIR)
+EXAMPLES_DIR = os.path.join(SCRIPT_DIR, "examples")
+
+# Import tools
+from tools.pdf_reader import read_pdf
+from tools.text_extractor import extract_text
+from tools.web_fetcher import fetch_web_content
+from tools.rag_search import search_documents
+from tools.data_visualizer import visualize_data
+from tools.file_converter import convert_file
+from tools.email_intent_classifier import classify_email_intent
+from tools.kpi_generator import generate_kpis
+
+
+# ============================================================================
+# TOOL FUNCTIONS
+# ============================================================================
+
+def tool_pdf_reader(pdf_file):
+    """PDF Reader tool"""
+    try:
+        if pdf_file is None:
+            return "❌ Please upload a PDF file!", None
+        
+        result = read_pdf(pdf_file.name)
+        
+        output = f"""✅ **PDF Analysis Complete!**
+
+📄 **Metadata:**
+- Pages: {result['pages']}
+- Characters: {len(result['text']):,}
+- Author: {result['metadata'].get('author', 'N/A')}
+- Title: {result['metadata'].get('title', 'N/A')}
+
+📝 **Extracted Text (first 1000 chars):**
+{result['text'][:1000]}...
+"""
+        
+        # Extract keywords
+        keywords = extract_text(result['text'], operation="keywords")
+        output += f"\n\n🔑 **Keywords:** {keywords['result']}"
+        
+        return output, None
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}", None
+
+
+def tool_text_extractor(text, operation, max_length):
+    """Text Extractor tool"""
+    try:
+        if not text.strip():
+            return "❌ Please enter some text!"
+        
+        result = extract_text(text, operation=operation, max_length=max_length)
+        
+        output = f"""✅ **Text Processing Complete!**
+
+📊 **Operation:** {operation.upper()}
+📏 **Word Count:** {result['word_count']}
+
+📝 **Result:**
+{result['result']}
+"""
+        
+        return output
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+def tool_web_fetcher(url):
+    """Web Fetcher tool"""
+    try:
+        if not url.strip():
+            return "❌ Please enter a URL!"
+        
+        result = fetch_web_content(url)
+        
+        if result['status_code'] == 999:
+            return f"""⚠️ **Status 999 - Bot Detection**
+
+The website is blocking automated requests.
+This is common for LinkedIn, Facebook, etc.
+
+Try a different website!"""
+        
+        output = f"""✅ **Website Fetched Successfully!**
+
+🌐 **URL:** {url}
+📊 **Status:** {result['status_code']}
+📄 **Title:** {result.get('title', 'N/A')}
+📏 **Content Length:** {len(result['content']):,} characters
+🔗 **Links Found:** {len(result.get('links', []))}
+
+📝 **Content Preview (first 1000 chars):**
+{result['content'][:1000]}...
+"""
+        
+        # Extract keywords
+        if len(result['content']) > 50:
+            keywords = extract_text(result['content'], operation="keywords")
+            output += f"\n\n🔑 **Keywords:** {keywords['result']}"
+        
+        return output
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+def tool_rag_search(query):
+    """RAG Search tool"""
+    try:
+        if not query.strip():
+            return "❌ Please enter a search query!"
+        
+        # Load sample documents
+        docs_file = os.path.join(EXAMPLES_DIR, "sample_documents.txt")
+        with open(docs_file, "r", encoding="utf-8") as f:
+            content = f.read()
+        
+        documents = [doc.strip() for doc in content.split("##") if doc.strip()]
+        
+        result = search_documents(query, documents, top_k=3)
+        
+        output = f"""✅ **Search Complete!**
+
+🔍 **Query:** "{query}"
+📚 **Documents Searched:** {len(documents)}
+📊 **Results Found:** {len(result['results'])}
+
+🎯 **Top Results:**
+
+"""
+        
+        for i, res in enumerate(result['results'], 1):
+            preview = res['document'][:200].replace('\n', ' ')
+            output += f"""
+**Result {i}** (Score: {res['score']:.4f})
+{preview}...
+
+"""
+        
+        return output
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+def tool_data_visualizer(csv_data, chart_type, x_col, y_col, title):
+    """Data Visualizer tool"""
+    try:
+        if not csv_data.strip():
+            return "❌ Please enter CSV data!", None
+        
+        result = visualize_data(
+            data=csv_data,
+            chart_type=chart_type,
+            x_column=x_col,
+            y_column=y_col,
+            title=title
+        )
+        
+        # Convert base64 to image
+        img_data = base64.b64decode(result['image_base64'])
+        image = Image.open(BytesIO(img_data))
+        
+        output = f"""✅ **Chart Created!**
+
+📊 **Chart Type:** {chart_type.upper()}
+📏 **Dimensions:** {result['dimensions']}
+📈 **Title:** {title}
+"""
+        
+        return output, image
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}", None
+
+
+def tool_email_classifier(email_text):
+    """Email Intent Classifier tool"""
+    try:
+        if not email_text.strip():
+            return "❌ Please enter email text!"
+        
+        result = classify_email_intent(email_text)
+        
+        output = f"""✅ **Email Classified!**
+
+🎯 **Primary Intent:** {result['intent'].upper()}
+📊 **Confidence:** {result['confidence']:.2%}
+
+💬 **Explanation:**
+{result['explanation']}
+"""
+        
+        if result['secondary_intents']:
+            output += "\n\n📋 **Secondary Intents:**\n"
+            for intent in result['secondary_intents'][:3]:
+                output += f"- {intent['intent']}: {intent['confidence']:.2%}\n"
+        
+        return output
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+def tool_kpi_generator(business_json, metrics):
+    """KPI Generator tool"""
+    try:
+        if not business_json.strip():
+            return "❌ Please enter business data!"
+        
+        # Validate JSON
+        json.loads(business_json)
+        
+        result = generate_kpis(business_json, metrics=metrics)
+        
+        output = f"""✅ **KPIs Generated!**
+
+📊 **Total KPIs Calculated:** {len(result['kpis'])}
+
+📈 **Key Metrics:**
+
+"""
+        
+        # Display top 15 KPIs
+        for i, (name, value) in enumerate(list(result['kpis'].items())[:15], 1):
+            # Format based on metric type
+            if 'percent' in name or 'rate' in name or 'margin' in name:
+                formatted = f"{value:.1f}%"
+            elif 'revenue' in name or 'profit' in name or 'cost' in name:
+                formatted = f"${value:,.0f}"
+            else:
+                formatted = f"{value:,.2f}"
+            
+            display_name = name.replace('_', ' ').title()
+            output += f"{i}. **{display_name}:** {formatted}\n"
+        
+        output += f"\n\n📝 **Executive Summary:**\n{result['summary']}"
+        
+        if result.get('trends'):
+            output += "\n\n📊 **Key Trends:**\n"
+            for trend in result['trends'][:5]:
+                output += f"- {trend}\n"
+        
+        return output
+        
+    except json.JSONDecodeError:
+        return "❌ Invalid JSON format! Please check your data."
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+# ============================================================================
+# LOAD SAMPLE DATA
+# ============================================================================
+
+def load_sample_csv():
+    csv_file = os.path.join(EXAMPLES_DIR, "business_data.csv")
+    with open(csv_file, "r") as f:
+        return f.read()
+
+def load_sample_email():
+    email_file = os.path.join(EXAMPLES_DIR, "sample_email_complaint.txt")
+    with open(email_file, "r", encoding="utf-8") as f:
+        return f.read()
+
+def load_sample_json():
+    return """{
+    "revenue": 5500000,
+    "costs": 3400000,
+    "customers": 2700,
+    "current_revenue": 5500000,
+    "previous_revenue": 5400000,
+    "current_customers": 2700,
+    "previous_customers": 2650,
+    "employees": 50,
+    "marketing_spend": 500000,
+    "sales": 5500000,
+    "cogs": 2000000
+}"""
+
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+# Custom CSS
+custom_css = """
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+.tab-label {
+    font-size: 16px !important;
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP Demo") as demo:
+    
+    gr.Markdown("""
+    # 🚀 MissionControlMCP - Enterprise Automation Tools
+    
+    **Try all 8 powerful tools in your browser!** No installation needed.
+    
+    📌 Built for the HuggingFace Gradio Hackathon | 🏆 Claude MCP Integration
+    """)
+    
+    with gr.Tabs():
+        
+        # ====== TAB 1: PDF READER ======
+        with gr.Tab("📄 PDF Reader"):
+            gr.Markdown("### Extract text and metadata from PDF documents")
+            
+            with gr.Row():
+                with gr.Column():
+                    pdf_input = gr.File(label="Upload PDF", file_types=[".pdf"])
+                    pdf_btn = gr.Button("🔍 Extract Text", variant="primary")
+                
+                with gr.Column():
+                    pdf_output = gr.Textbox(label="Results", lines=15)
+                    pdf_img = gr.Image(label="Preview", visible=False)
+            
+            pdf_btn.click(tool_pdf_reader, inputs=[pdf_input], outputs=[pdf_output, pdf_img])
+            
+            gr.Examples([["Use the file upload above to try with your own PDF!"]], inputs=[])
+        
+        # ====== TAB 2: TEXT EXTRACTOR ======
+        with gr.Tab("📝 Text Extractor"):
+            gr.Markdown("### Extract keywords, generate summaries, clean text")
+            
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Enter Text", 
+                        lines=8,
+                        placeholder="Paste your text here..."
+                    )
+                    text_operation = gr.Radio(
+                        ["keywords", "summarize", "clean", "chunk"],
+                        label="Operation",
+                        value="keywords"
+                    )
+                    text_length = gr.Slider(100, 1000, 300, label="Max Length (for summarize/chunk)")
+                    text_btn = gr.Button("✨ Process Text", variant="primary")
+                
+                with gr.Column():
+                    text_output = gr.Textbox(label="Results", lines=15)
+            
+            text_btn.click(
+                tool_text_extractor,
+                inputs=[text_input, text_operation, text_length],
+                outputs=[text_output]
+            )
+            
+            gr.Examples([
+                ["Artificial Intelligence is transforming businesses worldwide. Companies are leveraging AI for automation, decision-making, and customer service. Machine learning models can now process vast amounts of data and provide actionable insights.", "keywords", 300],
+                ["Climate change is one of the most pressing challenges of our time. Rising temperatures, extreme weather events, and environmental degradation require urgent action.", "summarize", 300]
+            ], inputs=[text_input, text_operation, text_length])
+        
+        # ====== TAB 3: WEB FETCHER ======
+        with gr.Tab("🌐 Web Fetcher"):
+            gr.Markdown("### Scrape and analyze web content")
+            
+            with gr.Row():
+                with gr.Column():
+                    web_input = gr.Textbox(
+                        label="Website URL",
+                        placeholder="https://example.com",
+                        value="https://example.com"
+                    )
+                    web_btn = gr.Button("🌐 Fetch Website", variant="primary")
+                
+                with gr.Column():
+                    web_output = gr.Textbox(label="Results", lines=15)
+            
+            web_btn.click(tool_web_fetcher, inputs=[web_input], outputs=[web_output])
+            
+            gr.Examples([
+                ["https://example.com"],
+                ["https://python.org"],
+                ["https://github.com"]
+            ], inputs=[web_input])
+        
+        # ====== TAB 4: RAG SEARCH ======
+        with gr.Tab("🔍 RAG Search"):
+            gr.Markdown("### Semantic document search with AI embeddings")
+            
+            with gr.Row():
+                with gr.Column():
+                    rag_input = gr.Textbox(
+                        label="Search Query",
+                        placeholder="What are you looking for?",
+                        value="What is machine learning?"
+                    )
+                    rag_btn = gr.Button("🔍 Search Documents", variant="primary")
+                
+                with gr.Column():
+                    rag_output = gr.Textbox(label="Search Results", lines=15)
+            
+            rag_btn.click(tool_rag_search, inputs=[rag_input], outputs=[rag_output])
+            
+            gr.Examples([
+                ["What is machine learning?"],
+                ["How to reduce carbon emissions?"],
+                ["What are modern web frameworks?"],
+                ["Digital marketing strategies"]
+            ], inputs=[rag_input])
+        
+        # ====== TAB 5: DATA VISUALIZER ======
+        with gr.Tab("📊 Data Visualizer"):
+            gr.Markdown("### Create beautiful charts from CSV data")
+            
+            with gr.Row():
+                with gr.Column():
+                    viz_csv = gr.Textbox(
+                        label="CSV Data",
+                        lines=8,
+                        value=load_sample_csv(),
+                        placeholder="month,revenue,costs\nJan,100000,60000"
+                    )
+                    viz_chart = gr.Radio(
+                        ["line", "bar", "pie", "scatter"],
+                        label="Chart Type",
+                        value="line"
+                    )
+                    viz_x = gr.Textbox(label="X Column", value="month")
+                    viz_y = gr.Textbox(label="Y Column", value="revenue")
+                    viz_title = gr.Textbox(label="Chart Title", value="Monthly Revenue")
+                    viz_btn = gr.Button("📊 Create Chart", variant="primary")
+                
+                with gr.Column():
+                    viz_output = gr.Textbox(label="Status", lines=5)
+                    viz_img = gr.Image(label="Chart")
+            
+            viz_btn.click(
+                tool_data_visualizer,
+                inputs=[viz_csv, viz_chart, viz_x, viz_y, viz_title],
+                outputs=[viz_output, viz_img]
+            )
+        
+        # ====== TAB 6: EMAIL CLASSIFIER ======
+        with gr.Tab("📧 Email Classifier"):
+            gr.Markdown("### Detect email intent with AI")
+            
+            with gr.Row():
+                with gr.Column():
+                    email_input = gr.Textbox(
+                        label="Email Text",
+                        lines=10,
+                        value=load_sample_email(),
+                        placeholder="Paste email content here..."
+                    )
+                    email_btn = gr.Button("🎯 Classify Email", variant="primary")
+                
+                with gr.Column():
+                    email_output = gr.Textbox(label="Classification Results", lines=15)
+            
+            email_btn.click(tool_email_classifier, inputs=[email_input], outputs=[email_output])
+            
+            gr.Examples([
+                ["I am writing to complain about the poor service I received at your store yesterday."],
+                ["Could you please send me more information about your pricing plans?"],
+                ["URGENT: The server is down and customers cannot access the website!"]
+            ], inputs=[email_input])
+        
+        # ====== TAB 7: KPI GENERATOR ======
+        with gr.Tab("📈 KPI Generator"):
+            gr.Markdown("### Calculate business metrics and KPIs")
+            
+            with gr.Row():
+                with gr.Column():
+                    kpi_json = gr.Textbox(
+                        label="Business Data (JSON)",
+                        lines=12,
+                        value=load_sample_json(),
+                        placeholder='{"revenue": 1000000, "costs": 600000}'
+                    )
+                    kpi_metrics = gr.CheckboxGroup(
+                        ["revenue", "growth", "efficiency", "customer", "operational"],
+                        label="Metrics to Calculate",
+                        value=["revenue", "growth", "efficiency"]
+                    )
+                    kpi_btn = gr.Button("📈 Generate KPIs", variant="primary")
+                
+                with gr.Column():
+                    kpi_output = gr.Textbox(label="KPI Report", lines=20)
+            
+            kpi_btn.click(
+                tool_kpi_generator,
+                inputs=[kpi_json, kpi_metrics],
+                outputs=[kpi_output]
+            )
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    
+    ### 🎯 About MissionControlMCP
+    
+    8 enterprise-grade automation tools integrated with Claude Desktop via Model Context Protocol (MCP).
+    
+    - **PDF Reader** - Extract text from documents
+    - **Text Extractor** - Keywords, summaries, cleaning
+    - **Web Fetcher** - Scrape websites
+    - **RAG Search** - Semantic document search
+    - **Data Visualizer** - Create charts
+    - **File Converter** - Format conversions
+    - **Email Classifier** - Intent detection
+    - **KPI Generator** - Business analytics
+    
+    🔗 **GitHub:** [AlBaraa-1/CleanEye-Hackathon](https://github.com/AlBaraa-1/CleanEye-Hackathon)
+    
+    🏆 Built for HuggingFace Gradio x BuildWithMCP Hackathon
+    """)
+
+
+# ============================================================================
+# LAUNCH
+# ============================================================================
+
+if __name__ == "__main__":
+    print("\n" + "="*80)
+    print("🚀 Launching MissionControlMCP Web Interface...")
+    print("="*80)
+    
+    # Launch with public sharing enabled
+    demo.launch(
+        share=True,  # Creates public URL!
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )

examples/business_data.csv

@@ -0,0 +1,13 @@
+month,revenue,costs,customers,employees
+January,4200000,2800000,2100,42
+February,4350000,2850000,2200,44
+March,4500000,2900000,2300,45
+April,4650000,2950000,2350,46
+May,4800000,3000000,2400,47
+June,4900000,3100000,2450,48
+July,4950000,3050000,2480,48
+August,5100000,3150000,2520,49
+September,5200000,3200000,2550,49
+October,5300000,3250000,2600,50
+November,5400000,3300000,2650,50
+December,5500000,3400000,2700,50

examples/sample_documents.txt

@@ -0,0 +1,31 @@
+# Sample Test Documents for RAG Search
+
+## Document 1: Artificial Intelligence Overview
+
+Artificial intelligence (AI) represents one of the most transformative technologies of our time. Machine learning, a subset of AI, enables computers to learn from data without explicit programming. Deep learning takes this further by using neural networks with multiple layers to process complex patterns.
+
+AI applications span numerous industries including healthcare, finance, transportation, and entertainment. Natural language processing allows machines to understand and generate human language, while computer vision enables image and video analysis.
+
+## Document 2: Climate Change and Sustainability
+
+Climate change poses one of the greatest challenges facing humanity. Rising global temperatures, extreme weather events, and sea level rise threaten ecosystems and human societies. Sustainable practices are essential for reducing carbon emissions and protecting our planet.
+
+Renewable energy sources like solar and wind power offer alternatives to fossil fuels. Energy efficiency improvements in buildings and transportation can significantly reduce environmental impact. Individual actions, from recycling to reducing consumption, contribute to collective climate solutions.
+
+## Document 3: Modern Web Development
+
+Web development has evolved significantly with modern frameworks and technologies. React, Vue, and Angular dominate frontend development, while Node.js enables JavaScript on the backend. Progressive Web Apps blur the line between web and native applications.
+
+Cloud platforms like AWS, Azure, and Google Cloud provide scalable infrastructure for web applications. DevOps practices automate deployment and monitoring. Security considerations, including authentication and data protection, are paramount in web development.
+
+## Document 4: Digital Marketing Strategies
+
+Digital marketing encompasses SEO, content marketing, social media, and paid advertising. Understanding your target audience is crucial for effective campaigns. Analytics tools provide insights into user behavior and campaign performance.
+
+Content marketing focuses on creating valuable content to attract and engage audiences. Social media platforms offer direct communication channels with customers. Email marketing remains one of the highest ROI channels for businesses.
+
+## Document 5: Financial Technology Innovation
+
+Fintech is revolutionizing financial services through technology. Mobile payments, cryptocurrency, and blockchain are transforming how we transact. Robo-advisors use algorithms to provide investment advice at lower costs than traditional advisors.
+
+Open banking APIs enable third-party developers to build financial applications. Peer-to-peer lending platforms connect borrowers directly with lenders. Regulatory technology helps firms comply with complex financial regulations.

examples/sample_email_complaint.txt

@@ -0,0 +1,14 @@
+Subject: Issue with Order #45678
+From: customer@example.com
+Date: January 15, 2025
+
+Hello,
+
+I placed order #45678 on January 10th, but it still hasn't arrived. The tracking shows it's been stuck at the distribution center for 3 days now. This is extremely frustrating as I needed these items for an important event this weekend.
+
+Can you please look into this urgently and let me know when I can expect delivery? If it won't arrive by Friday, I'll need to cancel the order and get a refund.
+
+This isn't the first time I've had delivery issues with your company.
+
+Thanks,
+Jane Smith

examples/sample_email_inquiry.txt

@@ -0,0 +1,21 @@
+Subject: Product Inquiry - Enterprise Plan
+From: john.doe@bigcorp.com
+Date: January 15, 2025
+
+Hello,
+
+I'm reaching out on behalf of BigCorp Inc. We're currently evaluating automation solutions for our enterprise operations and came across your platform.
+
+Could you provide more information about:
+1. Enterprise pricing plans
+2. Available features for teams of 500+ users
+3. API integration capabilities
+4. Security and compliance certifications
+5. Implementation timeline
+
+We're looking to make a decision by the end of Q1. Would it be possible to schedule a demo call next week?
+
+Best regards,
+John Doe
+Director of IT Operations
+BigCorp Inc.

examples/sample_email_urgent.txt

@@ -0,0 +1,23 @@
+Subject: URGENT - System Outage
+From: ops.team@company.com
+Date: January 15, 2025
+
+URGENT: Production system is down!
+
+Our main application server crashed at 2:30 PM EST. All customer-facing services are currently unavailable. Error logs show database connection timeout errors.
+
+Impact:
+- 5,000+ active users affected
+- Revenue loss: ~$10K per hour
+- Customer support receiving high volume of complaints
+
+Actions taken so far:
+- Restarted application servers (no success)
+- Database team investigating
+- Switched to emergency maintenance page
+
+NEED IMMEDIATE ATTENTION from DevOps and Database teams!
+
+Updates being posted to #incident-response Slack channel.
+
+- Operations Team

examples/sample_report.txt

@@ -0,0 +1,42 @@
+# Sample Business Report
+
+## Q4 2024 Performance Summary
+
+**Executive Summary:**
+Our company achieved outstanding performance in Q4 2024, with revenue reaching $5,000,000, representing a 19% increase compared to the previous quarter. This growth was driven by strong customer acquisition and improved operational efficiency.
+
+### Key Highlights:
+- **Revenue Growth:** 19% quarter-over-quarter increase
+- **Customer Base:** Expanded to 2,500 active customers
+- **Profit Margin:** Maintained at 40%, indicating strong cost management
+- **Team Expansion:** Grew from 42 to 50 employees
+
+### Financial Metrics:
+The company generated $5M in revenue against $3M in costs, resulting in a healthy $2M profit. Revenue per employee stands at $100,000, demonstrating excellent productivity levels.
+
+### Market Position:
+We've successfully penetrated three new market segments, with enterprise clients now representing 35% of our customer base. Customer satisfaction scores remain high at 4.6/5.0.
+
+### Looking Forward:
+Based on current trends, we project 25% revenue growth for Q1 2025. Key initiatives include expanding our sales team, launching two new product features, and entering the European market.
+
+### Operational Efficiency:
+- Customer acquisition cost: $800
+- Lifetime value: $5,000
+- Churn rate: 3.2% (industry average: 5%)
+- Support response time: Under 2 hours
+
+### Technology Investments:
+We've invested $500K in infrastructure improvements, including AI-powered customer service tools and automated reporting systems. These investments are expected to reduce operational costs by 15% in 2025.
+
+### Challenges and Mitigation:
+While we faced increased competition in Q4, our unique value proposition and superior customer service allowed us to maintain market share. We're addressing scaling challenges through process automation and strategic hiring.
+
+### Conclusion:
+Q4 2024 demonstrated strong business fundamentals and positioned us well for continued growth. Our focus on customer success, operational excellence, and strategic innovation will drive performance in 2025.
+
+---
+
+*This report was generated on January 15, 2025*
+*Prepared by: Finance Department*
+*Confidential - Internal Use Only*

requirements.txt

@@ -0,0 +1,37 @@
+# MissionControlMCP Requirements
+# Python 3.11+ required
+
+# MCP SDK
+mcp>=1.0.0
+
+# Document Processing
+pypdf2>=3.0.0
+python-docx>=1.0.0
+
+# Web Scraping
+requests>=2.31.0
+beautifulsoup4>=4.12.0
+
+# Data Processing
+pandas>=2.0.0
+numpy>=1.24.0
+
+# Vector Store & Embeddings
+faiss-cpu>=1.7.4
+sentence-transformers>=2.2.0
+
+# Visualization
+matplotlib>=3.7.0
+seaborn>=0.12.0
+pillow>=10.0.0
+
+# Web Interface (for demo_gui.py)
+gradio>=4.0.0
+
+# NLP & Text Processing
+nltk>=3.8.0
+scikit-learn>=1.3.0
+
+# Utilities
+python-dateutil>=2.8.0
+pydantic>=2.0.0

tools/__init__.py

@@ -0,0 +1,3 @@
+"""
+MissionControlMCP Tools Package
+"""

tools/data_visualizer.py

@@ -0,0 +1,231 @@
+"""
+Data Visualizer Tool - Create charts from data
+"""
+import logging
+from typing import Dict, Any
+import io
+import base64
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.helpers import parse_json_safe
+
+logger = logging.getLogger(__name__)
+
+
+def visualize_data(
+    data: str, 
+    chart_type: str = "bar", 
+    x_column: str = None, 
+    y_column: str = None,
+    title: str = "Data Visualization"
+) -> Dict[str, Any]:
+    """
+    Create a chart visualization from data.
+    
+    Args:
+        data: JSON or CSV string data
+        chart_type: Type of chart - 'bar', 'line', 'pie', 'scatter'
+        x_column: X-axis column name
+        y_column: Y-axis column name
+        title: Chart title
+        
+    Returns:
+        Dictionary with base64 encoded image and metadata
+    """
+    try:
+        import matplotlib.pyplot as plt
+        import pandas as pd
+        import json
+        
+        # Parse data
+        try:
+            # Try JSON first
+            data_dict = json.loads(data)
+            df = pd.DataFrame(data_dict)
+        except json.JSONDecodeError:
+            # Try CSV
+            from io import StringIO
+            df = pd.read_csv(StringIO(data))
+        
+        if df.empty:
+            raise ValueError("Data is empty")
+        
+        # Auto-select columns if not specified
+        if x_column is None and len(df.columns) > 0:
+            x_column = df.columns[0]
+        if y_column is None and len(df.columns) > 1:
+            y_column = df.columns[1]
+        elif y_column is None:
+            y_column = df.columns[0]
+        
+        # Validate columns exist
+        if x_column not in df.columns:
+            raise ValueError(f"Column '{x_column}' not found in data")
+        if y_column not in df.columns:
+            raise ValueError(f"Column '{y_column}' not found in data")
+        
+        # Create figure
+        plt.figure(figsize=(10, 6))
+        
+        # Generate chart based on type
+        if chart_type == "bar":
+            plt.bar(df[x_column], df[y_column])
+            plt.xlabel(x_column)
+            plt.ylabel(y_column)
+            
+        elif chart_type == "line":
+            plt.plot(df[x_column], df[y_column], marker='o')
+            plt.xlabel(x_column)
+            plt.ylabel(y_column)
+            plt.grid(True, alpha=0.3)
+            
+        elif chart_type == "pie":
+            plt.pie(df[y_column], labels=df[x_column], autopct='%1.1f%%')
+            
+        elif chart_type == "scatter":
+            plt.scatter(df[x_column], df[y_column], alpha=0.6)
+            plt.xlabel(x_column)
+            plt.ylabel(y_column)
+            plt.grid(True, alpha=0.3)
+            
+        else:
+            raise ValueError(f"Unknown chart type: {chart_type}")
+        
+        plt.title(title)
+        plt.tight_layout()
+        
+        # Convert to base64
+        buffer = io.BytesIO()
+        plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
+        buffer.seek(0)
+        image_base64 = base64.b64encode(buffer.read()).decode('utf-8')
+        plt.close()
+        
+        return {
+            "image_base64": image_base64,
+            "dimensions": {"width": 1000, "height": 600},
+            "chart_type": chart_type,
+            "title": title,
+            "columns_used": {"x": x_column, "y": y_column}
+        }
+        
+    except Exception as e:
+        logger.error(f"Error creating visualization: {e}")
+        raise
+
+
+def create_multi_chart(data: str, chart_configs: list) -> Dict[str, Any]:
+    """
+    Create multiple charts from the same dataset.
+    
+    Args:
+        data: JSON or CSV string data
+        chart_configs: List of chart configuration dictionaries
+        
+    Returns:
+        Dictionary with multiple chart images
+    """
+    try:
+        import matplotlib.pyplot as plt
+        import pandas as pd
+        import json
+        
+        # Parse data once
+        try:
+            data_dict = json.loads(data)
+            df = pd.DataFrame(data_dict)
+        except json.JSONDecodeError:
+            from io import StringIO
+            df = pd.read_csv(StringIO(data))
+        
+        charts = []
+        for idx, config in enumerate(chart_configs):
+            try:
+                result = visualize_data(
+                    data,
+                    chart_type=config.get("chart_type", "bar"),
+                    x_column=config.get("x_column"),
+                    y_column=config.get("y_column"),
+                    title=config.get("title", f"Chart {idx+1}")
+                )
+                charts.append(result)
+            except Exception as e:
+                logger.error(f"Error creating chart {idx+1}: {e}")
+                charts.append({"error": str(e)})
+        
+        return {
+            "total_charts": len(charts),
+            "charts": charts
+        }
+        
+    except Exception as e:
+        logger.error(f"Error creating multi-chart: {e}")
+        raise
+
+
+def generate_statistics_chart(data: str) -> Dict[str, Any]:
+    """
+    Generate a statistical summary chart from numeric data.
+    
+    Args:
+        data: JSON or CSV string with numeric data
+        
+    Returns:
+        Dictionary with statistics chart
+    """
+    try:
+        import matplotlib.pyplot as plt
+        import pandas as pd
+        import json
+        
+        # Parse data
+        try:
+            data_dict = json.loads(data)
+            df = pd.DataFrame(data_dict)
+        except json.JSONDecodeError:
+            from io import StringIO
+            df = pd.read_csv(StringIO(data))
+        
+        # Get numeric columns
+        numeric_cols = df.select_dtypes(include=['number']).columns
+        
+        if len(numeric_cols) == 0:
+            raise ValueError("No numeric columns found in data")
+        
+        # Create statistics summary
+        fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+        
+        # Box plot
+        df[numeric_cols].boxplot(ax=axes[0])
+        axes[0].set_title("Distribution (Box Plot)")
+        axes[0].set_ylabel("Values")
+        
+        # Histogram
+        df[numeric_cols].hist(ax=axes[1], bins=20, alpha=0.7)
+        axes[1].set_title("Distribution (Histogram)")
+        
+        plt.tight_layout()
+        
+        # Convert to base64
+        buffer = io.BytesIO()
+        plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
+        buffer.seek(0)
+        image_base64 = base64.b64encode(buffer.read()).decode('utf-8')
+        plt.close()
+        
+        # Calculate statistics
+        stats = df[numeric_cols].describe().to_dict()
+        
+        return {
+            "image_base64": image_base64,
+            "statistics": stats,
+            "numeric_columns": list(numeric_cols)
+        }
+        
+    except Exception as e:
+        logger.error(f"Error generating statistics chart: {e}")
+        raise

tools/email_intent_classifier.py

@@ -0,0 +1,234 @@
+"""
+Email Intent Classifier Tool - Classify email intents using NLP
+"""
+import logging
+from typing import Dict, Any, List
+import re
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+logger = logging.getLogger(__name__)
+
+
+class EmailIntentClassifier:
+    """
+    Rule-based email intent classifier with confidence scoring
+    """
+    
+    # Define intent patterns (keywords and phrases)
+    INTENT_PATTERNS = {
+        "inquiry": [
+            r'\b(question|wondering|curious|clarification|information|details|help)\b',
+            r'\b(what|when|where|who|why|how)\b.*\?',
+            r'\b(could you|can you|would you).*\b(explain|tell|provide|share)\b'
+        ],
+        "complaint": [
+            r'\b(complaint|issue|problem|disappointed|frustrated|unhappy|angry)\b',
+            r'\b(not working|broken|failed|error|mistake)\b',
+            r'\b(terrible|awful|worst|horrible|unacceptable)\b'
+        ],
+        "request": [
+            r'\b(please|kindly|request|need|require|would like)\b',
+            r'\b(send|provide|share|give|deliver|forward)\b.*\b(me|us)\b',
+            r'\b(need|want|looking for)\b'
+        ],
+        "feedback": [
+            r'\b(feedback|suggestion|recommend|improve|enhancement)\b',
+            r'\b(think|believe|feel|opinion)\b.*\b(should|could|would)\b',
+            r'\b(great|excellent|good|nice|appreciate|love)\b'
+        ],
+        "meeting": [
+            r'\b(meeting|schedule|appointment|call|discuss|conference)\b',
+            r'\b(available|availability|free time|calendar)\b',
+            r'\b(reschedule|postpone|cancel|confirm)\b'
+        ],
+        "order": [
+            r'\b(order|purchase|buy|payment|invoice|receipt)\b',
+            r'\b(shipping|delivery|tracking|status)\b',
+            r'\b(product|item|package)\b'
+        ],
+        "urgent": [
+            r'\b(urgent|asap|immediately|critical|emergency|priority)\b',
+            r'\b(time-sensitive|deadline|due)\b',
+            r'!!+|\bIMPORTANT\b'
+        ],
+        "follow_up": [
+            r'\b(follow up|following up|checking in|reminder)\b',
+            r'\b(haven\'t heard|waiting for|still pending)\b',
+            r'\b(previous|earlier|sent|mentioned)\b.*\b(email|message)\b'
+        ],
+        "thank_you": [
+            r'\b(thank|thanks|grateful|appreciate|gratitude)\b',
+            r'\b(wonderful|excellent|helpful)\b.*\b(work|help|support)\b'
+        ],
+        "application": [
+            r'\b(apply|application|position|job|role|opportunity)\b',
+            r'\b(resume|cv|cover letter|portfolio)\b',
+            r'\b(interested in|applying for)\b'
+        ]
+    }
+    
+    def classify(self, email_text: str) -> Dict[str, Any]:
+        """
+        Classify email intent with confidence scores.
+        
+        Args:
+            email_text: Email text to classify
+            
+        Returns:
+            Dictionary with primary intent, confidence, and secondary intents
+        """
+        if not email_text or not email_text.strip():
+            raise ValueError("Email text cannot be empty")
+        
+        # Convert to lowercase for matching
+        text_lower = email_text.lower()
+        
+        # Calculate scores for each intent
+        intent_scores = {}
+        
+        for intent, patterns in self.INTENT_PATTERNS.items():
+            score = 0
+            matches = 0
+            
+            for pattern in patterns:
+                found = re.findall(pattern, text_lower, re.IGNORECASE)
+                if found:
+                    matches += len(found)
+                    score += len(found)
+            
+            # Normalize score
+            if score > 0:
+                intent_scores[intent] = min(score / 3.0, 1.0)  # Cap at 1.0
+        
+        # If no patterns matched, classify as "general"
+        if not intent_scores:
+            return {
+                "intent": "general",
+                "confidence": 0.5,
+                "secondary_intents": [],
+                "explanation": "No specific intent patterns detected"
+            }
+        
+        # Sort by score
+        sorted_intents = sorted(intent_scores.items(), key=lambda x: x[1], reverse=True)
+        
+        # Get primary intent
+        primary_intent = sorted_intents[0][0]
+        primary_confidence = sorted_intents[0][1]
+        
+        # Get secondary intents (top 3)
+        secondary_intents = [
+            {"intent": intent, "confidence": round(score, 3)}
+            for intent, score in sorted_intents[1:4]
+        ]
+        
+        return {
+            "intent": primary_intent,
+            "confidence": round(primary_confidence, 3),
+            "secondary_intents": secondary_intents,
+            "explanation": f"Detected {primary_intent} intent based on keyword analysis"
+        }
+
+
+def classify_email_intent(email_text: str) -> Dict[str, Any]:
+    """
+    Classify the intent of an email.
+    
+    Args:
+        email_text: Email text to classify
+        
+    Returns:
+        Dictionary with classification results
+    """
+    try:
+        classifier = EmailIntentClassifier()
+        result = classifier.classify(email_text)
+        
+        # Add metadata
+        result["email_length"] = len(email_text)
+        result["word_count"] = len(email_text.split())
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error classifying email intent: {e}")
+        raise
+
+
+def classify_batch_emails(emails: List[str]) -> Dict[str, Any]:
+    """
+    Classify multiple emails at once.
+    
+    Args:
+        emails: List of email text strings
+        
+    Returns:
+        Dictionary with batch classification results
+    """
+    try:
+        classifier = EmailIntentClassifier()
+        results = []
+        
+        for idx, email_text in enumerate(emails):
+            try:
+                result = classifier.classify(email_text)
+                result["email_index"] = idx
+                results.append(result)
+            except Exception as e:
+                logger.error(f"Error classifying email {idx}: {e}")
+                results.append({
+                    "email_index": idx,
+                    "error": str(e),
+                    "intent": "error",
+                    "confidence": 0.0
+                })
+        
+        # Aggregate statistics
+        intent_distribution = {}
+        for result in results:
+            intent = result.get("intent", "unknown")
+            intent_distribution[intent] = intent_distribution.get(intent, 0) + 1
+        
+        return {
+            "total_emails": len(emails),
+            "results": results,
+            "intent_distribution": intent_distribution
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in batch email classification: {e}")
+        raise
+
+
+def extract_email_features(email_text: str) -> Dict[str, Any]:
+    """
+    Extract features from an email for analysis.
+    
+    Args:
+        email_text: Email text
+        
+    Returns:
+        Dictionary with extracted features
+    """
+    try:
+        features = {
+            "length": len(email_text),
+            "word_count": len(email_text.split()),
+            "sentence_count": len(re.split(r'[.!?]+', email_text)),
+            "has_greeting": bool(re.search(r'\b(hi|hello|dear|hey)\b', email_text.lower())),
+            "has_closing": bool(re.search(r'\b(regards|sincerely|thanks|best)\b', email_text.lower())),
+            "question_count": len(re.findall(r'\?', email_text)),
+            "exclamation_count": len(re.findall(r'!', email_text)),
+            "has_url": bool(re.search(r'https?://', email_text)),
+            "has_email_address": bool(re.search(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', email_text))
+        }
+        
+        return features
+        
+    except Exception as e:
+        logger.error(f"Error extracting email features: {e}")
+        raise

tools/file_converter.py

@@ -0,0 +1,200 @@
+"""
+File Converter Tool - Convert between different file formats
+"""
+import logging
+from typing import Dict, Any
+from pathlib import Path
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+logger = logging.getLogger(__name__)
+
+
+def convert_file(input_path: str, output_format: str, output_path: str = None) -> Dict[str, Any]:
+    """
+    Convert a file from one format to another.
+    
+    Supported conversions:
+    - PDF to TXT
+    - TXT to CSV (assumes structured text)
+    - CSV to TXT
+    - Any text-based format conversions
+    
+    Args:
+        input_path: Path to input file
+        output_format: Desired output format ('txt', 'csv', 'pdf')
+        output_path: Optional output path; auto-generated if not provided
+        
+    Returns:
+        Dictionary with conversion results
+    """
+    try:
+        input_file = Path(input_path)
+        
+        if not input_file.exists():
+            raise FileNotFoundError(f"Input file not found: {input_path}")
+        
+        # Determine input format
+        input_format = input_file.suffix.lower().replace('.', '')
+        
+        # Generate output path if not provided
+        if output_path is None:
+            output_path = str(input_file.parent / f"{input_file.stem}.{output_format}")
+        
+        output_file = Path(output_path)
+        
+        # Perform conversion based on formats
+        if input_format == 'pdf' and output_format == 'txt':
+            success, message = _pdf_to_txt(input_path, output_path)
+            
+        elif input_format == 'txt' and output_format == 'csv':
+            success, message = _txt_to_csv(input_path, output_path)
+            
+        elif input_format == 'csv' and output_format == 'txt':
+            success, message = _csv_to_txt(input_path, output_path)
+            
+        elif input_format in ['txt', 'md', 'log'] and output_format in ['txt', 'md', 'log']:
+            success, message = _text_to_text(input_path, output_path)
+            
+        else:
+            raise ValueError(f"Conversion from {input_format} to {output_format} not supported")
+        
+        return {
+            "output_path": str(output_file),
+            "success": success,
+            "message": message,
+            "input_format": input_format,
+            "output_format": output_format,
+            "file_size_bytes": output_file.stat().st_size if output_file.exists() else 0
+        }
+        
+    except Exception as e:
+        logger.error(f"Error converting file: {e}")
+        raise
+
+
+def _pdf_to_txt(input_path: str, output_path: str) -> tuple:
+    """Convert PDF to TXT"""
+    try:
+        from PyPDF2 import PdfReader
+        
+        reader = PdfReader(input_path)
+        text_parts = []
+        
+        for page in reader.pages:
+            text = page.extract_text()
+            if text:
+                text_parts.append(text)
+        
+        full_text = "\n\n".join(text_parts)
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(full_text)
+        
+        return True, f"Successfully converted PDF to TXT ({len(reader.pages)} pages)"
+        
+    except Exception as e:
+        logger.error(f"PDF to TXT conversion error: {e}")
+        return False, str(e)
+
+
+def _txt_to_csv(input_path: str, output_path: str) -> tuple:
+    """Convert TXT to CSV (assumes tab or comma separated values)"""
+    try:
+        import pandas as pd
+        
+        # Try to read as CSV with different delimiters
+        try:
+            df = pd.read_csv(input_path, sep='\t')
+        except:
+            try:
+                df = pd.read_csv(input_path, sep=',')
+            except:
+                # If not structured, create simple CSV with one column
+                with open(input_path, 'r', encoding='utf-8') as f:
+                    lines = f.readlines()
+                
+                df = pd.DataFrame({'text': [line.strip() for line in lines if line.strip()]})
+        
+        df.to_csv(output_path, index=False)
+        
+        return True, f"Successfully converted TXT to CSV ({len(df)} rows)"
+        
+    except Exception as e:
+        logger.error(f"TXT to CSV conversion error: {e}")
+        return False, str(e)
+
+
+def _csv_to_txt(input_path: str, output_path: str) -> tuple:
+    """Convert CSV to TXT"""
+    try:
+        import pandas as pd
+        
+        df = pd.read_csv(input_path)
+        
+        # Convert to formatted text
+        text = df.to_string(index=False)
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(text)
+        
+        return True, f"Successfully converted CSV to TXT ({len(df)} rows)"
+        
+    except Exception as e:
+        logger.error(f"CSV to TXT conversion error: {e}")
+        return False, str(e)
+
+
+def _text_to_text(input_path: str, output_path: str) -> tuple:
+    """Convert between text-based formats"""
+    try:
+        with open(input_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        return True, "Successfully converted text file"
+        
+    except Exception as e:
+        logger.error(f"Text to text conversion error: {e}")
+        return False, str(e)
+
+
+def batch_convert(input_files: list, output_format: str) -> Dict[str, Any]:
+    """
+    Convert multiple files to the same output format.
+    
+    Args:
+        input_files: List of input file paths
+        output_format: Desired output format for all files
+        
+    Returns:
+        Dictionary with batch conversion results
+    """
+    results = []
+    
+    for input_file in input_files:
+        try:
+            result = convert_file(input_file, output_format)
+            result["input_file"] = input_file
+            results.append(result)
+        except Exception as e:
+            logger.error(f"Error converting {input_file}: {e}")
+            results.append({
+                "input_file": input_file,
+                "success": False,
+                "message": str(e)
+            })
+    
+    successful = sum(1 for r in results if r.get("success", False))
+    
+    return {
+        "total_files": len(input_files),
+        "successful": successful,
+        "failed": len(input_files) - successful,
+        "results": results
+    }

tools/kpi_generator.py

@@ -0,0 +1,292 @@
+"""
+KPI Generator Tool - Generate business KPIs from data
+"""
+import logging
+from typing import Dict, Any, List
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.helpers import parse_json_safe, safe_divide
+
+logger = logging.getLogger(__name__)
+
+
+def generate_kpis(data: str, metrics: List[str] = None) -> Dict[str, Any]:
+    """
+    Generate KPI report from business data.
+    
+    Args:
+        data: JSON string containing business data
+        metrics: List of metrics to calculate (revenue, growth, efficiency, etc.)
+        
+    Returns:
+        Dictionary with calculated KPIs and insights
+    """
+    try:
+        import json
+        
+        # Parse input data
+        try:
+            business_data = json.loads(data)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON data: {e}")
+        
+        if metrics is None:
+            metrics = ["revenue", "growth", "efficiency"]
+        
+        kpis = {}
+        trends = []
+        
+        # Calculate different KPIs based on requested metrics
+        for metric in metrics:
+            if metric == "revenue":
+                revenue_kpis = _calculate_revenue_kpis(business_data)
+                kpis.update(revenue_kpis)
+                
+            elif metric == "growth":
+                growth_kpis = _calculate_growth_kpis(business_data)
+                kpis.update(growth_kpis)
+                
+            elif metric == "efficiency":
+                efficiency_kpis = _calculate_efficiency_kpis(business_data)
+                kpis.update(efficiency_kpis)
+                
+            elif metric == "customer":
+                customer_kpis = _calculate_customer_kpis(business_data)
+                kpis.update(customer_kpis)
+                
+            elif metric == "operational":
+                operational_kpis = _calculate_operational_kpis(business_data)
+                kpis.update(operational_kpis)
+        
+        # Generate trends
+        trends = _identify_trends(kpis, business_data)
+        
+        # Generate executive summary
+        summary = _generate_summary(kpis, trends)
+        
+        return {
+            "kpis": kpis,
+            "summary": summary,
+            "trends": trends,
+            "metrics_analyzed": metrics,
+            "data_points": len(business_data) if isinstance(business_data, list) else len(business_data.keys())
+        }
+        
+    except Exception as e:
+        logger.error(f"Error generating KPIs: {e}")
+        raise
+
+
+def _calculate_revenue_kpis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Calculate revenue-related KPIs"""
+    kpis = {}
+    
+    try:
+        # Total Revenue
+        if "revenue" in data:
+            if isinstance(data["revenue"], list):
+                kpis["total_revenue"] = sum(data["revenue"])
+                kpis["average_revenue"] = sum(data["revenue"]) / len(data["revenue"])
+                kpis["min_revenue"] = min(data["revenue"])
+                kpis["max_revenue"] = max(data["revenue"])
+            else:
+                kpis["total_revenue"] = data["revenue"]
+        
+        # Revenue per customer
+        if "revenue" in data and "customers" in data:
+            revenue = data["revenue"] if not isinstance(data["revenue"], list) else sum(data["revenue"])
+            customers = data["customers"] if not isinstance(data["customers"], list) else sum(data["customers"])
+            kpis["revenue_per_customer"] = safe_divide(revenue, customers)
+        
+        # Profit margin
+        if "revenue" in data and "costs" in data:
+            revenue = data["revenue"] if not isinstance(data["revenue"], list) else sum(data["revenue"])
+            costs = data["costs"] if not isinstance(data["costs"], list) else sum(data["costs"])
+            profit = revenue - costs
+            kpis["profit"] = profit
+            kpis["profit_margin_percent"] = safe_divide(profit * 100, revenue)
+        
+    except Exception as e:
+        logger.warning(f"Error calculating revenue KPIs: {e}")
+    
+    return kpis
+
+
+def _calculate_growth_kpis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Calculate growth-related KPIs"""
+    kpis = {}
+    
+    try:
+        # Year-over-year growth
+        if "current_revenue" in data and "previous_revenue" in data:
+            growth = data["current_revenue"] - data["previous_revenue"]
+            growth_rate = safe_divide(growth * 100, data["previous_revenue"])
+            kpis["revenue_growth"] = growth
+            kpis["revenue_growth_rate_percent"] = growth_rate
+        
+        # Customer growth
+        if "current_customers" in data and "previous_customers" in data:
+            customer_growth = data["current_customers"] - data["previous_customers"]
+            customer_growth_rate = safe_divide(customer_growth * 100, data["previous_customers"])
+            kpis["customer_growth"] = customer_growth
+            kpis["customer_growth_rate_percent"] = customer_growth_rate
+        
+        # Monthly growth rate (if time series data provided)
+        if "monthly_revenue" in data and isinstance(data["monthly_revenue"], list):
+            revenues = data["monthly_revenue"]
+            if len(revenues) >= 2:
+                recent_growth = safe_divide((revenues[-1] - revenues[-2]) * 100, revenues[-2])
+                kpis["recent_monthly_growth_percent"] = recent_growth
+        
+    except Exception as e:
+        logger.warning(f"Error calculating growth KPIs: {e}")
+    
+    return kpis
+
+
+def _calculate_efficiency_kpis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Calculate efficiency-related KPIs"""
+    kpis = {}
+    
+    try:
+        # Cost per acquisition
+        if "marketing_costs" in data and "new_customers" in data:
+            kpis["cost_per_acquisition"] = safe_divide(data["marketing_costs"], data["new_customers"])
+        
+        # Operational efficiency
+        if "revenue" in data and "operational_costs" in data:
+            revenue = data["revenue"] if not isinstance(data["revenue"], list) else sum(data["revenue"])
+            kpis["operational_efficiency_ratio"] = safe_divide(revenue, data["operational_costs"])
+        
+        # Employee productivity
+        if "revenue" in data and "employees" in data:
+            revenue = data["revenue"] if not isinstance(data["revenue"], list) else sum(data["revenue"])
+            kpis["revenue_per_employee"] = safe_divide(revenue, data["employees"])
+        
+        # ROI
+        if "revenue" in data and "investment" in data:
+            revenue = data["revenue"] if not isinstance(data["revenue"], list) else sum(data["revenue"])
+            roi = safe_divide((revenue - data["investment"]) * 100, data["investment"])
+            kpis["roi_percent"] = roi
+        
+    except Exception as e:
+        logger.warning(f"Error calculating efficiency KPIs: {e}")
+    
+    return kpis
+
+
+def _calculate_customer_kpis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Calculate customer-related KPIs"""
+    kpis = {}
+    
+    try:
+        # Customer lifetime value
+        if "average_purchase_value" in data and "purchase_frequency" in data and "customer_lifespan" in data:
+            clv = data["average_purchase_value"] * data["purchase_frequency"] * data["customer_lifespan"]
+            kpis["customer_lifetime_value"] = clv
+        
+        # Churn rate
+        if "churned_customers" in data and "total_customers" in data:
+            kpis["churn_rate_percent"] = safe_divide(data["churned_customers"] * 100, data["total_customers"])
+        
+        # Retention rate
+        if "retained_customers" in data and "total_customers" in data:
+            kpis["retention_rate_percent"] = safe_divide(data["retained_customers"] * 100, data["total_customers"])
+        
+        # Net Promoter Score (if provided)
+        if "nps_score" in data:
+            kpis["net_promoter_score"] = data["nps_score"]
+        
+    except Exception as e:
+        logger.warning(f"Error calculating customer KPIs: {e}")
+    
+    return kpis
+
+
+def _calculate_operational_kpis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Calculate operational KPIs"""
+    kpis = {}
+    
+    try:
+        # Inventory turnover
+        if "cost_of_goods_sold" in data and "average_inventory" in data:
+            kpis["inventory_turnover"] = safe_divide(data["cost_of_goods_sold"], data["average_inventory"])
+        
+        # Order fulfillment rate
+        if "orders_fulfilled" in data and "total_orders" in data:
+            kpis["fulfillment_rate_percent"] = safe_divide(data["orders_fulfilled"] * 100, data["total_orders"])
+        
+        # Average response time
+        if "total_response_time" in data and "ticket_count" in data:
+            kpis["average_response_time"] = safe_divide(data["total_response_time"], data["ticket_count"])
+        
+    except Exception as e:
+        logger.warning(f"Error calculating operational KPIs: {e}")
+    
+    return kpis
+
+
+def _identify_trends(kpis: Dict[str, Any], data: Dict[str, Any]) -> List[str]:
+    """Identify key trends from KPIs"""
+    trends = []
+    
+    try:
+        # Check growth trends
+        if "revenue_growth_rate_percent" in kpis:
+            rate = kpis["revenue_growth_rate_percent"]
+            if rate > 20:
+                trends.append(f"Strong revenue growth of {rate:.1f}%")
+            elif rate > 0:
+                trends.append(f"Positive revenue growth of {rate:.1f}%")
+            else:
+                trends.append(f"Revenue decline of {abs(rate):.1f}%")
+        
+        # Check profitability
+        if "profit_margin_percent" in kpis:
+            margin = kpis["profit_margin_percent"]
+            if margin > 20:
+                trends.append(f"Healthy profit margin at {margin:.1f}%")
+            elif margin > 0:
+                trends.append(f"Modest profit margin at {margin:.1f}%")
+            else:
+                trends.append(f"Operating at a loss with {abs(margin):.1f}% negative margin")
+        
+        # Check efficiency
+        if "roi_percent" in kpis:
+            roi = kpis["roi_percent"]
+            if roi > 100:
+                trends.append(f"Excellent ROI of {roi:.1f}%")
+            elif roi > 0:
+                trends.append(f"Positive ROI of {roi:.1f}%")
+        
+        # Check customer metrics
+        if "churn_rate_percent" in kpis:
+            churn = kpis["churn_rate_percent"]
+            if churn > 10:
+                trends.append(f"High customer churn rate of {churn:.1f}%")
+            else:
+                trends.append(f"Healthy churn rate of {churn:.1f}%")
+        
+    except Exception as e:
+        logger.warning(f"Error identifying trends: {e}")
+    
+    return trends if trends else ["Insufficient data for trend analysis"]
+
+
+def _generate_summary(kpis: Dict[str, Any], trends: List[str]) -> str:
+    """Generate executive summary"""
+    summary_parts = []
+    
+    summary_parts.append("Executive KPI Summary:")
+    summary_parts.append(f"- Analyzed {len(kpis)} key performance indicators")
+    
+    if trends:
+        summary_parts.append("- Key insights:")
+        for trend in trends[:3]:  # Top 3 trends
+            summary_parts.append(f"  • {trend}")
+    
+    return "\n".join(summary_parts)

tools/pdf_reader.py

@@ -0,0 +1,93 @@
+"""
+PDF Reader Tool - Extract text and metadata from PDF files
+"""
+import logging
+from typing import Dict, Any
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def read_pdf(file_path: str) -> Dict[str, Any]:
+    """
+    Read and extract text from a PDF file.
+    
+    Args:
+        file_path: Path to the PDF file
+        
+    Returns:
+        Dictionary containing extracted text, page count, and metadata
+    """
+    try:
+        from PyPDF2 import PdfReader
+        
+        # Validate file exists
+        if not Path(file_path).exists():
+            raise FileNotFoundError(f"PDF file not found: {file_path}")
+        
+        # Read PDF
+        reader = PdfReader(file_path)
+        
+        # Extract text from all pages
+        text_parts = []
+        for page_num, page in enumerate(reader.pages, 1):
+            try:
+                text = page.extract_text()
+                if text:
+                    text_parts.append(f"--- Page {page_num} ---\n{text}")
+            except Exception as e:
+                logger.warning(f"Failed to extract text from page {page_num}: {e}")
+                text_parts.append(f"--- Page {page_num} ---\n[Extraction failed]")
+        
+        full_text = "\n\n".join(text_parts)
+        
+        # Extract metadata
+        metadata = {}
+        if reader.metadata:
+            metadata = {
+                "author": reader.metadata.get("/Author", "Unknown"),
+                "creator": reader.metadata.get("/Creator", "Unknown"),
+                "producer": reader.metadata.get("/Producer", "Unknown"),
+                "subject": reader.metadata.get("/Subject", "Unknown"),
+                "title": reader.metadata.get("/Title", "Unknown"),
+                "creation_date": str(reader.metadata.get("/CreationDate", "Unknown"))
+            }
+        
+        return {
+            "text": full_text,
+            "pages": len(reader.pages),
+            "metadata": metadata
+        }
+        
+    except ImportError:
+        logger.error("PyPDF2 not installed. Install with: pip install pypdf2")
+        raise
+    except Exception as e:
+        logger.error(f"Error reading PDF: {e}")
+        raise
+
+
+def get_pdf_info(file_path: str) -> Dict[str, Any]:
+    """
+    Get basic information about a PDF without extracting all text.
+    
+    Args:
+        file_path: Path to the PDF file
+        
+    Returns:
+        Dictionary with PDF information
+    """
+    try:
+        from PyPDF2 import PdfReader
+        
+        reader = PdfReader(file_path)
+        
+        return {
+            "page_count": len(reader.pages),
+            "is_encrypted": reader.is_encrypted,
+            "file_size_bytes": Path(file_path).stat().st_size,
+            "file_name": Path(file_path).name
+        }
+    except Exception as e:
+        logger.error(f"Error getting PDF info: {e}")
+        raise

tools/rag_search.py

@@ -0,0 +1,153 @@
+"""
+RAG Search Tool - Semantic search using vector embeddings
+"""
+import logging
+from typing import Dict, Any, List
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.rag_utils import semantic_search, create_rag_store
+
+logger = logging.getLogger(__name__)
+
+
+def search_documents(query: str, documents: List[str], top_k: int = 3) -> Dict[str, Any]:
+    """
+    Perform semantic search on a collection of documents.
+    
+    Args:
+        query: Search query string
+        documents: List of document strings to search
+        top_k: Number of top results to return
+        
+    Returns:
+        Dictionary containing search results with scores
+    """
+    try:
+        if not query or not query.strip():
+            raise ValueError("Query cannot be empty")
+        
+        if not documents or len(documents) == 0:
+            raise ValueError("Documents list cannot be empty")
+        
+        # Perform semantic search
+        results = semantic_search(query, documents, top_k)
+        
+        return {
+            "query": query,
+            "total_documents": len(documents),
+            "returned_results": len(results),
+            "results": results
+        }
+        
+    except Exception as e:
+        logger.error(f"Error performing RAG search: {e}")
+        raise
+
+
+def build_knowledge_base(documents: List[str]) -> Dict[str, Any]:
+    """
+    Build a knowledge base from documents for later querying.
+    
+    Args:
+        documents: List of documents to index
+        
+    Returns:
+        Dictionary with knowledge base info
+    """
+    try:
+        if not documents:
+            raise ValueError("Documents list cannot be empty")
+        
+        # Create RAG store
+        store = create_rag_store(documents)
+        
+        return {
+            "success": True,
+            "document_count": len(documents),
+            "message": "Knowledge base built successfully",
+            "store": store  # In a real scenario, this would be persisted
+        }
+        
+    except Exception as e:
+        logger.error(f"Error building knowledge base: {e}")
+        raise
+
+
+def multi_query_search(queries: List[str], documents: List[str], top_k: int = 3) -> Dict[str, Any]:
+    """
+    Perform multiple searches with different queries on the same document set.
+    
+    Args:
+        queries: List of query strings
+        documents: List of documents to search
+        top_k: Number of results per query
+        
+    Returns:
+        Dictionary with results for each query
+    """
+    try:
+        if not queries or not documents:
+            raise ValueError("Both queries and documents must be provided")
+        
+        # Build store once for efficiency
+        store = create_rag_store(documents)
+        
+        all_results = {}
+        for idx, query in enumerate(queries):
+            try:
+                results = store.search(query, top_k)
+                all_results[f"query_{idx+1}"] = {
+                    "query": query,
+                    "results": results
+                }
+            except Exception as e:
+                logger.error(f"Error searching query {idx+1}: {e}")
+                all_results[f"query_{idx+1}"] = {
+                    "query": query,
+                    "error": str(e),
+                    "results": []
+                }
+        
+        return {
+            "total_queries": len(queries),
+            "total_documents": len(documents),
+            "results": all_results
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in multi-query search: {e}")
+        raise
+
+
+def find_similar_documents(target_doc: str, documents: List[str], top_k: int = 5) -> Dict[str, Any]:
+    """
+    Find documents similar to a target document.
+    
+    Args:
+        target_doc: The document to find similar ones for
+        documents: Corpus of documents to search
+        top_k: Number of similar documents to return
+        
+    Returns:
+        Dictionary with similar documents
+    """
+    try:
+        if not target_doc or not documents:
+            raise ValueError("Target document and documents list must be provided")
+        
+        # Use target doc as query
+        results = semantic_search(target_doc, documents, top_k)
+        
+        return {
+            "target_document": target_doc[:200] + "..." if len(target_doc) > 200 else target_doc,
+            "corpus_size": len(documents),
+            "similar_documents": results
+        }
+        
+    except Exception as e:
+        logger.error(f"Error finding similar documents: {e}")
+        raise

tools/text_extractor.py

@@ -0,0 +1,114 @@
+"""
+Text Extractor Tool - Clean, summarize, and process text
+"""
+import logging
+from typing import Dict, Any
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.helpers import clean_text, chunk_text, summarize_text, extract_keywords
+
+logger = logging.getLogger(__name__)
+
+
+def extract_text(text: str, operation: str = "clean", max_length: int = 500) -> Dict[str, Any]:
+    """
+    Process text based on the specified operation.
+    
+    Args:
+        text: Raw text to process
+        operation: Operation to perform - 'clean', 'summarize', 'chunk', or 'keywords'
+        max_length: Maximum length for summary operations
+        
+    Returns:
+        Dictionary containing processed text and metadata
+    """
+    try:
+        if not text or not text.strip():
+            raise ValueError("Input text is empty")
+        
+        result = ""
+        metadata = {}
+        
+        if operation == "clean":
+            result = clean_text(text)
+            metadata = {
+                "operation": "clean",
+                "original_length": len(text),
+                "cleaned_length": len(result)
+            }
+            
+        elif operation == "summarize":
+            result = summarize_text(text, max_length)
+            metadata = {
+                "operation": "summarize",
+                "original_length": len(text),
+                "summary_length": len(result),
+                "compression_ratio": round(len(result) / len(text), 2) if len(text) > 0 else 0
+            }
+            
+        elif operation == "chunk":
+            chunks = chunk_text(text, chunk_size=max_length, overlap=50)
+            result = "\n\n---CHUNK---\n\n".join(chunks)
+            metadata = {
+                "operation": "chunk",
+                "total_chunks": len(chunks),
+                "chunk_size": max_length
+            }
+            
+        elif operation == "keywords":
+            keywords = extract_keywords(text, top_n=10)
+            result = ", ".join(keywords)
+            metadata = {
+                "operation": "keywords",
+                "keyword_count": len(keywords),
+                "keywords": keywords
+            }
+            
+        else:
+            raise ValueError(f"Unknown operation: {operation}. Use 'clean', 'summarize', 'chunk', or 'keywords'")
+        
+        # Calculate word count
+        word_count = len(result.split())
+        
+        return {
+            "result": result,
+            "word_count": word_count,
+            "metadata": metadata
+        }
+        
+    except Exception as e:
+        logger.error(f"Error extracting text: {e}")
+        raise
+
+
+def process_multiple_texts(texts: list, operation: str = "clean") -> list:
+    """
+    Process multiple texts with the same operation.
+    
+    Args:
+        texts: List of text strings to process
+        operation: Operation to apply to all texts
+        
+    Returns:
+        List of results for each text
+    """
+    results = []
+    for idx, text in enumerate(texts):
+        try:
+            result = extract_text(text, operation)
+            result["index"] = idx
+            results.append(result)
+        except Exception as e:
+            logger.error(f"Error processing text at index {idx}: {e}")
+            results.append({
+                "index": idx,
+                "error": str(e),
+                "result": "",
+                "word_count": 0
+            })
+    
+    return results

tools/web_fetcher.py

@@ -0,0 +1,179 @@
+"""
+Web Fetcher Tool - Fetch and extract content from web pages
+"""
+import logging
+from typing import Dict, Any
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.helpers import validate_url, clean_text, format_timestamp
+
+logger = logging.getLogger(__name__)
+
+
+def fetch_web_content(url: str, extract_text_only: bool = True, timeout: int = 30) -> Dict[str, Any]:
+    """
+    Fetch content from a web URL.
+    
+    Args:
+        url: URL to fetch
+        extract_text_only: If True, extract only text content; if False, return HTML
+        timeout: Request timeout in seconds
+        
+    Returns:
+        Dictionary containing fetched content, status code, and metadata
+    """
+    try:
+        import requests
+        from bs4 import BeautifulSoup
+        
+        # Validate URL
+        if not validate_url(url):
+            raise ValueError(f"Invalid URL format: {url}")
+        
+        # Set headers to mimic a browser
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        # Fetch content
+        response = requests.get(url, headers=headers, timeout=timeout)
+        response.raise_for_status()
+        
+        content = ""
+        content_type = response.headers.get('Content-Type', '')
+        
+        if extract_text_only and 'text/html' in content_type:
+            # Parse HTML and extract text
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Extract title
+            title = soup.title.string if soup.title else "No title"
+            
+            # Extract links
+            links = []
+            for link in soup.find_all('a', href=True):
+                href = link.get('href', '')
+                if href and not href.startswith('#'):
+                    links.append(href)
+            
+            # Remove script and style elements
+            for script in soup(["script", "style", "nav", "footer", "header"]):
+                script.decompose()
+            
+            # Get text
+            text = soup.get_text()
+            
+            # Clean up text
+            lines = (line.strip() for line in text.splitlines())
+            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+            content = '\n'.join(chunk for chunk in chunks if chunk)
+            
+            # Further clean
+            content = clean_text(content)
+            
+        else:
+            # Return raw content
+            content = response.text
+            title = "N/A (non-HTML content)"
+            links = []
+        
+        # Build metadata
+        metadata = {
+            "url": url,
+            "status_code": response.status_code,
+            "content_type": content_type,
+            "content_length": len(content),
+            "encoding": response.encoding,
+            "timestamp": format_timestamp(),
+            "headers": dict(response.headers)
+        }
+        
+        return {
+            "content": content,
+            "status_code": response.status_code,
+            "title": title,
+            "links": links,
+            "metadata": metadata
+        }
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request error fetching {url}: {e}")
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching web content: {e}")
+        raise
+
+
+def fetch_multiple_urls(urls: list, extract_text_only: bool = True) -> list:
+    """
+    Fetch content from multiple URLs.
+    
+    Args:
+        urls: List of URLs to fetch
+        extract_text_only: Whether to extract text only
+        
+    Returns:
+        List of results for each URL
+    """
+    results = []
+    for idx, url in enumerate(urls):
+        try:
+            result = fetch_web_content(url, extract_text_only)
+            result["index"] = idx
+            result["success"] = True
+            results.append(result)
+        except Exception as e:
+            logger.error(f"Error fetching URL at index {idx} ({url}): {e}")
+            results.append({
+                "index": idx,
+                "url": url,
+                "success": False,
+                "error": str(e),
+                "content": "",
+                "status_code": 0
+            })
+    
+    return results
+
+
+def extract_links(url: str) -> Dict[str, Any]:
+    """
+    Extract all links from a web page.
+    
+    Args:
+        url: URL to extract links from
+        
+    Returns:
+        Dictionary with extracted links
+    """
+    try:
+        import requests
+        from bs4 import BeautifulSoup
+        from urllib.parse import urljoin
+        
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        links = []
+        for link in soup.find_all('a', href=True):
+            absolute_url = urljoin(url, link['href'])
+            links.append({
+                "text": link.get_text(strip=True),
+                "href": absolute_url
+            })
+        
+        return {
+            "url": url,
+            "total_links": len(links),
+            "links": links
+        }
+        
+    except Exception as e:
+        logger.error(f"Error extracting links: {e}")
+        raise

utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+MissionControlMCP Utilities Package
+"""

utils/helpers.py

@@ -0,0 +1,180 @@
+"""
+Helper utility functions
+"""
+import re
+import logging
+from typing import List, Dict, Any
+from datetime import datetime
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def clean_text(text: str) -> str:
+    """
+    Clean and normalize text by removing extra whitespace, special characters, etc.
+    
+    Args:
+        text: Raw text to clean
+        
+    Returns:
+        Cleaned text string
+    """
+    # Remove extra whitespace
+    text = re.sub(r'\s+', ' ', text)
+    # Remove special characters but keep basic punctuation
+    text = re.sub(r'[^\w\s.,!?;:\-\'\"()]', '', text)
+    # Strip leading/trailing whitespace
+    text = text.strip()
+    return text
+
+
+def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> List[str]:
+    """
+    Split text into overlapping chunks for processing.
+    
+    Args:
+        text: Text to chunk
+        chunk_size: Size of each chunk in characters
+        overlap: Overlap between chunks
+        
+    Returns:
+        List of text chunks
+    """
+    chunks = []
+    start = 0
+    text_length = len(text)
+    
+    while start < text_length:
+        end = start + chunk_size
+        chunk = text[start:end]
+        chunks.append(chunk)
+        start = end - overlap
+        
+    return chunks
+
+
+def summarize_text(text: str, max_length: int = 500) -> str:
+    """
+    Create a simple extractive summary by taking the first sentences.
+    
+    Args:
+        text: Text to summarize
+        max_length: Maximum length of summary
+        
+    Returns:
+        Summarized text
+    """
+    sentences = re.split(r'[.!?]+', text)
+    summary = ""
+    
+    for sentence in sentences:
+        sentence = sentence.strip()
+        if not sentence:
+            continue
+        if len(summary) + len(sentence) + 2 <= max_length:  # +2 for ". "
+            summary += sentence + ". "
+        else:
+            break
+    
+    # If no sentences fit, return truncated text
+    if not summary and text:
+        summary = text[:max_length].rsplit(' ', 1)[0] + "..."
+            
+    return summary.strip()
+
+
+def extract_keywords(text: str, top_n: int = 10) -> List[str]:
+    """
+    Extract top keywords from text using simple frequency analysis.
+    
+    Args:
+        text: Text to analyze
+        top_n: Number of top keywords to return
+        
+    Returns:
+        List of keywords
+    """
+    # Simple word frequency approach
+    words = re.findall(r'\b[a-zA-Z]{4,}\b', text.lower())
+    
+    # Remove common stop words
+    stop_words = {'that', 'this', 'with', 'from', 'have', 'been', 'were', 
+                  'will', 'would', 'could', 'should', 'about', 'their', 'there'}
+    words = [w for w in words if w not in stop_words]
+    
+    # Count frequency
+    word_freq: Dict[str, int] = {}
+    for word in words:
+        word_freq[word] = word_freq.get(word, 0) + 1
+    
+    # Sort by frequency and return top N
+    sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
+    return [word for word, freq in sorted_words[:top_n]]
+
+
+def validate_url(url: str) -> bool:
+    """
+    Validate if a string is a proper URL.
+    
+    Args:
+        url: URL string to validate
+        
+    Returns:
+        True if valid URL, False otherwise
+    """
+    url_pattern = re.compile(
+        r'^https?://'  # http:// or https://
+        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'  # domain...
+        r'localhost|'  # localhost...
+        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'  # ...or ip
+        r'(?::\d+)?'  # optional port
+        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+    return url_pattern.match(url) is not None
+
+
+def format_timestamp() -> str:
+    """
+    Get current timestamp in ISO format.
+    
+    Returns:
+        ISO formatted timestamp string
+    """
+    return datetime.now().isoformat()
+
+
+def safe_divide(numerator: float, denominator: float, default: float = 0.0) -> float:
+    """
+    Safely divide two numbers, returning default if denominator is zero.
+    
+    Args:
+        numerator: Numerator value
+        denominator: Denominator value
+        default: Default value if division by zero
+        
+    Returns:
+        Division result or default
+    """
+    try:
+        return numerator / denominator if denominator != 0 else default
+    except (TypeError, ZeroDivisionError):
+        return default
+
+
+def parse_json_safe(json_str: str) -> Dict[str, Any]:
+    """
+    Safely parse JSON string with error handling.
+    
+    Args:
+        json_str: JSON string to parse
+        
+    Returns:
+        Parsed dictionary or empty dict on error
+    """
+    import json
+    try:
+        return json.loads(json_str)
+    except json.JSONDecodeError as e:
+        logger.error(f"JSON parse error: {e}")
+        return {}

utils/rag_utils.py

@@ -0,0 +1,141 @@
+"""
+RAG (Retrieval Augmented Generation) utilities using FAISS and embeddings
+"""
+import numpy as np
+from typing import List, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleRAGStore:
+    """
+    Simple RAG implementation using FAISS for vector similarity search
+    """
+    
+    def __init__(self):
+        """Initialize the RAG store"""
+        self.documents: List[str] = []
+        self.embeddings: List[np.ndarray] = []
+        self.index = None
+        self._model = None
+        
+    def _get_model(self):
+        """Lazy load the sentence transformer model"""
+        if self._model is None:
+            try:
+                from sentence_transformers import SentenceTransformer
+                self._model = SentenceTransformer('all-MiniLM-L6-v2')
+                logger.info("Loaded sentence transformer model")
+            except Exception as e:
+                logger.error(f"Failed to load sentence transformer: {e}")
+                raise
+        return self._model
+    
+    def add_documents(self, documents: List[str]) -> None:
+        """
+        Add documents to the RAG store and build FAISS index.
+        
+        Args:
+            documents: List of document strings to add
+        """
+        import faiss
+        
+        if not documents:
+            logger.warning("No documents provided to add")
+            return
+            
+        self.documents.extend(documents)
+        
+        # Generate embeddings
+        model = self._get_model()
+        new_embeddings = model.encode(documents, show_progress_bar=False)
+        self.embeddings.extend(new_embeddings)
+        
+        # Build or update FAISS index
+        embeddings_array = np.array(self.embeddings).astype('float32')
+        dimension = embeddings_array.shape[1]
+        
+        if self.index is None:
+            self.index = faiss.IndexFlatL2(dimension)
+        
+        self.index.add(embeddings_array)
+        logger.info(f"Added {len(documents)} documents to RAG store")
+    
+    def search(self, query: str, top_k: int = 3) -> List[Dict[str, Any]]:
+        """
+        Search for similar documents using the query.
+        
+        Args:
+            query: Search query string
+            top_k: Number of top results to return
+            
+        Returns:
+            List of search results with scores
+        """
+        if self.index is None or len(self.documents) == 0:
+            logger.warning("No documents in RAG store")
+            return []
+        
+        # Encode query
+        model = self._get_model()
+        query_embedding = model.encode([query], show_progress_bar=False)
+        query_embedding = np.array(query_embedding).astype('float32')
+        
+        # Search FAISS index
+        top_k = min(top_k, len(self.documents))
+        distances, indices = self.index.search(query_embedding, top_k)
+        
+        # Format results
+        results = []
+        for i, (distance, idx) in enumerate(zip(distances[0], indices[0])):
+            if idx < len(self.documents):
+                # Convert L2 distance to similarity score (inverse relationship)
+                similarity_score = 1.0 / (1.0 + float(distance))
+                results.append({
+                    "rank": i + 1,
+                    "document": self.documents[idx],
+                    "score": round(similarity_score, 4),
+                    "distance": float(distance)
+                })
+        
+        return results
+    
+    def clear(self) -> None:
+        """Clear all documents and reset the index"""
+        self.documents = []
+        self.embeddings = []
+        self.index = None
+        logger.info("Cleared RAG store")
+
+
+def create_rag_store(documents: List[str]) -> SimpleRAGStore:
+    """
+    Factory function to create and populate a RAG store.
+    
+    Args:
+        documents: List of documents to add to store
+        
+    Returns:
+        Initialized SimpleRAGStore instance
+    """
+    store = SimpleRAGStore()
+    if documents:
+        store.add_documents(documents)
+    return store
+
+
+def semantic_search(query: str, documents: List[str], top_k: int = 3) -> List[Dict[str, Any]]:
+    """
+    Perform semantic search on a list of documents.
+    
+    Args:
+        query: Search query
+        documents: List of documents to search
+        top_k: Number of results to return
+        
+    Returns:
+        List of search results
+    """
+    store = create_rag_store(documents)
+    return store.search(query, top_k)