Upload 44 files

.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

@@ -9,6 +9,7 @@ app_file: app.py
 pinned: false
 tags:
 - building-mcp-track-enterprise
+- mcp-in-action-track-enterprise
 - mcp
 - anthropic
 - enterprise-automation
@@ -23,9 +24,17 @@ tags:
 
 A fully functional Model Context Protocol (MCP) server providing 8 powerful enterprise automation tools for document processing, web scraping, semantic search, data visualization, and business analytics.
 
-Built for the **MCP 1st Birthday Hackathon – Winter 2025** (Track 1: Building MCP - Enterprise Category).
+Built for the **MCP 1st Birthday Hackathon – Winter 2025** (Tracks: Building MCP + MCP in Action - Enterprise).
 
-🏆 **Hackathon Submission** | 🔧 **Track 1: Building MCP** | 🏢 **Enterprise Category**
+🏆 **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)
 
 ---
 
@@ -65,7 +74,7 @@ Built for the **MCP 1st Birthday Hackathon – Winter 2025** (Track 1: Building
 
 ```bash
 # Test all tools with sample files
-python test_samples.py
+python demo.py
 ```
 
 **See [TESTING.md](TESTING.md) for complete testing guide with examples!**
@@ -407,13 +416,13 @@ After configuration, restart Claude Desktop. You can then ask Claude to:
 
 ## 🧪 Testing
 
-Run the comprehensive test suite:
+Run the comprehensive demo:
 
 ```bash
-python test_server.py
+python demo.py
 ```
 
-The test suite includes:
+The demo includes:
 - Text extraction and processing tests
 - Web fetching tests
 - RAG search demonstrations
@@ -429,11 +438,12 @@ The test suite includes:
 ```
 mission_control_mcp/
 ├── mcp_server.py              # Main MCP server
+├── app.py                     # Gradio web interface
+├── demo.py                    # Demo & test suite
 ├── requirements.txt           # Dependencies
-├── test_server.py            # Test suite
-├── README.md                 # Documentation
+├── README.md                  # Documentation
 │
-├── tools/                    # Tool implementations
+├── tools/                     # Tool implementations
 │   ├── pdf_reader.py
 │   ├── text_extractor.py
 │   ├── web_fetcher.py
@@ -490,11 +500,12 @@ mission_control_mcp/
 
 ---
 
-## � Documentation & Examples
+## 📝 Documentation & Examples
 
 - **[EXAMPLES.md](EXAMPLES.md)** - Real-world use cases, workflows, and ROI examples
-- **[HACKATHON_SUBMISSION.md](HACKATHON_SUBMISSION.md)** - Judge evaluation guide
-- **[VIDEO_SCRIPT.md](VIDEO_SCRIPT.md)** - Demo video script and talking points
+- **[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

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

@@ -480,6 +480,11 @@ with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP
                     - Supports multi-page PDFs
                     - Extracts metadata (author, title)
                     - Automatically generates keywords
+                    
+                    **⚠️ Limitations:**
+                    - Max file size: 200 MB (HuggingFace limit)
+                    - Text-based PDFs only (scanned images need OCR)
+                    - Processing time: ~2-5 seconds per page
                     """)
                 
                 with gr.Column(scale=2):
@@ -499,6 +504,11 @@ with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP
             gr.Markdown("""
             ### 📝 AI-Powered Text Analysis
             Extract keywords, generate summaries, clean text, or split into chunks.
+            
+            **⚠️ Limitations:**
+            - Max input: ~50,000 characters
+            - Summary length: 100-1000 characters (adjustable)
+            - Processing time: ~1-3 seconds
             """)
             
             with gr.Row():
@@ -550,6 +560,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP
             gr.Markdown("""
             ### 🌐 Scrape and Analyze Web Content
             Fetch content from any website, extract clean text, and analyze it.
+            
+            **⚠️ Limitations:**
+            - Timeout: 30 seconds per request
+            - Some sites block automated access (LinkedIn, Facebook, etc.)
+            - JavaScript-heavy sites may not render fully
+            - Rate limits apply to prevent abuse
             """)
             
             with gr.Row():
@@ -594,6 +610,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP
             gr.Markdown("""
             ### 🔍 Semantic Document Search with AI
             Search through documents using AI-powered semantic understanding (RAG - Retrieval Augmented Generation).
+            
+            **⚠️ Limitations:**
+            - Currently searches 5 pre-loaded sample documents
+            - First search: ~5-10 seconds (loads AI model)
+            - Subsequent searches: ~1-2 seconds
+            - Max 1000 documents supported
             """)
             
             with gr.Row():
@@ -640,6 +662,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP
             gr.Markdown("""
             ### 📊 Create Beautiful Charts from Your Data
             Transform CSV data into stunning visualizations - line charts, bar charts, pie charts, and scatter plots.
+            
+            **⚠️ Limitations:**
+            - Max 10,000 rows of data
+            - CSV format only (comma-separated)
+            - Generated as PNG images (800x600px)
+            - Numeric columns required for pie/scatter charts
             """)
             
             with gr.Row():
@@ -688,6 +716,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP
             gr.Markdown("""
             ### 📧 AI-Powered Email Intent Detection
             Automatically classify email intent and detect sentiment - complaint, inquiry, urgent, etc.
+            
+            **⚠️ Limitations:**
+            - Rule-based classification (not deep learning)
+            - Max 10,000 characters per email
+            - English language optimized
+            - 10 intent categories supported
             """)
             
             with gr.Row():
@@ -739,6 +773,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MissionControlMCP
             gr.Markdown("""
             ### 📈 Business KPI & Analytics Dashboard
             Generate comprehensive business metrics and KPIs from your data automatically.
+            
+            **⚠️ Limitations:**
+            - JSON format required
+            - Max 50 KPIs calculated per request
+            - Numeric data only for calculations
+            - Processing time: ~1-2 seconds
             """)
             
             with gr.Row():

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())

models/__init__.py

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

models/schemas.py

@@ -0,0 +1,109 @@
+"""
+Pydantic schemas for tool inputs and outputs
+"""
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+
+
+class PdfReaderInput(BaseModel):
+    """Input schema for PDF reader tool"""
+    file_path: str = Field(description="Path to the PDF file to read")
+
+
+class PdfReaderOutput(BaseModel):
+    """Output schema for PDF reader tool"""
+    text: str = Field(description="Extracted text from PDF")
+    pages: int = Field(description="Number of pages in PDF")
+    metadata: Dict[str, Any] = Field(description="PDF metadata")
+
+
+class TextExtractorInput(BaseModel):
+    """Input schema for text extractor tool"""
+    text: str = Field(description="Raw text to process")
+    operation: str = Field(description="Operation: 'clean', 'summarize', or 'chunk'", default="clean")
+    max_length: Optional[int] = Field(description="Max length for summary", default=500)
+
+
+class TextExtractorOutput(BaseModel):
+    """Output schema for text extractor tool"""
+    result: str = Field(description="Processed text")
+    word_count: int = Field(description="Word count of result")
+
+
+class WebFetcherInput(BaseModel):
+    """Input schema for web fetcher tool"""
+    url: str = Field(description="URL to fetch")
+    extract_text_only: bool = Field(description="Extract only text content", default=True)
+
+
+class WebFetcherOutput(BaseModel):
+    """Output schema for web fetcher tool"""
+    content: str = Field(description="Fetched content")
+    status_code: int = Field(description="HTTP status code")
+    metadata: Dict[str, Any] = Field(description="Response metadata")
+
+
+class RagSearchInput(BaseModel):
+    """Input schema for RAG search tool"""
+    query: str = Field(description="Search query")
+    documents: List[str] = Field(description="List of documents to search in")
+    top_k: int = Field(description="Number of top results to return", default=3)
+
+
+class RagSearchOutput(BaseModel):
+    """Output schema for RAG search tool"""
+    results: List[Dict[str, Any]] = Field(description="Search results with scores")
+
+
+class DataVisualizerInput(BaseModel):
+    """Input schema for data visualizer tool"""
+    data: str = Field(description="JSON or CSV string data")
+    chart_type: str = Field(description="Chart type: 'bar', 'line', 'pie', 'scatter'", default="bar")
+    x_column: Optional[str] = Field(description="X-axis column name", default=None)
+    y_column: Optional[str] = Field(description="Y-axis column name", default=None)
+    title: Optional[str] = Field(description="Chart title", default="Data Visualization")
+
+
+class DataVisualizerOutput(BaseModel):
+    """Output schema for data visualizer tool"""
+    image_base64: str = Field(description="Base64 encoded chart image")
+    dimensions: Dict[str, int] = Field(description="Image dimensions")
+
+
+class FileConverterInput(BaseModel):
+    """Input schema for file converter tool"""
+    input_path: str = Field(description="Path to input file")
+    output_format: str = Field(description="Output format: 'txt', 'csv', 'pdf'")
+    output_path: Optional[str] = Field(description="Path for output file", default=None)
+
+
+class FileConverterOutput(BaseModel):
+    """Output schema for file converter tool"""
+    output_path: str = Field(description="Path to converted file")
+    success: bool = Field(description="Conversion success status")
+    message: str = Field(description="Status message")
+
+
+class EmailIntentInput(BaseModel):
+    """Input schema for email intent classifier tool"""
+    email_text: str = Field(description="Email text to classify")
+
+
+class EmailIntentOutput(BaseModel):
+    """Output schema for email intent classifier tool"""
+    intent: str = Field(description="Classified intent category")
+    confidence: float = Field(description="Confidence score (0-1)")
+    secondary_intents: List[Dict[str, float]] = Field(description="Other possible intents")
+
+
+class KpiGeneratorInput(BaseModel):
+    """Input schema for KPI generator tool"""
+    data: str = Field(description="JSON string with business data")
+    metrics: List[str] = Field(description="List of metrics to calculate", default=["revenue", "growth", "efficiency"])
+
+
+class KpiGeneratorOutput(BaseModel):
+    """Output schema for KPI generator tool"""
+    kpis: Dict[str, Any] = Field(description="Calculated KPIs")
+    summary: str = Field(description="Executive summary")
+    trends: List[str] = Field(description="Key trends identified")

requirements.txt

@@ -25,8 +25,8 @@ matplotlib>=3.7.0
 seaborn>=0.12.0
 pillow>=10.0.0
 
-# Web Interface (for demo_gui.py)
-gradio>=4.0.0
+# Web Interface (Gradio for hackathon demo)
+gradio>=5.48.0
 
 # NLP & Text Processing
 nltk>=3.8.0