Initial commit: MissionControlMCP - 8 Enterprise Automation Tools

.gitignore

@@ -0,0 +1,91 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# PyCharm
+.idea/
+
+# VSCode
+.vscode/
+*.code-workspace
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pytest
+.pytest_cache/
+.coverage
+htmlcov/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+
+# Logs
+*.log
+
+# Environment variables
+.env
+.env.local
+
+# Model cache (sentence transformers)
+.cache/
+models/
+
+# Hugging Face cache
+~/.cache/huggingface/
+
+# Test output files
+test_output/
+*.pdf
+*.txt
+*.csv
+output_*.png
+
+# Temporary test files
+test_*.py
+temp/
+tmp/

API.md

@@ -0,0 +1,583 @@
+# 📖 API Reference
+
+Complete API documentation for all 8 MissionControlMCP tools.
+
+---
+
+## 1. PDF Reader
+
+### `read_pdf(file_path: str) -> Dict[str, Any]`
+
+Extract text and metadata from PDF files.
+
+**Parameters:**
+- `file_path` (str): Absolute path to PDF file
+
+**Returns:**
+```python
+{
+    "text": str,           # Full text content from all pages
+    "pages": int,          # Number of pages
+    "metadata": {          # Document metadata
+        "author": str,
+        "creator": str,
+        "producer": str,
+        "subject": str,
+        "title": str,
+        "creation_date": str,
+        "modification_date": str
+    }
+}
+```
+
+**Example:**
+```python
+from tools.pdf_reader import read_pdf
+
+result = read_pdf("C:/docs/report.pdf")
+print(f"Pages: {result['pages']}")
+print(f"Author: {result['metadata']['author']}")
+print(result['text'][:500])  # First 500 chars
+```
+
+**Errors:**
+- `FileNotFoundError`: PDF file not found
+- `ImportError`: PyPDF2 not installed
+- `Exception`: Invalid or corrupted PDF
+
+---
+
+### `get_pdf_info(file_path: str) -> Dict[str, Any]`
+
+Get basic PDF information without extracting text.
+
+**Parameters:**
+- `file_path` (str): Path to PDF file
+
+**Returns:**
+```python
+{
+    "page_count": int,
+    "is_encrypted": bool,
+    "file_size_bytes": int,
+    "file_name": str
+}
+```
+
+---
+
+## 2. Text Extractor
+
+### `extract_text(text: str, operation: str, **kwargs) -> Dict[str, Any]`
+
+Process and extract information from text.
+
+**Parameters:**
+- `text` (str): Input text to process
+- `operation` (str): Operation type
+  - `"clean"` - Remove extra whitespace
+  - `"summarize"` - Create summary
+  - `"chunk"` - Split into chunks
+  - `"keywords"` - Extract keywords
+- `**kwargs`: Operation-specific parameters
+
+**Operation: clean**
+```python
+extract_text(text, operation="clean")
+# Returns: {"result": str, "word_count": int}
+```
+
+**Operation: summarize**
+```python
+extract_text(text, operation="summarize", max_length=500)
+# max_length: Maximum summary length (default: 500)
+# Returns: {"result": str, "word_count": int, "original_length": int}
+```
+
+**Operation: chunk**
+```python
+extract_text(text, operation="chunk", chunk_size=100, overlap=20)
+# chunk_size: Characters per chunk (default: 100)
+# overlap: Overlapping characters (default: 20)
+# Returns: {"chunks": List[str], "chunk_count": int}
+```
+
+**Operation: keywords**
+```python
+extract_text(text, operation="keywords", top_n=10)
+# top_n: Number of keywords (default: 10)
+# Returns: {"result": str, "keywords": List[str]}
+```
+
+**Example:**
+```python
+from tools.text_extractor import extract_text
+
+# Get keywords
+result = extract_text("Your text here...", operation="keywords")
+print(result['result'])  # "keyword1, keyword2, keyword3"
+
+# Summarize
+summary = extract_text("Long text...", operation="summarize", max_length=200)
+print(summary['result'])
+```
+
+---
+
+## 3. Web Fetcher
+
+### `fetch_web_content(url: str, timeout: int = 30) -> Dict[str, Any]`
+
+Fetch and parse web page content.
+
+**Parameters:**
+- `url` (str): Website URL
+- `timeout` (int): Request timeout in seconds (default: 30)
+
+**Returns:**
+```python
+{
+    "url": str,
+    "title": str,
+    "content": str,         # Clean text content
+    "html": str,            # Raw HTML
+    "links": List[str],     # All URLs found
+    "status_code": int,     # HTTP status
+    "timestamp": str
+}
+```
+
+**Example:**
+```python
+from tools.web_fetcher import fetch_web_content
+
+result = fetch_web_content("https://example.com")
+print(f"Title: {result['title']}")
+print(f"Content: {result['content'][:200]}")
+print(f"Links found: {len(result['links'])}")
+```
+
+**Errors:**
+- `requests.exceptions.Timeout`: Request timed out
+- `requests.exceptions.RequestException`: Network error
+- `Exception`: Invalid URL or parsing error
+
+---
+
+## 4. RAG Search
+
+### `search_documents(query: str, documents: List[str], top_k: int = 3) -> Dict[str, Any]`
+
+Semantic search using vector embeddings and FAISS.
+
+**Parameters:**
+- `query` (str): Search query
+- `documents` (List[str]): List of documents to search
+- `top_k` (int): Number of results to return (default: 3)
+
+**Returns:**
+```python
+{
+    "query": str,
+    "total_documents": int,
+    "returned_results": int,
+    "results": [
+        {
+            "rank": int,
+            "document": str,
+            "score": float,      # 0.0 to 1.0 (higher = more relevant)
+            "distance": float    # L2 distance
+        }
+    ]
+}
+```
+
+**Example:**
+```python
+from tools.rag_search import search_documents
+
+docs = [
+    "Machine learning is a subset of AI",
+    "Python is a programming language",
+    "Data science uses statistics"
+]
+
+result = search_documents("artificial intelligence", docs, top_k=2)
+
+for item in result['results']:
+    print(f"Score: {item['score']:.4f} - {item['document']}")
+```
+
+**Features:**
+- Semantic matching (understands meaning, not just keywords)
+- Uses sentence-transformers (all-MiniLM-L6-v2)
+- FAISS for fast vector search
+
+---
+
+### `multi_query_search(queries: List[str], documents: List[str], top_k: int = 3) -> Dict[str, Any]`
+
+Search multiple queries at once.
+
+**Returns:**
+```python
+{
+    "queries": List[str],
+    "results": {
+        "query1": [results],
+        "query2": [results]
+    }
+}
+```
+
+---
+
+## 5. Data Visualizer
+
+### `visualize_data(data: str, chart_type: str, x_column: str = None, y_column: str = None, title: str = "Data Visualization") -> Dict[str, Any]`
+
+Create charts from CSV or JSON data.
+
+**Parameters:**
+- `data` (str): CSV or JSON string
+- `chart_type` (str): Chart type
+  - `"bar"` - Bar chart
+  - `"line"` - Line chart
+  - `"pie"` - Pie chart
+  - `"scatter"` - Scatter plot
+- `x_column` (str): X-axis column name
+- `y_column` (str): Y-axis column name
+- `title` (str): Chart title
+
+**Returns:**
+```python
+{
+    "image_base64": str,     # Base64-encoded PNG image
+    "dimensions": {
+        "width": int,
+        "height": int
+    },
+    "chart_type": str,
+    "title": str,
+    "columns_used": {
+        "x": str,
+        "y": str
+    }
+}
+```
+
+**Example:**
+```python
+from tools.data_visualizer import visualize_data
+import base64
+
+csv_data = """month,revenue
+Jan,5000000
+Feb,5200000
+Mar,5400000"""
+
+result = visualize_data(
+    data=csv_data,
+    chart_type="line",
+    x_column="month",
+    y_column="revenue",
+    title="Revenue Trends"
+)
+
+# Save chart
+with open("chart.png", "wb") as f:
+    f.write(base64.b64decode(result['image_base64']))
+```
+
+---
+
+## 6. File Converter
+
+### `convert_file(input_path: str, output_path: str, conversion_type: str) -> Dict[str, Any]`
+
+Convert between PDF, TXT, and CSV formats.
+
+**Parameters:**
+- `input_path` (str): Input file path
+- `output_path` (str): Output file path
+- `conversion_type` (str): Conversion type
+  - `"pdf_to_txt"` - PDF → Text
+  - `"txt_to_pdf"` - Text → PDF
+  - `"csv_to_txt"` - CSV → Text
+  - `"txt_to_csv"` - Text → CSV
+
+**Returns:**
+```python
+{
+    "success": bool,
+    "input_file": str,
+    "output_file": str,
+    "conversion_type": str,
+    "file_size_bytes": int
+}
+```
+
+**Example:**
+```python
+from tools.file_converter import convert_file
+
+result = convert_file(
+    input_path="document.pdf",
+    output_path="document.txt",
+    conversion_type="pdf_to_txt"
+)
+
+print(f"Converted: {result['success']}")
+print(f"Output: {result['output_file']}")
+```
+
+---
+
+## 7. Email Intent Classifier
+
+### `classify_email_intent(email_text: str) -> Dict[str, Any]`
+
+Classify email intent using NLP pattern matching.
+
+**Parameters:**
+- `email_text` (str): Email content (subject + body)
+
+**Returns:**
+```python
+{
+    "intent": str,          # Primary intent
+    "confidence": float,    # 0.0 to 1.0
+    "secondary_intents": [
+        {
+            "intent": str,
+            "confidence": float
+        }
+    ],
+    "explanation": str
+}
+```
+
+**Intent Types:**
+- `complaint` - Customer complaints
+- `inquiry` - Information requests
+- `request` - Action requests
+- `feedback` - Suggestions/reviews
+- `order` - Purchase-related
+- `meeting` - Meeting scheduling
+- `urgent` - High priority issues
+- `application` - Job applications
+- `sales` - Sales pitches
+- `other` - Unclassified
+
+**Example:**
+```python
+from tools.email_intent_classifier import classify_email_intent
+
+email = """
+Subject: Order Issue
+My order #12345 hasn't arrived yet. Can you help?
+"""
+
+result = classify_email_intent(email)
+print(f"Intent: {result['intent']}")          # "complaint"
+print(f"Confidence: {result['confidence']}")  # 0.85
+```
+
+---
+
+### `classify_batch(emails: List[str]) -> Dict[str, Any]`
+
+Classify multiple emails at once.
+
+**Returns:**
+```python
+{
+    "results": [
+        {"email_index": int, "intent": str, "confidence": float},
+        ...
+    ],
+    "total_processed": int
+}
+```
+
+---
+
+## 8. KPI Generator
+
+### `generate_kpis(data: str, metrics: List[str] = None) -> Dict[str, Any]`
+
+Calculate business KPIs from financial data.
+
+**Parameters:**
+- `data` (str): JSON string with business data
+- `metrics` (List[str]): Metric categories (optional)
+  - `"revenue"` - Revenue-related KPIs
+  - `"growth"` - Growth rates
+  - `"efficiency"` - Efficiency metrics
+  - `"customer"` - Customer metrics
+  - `"operational"` - Operational metrics
+
+**Input Data Format:**
+```json
+{
+    "revenue": 5000000,
+    "costs": 3000000,
+    "customers": 2500,
+    "current_revenue": 5000000,
+    "previous_revenue": 4500000,
+    "current_customers": 2500,
+    "previous_customers": 2300,
+    "employees": 50,
+    "marketing_spend": 500000,
+    "sales": 5000000,
+    "cogs": 2000000
+}
+```
+
+**Returns:**
+```python
+{
+    "kpis": {
+        "total_revenue": float,
+        "profit": float,
+        "profit_margin_percent": float,
+        "revenue_growth": float,
+        "revenue_per_customer": float,
+        "revenue_per_employee": float,
+        "customer_growth_rate": float,
+        ...
+    },
+    "summary": str,              # Executive summary
+    "trends": List[str],         # Identified trends
+    "metrics_analyzed": List[str],
+    "data_points": int
+}
+```
+
+**Example:**
+```python
+from tools.kpi_generator import generate_kpis
+import json
+
+data = {
+    "revenue": 5000000,
+    "costs": 3000000,
+    "customers": 2500,
+    "employees": 50
+}
+
+result = generate_kpis(json.dumps(data), metrics=["revenue", "efficiency"])
+
+print(f"Profit: ${result['kpis']['profit']:,.0f}")
+print(f"Margin: {result['kpis']['profit_margin_percent']:.1f}%")
+print(f"\nSummary: {result['summary']}")
+```
+
+---
+
+## Error Handling
+
+All tools follow consistent error handling:
+
+```python
+try:
+    result = tool_function(params)
+except FileNotFoundError as e:
+    print(f"File not found: {e}")
+except ValueError as e:
+    print(f"Invalid input: {e}")
+except ImportError as e:
+    print(f"Missing dependency: {e}")
+except Exception as e:
+    print(f"Unexpected error: {e}")
+```
+
+---
+
+## Type Hints
+
+All functions use Python type hints:
+
+```python
+from typing import Dict, Any, List
+
+def function_name(param: str) -> Dict[str, Any]:
+    ...
+```
+
+---
+
+## Logging
+
+All tools use Python logging:
+
+```python
+import logging
+logger = logging.getLogger(__name__)
+
+logger.info("Operation completed")
+logger.warning("Warning message")
+logger.error("Error occurred")
+```
+
+---
+
+## Dependencies
+
+See `requirements.txt` for all dependencies:
+
+```txt
+mcp>=1.0.0
+pypdf2>=3.0.0
+requests>=2.31.0
+beautifulsoup4>=4.12.0
+pandas>=2.0.0
+numpy>=1.24.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+scikit-learn>=1.3.0
+nltk>=3.8.0
+pydantic>=2.0.0
+faiss-cpu>=1.7.4
+sentence-transformers>=2.2.0
+```
+
+---
+
+## MCP Integration
+
+All tools are registered in `mcp_server.py`:
+
+```python
+server.register_tool(
+    name="pdf_reader",
+    description="Extract text and metadata from PDF files",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "file_path": {"type": "string"}
+        },
+        "required": ["file_path"]
+    }
+)
+```
+
+---
+
+## Version Information
+
+- **API Version:** 1.0.0
+- **Python:** 3.8+
+- **MCP Protocol:** 1.0.0
+
+---
+
+## Support
+
+For issues or questions:
+- GitHub: AlBaraa-1/CleanEye-Hackathon
+- Documentation: README.md
+- Examples: EXAMPLES.md
+- Testing: TESTING.md
+
+**Complete API reference for MissionControlMCP!** 🚀

ARCHITECTURE.md

@@ -0,0 +1,557 @@
+# 🏗️ System Architecture
+
+MissionControlMCP system design and architecture documentation.
+
+---
+
+## 📊 High-Level Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        Client Layer                          │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
+│  │ Claude       │  │  Custom      │  │  Other MCP   │      │
+│  │ Desktop      │  │  Client      │  │  Clients     │      │
+│  └──────────────┘  └──────────────┘  └──────────────┘      │
+└──────────────────────┬──────────────────────────────────────┘
+                       │ MCP Protocol (stdio)
+┌──────────────────────┴──────────────────────────────────────┐
+│                    MCP Server Layer                          │
+│  ┌────────────────────────────────────────────────────────┐ │
+│  │              mcp_server.py                             │ │
+│  │  • Tool Registration                                   │ │
+│  │  • Request Routing                                     │ │
+│  │  • Response Formatting                                 │ │
+│  └────────────────────────────────────────────────────────┘ │
+└──────────────────────┬──────────────────────────────────────┘
+                       │
+┌──────────────────────┴──────────────────────────────────────┐
+│                    Business Logic Layer                      │
+│  ┌──────────┬──────────┬──────────┬──────────┐            │
+│  │ PDF      │ Text     │ Web      │ RAG      │            │
+│  │ Reader   │ Extract  │ Fetcher  │ Search   │            │
+│  ├──────────┼──────────┼──────────┼──────────┤            │
+│  │ Data     │ File     │ Email    │ KPI      │            │
+│  │ Visual   │ Convert  │ Classify │ Generate │            │
+│  └──────────┴──────────┴──────────┴──────────┘            │
+└──────────────────────┬──────────────────────────────────────┘
+                       │
+┌──────────────────────┴──────────────────────────────────────┐
+│                    Utility Layer                             │
+│  ┌────────────────────────────────────────────────────────┐ │
+│  │  • helpers.py      - Text processing utilities         │ │
+│  │  • rag_utils.py    - Vector search & FAISS             │ │
+│  │  • schemas.py      - Pydantic models                   │ │
+│  └────────────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🧩 Component Architecture
+
+### 1. MCP Server (`mcp_server.py`)
+
+**Responsibilities:**
+- Register all 8 tools with MCP SDK
+- Handle incoming tool requests
+- Route requests to appropriate tool functions
+- Format and return responses
+- Error handling and logging
+
+**Flow:**
+```
+Client Request → MCP Protocol → Server → Tool → Response → Client
+```
+
+**Code Structure:**
+```python
+# Tool Registration
+server.register_tool(name, description, input_schema)
+
+# Request Handler
+async def call_tool(name, arguments):
+    if name == "pdf_reader":
+        return await pdf_reader.read_pdf(**arguments)
+    elif name == "text_extractor":
+        return await text_extractor.extract_text(**arguments)
+    # ... other tools
+
+# Server Startup
+async with stdio_server() as (read_stream, write_stream):
+    await server.run(read_stream, write_stream)
+```
+
+---
+
+### 2. Tool Layer (`tools/`)
+
+Each tool is independent and follows this pattern:
+
+**Tool Structure:**
+```python
+"""
+Tool Name - Description
+"""
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+def tool_function(param: str) -> Dict[str, Any]:
+    """
+    Tool description.
+    
+    Args:
+        param: Parameter description
+        
+    Returns:
+        Standardized result dictionary
+    """
+    try:
+        # Validation
+        if not param:
+            raise ValueError("Invalid input")
+        
+        # Processing
+        result = process_data(param)
+        
+        # Return standardized format
+        return {
+            "success": True,
+            "data": result,
+            "metadata": {}
+        }
+        
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        raise
+```
+
+**Tool Independence:**
+- Each tool is self-contained
+- No dependencies between tools
+- Can be tested individually
+- Easy to add/remove tools
+
+---
+
+### 3. Utility Layer (`utils/`)
+
+**helpers.py - Text Processing:**
+```python
+• clean_text() - Remove extra whitespace
+• extract_keywords() - NLP keyword extraction
+• chunk_text() - Text splitting with overlap
+• validate_url() - URL validation
+```
+
+**rag_utils.py - Vector Search:**
+```python
+• SimpleRAGStore - FAISS-based vector database
+• semantic_search() - Sentence transformer embeddings
+• create_rag_store() - Initialize vector store
+```
+
+**Models (models/schemas.py):**
+```python
+• Pydantic models for type validation
+• Input/output schemas
+• Data validation
+```
+
+---
+
+## 🔄 Data Flow
+
+### Request Flow
+
+```
+1. Client sends MCP request
+   ↓
+2. mcp_server.py receives request
+   ↓
+3. Server validates input schema
+   ↓
+4. Server routes to tool function
+   ↓
+5. Tool processes data
+   ↓
+6. Tool returns result dict
+   ↓
+7. Server formats MCP response
+   ↓
+8. Client receives response
+```
+
+### Example: PDF Reading Flow
+
+```
+Client: "Read this PDF"
+   ↓
+MCP Server: Receives pdf_reader request
+   ↓
+pdf_reader.py: read_pdf(file_path)
+   ↓
+PyPDF2: Extract text from pages
+   ↓
+Return: {text, pages, metadata}
+   ↓
+MCP Server: Format response
+   ↓
+Client: Receives extracted text
+```
+
+---
+
+## 🗂️ Project Structure
+
+```
+mission_control_mcp/
+│
+├── mcp_server.py              # MCP server entry point
+│
+├── tools/                     # 8 independent tools
+│   ├── pdf_reader.py          # PDF text extraction
+│   ├── text_extractor.py      # Text processing (4 ops)
+│   ├── web_fetcher.py         # Web scraping
+│   ├── rag_search.py          # Semantic search
+│   ├── data_visualizer.py     # Chart generation
+│   ├── file_converter.py      # File format conversion
+│   ├── email_intent_classifier.py  # Email classification
+│   └── kpi_generator.py       # Business metrics
+│
+├── utils/                     # Shared utilities
+│   ├── helpers.py             # Text processing helpers
+│   └── rag_utils.py           # Vector search utilities
+│
+├── models/                    # Data models
+│   └── schemas.py             # Pydantic schemas
+│
+├── examples/                  # Sample test data
+│   ├── sample_report.txt      # Business report
+│   ├── business_data.csv      # Financial data
+│   ├── sample_email_*.txt     # Email samples
+│   └── sample_documents.txt   # RAG search docs
+│
+├── app.py                     # Gradio web interface
+├── demo.py                    # Demo & test suite
+│
+├── docs/                      # Documentation
+│   ├── README.md              # Main documentation
+│   ├── API.md                 # API reference
+│   ├── EXAMPLES.md            # Use cases
+│   ├── TESTING.md             # Testing guide
+│   ├── ARCHITECTURE.md        # This file
+│   └── CONTRIBUTING.md        # Contribution guide
+│
+├── requirements.txt           # Python dependencies
+├── .gitignore                 # Git ignore rules
+└── LICENSE                    # MIT License
+```
+
+---
+
+## 🔌 Integration Points
+
+### MCP Protocol Integration
+
+```python
+from mcp.server import Server
+from mcp.types import Tool, TextContent
+
+# Create server
+server = Server("mission-control")
+
+# Register tool
+@server.tool()
+async def pdf_reader(file_path: str) -> str:
+    result = read_pdf(file_path)
+    return json.dumps(result)
+
+# Run server
+await server.run(stdin, stdout)
+```
+
+### Claude Desktop Integration
+
+**Configuration:**
+```json
+{
+  "mcpServers": {
+    "mission-control": {
+      "command": "python",
+      "args": ["path/to/mcp_server.py"]
+    }
+  }
+}
+```
+
+**Communication:**
+```
+Claude Desktop ←→ MCP Protocol ←→ mcp_server.py ←→ Tools
+```
+
+---
+
+## 🚀 Scalability Design
+
+### Horizontal Scaling
+
+**Current:** Single-process server
+**Future:** Multi-process with load balancing
+
+```
+             Load Balancer
+                   │
+        ┌──────────┼──────────┐
+        │          │          │
+   Server 1    Server 2    Server 3
+        │          │          │
+        └──────────┴──────────┘
+                Tools
+```
+
+### Caching Strategy
+
+**Implemented:**
+- RAG model caching (sentence transformers)
+- NLTK data caching
+
+**Future Improvements:**
+- Redis for result caching
+- Database for document storage
+- CDN for static assets
+
+---
+
+## 🔒 Security Architecture
+
+### Input Validation
+
+```python
+# Pydantic schemas
+from pydantic import BaseModel, validator
+
+class PDFReaderInput(BaseModel):
+    file_path: str
+    
+    @validator('file_path')
+    def validate_path(cls, v):
+        if not Path(v).exists():
+            raise ValueError("File not found")
+        return v
+```
+
+### Error Handling
+
+```python
+try:
+    result = tool_function(input)
+except FileNotFoundError:
+    return {"error": "File not found", "code": 404}
+except ValueError:
+    return {"error": "Invalid input", "code": 400}
+except Exception:
+    return {"error": "Internal error", "code": 500}
+```
+
+### Authentication
+
+**Current:** None (local tool execution)
+**Production Considerations:**
+- API key authentication
+- Rate limiting
+- Request logging
+- User permissions
+
+---
+
+## 📊 Performance Characteristics
+
+### Tool Performance
+
+| Tool | Avg Time | Memory | Notes |
+|------|----------|--------|-------|
+| PDF Reader | 1s | 50MB | Depends on PDF size |
+| Text Extractor | 0.5s | 10MB | Fast text processing |
+| Web Fetcher | 2-3s | 20MB | Network dependent |
+| RAG Search | 2.5s* | 200MB | *First run (model load) |
+| RAG Search | 0.5s | 200MB | Subsequent runs |
+| Data Visualizer | 1.2s | 30MB | Chart generation |
+| File Converter | 1-2s | 50MB | File size dependent |
+| Email Classifier | 0.1s | 5MB | Very fast |
+| KPI Generator | 0.3s | 10MB | Quick calculations |
+
+### Bottlenecks
+
+1. **RAG Search** - Initial model loading (~2s)
+   - Solution: Keep model in memory
+   
+2. **Web Fetcher** - Network latency
+   - Solution: Async requests, caching
+   
+3. **PDF Reader** - Large files
+   - Solution: Stream processing
+
+---
+
+## 🔄 State Management
+
+### Stateless Design
+
+Each tool request is independent:
+- No session state
+- No user context
+- Pure function design
+
+**Benefits:**
+- Easy scaling
+- No state synchronization
+- Simple debugging
+- High availability
+
+### RAG Store State
+
+Exception: RAG search maintains in-memory vector store:
+```python
+class SimpleRAGStore:
+    def __init__(self):
+        self.documents = []
+        self.index = None  # FAISS index
+```
+
+**Lifecycle:**
+- Created on first search
+- Persists during server lifetime
+- Cleared on server restart
+
+---
+
+## 🧪 Testing Architecture
+
+### Test Pyramid
+
+```
+         ┌─────────────┐
+         │   E2E Tests │  (MCP integration)
+         ├─────────────┤
+         │ Integration │  (Tool combinations)
+         ├─────────────┤
+         │  Unit Tests │  (Individual functions)
+         └─────────────┘
+```
+
+### Test Coverage
+
+- **Unit Tests:** Test each function independently
+- **Integration Tests:** Test tool interactions
+- **MCP Tests:** Test server communication
+- **Sample Tests:** Test with real data
+
+---
+
+## 📦 Dependency Management
+
+### Core Dependencies
+
+```
+MCP SDK (>=1.0.0)
+├── stdio communication
+└── Tool registration
+
+Processing Libraries
+├── PyPDF2 (PDF reading)
+├── BeautifulSoup4 (HTML parsing)
+├── Pandas (Data processing)
+└── Matplotlib (Visualization)
+
+ML/NLP Libraries
+├── scikit-learn (Text processing)
+├── NLTK (Keyword extraction)
+├── sentence-transformers (Embeddings)
+└── FAISS (Vector search)
+```
+
+### Optional Dependencies
+
+- faiss-cpu: Can use faiss-gpu on GPU systems
+- reportlab: Optional for PDF generation
+
+---
+
+## 🔮 Future Architecture Improvements
+
+### Planned Enhancements
+
+1. **Database Integration**
+   ```
+   PostgreSQL for persistent storage
+   Redis for caching
+   ```
+
+2. **Async Processing**
+   ```python
+   async def process_pdf(file_path: str):
+       # Async PDF processing
+       return await asyncio.to_thread(read_pdf, file_path)
+   ```
+
+3. **Microservices**
+   ```
+   Each tool as separate service
+   API gateway for routing
+   Service mesh for communication
+   ```
+
+4. **Monitoring**
+   ```
+   Prometheus metrics
+   Grafana dashboards
+   Error tracking (Sentry)
+   ```
+
+---
+
+## 📝 Design Principles
+
+### SOLID Principles
+
+- **Single Responsibility:** Each tool does one thing
+- **Open/Closed:** Easy to add new tools
+- **Liskov Substitution:** Tools are interchangeable
+- **Interface Segregation:** Minimal tool interfaces
+- **Dependency Inversion:** Tools depend on abstractions
+
+### Clean Architecture
+
+- **Independent of Frameworks:** Core logic separate from MCP
+- **Testable:** Can test without MCP server
+- **Independent of UI:** Works with any MCP client
+- **Independent of Database:** No database coupling
+
+---
+
+## 🎯 Architectural Goals
+
+✅ **Achieved:**
+- Modular design
+- Easy to extend
+- Well-documented
+- Testable
+- Production-ready
+
+🔄 **In Progress:**
+- Performance optimization
+- Enhanced caching
+- Better error handling
+
+🎯 **Future:**
+- Multi-tenancy
+- Distributed processing
+- Advanced monitoring
+- Auto-scaling
+
+---
+
+**MissionControlMCP Architecture Documentation v1.0** 🏗️

CONTRIBUTING.md

@@ -0,0 +1,529 @@
+# 🤝 Contributing to MissionControlMCP
+
+Thank you for considering contributing to MissionControlMCP! This document provides guidelines for contributing to the project.
+
+---
+
+## 📋 Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Getting Started](#getting-started)
+- [Development Setup](#development-setup)
+- [How to Contribute](#how-to-contribute)
+- [Coding Standards](#coding-standards)
+- [Testing Guidelines](#testing-guidelines)
+- [Pull Request Process](#pull-request-process)
+- [Reporting Bugs](#reporting-bugs)
+- [Suggesting Features](#suggesting-features)
+
+---
+
+## 📜 Code of Conduct
+
+This project adheres to a code of conduct. By participating, you are expected to uphold this code:
+
+- **Be Respectful:** Treat everyone with respect and consideration
+- **Be Constructive:** Provide helpful feedback and suggestions
+- **Be Collaborative:** Work together towards common goals
+- **Be Professional:** Maintain professionalism in all interactions
+
+---
+
+## 🚀 Getting Started
+
+### Prerequisites
+
+- Python 3.11 or higher
+- Git
+- Basic knowledge of Python and MCP protocol
+
+### Fork and Clone
+
+1. Fork the repository on GitHub
+2. Clone your fork locally:
+```bash
+git clone https://github.com/YOUR_USERNAME/CleanEye-Hackathon.git
+cd CleanEye-Hackathon/mission_control_mcp
+```
+
+3. Add upstream remote:
+```bash
+git remote add upstream https://github.com/AlBaraa-1/CleanEye-Hackathon.git
+```
+
+---
+
+## 💻 Development Setup
+
+### 1. Create Virtual Environment
+
+```bash
+python -m venv venv
+
+# Windows
+venv\Scripts\activate
+
+# Linux/Mac
+source venv/bin/activate
+```
+
+### 2. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Install Development Dependencies
+
+```bash
+pip install pytest black flake8 mypy
+```
+
+### 4. Run Tests
+
+```bash
+python demo.py
+```
+
+---
+
+## 🛠️ How to Contribute
+
+### Types of Contributions
+
+We welcome:
+
+1. **Bug Fixes** - Fix issues in existing tools
+2. **New Tools** - Add new MCP tools
+3. **Documentation** - Improve docs and examples
+4. **Tests** - Add or improve test coverage
+5. **Performance** - Optimize existing code
+6. **Examples** - Add real-world use cases
+
+---
+
+## 📝 Coding Standards
+
+### Python Style Guide
+
+We follow [PEP 8](https://pep8.org/) with these specifics:
+
+**Formatting:**
+```python
+# Good
+def function_name(param1: str, param2: int) -> Dict[str, Any]:
+    """
+    Function description.
+    
+    Args:
+        param1: Parameter description
+        param2: Parameter description
+        
+    Returns:
+        Dictionary with results
+    """
+    result = {"key": "value"}
+    return result
+
+# Bad
+def functionName(param1,param2):
+    result={"key":"value"}
+    return result
+```
+
+**Use Black for Formatting:**
+```bash
+black tools/your_tool.py
+```
+
+**Type Hints:**
+```python
+from typing import Dict, Any, List, Optional
+
+def process_data(data: List[str], limit: Optional[int] = None) -> Dict[str, Any]:
+    ...
+```
+
+**Docstrings:**
+```python
+def my_function(param: str) -> Dict[str, Any]:
+    """
+    Brief description (one line).
+    
+    Longer description if needed explaining the function's
+    purpose, behavior, and any important details.
+    
+    Args:
+        param: Description of parameter
+        
+    Returns:
+        Description of return value
+        
+    Raises:
+        ValueError: When invalid input
+        FileNotFoundError: When file not found
+        
+    Example:
+        >>> result = my_function("example")
+        >>> print(result['key'])
+        'value'
+    """
+    ...
+```
+
+---
+
+## ✅ Testing Guidelines
+
+### Writing Tests
+
+All new tools must include tests:
+
+**1. Create Test File:**
+```python
+# tests/test_your_tool.py
+import pytest
+from tools.your_tool import your_function
+
+def test_your_function_success():
+    """Test successful operation"""
+    result = your_function("valid_input")
+    assert result['success'] == True
+    assert 'data' in result
+
+def test_your_function_error():
+    """Test error handling"""
+    with pytest.raises(ValueError):
+        your_function("invalid_input")
+```
+
+**2. Run Tests:**
+```bash
+pytest tests/test_your_tool.py -v
+```
+
+### Test Coverage
+
+Aim for 90%+ coverage:
+```bash
+pytest --cov=tools tests/
+```
+
+### Test Categories
+
+- **Unit Tests** - Test individual functions
+- **Integration Tests** - Test tool combinations
+- **MCP Tests** - Test MCP protocol integration
+
+---
+
+## 🔄 Pull Request Process
+
+### 1. Create Feature Branch
+
+```bash
+git checkout -b feature/your-feature-name
+# or
+git checkout -b fix/bug-description
+```
+
+### 2. Make Changes
+
+- Write code following style guide
+- Add tests for new functionality
+- Update documentation
+- Run tests locally
+
+### 3. Commit Changes
+
+Use clear commit messages:
+```bash
+git add .
+git commit -m "Add: New email sentiment analysis tool"
+# or
+git commit -m "Fix: PDF reader handling encrypted files"
+# or
+git commit -m "Docs: Update API reference for web fetcher"
+```
+
+**Commit Message Format:**
+- `Add:` - New features
+- `Fix:` - Bug fixes
+- `Docs:` - Documentation changes
+- `Test:` - Test additions/changes
+- `Refactor:` - Code refactoring
+- `Perf:` - Performance improvements
+
+### 4. Push to Fork
+
+```bash
+git push origin feature/your-feature-name
+```
+
+### 5. Create Pull Request
+
+1. Go to GitHub repository
+2. Click "New Pull Request"
+3. Select your branch
+4. Fill in PR template:
+
+```markdown
+## Description
+Brief description of changes
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Documentation update
+- [ ] Performance improvement
+
+## Testing
+- [ ] All tests pass
+- [ ] New tests added
+- [ ] Manual testing completed
+
+## Checklist
+- [ ] Code follows style guide
+- [ ] Documentation updated
+- [ ] Tests added/updated
+- [ ] No breaking changes
+```
+
+### 6. Code Review
+
+- Address reviewer feedback
+- Make requested changes
+- Push updates to same branch
+
+### 7. Merge
+
+Once approved, maintainers will merge your PR.
+
+---
+
+## 🐛 Reporting Bugs
+
+### Before Submitting
+
+1. Check existing issues
+2. Verify bug in latest version
+3. Gather reproduction steps
+
+### Bug Report Template
+
+```markdown
+**Bug Description**
+Clear description of the bug
+
+**To Reproduce**
+Steps to reproduce:
+1. Run command '...'
+2. Call function '...'
+3. See error
+
+**Expected Behavior**
+What should happen
+
+**Actual Behavior**
+What actually happens
+
+**Environment**
+- OS: Windows 11
+- Python: 3.12
+- MCP Version: 1.0.0
+
+**Error Messages**
+```
+Paste error messages here
+```
+
+**Additional Context**
+Any other relevant information
+```
+
+---
+
+## 💡 Suggesting Features
+
+### Feature Request Template
+
+```markdown
+**Feature Description**
+What feature would you like to see?
+
+**Use Case**
+Why is this feature needed? How will it be used?
+
+**Proposed Solution**
+How should this feature work?
+
+**Alternatives Considered**
+What other approaches did you consider?
+
+**Additional Context**
+Any mockups, examples, or references
+```
+
+---
+
+## 🏗️ Adding New Tools
+
+### Tool Structure
+
+```python
+# tools/my_new_tool.py
+"""
+Tool Name - Brief description
+"""
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+def my_tool_function(param: str) -> Dict[str, Any]:
+    """
+    Tool description.
+    
+    Args:
+        param: Parameter description
+        
+    Returns:
+        Dictionary with results
+    """
+    try:
+        # Implementation
+        result = process_data(param)
+        
+        return {
+            "success": True,
+            "data": result,
+            "metadata": {}
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in my_tool: {e}")
+        raise
+```
+
+### Register Tool in MCP Server
+
+```python
+# mcp_server.py
+from tools.my_new_tool import my_tool_function
+
+# In tool registration section:
+server.register_tool(
+    name="my_tool",
+    description="What this tool does",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "param": {"type": "string", "description": "Param description"}
+        },
+        "required": ["param"]
+    }
+)
+```
+
+### Add Tests
+
+```python
+# tests/test_my_tool.py
+def test_my_tool():
+    result = my_tool_function("test_input")
+    assert result['success'] == True
+```
+
+### Update Documentation
+
+1. Add to README.md tool list
+2. Add to API.md reference
+3. Add to EXAMPLES.md with use case
+4. Add sample files to examples/
+
+---
+
+## 📚 Documentation Guidelines
+
+### What to Document
+
+- **README.md** - Overview, setup, quick start
+- **API.md** - Complete function signatures
+- **EXAMPLES.md** - Real-world use cases
+- **TESTING.md** - How to test
+- **Code Comments** - Complex logic explanation
+
+### Documentation Style
+
+```python
+# Good - Clear and concise
+def calculate_total(items: List[float]) -> float:
+    """Calculate the sum of item prices."""
+    return sum(items)
+
+# Bad - Over-documented
+def calculate_total(items: List[float]) -> float:
+    """
+    This function takes a list of items and calculates the total
+    by iterating through each item and adding them together using
+    the built-in sum function and then returns the result.
+    """
+    return sum(items)
+```
+
+---
+
+## 🎯 Development Workflow
+
+### Typical Workflow
+
+1. **Check Issues** - Find or create issue
+2. **Discuss** - Comment on issue before starting
+3. **Branch** - Create feature branch
+4. **Develop** - Write code + tests
+5. **Test** - Run all tests locally
+6. **Document** - Update docs
+7. **Commit** - Clear commit messages
+8. **Push** - Push to your fork
+9. **PR** - Create pull request
+10. **Review** - Address feedback
+11. **Merge** - Maintainer merges
+
+### Stay in Sync
+
+```bash
+# Pull latest changes from upstream
+git fetch upstream
+git checkout main
+git merge upstream/main
+git push origin main
+```
+
+---
+
+## 🏆 Recognition
+
+Contributors will be:
+- Listed in README.md contributors section
+- Mentioned in release notes
+- Credited in commit history
+
+---
+
+## 📞 Getting Help
+
+- **Questions:** Open a GitHub Discussion
+- **Chat:** Join our Discord (link in README)
+- **Issues:** GitHub Issues for bugs/features
+
+---
+
+## 📄 License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.
+
+---
+
+**Thank you for contributing to MissionControlMCP!** 🚀
+
+Every contribution, no matter how small, helps make this project better for everyone.

EXAMPLES.md

@@ -0,0 +1,319 @@
+# 💼 Real-World Use Cases & Examples
+
+This document showcases practical, real-world applications of MissionControlMCP's tools.
+
+---
+
+## 🏢 Enterprise Use Cases
+
+### Use Case 1: Automated Report Generation
+**Scenario:** Monthly business reporting automation
+
+**Workflow:**
+1. **pdf_reader** → Extract data from quarterly reports
+2. **text_extractor** → Summarize key findings
+3. **kpi_generator** → Calculate business metrics
+4. **data_visualizer** → Create performance charts
+
+**Business Value:** Saves 10+ hours per month of manual work
+
+---
+
+### Use Case 2: Customer Support Intelligence
+**Scenario:** Automated email triage and routing
+
+**Workflow:**
+1. **email_intent_classifier** → Categorize incoming emails
+2. Route based on intent:
+   - Complaints → Priority queue
+   - Inquiries → Sales team
+   - Urgent → Immediate escalation
+
+**Business Value:** 80% faster email routing, improved response times
+
+---
+
+### Use Case 3: Market Research Automation
+**Scenario:** Competitive analysis from web sources
+
+**Workflow:**
+1. **web_fetcher** → Collect competitor website content
+2. **text_extractor** → Extract key information
+3. **rag_search** → Find relevant insights across sources
+4. **text_extractor** → Generate executive summary
+
+**Business Value:** Real-time market intelligence, faster decision making
+
+---
+
+### Use Case 4: Knowledge Base Search
+**Scenario:** Internal document search system
+
+**Workflow:**
+1. **pdf_reader** → Index company documents
+2. **rag_search** → Semantic search across knowledge base
+3. Find relevant information even with different wording
+
+**Business Value:** Instant access to company knowledge, reduced information silos
+
+---
+
+### Use Case 5: Data Analysis Pipeline
+**Scenario:** Convert and visualize business data
+
+**Workflow:**
+1. **file_converter** → Convert PDF reports to CSV
+2. **data_visualizer** → Generate trend charts
+3. **kpi_generator** → Calculate performance metrics
+
+**Business Value:** Automated data transformation, visual insights
+
+---
+
+## 🎯 Specific Examples
+
+### Example 1: Text Processing Chain
+
+**Input:**
+```
+Long technical document with 5000 words about machine learning algorithms...
+```
+
+**Processing:**
+```python
+# Step 1: Clean the text
+cleaned = text_extractor(text, operation="clean")
+
+# Step 2: Extract keywords
+keywords = text_extractor(text, operation="keywords")
+
+# Step 3: Create summary
+summary = text_extractor(text, operation="summarize", max_length=300)
+```
+
+**Output:**
+- Clean text: Formatted, ready for analysis
+- Keywords: "machine learning, neural networks, algorithms, training, optimization"
+- Summary: 300-word executive summary
+
+---
+
+### Example 2: Business Intelligence Dashboard
+
+**Input Data:**
+```json
+{
+  "revenue": 5000000,
+  "costs": 3000000,
+  "customers": 2500,
+  "current_revenue": 5000000,
+  "previous_revenue": 4200000,
+  "employees": 50
+}
+```
+
+**Processing:**
+```python
+# Generate KPIs
+kpis = kpi_generator(data, metrics=["revenue", "growth", "efficiency"])
+
+# Visualize monthly trends
+chart = data_visualizer(monthly_data, chart_type="line", title="Revenue Trends")
+```
+
+**Output:**
+- Profit margin: 40%
+- Revenue growth: 19%
+- Revenue per employee: $100,000
+- Interactive chart showing trends
+
+---
+
+### Example 3: Email Routing System
+
+**Sample Emails:**
+
+1. **"I need help with my order #12345 that hasn't arrived"**
+   - Intent: `complaint` + `order` (Confidence: 0.8)
+   - Action: Route to support + Priority flag
+
+2. **"Can we schedule a meeting to discuss the proposal?"**
+   - Intent: `meeting` (Confidence: 0.9)
+   - Action: Route to calendar system
+
+3. **"URGENT: Server down, customers can't access site"**
+   - Intent: `urgent` + `complaint` (Confidence: 1.0)
+   - Action: Immediate escalation to DevOps
+
+---
+
+### Example 4: Research Assistant Workflow
+
+**Task:** Research "AI safety frameworks"
+
+**Automated Process:**
+```python
+# 1. Fetch relevant articles
+urls = ["https://ai-safety-org.com/frameworks", 
+        "https://research-institute.edu/ai-ethics"]
+articles = [web_fetcher(url) for url in urls]
+
+# 2. Extract content
+summaries = [text_extractor(article, operation="summarize") 
+             for article in articles]
+
+# 3. Semantic search across all content
+insights = rag_search("governance frameworks", summaries, top_k=5)
+
+# 4. Generate final report
+report = text_extractor(combined_insights, operation="summarize")
+```
+
+**Result:** Comprehensive research report in minutes
+
+---
+
+### Example 5: Document Processing Pipeline
+
+**Scenario:** Process 100 contract PDFs
+
+**Automated Workflow:**
+```python
+for contract in contracts:
+    # Extract text from PDF
+    text = pdf_reader(contract)
+    
+    # Extract key terms
+    keywords = text_extractor(text, operation="keywords")
+    
+    # Search for specific clauses
+    results = rag_search("termination clause", [text], top_k=1)
+    
+    # Store in database
+    save_to_database(contract_id, text, keywords, results)
+```
+
+**Business Impact:**
+- Manual processing: 5 minutes/contract = 8.3 hours
+- Automated: 10 seconds/contract = 17 minutes
+- Time saved: 90%
+
+---
+
+## 📊 ROI Examples
+
+### Small Business (10 employees)
+**Monthly Automation Savings:**
+- Email classification: 20 hours → $600
+- Report generation: 15 hours → $450
+- Data analysis: 10 hours → $300
+- **Total: 45 hours/$1,350 per month**
+
+### Enterprise (500 employees)
+**Annual Automation Value:**
+- Customer support efficiency: $500K
+- Knowledge management: $300K
+- Business intelligence: $400K
+- **Total: $1.2M annually**
+
+---
+
+## 🎓 Learning Path
+
+### Beginner: Start Simple
+1. Try **text_extractor** with a sample document
+2. Use **email_intent_classifier** on sample emails
+3. Create a basic chart with **data_visualizer**
+
+### Intermediate: Build Workflows
+1. Combine **web_fetcher** + **text_extractor**
+2. Set up **rag_search** with your documents
+3. Create a KPI dashboard with **kpi_generator**
+
+### Advanced: Full Automation
+1. Build complete document processing pipelines
+2. Implement intelligent email routing systems
+3. Create real-time business intelligence dashboards
+
+---
+
+## 🔗 Integration Examples
+
+### With Claude Desktop
+```json
+{
+  "mcpServers": {
+    "mission-control": {
+      "command": "python",
+      "args": ["path/to/mcp_server.py"]
+    }
+  }
+}
+```
+
+**Usage in Claude:**
+- "Extract text from this PDF and summarize it"
+- "Fetch this website and find information about pricing"
+- "Calculate KPIs from this business data"
+
+---
+
+## 🚀 Quick Start Templates
+
+### Template 1: Document Summarizer
+```python
+from tools.pdf_reader import read_pdf
+from tools.text_extractor import extract_text
+
+# Read PDF
+content = read_pdf("document.pdf")
+
+# Generate summary
+summary = extract_text(content["text"], 
+                      operation="summarize", 
+                      max_length=500)
+
+print(summary["result"])
+```
+
+### Template 2: Web Research Assistant
+```python
+from tools.web_fetcher import fetch_web_content
+from tools.rag_search import search_documents
+
+# Fetch multiple sources
+urls = ["url1", "url2", "url3"]
+docs = [fetch_web_content(url)["content"] for url in urls]
+
+# Search for specific information
+results = search_documents("your query", docs, top_k=3)
+```
+
+### Template 3: Business Dashboard
+```python
+from tools.kpi_generator import generate_kpis
+from tools.data_visualizer import visualize_data
+
+# Calculate KPIs
+kpis = generate_kpis(business_data, 
+                     metrics=["revenue", "growth"])
+
+# Visualize trends
+chart = visualize_data(trend_data, 
+                      chart_type="line",
+                      title="Q4 Performance")
+```
+
+---
+
+## 💡 Tips for Success
+
+1. **Chain Tools Together** - Combine multiple tools for powerful workflows
+2. **Use RAG Search** - Best for finding information across documents
+3. **Automate Repetitive Tasks** - Perfect for daily/weekly operations
+4. **Start Small** - Test individual tools before building complex systems
+5. **Monitor Performance** - Track time/cost savings from automation
+
+---
+
+**Ready to automate your enterprise workflows? Start with these examples!** 🚀

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AlBaraa-1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,545 @@
 ---
-title: MissionControlMCP
-emoji: 🐢
-colorFrom: green
-colorTo: red
+title: MissionControlMCP - Enterprise Automation Tools
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: "5.48.0"
 app_file: app.py
 pinned: false
+tags:
+- building-mcp-track-enterprise
+- mcp-in-action-track-enterprise
+- mcp
+- anthropic
+- enterprise-automation
+- gradio-hackathon
+- ai-agents
+- mcp-server
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚀 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** (Tracks: Building MCP + MCP in Action - Enterprise).
+
+🏆 **Hackathon Submission** | 🔧 **Both Tracks** | 🏢 **Enterprise Category**
+
+---
+
+## 📱 Social Media & Links
+
+- 🔗 **LinkedIn Post:** [View Announcement](https://www.linkedin.com/posts/albaraa-alolabi_mcphackathon-gradiohackathon-huggingface-activity-7395722042223886336-kp7K?utm_source=share&utm_medium=member_desktop)
+- 🚀 **Live Demo:** [Try on Hugging Face](https://huggingface.co/spaces/AlBaraa63/8_tools)
+- 💻 **GitHub Repository:** [Source Code](https://github.com/AlBaraa-1/CleanEye-Hackathon)
+
+---
+
+## 📋 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 demo.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 demo:
+
+```bash
+python demo.py
+```
+
+The demo 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
+├── app.py                     # Gradio web interface
+├── demo.py                    # Demo & test suite
+├── requirements.txt           # Dependencies
+├── 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
+- **[TESTING.md](TESTING.md)** - Complete testing guide with examples
+- **[ARCHITECTURE.md](ARCHITECTURE.md)** - System design and architecture details
+- **[API.md](API.md)** - Complete API documentation
+- **[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! 🚀**

TESTING.md

@@ -0,0 +1,267 @@
+# 🧪 Testing Guide
+
+## Quick Start: Test with Sample Files
+
+We've created sample files in the `examples/` directory to demonstrate all MissionControlMCP tools.
+
+### Run All Tests
+
+```bash
+python demo.py
+```
+
+This will test:
+- ✅ **Text Extraction** - Keywords & summarization from business report
+- ✅ **Email Classification** - Intent detection on 3 sample emails  
+- ✅ **Data Visualization** - Line and bar charts from CSV data
+- ✅ **KPI Generation** - Calculate business metrics
+- ✅ **RAG Semantic Search** - Semantic search across documents
+
+---
+
+## Test Individual Tools
+
+### 1. Text Extractor
+```python
+from tools.text_extractor import extract_text
+
+# Read sample report
+with open("examples/sample_report.txt", "r") as f:
+    text = f.read()
+
+# Extract keywords
+keywords = extract_text(text, operation="keywords")
+print(keywords)
+
+# Generate summary
+summary = extract_text(text, operation="summarize", max_length=200)
+print(summary['result'])
+```
+
+### 2. Email Intent Classifier
+```python
+from tools.email_intent_classifier import classify_email_intent
+
+# Test complaint email
+with open("examples/sample_email_complaint.txt", "r") as f:
+    email = f.read()
+
+result = classify_email_intent(email)
+print(f"Intent: {result['intent']} (confidence: {result['confidence']})")
+```
+
+### 3. Data Visualizer
+```python
+from tools.data_visualizer import visualize_data
+
+# Load CSV data
+with open("examples/business_data.csv", "r") as f:
+    data = f.read()
+
+# Create revenue trend chart
+chart = visualize_data(
+    data=data,
+    chart_type="line",
+    x_column="month",
+    y_column="revenue",
+    title="Revenue Trends"
+)
+
+# Save chart
+import base64
+with open("revenue_chart.png", "wb") as f:
+    f.write(base64.b64decode(chart['image_base64']))
+```
+
+### 4. KPI Generator
+```python
+from tools.kpi_generator import generate_kpis
+import json
+
+data = {
+    "revenue": 5500000,
+    "costs": 3400000,
+    "customers": 2700,
+    "current_revenue": 5500000,
+    "previous_revenue": 5400000,
+    "employees": 50
+}
+
+result = generate_kpis(json.dumps(data), metrics=["revenue", "growth", "efficiency"])
+print(f"Generated {len(result['kpis'])} KPIs")
+print(result['summary'])
+```
+
+### 5. RAG Semantic Search
+```python
+from tools.rag_search import search_documents
+
+# Load sample documents
+with open("examples/sample_documents.txt", "r") as f:
+    content = f.read()
+
+documents = [doc.strip() for doc in content.split("##") if doc.strip()]
+
+# Search
+results = search_documents("What is machine learning?", documents, top_k=3)
+for res in results['results']:
+    print(f"Score: {res['score']:.4f} - {res['document'][:100]}...")
+```
+
+---
+
+## Test with Claude Desktop
+
+### 1. Configure Claude Desktop
+
+Edit `%AppData%\Claude\claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "mission-control": {
+      "command": "python",
+      "args": ["C:/path/to/mission_control_mcp/mcp_server.py"]
+    }
+  }
+}
+```
+
+### 2. Restart Claude Desktop
+
+### 3. Try These Prompts
+
+**Text Processing:**
+```
+Extract keywords from this text: [paste sample_report.txt content]
+```
+
+**Email Classification:**
+```
+Classify this email: [paste sample_email_complaint.txt content]
+```
+
+**Data Visualization:**
+```
+Create a line chart showing revenue trends from this data: [paste business_data.csv]
+```
+
+**KPI Generation:**
+```
+Calculate KPIs from this business data: {"revenue": 5000000, "costs": 3000000, "customers": 2500}
+```
+
+**Semantic Search:**
+```
+Search these documents for information about AI: [paste sample_documents.txt]
+```
+
+---
+
+## Test MCP Server Directly
+
+### Run the MCP Server
+
+```bash
+python mcp_server.py
+```
+
+### Test Individual Tools
+
+```bash
+python test_individual.py
+```
+
+This runs isolated tests on each tool (8 total).
+
+### MCP Server Tests
+
+```bash
+python demo.py
+```
+
+Tests all MCP tool handlers and server integration.
+
+---
+
+## Sample Files Overview
+
+| File | Purpose | Tool |
+|------|---------|------|
+| `sample_report.txt` | Business report (2,200 chars) | Text Extractor |
+| `business_data.csv` | 12 months financial data | Data Visualizer, KPI Generator |
+| `sample_email_complaint.txt` | Customer complaint | Email Classifier |
+| `sample_email_inquiry.txt` | Sales inquiry | Email Classifier |
+| `sample_email_urgent.txt` | Urgent system alert | Email Classifier |
+| `sample_documents.txt` | 5 topic documents | RAG Search |
+
+---
+
+## Expected Results
+
+### Text Extraction
+- **Keywords:** customer, revenue, growth, operational, market, performance
+- **Summary:** ~200 character executive summary
+
+### Email Classification
+- **Complaint:** request + order intents (confidence: 1.00)
+- **Inquiry:** meeting + inquiry intents (confidence: 1.00)
+- **Urgent:** urgent intent (confidence: 1.00)
+
+### Data Visualization
+- **Line Chart:** 48KB base64 PNG (1000x600px)
+- **Bar Chart:** 26KB base64 PNG (1000x600px)
+
+### KPI Generation
+- **9 KPIs calculated:** total_revenue, profit, profit_margin_percent, revenue_growth, etc.
+- **Summary:** Executive insights on revenue growth and profitability
+
+### RAG Search
+- **Query:** "What is machine learning?"
+- **Top Result:** Document 1 (AI Overview) - Score: 0.56
+- **Semantic matching:** Finds relevant content even with different wording
+
+---
+
+## Troubleshooting
+
+### FAISS Errors
+```bash
+pip install faiss-cpu sentence-transformers
+```
+
+### Import Errors
+```bash
+cd mission_control_mcp
+pip install -r requirements.txt
+```
+
+### Python Version
+Requires Python 3.11+. Check with:
+```bash
+python --version
+```
+
+---
+
+## Performance Benchmarks
+
+| Tool | Sample File | Execution Time |
+|------|-------------|----------------|
+| Text Extractor | 2,200 chars | ~0.5s |
+| Email Classifier | 500 chars | ~0.1s |
+| Data Visualizer | 12 data points | ~1.2s |
+| KPI Generator | 10 metrics | ~0.3s |
+| RAG Search | 6 documents | ~2.5s (first run, includes model load) |
+
+---
+
+## Next Steps
+
+1. ✅ Run `python demo.py` to verify all tools work
+2. ✅ Try individual tool tests with your own data
+3. ✅ Configure Claude Desktop integration
+4. ✅ Test with Claude using sample prompts
+5. ✅ Create custom workflows combining multiple tools
+
+**Happy Testing!** 🚀

app.py

@@ -0,0 +1,864 @@
+"""
+🚀 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 for beautiful UI
+custom_css = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+
+.gradio-container {
+    font-family: 'Inter', sans-serif !important;
+    max-width: 1400px !important;
+    margin: 0 auto !important;
+}
+
+/* Header styling */
+.gradio-container h1 {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    font-size: 3em !important;
+    font-weight: 700 !important;
+    text-align: center;
+    margin-bottom: 0.5em;
+}
+
+/* Tab styling */
+.tab-nav {
+    border-radius: 12px !important;
+    background: linear-gradient(to right, #f8f9fa, #e9ecef) !important;
+    padding: 8px !important;
+    margin-bottom: 20px !important;
+}
+
+button.selected {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    color: white !important;
+    border-radius: 8px !important;
+    font-weight: 600 !important;
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4) !important;
+}
+
+/* Button styling */
+.primary-btn {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    border: none !important;
+    color: white !important;
+    font-weight: 600 !important;
+    border-radius: 10px !important;
+    padding: 12px 24px !important;
+    font-size: 16px !important;
+    transition: all 0.3s ease !important;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4) !important;
+}
+
+.primary-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6) !important;
+}
+
+/* Input fields */
+textarea, input[type="text"] {
+    border-radius: 10px !important;
+    border: 2px solid #e9ecef !important;
+    padding: 12px !important;
+    font-size: 15px !important;
+    transition: border-color 0.3s ease !important;
+}
+
+textarea:focus, input[type="text"]:focus {
+    border-color: #667eea !important;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1) !important;
+}
+
+/* Output boxes */
+.output-class {
+    background: linear-gradient(to bottom, #ffffff, #f8f9fa) !important;
+    border-radius: 12px !important;
+    padding: 20px !important;
+    border: 2px solid #e9ecef !important;
+}
+
+/* Cards and containers */
+.gr-box {
+    border-radius: 12px !important;
+    border: 1px solid #e9ecef !important;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.05) !important;
+}
+
+/* Labels */
+label {
+    font-weight: 600 !important;
+    color: #495057 !important;
+    font-size: 14px !important;
+    margin-bottom: 8px !important;
+}
+
+/* Examples */
+.gr-samples-table {
+    border-radius: 10px !important;
+    overflow: hidden !important;
+}
+
+/* Footer */
+.footer {
+    text-align: center;
+    padding: 30px;
+    background: linear-gradient(to right, #f8f9fa, #e9ecef);
+    border-radius: 12px;
+    margin-top: 30px;
+}
+
+/* Image display */
+.gr-image {
+    border-radius: 12px !important;
+    border: 2px solid #e9ecef !important;
+    box-shadow: 0 4px 15px rgba(0,0,0,0.1) !important;
+}
+
+/* Radio buttons and checkboxes */
+.gr-radio, .gr-checkbox {
+    padding: 10px !important;
+    border-radius: 8px !important;
+}
+
+/* File upload */
+.gr-file {
+    border: 2px dashed #667eea !important;
+    border-radius: 12px !important;
+    background: linear-gradient(to bottom, #ffffff, #f8f9fa) !important;
+    padding: 30px !important;
+}
+
+.gr-file:hover {
+    border-color: #764ba2 !important;
+    background: #f8f9fa !important;
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP Demo") as demo:
+    
+    gr.Markdown("# 🚀 MissionControlMCP")
+    gr.Markdown("### Enterprise Automation Tools - Powered by AI")
+    
+    gr.HTML("""
+    <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; color: white; margin-bottom: 30px;">
+        <h3 style="color: white; margin: 0;">✨ Try all 8 powerful tools in your browser - No installation needed! ✨</h3>
+        <p style="margin: 10px 0 0 0; opacity: 0.9;">Built for HuggingFace Gradio Hackathon | Claude MCP Integration</p>
+    </div>
+    """)
+    
+    with gr.Tabs():
+        
+        # ====== TAB 1: PDF READER ======
+        with gr.Tab("📄 PDF Reader"):
+            gr.Markdown("""
+            ### 📄 Extract Text and Metadata from PDF Documents
+            Upload any PDF file to extract its content, metadata, and keywords instantly.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    pdf_input = gr.File(
+                        label="📎 Upload PDF File",
+                        file_types=[".pdf"],
+                        elem_classes=["file-upload"]
+                    )
+                    pdf_btn = gr.Button(
+                        "🔍 Extract Text from PDF",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["primary-btn"]
+                    )
+                    gr.Markdown("""
+                    **💡 Tips:**
+                    - Supports multi-page PDFs
+                    - Extracts metadata (author, title)
+                    - Automatically generates keywords
+                    """)
+                
+                with gr.Column(scale=2):
+                    pdf_output = gr.Textbox(
+                        label="📊 Extraction Results",
+                        lines=20,
+                        elem_classes=["output-class"]
+                    )
+                    pdf_img = gr.Image(label="Preview", visible=False)
+            
+            pdf_btn.click(tool_pdf_reader, inputs=[pdf_input], outputs=[pdf_output, pdf_img])
+            
+            gr.Markdown("*💡 Try uploading your resume, research paper, or any PDF document!*")
+        
+        # ====== TAB 2: TEXT EXTRACTOR ======
+        with gr.Tab("📝 Text Extractor"):
+            gr.Markdown("""
+            ### 📝 AI-Powered Text Analysis
+            Extract keywords, generate summaries, clean text, or split into chunks.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    text_input = gr.Textbox(
+                        label="✍️ Enter Your Text", 
+                        lines=10,
+                        placeholder="Paste any text here - articles, reports, emails, etc...",
+                        elem_classes=["input-field"]
+                    )
+                    text_operation = gr.Radio(
+                        ["keywords", "summarize", "clean", "chunk"],
+                        label="🛠️ Select Operation",
+                        value="keywords",
+                        info="Choose what to do with your text"
+                    )
+                    text_length = gr.Slider(
+                        100, 1000, 300,
+                        label="📏 Max Length (for summarize/chunk)",
+                        info="Adjust output length"
+                    )
+                    text_btn = gr.Button(
+                        "✨ Process Text",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["primary-btn"]
+                    )
+                
+                with gr.Column(scale=2):
+                    text_output = gr.Textbox(
+                        label="📊 Processing Results",
+                        lines=20,
+                        elem_classes=["output-class"]
+                    )
+            
+            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], label="📚 Try These Examples")
+        
+        # ====== TAB 3: WEB FETCHER ======
+        with gr.Tab("🌐 Web Fetcher"):
+            gr.Markdown("""
+            ### 🌐 Scrape and Analyze Web Content
+            Fetch content from any website, extract clean text, and analyze it.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    web_input = gr.Textbox(
+                        label="🔗 Website URL",
+                        placeholder="https://example.com",
+                        value="https://example.com",
+                        info="Enter any public website URL"
+                    )
+                    web_btn = gr.Button(
+                        "🌐 Fetch Website",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["primary-btn"]
+                    )
+                    gr.Markdown("""
+                    **💡 Tips:**
+                    - Works with most public websites
+                    - Extracts clean text (no HTML)
+                    - Finds all page links
+                    - Some sites block bots (e.g., LinkedIn)
+                    """)
+                
+                with gr.Column(scale=2):
+                    web_output = gr.Textbox(
+                        label="📊 Website Content",
+                        lines=20,
+                        elem_classes=["output-class"]
+                    )
+            
+            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], label="📚 Try These Examples")
+        
+        # ====== TAB 4: RAG SEARCH ======
+        with gr.Tab("🔍 RAG Search"):
+            gr.Markdown("""
+            ### 🔍 Semantic Document Search with AI
+            Search through documents using AI-powered semantic understanding (RAG - Retrieval Augmented Generation).
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    rag_input = gr.Textbox(
+                        label="🔎 Search Query",
+                        placeholder="What are you looking for?",
+                        value="What is machine learning?",
+                        lines=3,
+                        info="Ask questions in natural language"
+                    )
+                    rag_btn = gr.Button(
+                        "🔍 Search Documents",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["primary-btn"]
+                    )
+                    gr.Markdown("""
+                    **💡 How it works:**
+                    - Uses AI embeddings (FAISS)
+                    - Understands meaning, not just keywords
+                    - Searches 5 sample documents
+                    - Returns relevance scores
+                    """)
+                
+                with gr.Column(scale=2):
+                    rag_output = gr.Textbox(
+                        label="📊 Search Results",
+                        lines=20,
+                        elem_classes=["output-class"]
+                    )
+            
+            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], label="📚 Try These Searches")
+        
+        # ====== TAB 5: DATA VISUALIZER ======
+        with gr.Tab("📊 Data Visualizer"):
+            gr.Markdown("""
+            ### 📊 Create Beautiful Charts from Your Data
+            Transform CSV data into stunning visualizations - line charts, bar charts, pie charts, and scatter plots.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    viz_csv = gr.Textbox(
+                        label="📋 CSV Data",
+                        lines=10,
+                        value=load_sample_csv(),
+                        placeholder="month,revenue,costs\nJan,100000,60000",
+                        info="Paste your CSV data here"
+                    )
+                    viz_chart = gr.Radio(
+                        ["line", "bar", "pie", "scatter"],
+                        label="📈 Chart Type",
+                        value="line",
+                        info="Select visualization style"
+                    )
+                    viz_x = gr.Textbox(label="📍 X-Axis Column", value="month")
+                    viz_y = gr.Textbox(label="📍 Y-Axis Column", value="revenue")
+                    viz_title = gr.Textbox(label="📝 Chart Title", value="Monthly Revenue")
+                    viz_btn = gr.Button(
+                        "📊 Create Chart",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["primary-btn"]
+                    )
+                
+                with gr.Column(scale=2):
+                    viz_output = gr.Textbox(
+                        label="📊 Chart Status",
+                        lines=5,
+                        elem_classes=["output-class"]
+                    )
+                    viz_img = gr.Image(label="📈 Generated Chart", elem_classes=["chart-output"])
+            
+            viz_btn.click(
+                tool_data_visualizer,
+                inputs=[viz_csv, viz_chart, viz_x, viz_y, viz_title],
+                outputs=[viz_output, viz_img]
+            )
+            
+            gr.Markdown("*💡 Sample data is already loaded! Just click 'Create Chart' to see it in action.*")
+        
+        # ====== TAB 6: EMAIL CLASSIFIER ======
+        with gr.Tab("📧 Email Classifier"):
+            gr.Markdown("""
+            ### 📧 AI-Powered Email Intent Detection
+            Automatically classify email intent and detect sentiment - complaint, inquiry, urgent, etc.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    email_input = gr.Textbox(
+                        label="✉️ Email Content",
+                        lines=12,
+                        value=load_sample_email(),
+                        placeholder="Paste email content here...",
+                        info="Paste any email text for analysis"
+                    )
+                    email_btn = gr.Button(
+                        "🎯 Classify Email",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["primary-btn"]
+                    )
+                    gr.Markdown("""
+                    **💡 Detects 10 intents:**
+                    - Complaint
+                    - Inquiry
+                    - Request
+                    - Feedback
+                    - Order
+                    - Meeting
+                    - Urgent
+                    - Application
+                    - Sales
+                    - Other
+                    """)
+                
+                with gr.Column(scale=2):
+                    email_output = gr.Textbox(
+                        label="📊 Classification Results",
+                        lines=20,
+                        elem_classes=["output-class"]
+                    )
+            
+            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], label="📚 Try These Examples")
+        
+        # ====== TAB 7: KPI GENERATOR ======
+        with gr.Tab("📈 KPI Generator"):
+            gr.Markdown("""
+            ### 📈 Business KPI & Analytics Dashboard
+            Generate comprehensive business metrics and KPIs from your data automatically.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    kpi_json = gr.Textbox(
+                        label="📊 Business Data (JSON Format)",
+                        lines=14,
+                        value=load_sample_json(),
+                        placeholder='{"revenue": 1000000, "costs": 600000}',
+                        info="Enter your business metrics in JSON"
+                    )
+                    kpi_metrics = gr.CheckboxGroup(
+                        ["revenue", "growth", "efficiency", "customer", "operational"],
+                        label="📋 Metrics to Calculate",
+                        value=["revenue", "growth", "efficiency"],
+                        info="Select which KPI categories to generate"
+                    )
+                    kpi_btn = gr.Button(
+                        "📈 Generate KPIs",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["primary-btn"]
+                    )
+                    gr.Markdown("""
+                    **💡 Generates:**
+                    - Revenue metrics
+                    - Growth rates
+                    - Efficiency ratios
+                    - Customer metrics
+                    - Operational KPIs
+                    - Executive summary
+                    """)
+                
+                with gr.Column(scale=2):
+                    kpi_output = gr.Textbox(
+                        label="📊 KPI Report",
+                        lines=25,
+                        elem_classes=["output-class"]
+                    )
+            
+            kpi_btn.click(
+                tool_kpi_generator,
+                inputs=[kpi_json, kpi_metrics],
+                outputs=[kpi_output]
+            )
+            
+            gr.Markdown("*💡 Sample business data is already loaded! Just click 'Generate KPIs' to see results.*")
+    
+    # Footer
+    gr.HTML("""
+    <div class="footer">
+        <h2 style="margin-bottom: 20px;">🎯 About MissionControlMCP</h2>
+        
+        <p style="font-size: 18px; margin-bottom: 20px;">
+            <strong>8 enterprise-grade automation tools</strong> integrated with Claude Desktop via Model Context Protocol (MCP)
+        </p>
+        
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 30px 0;">
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>📄 PDF Reader</strong><br/>
+                <small>Extract text from documents</small>
+            </div>
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>📝 Text Extractor</strong><br/>
+                <small>Keywords & summaries</small>
+            </div>
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>🌐 Web Fetcher</strong><br/>
+                <small>Scrape websites</small>
+            </div>
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>🔍 RAG Search</strong><br/>
+                <small>Semantic search</small>
+            </div>
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>📊 Data Visualizer</strong><br/>
+                <small>Create charts</small>
+            </div>
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>🔄 File Converter</strong><br/>
+                <small>Format conversions</small>
+            </div>
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>📧 Email Classifier</strong><br/>
+                <small>Intent detection</small>
+            </div>
+            <div style="padding: 15px; background: white; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+                <strong>📈 KPI Generator</strong><br/>
+                <small>Business analytics</small>
+            </div>
+        </div>
+        
+        <div style="margin-top: 30px; padding-top: 20px; border-top: 2px solid #e9ecef;">
+            <p style="font-size: 16px; margin: 10px 0;">
+                🔗 <a href="https://github.com/AlBaraa-1/CleanEye-Hackathon" target="_blank" style="color: #667eea; text-decoration: none; font-weight: 600;">View on GitHub</a>
+            </p>
+            <p style="margin: 10px 0; color: #6c757d;">
+                🏆 Built for HuggingFace Gradio x BuildWithMCP Hackathon
+            </p>
+            <p style="margin: 10px 0; color: #6c757d;">
+                Made with ❤️ using Python, Gradio, Claude MCP, FAISS, and Sentence Transformers
+            </p>
+        </div>
+    </div>
+    """)
+
+
+# ============================================================================
+# 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
+    )

demo.py

@@ -0,0 +1,907 @@
+"""
+🚀 MissionControlMCP - Interactive Demo
+Try all 8 tools with real examples!
+
+Run: python demo.py
+"""
+
+import sys
+import os
+import json
+import base64
+from pathlib import Path
+
+# Setup paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(SCRIPT_DIR)
+EXAMPLES_DIR = os.path.join(SCRIPT_DIR, "examples")
+OUTPUT_DIR = os.path.join(SCRIPT_DIR, "demo_output")
+
+# Create output directory
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# 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
+
+
+def print_header(title):
+    """Print a nice header"""
+    print("\n" + "="*80)
+    print(f"  {title}")
+    print("="*80)
+
+
+def print_section(title):
+    """Print a section header"""
+    print(f"\n{'─'*80}")
+    print(f"📌 {title}")
+    print(f"{'─'*80}")
+
+
+def pause(message="Press Enter to continue..."):
+    """Pause and wait for user input"""
+    input(f"\n{message}")
+
+
+def save_chart(image_base64, filename):
+    """Save base64 chart to file"""
+    filepath = os.path.join(OUTPUT_DIR, filename)
+    with open(filepath, "wb") as f:
+        f.write(base64.b64decode(image_base64))
+    print(f"💾 Chart saved: {filepath}")
+    return filepath
+
+
+# ============================================================================
+# TOOL 1: PDF READER
+# ============================================================================
+
+def demo_pdf_reader():
+    """Demo: PDF Reader - Extract text from PDFs"""
+    print_header("TOOL 1: PDF READER 📄")
+    
+    print("\n📖 What it does:")
+    print("  • Extracts all text from PDF files")
+    print("  • Gets metadata (author, title, pages)")
+    print("  • Perfect for reading reports, contracts, invoices")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Extract data from invoices")
+    print("  • Read research papers")
+    print("  • Process legal contracts")
+    print("  • Analyze business reports")
+    
+    pause("\nReady to see it in action? Press Enter...")
+    
+    # Check if user has their own PDF
+    print("\n" + "─"*80)
+    custom_pdf = input("Enter PDF file path (or press Enter to skip): ").strip()
+    
+    if custom_pdf and os.path.exists(custom_pdf):
+        print(f"\n📄 Reading your PDF: {custom_pdf}")
+        try:
+            result = read_pdf(custom_pdf)
+            print(f"\n✅ Successfully extracted:")
+            print(f"  • Pages: {result['pages']}")
+            print(f"  • Characters: {len(result['text']):,}")
+            print(f"  • Author: {result['metadata'].get('author', 'N/A')}")
+            print(f"\n📝 First 300 characters:")
+            print(result['text'][:300] + "...")
+            
+            # Extract keywords from PDF
+            print("\n🔑 Extracting keywords from PDF...")
+            keywords = extract_text(result['text'], operation="keywords")
+            print(f"Keywords: {keywords['result']}")
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+    else:
+        print("\n📝 Example: How it works")
+        print("```python")
+        print("result = read_pdf('document.pdf')")
+        print("print(f'Pages: {result[\"pages\"]}')")
+        print("print(result['text'][:500])  # First 500 chars")
+        print("```")
+        print("\n💬 Output:")
+        print("  Pages: 16")
+        print("  Text: College Of Engineering - System Analysis Project...")
+    
+    pause()
+
+
+# ============================================================================
+# TOOL 2: TEXT EXTRACTOR
+# ============================================================================
+
+def demo_text_extractor():
+    """Demo: Text Extractor - Process and analyze text"""
+    print_header("TOOL 2: TEXT EXTRACTOR 📝")
+    
+    print("\n📖 What it does:")
+    print("  • Extract keywords from any text")
+    print("  • Generate summaries (any length)")
+    print("  • Clean messy text")
+    print("  • Split text into chunks")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Summarize long documents")
+    print("  • Find main topics in articles")
+    print("  • Clean data before analysis")
+    print("  • Prepare text for processing")
+    
+    pause("\nReady to try it? Press Enter...")
+    
+    # Load sample report
+    print_section("Using sample business report")
+    sample_file = os.path.join(EXAMPLES_DIR, "sample_report.txt")
+    
+    try:
+        with open(sample_file, "r", encoding="utf-8") as f:
+            text = f.read()
+        
+        print(f"📄 Loaded text: {len(text)} characters")
+        print(f"\nPreview: {text[:200]}...")
+        
+        pause("\nPress Enter to extract keywords...")
+        
+        # Operation 1: Keywords
+        print_section("Operation 1: Extract Keywords")
+        keywords = extract_text(text, operation="keywords")
+        print(f"🔑 Keywords: {keywords['result']}")
+        
+        pause("\nPress Enter to generate summary...")
+        
+        # Operation 2: Summarize
+        print_section("Operation 2: Generate Summary")
+        summary = extract_text(text, operation="summarize", max_length=300)
+        print(f"📝 Summary ({len(summary['result'])} chars):")
+        print(summary['result'])
+        
+        pause("\nPress Enter to clean text...")
+        
+        # Operation 3: Clean
+        print_section("Operation 3: Clean Text")
+        messy_text = "  This   has   extra    spaces\n\n\nand  newlines  "
+        cleaned = extract_text(messy_text, operation="clean")
+        print(f"Before: '{messy_text}'")
+        print(f"After:  '{cleaned['result']}'")
+        
+        # Operation 4: Chunk
+        print_section("Operation 4: Split into Chunks")
+        chunks = extract_text(text[:500], operation="chunk", max_length=100)
+        chunk_list = chunks['result'].split("\n\n---CHUNK---\n\n")
+        print(f"✂️ Split into {len(chunk_list)} chunks (100 chars each)")
+        print(f"Chunk 1: {chunk_list[0][:80]}...")
+        
+        # Try custom text
+        print("\n" + "─"*80)
+        custom_text = input("\n✏️ Want to try your own text? Enter it (or press Enter to skip): ").strip()
+        if custom_text:
+            print("\n🔑 Keywords from your text:")
+            result = extract_text(custom_text, operation="keywords")
+            print(result['result'])
+            
+            print("\n📝 Summary of your text:")
+            result = extract_text(custom_text, operation="summarize", max_length=300)
+            if result['result']:
+                print(result['result'])
+            else:
+                # If summary is empty, show first 300 chars as fallback
+                print(custom_text[:300] + ("..." if len(custom_text) > 300 else ""))
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+    
+    pause()
+
+
+# ============================================================================
+# TOOL 3: WEB FETCHER
+# ============================================================================
+
+def demo_web_fetcher():
+    """Demo: Web Fetcher - Scrape web content"""
+    print_header("TOOL 3: WEB FETCHER 🌐")
+    
+    print("\n📖 What it does:")
+    print("  • Fetches content from any website")
+    print("  • Extracts clean text (no HTML tags)")
+    print("  • Finds all links on the page")
+    print("  • Gets page title and metadata")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Monitor competitor websites")
+    print("  • Collect research data")
+    print("  • Track price changes")
+    print("  • Gather news articles")
+    
+    pause("\nReady to fetch a website? Press Enter...")
+    
+    # Allow retry loop
+    while True:
+        # Get URL from user
+        print("\n" + "─"*80)
+        url = input("Enter URL to fetch (or press Enter for example.com): ").strip()
+        if not url:
+            url = "https://example.com"
+        
+        print(f"\n🌐 Fetching: {url}")
+        print("⏳ Please wait...")
+        
+        success = False
+        try:
+            result = fetch_web_content(url)
+            
+            print(f"\n✅ Success!")
+            print(f"  • Status: {result['status_code']}")
+            print(f"  • Title: {result.get('title', 'N/A')}")
+            print(f"  • Content length: {len(result['content']):,} characters")
+            print(f"  • Links found: {len(result.get('links', []))}")
+            
+            # Check if content is available
+            if result['status_code'] == 999:
+                print(f"\n⚠️  Status 999 detected - Website is blocking automated requests")
+                print("   This is common for LinkedIn, Facebook, and other sites with bot protection")
+                print("   Try a different website!")
+            elif not result['content'].strip():
+                print(f"\n⚠️  No content extracted - the page might be dynamic (JavaScript-based)")
+            else:
+                success = True
+                print(f"\n📄 Content preview (first 500 chars):")
+                print(result['content'][:500] + "...")
+                
+                if result.get('links'):
+                    print(f"\n🔗 First 5 links:")
+                    for link in result['links'][:5]:
+                        print(f"  • {link[:80]}")  # Truncate long URLs
+                
+                # Extract keywords from webpage
+                if len(result['content']) > 50:
+                    pause("\nPress Enter to extract keywords from this page...")
+                    keywords = extract_text(result['content'], operation="keywords")
+                    print(f"\n🔑 Keywords from webpage:")
+                    print(f"  {keywords['result']}")
+            
+        except Exception as e:
+            print(f"❌ Error fetching URL: {e}")
+            print("Tip: Make sure the URL is valid and accessible!")
+        
+        # Ask if user wants to try another URL
+        print("\n" + "─"*80)
+        retry = input("Try another URL? (y/n): ").strip().lower()
+        if retry != 'y':
+            break
+    
+    pause()
+
+
+# ============================================================================
+# TOOL 4: RAG SEARCH
+# ============================================================================
+
+def demo_rag_search():
+    """Demo: RAG Search - Semantic document search"""
+    print_header("TOOL 4: RAG SEARCH 🔍")
+    
+    print("\n📖 What it does:")
+    print("  • Semantic search (understands meaning, not just keywords)")
+    print("  • Finds relevant documents even with different words")
+    print("  • Uses AI embeddings (sentence transformers)")
+    print("  • Powered by FAISS vector database")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Search company knowledge base")
+    print("  • Find similar documents")
+    print("  • Answer questions from docs")
+    print("  • Build smart FAQ systems")
+    
+    pause("\nReady to see semantic search in action? Press Enter...")
+    
+    # Load sample documents
+    print_section("Loading sample documents")
+    docs_file = os.path.join(EXAMPLES_DIR, "sample_documents.txt")
+    
+    try:
+        with open(docs_file, "r", encoding="utf-8") as f:
+            content = f.read()
+        
+        documents = [doc.strip() for doc in content.split("##") if doc.strip()]
+        print(f"📚 Loaded {len(documents)} documents about:")
+        topics = ["AI & Machine Learning", "Climate Change", "Web Development", 
+                  "Digital Marketing", "Financial Technology"]
+        for i, topic in enumerate(topics, 1):
+            print(f"  {i}. {topic}")
+        
+        pause("\nPress Enter to search...")
+        
+        # Example searches
+        queries = [
+            ("What is machine learning?", "Testing: Does it find AI doc?"),
+            ("How to reduce carbon emissions?", "Testing: Does it find climate doc?"),
+            ("What are modern web frameworks?", "Testing: Does it find web dev doc?"),
+        ]
+        
+        for query, description in queries:
+            print_section(description)
+            print(f"🔍 Query: '{query}'")
+            print("⏳ Searching...")
+            
+            result = search_documents(query, documents, top_k=2)
+            
+            print(f"\n✅ Found {len(result['results'])} relevant results:")
+            for i, res in enumerate(result['results'], 1):
+                preview = res['document'][:120].replace('\n', ' ')
+                print(f"\n  {i}. Relevance Score: {res['score']:.4f}")
+                print(f"     {preview}...")
+            
+            pause()
+        
+        # Custom search
+        print("\n" + "─"*80)
+        custom_query = input("\n✏️ Try your own search query (or press Enter to skip): ").strip()
+        if custom_query:
+            print(f"\n🔍 Searching for: '{custom_query}'")
+            result = search_documents(custom_query, documents, top_k=3)
+            print(f"\n📊 Top {len(result['results'])} results:")
+            for i, res in enumerate(result['results'], 1):
+                preview = res['document'][:100].replace('\n', ' ')
+                print(f"\n  {i}. Score: {res['score']:.4f}")
+                print(f"     {preview}...")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    pause()
+
+
+# ============================================================================
+# TOOL 5: DATA VISUALIZER
+# ============================================================================
+
+def demo_data_visualizer():
+    """Demo: Data Visualizer - Create charts"""
+    print_header("TOOL 5: DATA VISUALIZER 📊")
+    
+    print("\n📖 What it does:")
+    print("  • Creates beautiful charts from data")
+    print("  • Supports: Bar, Line, Pie, Scatter plots")
+    print("  • Accepts CSV or JSON data")
+    print("  • Exports as PNG images")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Visualize sales trends")
+    print("  • Create financial reports")
+    print("  • Compare performance metrics")
+    print("  • Present data insights")
+    
+    pause("\nReady to create charts? Press Enter...")
+    
+    # Load sample data
+    print_section("Loading business data")
+    csv_file = os.path.join(EXAMPLES_DIR, "business_data.csv")
+    
+    try:
+        with open(csv_file, "r") as f:
+            csv_data = f.read()
+        
+        print("📁 Sample data (12 months):")
+        print(csv_data[:200] + "...")
+        
+        pause("\nPress Enter to create LINE CHART (Revenue Trends)...")
+        
+        # Chart 1: Line chart
+        print_section("Creating Chart 1: Revenue Line Chart")
+        result1 = visualize_data(
+            data=csv_data,
+            chart_type="line",
+            x_column="month",
+            y_column="revenue",
+            title="Monthly Revenue Trends 2024"
+        )
+        filepath1 = save_chart(result1['image_base64'], "revenue_trends.png")
+        print(f"✅ Line chart created!")
+        print(f"   Size: {len(result1['image_base64']):,} bytes (base64)")
+        print(f"   Dimensions: {result1['dimensions']}")
+        
+        pause("\nPress Enter to create BAR CHART (Monthly Costs)...")
+        
+        # Chart 2: Bar chart
+        print_section("Creating Chart 2: Costs Bar Chart")
+        result2 = visualize_data(
+            data=csv_data,
+            chart_type="bar",
+            x_column="month",
+            y_column="costs",
+            title="Monthly Costs 2024"
+        )
+        filepath2 = save_chart(result2['image_base64'], "monthly_costs.png")
+        print(f"✅ Bar chart created!")
+        
+        pause("\nPress Enter to create PIE CHART (Customer Distribution)...")
+        
+        # Chart 3: Pie chart
+        print_section("Creating Chart 3: Customers Pie Chart")
+        # Create sample pie data
+        pie_data = """category,value
+Q1,650
+Q2,600
+Q3,550
+Q4,500"""
+        result3 = visualize_data(
+            data=pie_data,
+            chart_type="pie",
+            x_column="category",
+            y_column="value",
+            title="Customers by Quarter"
+        )
+        filepath3 = save_chart(result3['image_base64'], "customer_pie.png")
+        print(f"✅ Pie chart created!")
+        
+        print(f"\n📊 All charts saved in: {OUTPUT_DIR}")
+        print(f"  • {os.path.basename(filepath1)}")
+        print(f"  • {os.path.basename(filepath2)}")
+        print(f"  • {os.path.basename(filepath3)}")
+        
+        print("\n💡 You can open these PNG files to view the charts!")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    pause()
+
+
+# ============================================================================
+# TOOL 6: FILE CONVERTER
+# ============================================================================
+
+def demo_file_converter():
+    """Demo: File Converter - Convert between formats"""
+    print_header("TOOL 6: FILE CONVERTER 🔄")
+    
+    print("\n📖 What it does:")
+    print("  • Convert PDF ↔ TXT")
+    print("  • Convert TXT ↔ CSV")
+    print("  • Batch file processing")
+    print("  • Preserves data integrity")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Extract text from PDFs")
+    print("  • Convert reports to CSV for analysis")
+    print("  • Prepare data for databases")
+    print("  • Archive documents in different formats")
+    
+    print("\n🔧 Available conversions:")
+    print("  • pdf_to_txt - Extract text from PDF")
+    print("  • txt_to_pdf - Create PDF from text")
+    print("  • csv_to_txt - Convert CSV to plain text")
+    print("  • txt_to_csv - Structure text as CSV")
+    
+    pause("\nReady to see file conversions? Press Enter...")
+    
+    try:
+        # Demo 1: CSV to TXT
+        print_section("Demo 1: CSV → TXT Conversion")
+        csv_file = os.path.join(EXAMPLES_DIR, "business_data.csv")
+        txt_output = os.path.join(OUTPUT_DIR, "business_data.txt")
+        
+        print(f"📂 Converting: business_data.csv → business_data.txt")
+        print("⏳ Processing...")
+        
+        result1 = convert_file(
+            input_path=csv_file,
+            output_path=txt_output,
+            conversion_type="csv_to_txt"
+        )
+        
+        if result1['success']:
+            print(f"✅ Conversion successful!")
+            print(f"   Output: {result1['output_file']}")
+            
+            # Show preview
+            with open(txt_output, 'r', encoding='utf-8') as f:
+                preview = f.read()[:300]
+            print(f"\n📄 Preview of converted file:")
+            print(preview + "...")
+        
+        pause("\nPress Enter for next conversion...")
+        
+        # Demo 2: TXT to CSV
+        print_section("Demo 2: TXT → CSV Conversion")
+        txt_input = os.path.join(EXAMPLES_DIR, "sample_report.txt")
+        csv_output = os.path.join(OUTPUT_DIR, "sample_report.csv")
+        
+        print(f"📂 Converting: sample_report.txt → sample_report.csv")
+        print("⏳ Processing...")
+        
+        result2 = convert_file(
+            input_path=txt_input,
+            output_path=csv_output,
+            conversion_type="txt_to_csv"
+        )
+        
+        if result2['success']:
+            print(f"✅ Conversion successful!")
+            print(f"   Output: {result2['output_file']}")
+            
+            # Show preview
+            with open(csv_output, 'r', encoding='utf-8') as f:
+                lines = f.readlines()[:5]
+            print(f"\n📄 First 5 lines of CSV:")
+            for line in lines:
+                print(f"   {line.strip()}")
+        
+        print(f"\n� Converted files saved in: {OUTPUT_DIR}")
+        print(f"  • business_data.txt")
+        print(f"  • sample_report.csv")
+        
+        # Offer custom conversion
+        print("\n" + "─"*80)
+        print("\n🔧 Want to convert your own file?")
+        print("Supported conversions: pdf_to_txt, txt_to_pdf, csv_to_txt, txt_to_csv")
+        
+        custom_input = input("\nEnter input file path (or press Enter to skip): ").strip()
+        if custom_input and os.path.exists(custom_input):
+            custom_output = input("Enter output file path: ").strip()
+            conversion_type = input("Enter conversion type (e.g., pdf_to_txt): ").strip()
+            
+            if custom_output and conversion_type:
+                print(f"\n🔄 Converting {os.path.basename(custom_input)}...")
+                try:
+                    result = convert_file(custom_input, custom_output, conversion_type)
+                    if result['success']:
+                        print(f"✅ Success! File saved: {result['output_file']}")
+                except Exception as e:
+                    print(f"❌ Conversion failed: {e}")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    pause()
+
+
+# ============================================================================
+# TOOL 7: EMAIL INTENT CLASSIFIER
+# ============================================================================
+
+def demo_email_classifier():
+    """Demo: Email Intent Classifier - Understand email purpose"""
+    print_header("TOOL 7: EMAIL INTENT CLASSIFIER 📧")
+    
+    print("\n📖 What it does:")
+    print("  • Automatically classifies email intent")
+    print("  • Detects 10 different types")
+    print("  • Gives confidence scores")
+    print("  • Finds secondary intents too")
+    
+    print("\n📬 Detects these intents:")
+    intents = [
+        "complaint", "inquiry", "request", "feedback", "order",
+        "meeting", "urgent", "application", "sales", "other"
+    ]
+    for i, intent in enumerate(intents, 1):
+        print(f"  {i:2d}. {intent.title()}")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Auto-route customer emails")
+    print("  • Prioritize urgent messages")
+    print("  • Organize inbox automatically")
+    print("  • Track complaint patterns")
+    
+    pause("\nReady to classify emails? Press Enter...")
+    
+    # Test with sample emails
+    email_files = [
+        ("sample_email_complaint.txt", "Customer Complaint"),
+        ("sample_email_inquiry.txt", "Sales Inquiry"),
+        ("sample_email_urgent.txt", "Urgent Issue"),
+    ]
+    
+    for filename, label in email_files:
+        print_section(f"Email: {label}")
+        filepath = os.path.join(EXAMPLES_DIR, filename)
+        
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                email_text = f.read()
+            
+            print(f"📧 Email content:")
+            print(email_text[:200] + "...\n")
+            
+            result = classify_email_intent(email_text)
+            
+            print(f"🎯 Classification Results:")
+            print(f"  Primary Intent: {result['intent'].upper()}")
+            print(f"  Confidence: {result['confidence']:.2%}")
+            
+            if result['secondary_intents']:
+                print(f"\n  Secondary Intents:")
+                for intent in result['secondary_intents'][:3]:
+                    print(f"    • {intent['intent']}: {intent['confidence']:.2%}")
+            
+            print(f"\n💬 {result['explanation']}")
+            
+            pause()
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+    
+    # Custom email
+    print("\n" + "─"*80)
+    print("\n✏️ Want to try your own email?")
+    custom_email = input("Paste email text (or press Enter to skip): ").strip()
+    
+    if custom_email:
+        print("\n🔍 Analyzing your email...")
+        result = classify_email_intent(custom_email)
+        print(f"\n🎯 Intent: {result['intent'].upper()}")
+        print(f"   Confidence: {result['confidence']:.2%}")
+        if result['secondary_intents']:
+            print(f"   Also detected: {result['secondary_intents'][0]['intent']}")
+    
+    pause()
+
+
+# ============================================================================
+# TOOL 8: KPI GENERATOR
+# ============================================================================
+
+def demo_kpi_generator():
+    """Demo: KPI Generator - Calculate business metrics"""
+    print_header("TOOL 8: KPI GENERATOR 📈")
+    
+    print("\n📖 What it does:")
+    print("  • Calculates business KPIs automatically")
+    print("  • Analyzes 5 metric categories")
+    print("  • Identifies trends and insights")
+    print("  • Generates executive summaries")
+    
+    print("\n📊 Metric categories:")
+    print("  1. Revenue - Total revenue, profit, margins")
+    print("  2. Growth - Growth rates, trends over time")
+    print("  3. Efficiency - Revenue per employee/customer")
+    print("  4. Customer - Customer acquisition, retention")
+    print("  5. Operational - Operational efficiency metrics")
+    
+    print("\n💡 Real-world uses:")
+    print("  • Monthly performance reports")
+    print("  • Executive dashboards")
+    print("  • Investor presentations")
+    print("  • Business health monitoring")
+    
+    pause("\nReady to generate KPIs? Press Enter...")
+    
+    # Sample business data
+    print_section("Sample Business Data")
+    business_data = {
+        "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
+    }
+    
+    print("📊 Input data:")
+    for key, value in business_data.items():
+        if 'revenue' in key or 'cost' in key or 'spend' in key or 'sales' in key or 'cogs' in key:
+            print(f"  • {key}: ${value:,}")
+        else:
+            print(f"  • {key}: {value:,}")
+    
+    pause("\nPress Enter to calculate KPIs...")
+    
+    try:
+        # Generate KPIs
+        print_section("Calculating KPIs")
+        print("⏳ Analyzing data...")
+        
+        result = generate_kpis(
+            json.dumps(business_data),
+            metrics=["revenue", "growth", "efficiency"]
+        )
+        
+        print(f"\n✅ Generated {len(result['kpis'])} KPIs:")
+        print("\n📈 Key Metrics:")
+        
+        # Display KPIs nicely
+        kpi_items = list(result['kpis'].items())
+        for i, (name, value) in enumerate(kpi_items[:10], 1):  # Show top 10
+            # 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}"
+            
+            # Clean name
+            display_name = name.replace('_', ' ').title()
+            print(f"  {i:2d}. {display_name}: {formatted}")
+        
+        if len(kpi_items) > 10:
+            print(f"  ... and {len(kpi_items) - 10} more")
+        
+        pause("\nPress Enter to see executive summary...")
+        
+        # Summary
+        print_section("Executive Summary")
+        print(result['summary'])
+        
+        # Trends
+        if result.get('trends'):
+            print("\n📊 Key Trends Identified:")
+            for i, trend in enumerate(result['trends'], 1):
+                print(f"  {i}. {trend}")
+        
+        # Try custom data
+        print("\n" + "─"*80)
+        print("\n✏️ Want to calculate KPIs for your own data?")
+        print("Enter JSON data (or press Enter to skip):")
+        print("Example: {\"revenue\": 1000000, \"costs\": 600000, \"customers\": 500}")
+        
+        custom_data = input("\nYour data: ").strip()
+        if custom_data:
+            try:
+                # Validate JSON
+                json.loads(custom_data)
+                result = generate_kpis(custom_data, metrics=["revenue"])
+                print(f"\n✅ Your KPIs:")
+                for name, value in list(result['kpis'].items())[:5]:
+                    print(f"  • {name}: {value}")
+            except json.JSONDecodeError:
+                print("❌ Invalid JSON format!")
+            except Exception as e:
+                print(f"❌ Error: {e}")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    pause()
+
+
+# ============================================================================
+# MAIN MENU
+# ============================================================================
+
+def show_menu():
+    """Display main menu"""
+    print("\n" + "╔" + "═"*78 + "╗")
+    print("║" + " "*20 + "🚀 MissionControlMCP Demo" + " "*33 + "║")
+    print("║" + " "*25 + "Try All 8 Tools!" + " "*36 + "║")
+    print("╚" + "═"*78 + "╝")
+    
+    print("\n📋 MENU - Choose a tool to try:")
+    print("\n  [1] 📄 PDF Reader           - Extract text from PDFs")
+    print("  [2] 📝 Text Extractor       - Keywords, summaries, cleaning")
+    print("  [3] 🌐 Web Fetcher          - Scrape website content")
+    print("  [4] 🔍 RAG Search           - Semantic document search")
+    print("  [5] 📊 Data Visualizer      - Create beautiful charts")
+    print("  [6] 🔄 File Converter       - Convert file formats")
+    print("  [7] 📧 Email Classifier     - Detect email intent")
+    print("  [8] 📈 KPI Generator        - Business metrics & insights")
+    
+    print("\n  [9] 🎯 Run ALL Tools        - Full demo (recommended!)")
+    print("  [0] 🚪 Exit")
+    
+    print("\n" + "─"*80)
+
+
+def run_all_tools():
+    """Run all tool demos in sequence"""
+    print_header("🎯 RUNNING ALL TOOLS - COMPLETE DEMO")
+    print("\nThis will walk you through all 8 tools with examples.")
+    print("You can pause, try your own data, and explore each tool.")
+    
+    pause("\nReady to start? Press Enter...")
+    
+    tools = [
+        demo_pdf_reader,
+        demo_text_extractor,
+        demo_web_fetcher,
+        demo_rag_search,
+        demo_data_visualizer,
+        demo_file_converter,
+        demo_email_classifier,
+        demo_kpi_generator
+    ]
+    
+    for i, tool_func in enumerate(tools, 1):
+        print(f"\n\n{'='*80}")
+        print(f"  TOOL {i} OF {len(tools)}")
+        print(f"{'='*80}")
+        tool_func()
+    
+    print_header("🎉 DEMO COMPLETE!")
+    print("\n✅ You've explored all 8 MissionControlMCP tools!")
+    print(f"\n📁 Generated files saved in: {OUTPUT_DIR}")
+    print("\n💡 Next steps:")
+    print("  • Try the tools with your own data")
+    print("  • Integrate with Claude Desktop")
+    print("  • Build custom workflows")
+    print("  • Check out the documentation (README.md)")
+    print("\n🚀 Happy automating!")
+
+
+def main():
+    """Main program loop"""
+    
+    print("\n" + "╔" + "═"*78 + "╗")
+    print("║" + " "*15 + "Welcome to MissionControlMCP Demo!" + " "*29 + "║")
+    print("╚" + "═"*78 + "╝")
+    
+    print("\n👋 This interactive demo lets you:")
+    print("  ✅ Try all 8 enterprise automation tools")
+    print("  ✅ See real examples with sample data")
+    print("  ✅ Test with your own data")
+    print("  ✅ Understand what each tool does")
+    
+    pause("\nPress Enter to continue...")
+    
+    while True:
+        show_menu()
+        
+        choice = input("\n👉 Enter your choice (0-9): ").strip()
+        
+        if choice == "1":
+            demo_pdf_reader()
+        elif choice == "2":
+            demo_text_extractor()
+        elif choice == "3":
+            demo_web_fetcher()
+        elif choice == "4":
+            demo_rag_search()
+        elif choice == "5":
+            demo_data_visualizer()
+        elif choice == "6":
+            demo_file_converter()
+        elif choice == "7":
+            demo_email_classifier()
+        elif choice == "8":
+            demo_kpi_generator()
+        elif choice == "9":
+            run_all_tools()
+        elif choice == "0":
+            print("\n👋 Thanks for trying MissionControlMCP!")
+            print("🚀 Check out the docs for more: README.md")
+            break
+        else:
+            print("\n❌ Invalid choice! Please enter 0-9")
+        
+        # Ask if user wants to continue
+        if choice != "9":  # Don't ask after running all tools
+            print("\n" + "─"*80)
+            continue_choice = input("Return to menu? (y/n): ").strip().lower()
+            if continue_choice != 'y':
+                print("\n👋 Thanks for trying MissionControlMCP!")
+                break
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\n👋 Demo interrupted. See you next time!")
+    except Exception as e:
+        print(f"\n\n❌ Unexpected error: {e}")
+        import traceback
+        traceback.print_exc()

mcp_server.py

@@ -0,0 +1,316 @@
+"""
+MissionControlMCP - Enterprise Automation MCP Server
+Main server implementation using MCP SDK
+"""
+import logging
+from typing import Any
+import sys
+import os
+
+# Setup paths
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Import MCP SDK
+from mcp.server import Server
+from mcp.types import Tool, TextContent
+
+# Import tool functions
+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
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create MCP server instance
+app = Server("mission-control-mcp")
+
+
+# Tool definitions
+TOOLS = [
+    Tool(
+        name="pdf_reader",
+        description="Extract text and metadata from PDF files. Reads all pages and extracts document information.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the PDF file to read"
+                }
+            },
+            "required": ["file_path"]
+        }
+    ),
+    Tool(
+        name="text_extractor",
+        description="Process and extract information from text. Supports cleaning, summarization, chunking, and keyword extraction.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "text": {
+                    "type": "string",
+                    "description": "Raw text to process"
+                },
+                "operation": {
+                    "type": "string",
+                    "description": "Operation: 'clean', 'summarize', 'chunk', or 'keywords'",
+                    "enum": ["clean", "summarize", "chunk", "keywords"],
+                    "default": "clean"
+                },
+                "max_length": {
+                    "type": "integer",
+                    "description": "Maximum length for summary or chunk size",
+                    "default": 500
+                }
+            },
+            "required": ["text"]
+        }
+    ),
+    Tool(
+        name="web_fetcher",
+        description="Fetch and extract content from web URLs. Returns clean text or HTML content with metadata.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "URL to fetch content from"
+                },
+                "extract_text_only": {
+                    "type": "boolean",
+                    "description": "Extract only text content (removes HTML)",
+                    "default": True
+                }
+            },
+            "required": ["url"]
+        }
+    ),
+    Tool(
+        name="rag_search",
+        description="Semantic search using RAG (Retrieval Augmented Generation). Finds relevant documents using vector embeddings.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "Search query"
+                },
+                "documents": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of documents to search in"
+                },
+                "top_k": {
+                    "type": "integer",
+                    "description": "Number of top results to return",
+                    "default": 3
+                }
+            },
+            "required": ["query", "documents"]
+        }
+    ),
+    Tool(
+        name="data_visualizer",
+        description="Create data visualizations and charts. Supports bar, line, pie, and scatter charts from JSON or CSV data.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "string",
+                    "description": "JSON or CSV string data"
+                },
+                "chart_type": {
+                    "type": "string",
+                    "description": "Chart type",
+                    "enum": ["bar", "line", "pie", "scatter"],
+                    "default": "bar"
+                },
+                "x_column": {
+                    "type": "string",
+                    "description": "X-axis column name"
+                },
+                "y_column": {
+                    "type": "string",
+                    "description": "Y-axis column name"
+                },
+                "title": {
+                    "type": "string",
+                    "description": "Chart title",
+                    "default": "Data Visualization"
+                }
+            },
+            "required": ["data"]
+        }
+    ),
+    Tool(
+        name="file_converter",
+        description="Convert files between formats. Supports PDF↔TXT, TXT↔CSV conversions.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "input_path": {
+                    "type": "string",
+                    "description": "Path to input file"
+                },
+                "output_format": {
+                    "type": "string",
+                    "description": "Desired output format",
+                    "enum": ["txt", "csv", "pdf"]
+                },
+                "output_path": {
+                    "type": "string",
+                    "description": "Optional output file path"
+                }
+            },
+            "required": ["input_path", "output_format"]
+        }
+    ),
+    Tool(
+        name="email_intent_classifier",
+        description="Classify email intent using NLP. Identifies inquiry, complaint, request, feedback, meeting, order, urgent, follow-up, thank you, and application intents.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "email_text": {
+                    "type": "string",
+                    "description": "Email text to classify"
+                }
+            },
+            "required": ["email_text"]
+        }
+    ),
+    Tool(
+        name="kpi_generator",
+        description="Generate business KPIs and insights from data. Calculates revenue, growth, efficiency, customer, and operational metrics.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "string",
+                    "description": "JSON string with business data"
+                },
+                "metrics": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": ["revenue", "growth", "efficiency", "customer", "operational"]
+                    },
+                    "description": "List of metrics to calculate",
+                    "default": ["revenue", "growth", "efficiency"]
+                }
+            },
+            "required": ["data"]
+        }
+    )
+]
+
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    """List all available tools"""
+    return TOOLS
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: Any) -> list[TextContent]:
+    """
+    Handle tool execution requests
+    
+    Args:
+        name: Tool name
+        arguments: Tool arguments
+        
+    Returns:
+        List of TextContent responses
+    """
+    try:
+        logger.info(f"Executing tool: {name}")
+        
+        result = None
+        
+        if name == "pdf_reader":
+            result = read_pdf(arguments["file_path"])
+            
+        elif name == "text_extractor":
+            result = extract_text(
+                text=arguments["text"],
+                operation=arguments.get("operation", "clean"),
+                max_length=arguments.get("max_length", 500)
+            )
+            
+        elif name == "web_fetcher":
+            result = fetch_web_content(
+                url=arguments["url"],
+                extract_text_only=arguments.get("extract_text_only", True)
+            )
+            
+        elif name == "rag_search":
+            result = search_documents(
+                query=arguments["query"],
+                documents=arguments["documents"],
+                top_k=arguments.get("top_k", 3)
+            )
+            
+        elif name == "data_visualizer":
+            result = visualize_data(
+                data=arguments["data"],
+                chart_type=arguments.get("chart_type", "bar"),
+                x_column=arguments.get("x_column"),
+                y_column=arguments.get("y_column"),
+                title=arguments.get("title", "Data Visualization")
+            )
+            
+        elif name == "file_converter":
+            result = convert_file(
+                input_path=arguments["input_path"],
+                output_format=arguments["output_format"],
+                output_path=arguments.get("output_path")
+            )
+            
+        elif name == "email_intent_classifier":
+            result = classify_email_intent(arguments["email_text"])
+            
+        elif name == "kpi_generator":
+            result = generate_kpis(
+                data=arguments["data"],
+                metrics=arguments.get("metrics", ["revenue", "growth", "efficiency"])
+            )
+            
+        else:
+            raise ValueError(f"Unknown tool: {name}")
+        
+        # Format result as JSON string
+        import json
+        result_text = json.dumps(result, indent=2, default=str)
+        
+        return [TextContent(type="text", text=result_text)]
+        
+    except Exception as e:
+        logger.error(f"Error executing tool {name}: {e}", exc_info=True)
+        error_msg = f"Error executing {name}: {str(e)}"
+        return [TextContent(type="text", text=error_msg)]
+
+
+async def main():
+    """Main entry point for the MCP server"""
+    from mcp.server.stdio import stdio_server
+    
+    async with stdio_server() as (read_stream, write_stream):
+        logger.info("MissionControlMCP server starting...")
+        await app.run(
+            read_stream,
+            write_stream,
+            app.create_initialization_options()
+        )
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

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)