atlas-chat 0.1.0__py3-none-any.whl

atlas/mcp/api_key_demo/main.py

@@ -0,0 +1,172 @@
+"""
+MCP Server with API Key Authentication Demo
+
+This server validates X-API-Key header on all tool calls using middleware.
+Demonstrates per-user API key authentication for Atlas UI.
+
+Run with: python main.py
+Or configure in mcp.json with auth_type: "api_key"
+"""
+
+from contextvars import ContextVar
+
+from fastmcp import FastMCP
+from fastmcp.exceptions import ToolError
+from fastmcp.server.dependencies import get_http_headers
+from fastmcp.server.middleware import Middleware, MiddlewareContext
+
+# Context variable to store current user during request
+current_user_var: ContextVar[dict | None] = ContextVar("current_user", default=None)
+
+# API keys mapped to user info
+# In production, this would be a database lookup
+API_KEY_USERS = {
+    "test123": {
+        "email": "test@example.com",
+        "name": "Test User",
+        "role": "developer",
+    },
+    "admin123": {
+        "email": "admin@example.com",
+        "name": "Admin User",
+        "role": "admin",
+    },
+    "demo-api-key-12345": {
+        "email": "demo@example.com",
+        "name": "Demo User",
+        "role": "viewer",
+    },
+}
+
+
+def get_current_user() -> dict | None:
+    """Get the current authenticated user from context."""
+    return current_user_var.get()
+
+
+class ApiKeyAuthMiddleware(Middleware):
+    """Middleware that validates API key and sets current user context."""
+
+    def __init__(self, api_key_users: dict[str, dict], header_name: str = "x-api-key"):
+        self.api_key_users = api_key_users
+        self.header_name = header_name.lower()
+
+    async def on_call_tool(self, context: MiddlewareContext, call_next):
+        """Validate API key and set user context before each tool call."""
+        # Get tool name from context.message
+        tool_name = context.message.name
+        print(f"[AUTH] Checking API key for tool '{tool_name}'...", flush=True)
+        headers = get_http_headers() or {}
+        api_key = headers.get(self.header_name)
+
+        if not api_key:
+            print(f"[AUTH FAILED] Tool '{tool_name}': Missing {self.header_name} header", flush=True)
+            raise ToolError(
+                f"Authentication required: Missing {self.header_name} header. "
+                "Please provide your API key in Atlas UI settings."
+            )
+
+        user = self.api_key_users.get(api_key)
+        if not user:
+            # Don't log the API key value, even partially
+            print(f"[AUTH FAILED] Tool '{tool_name}': Invalid API key", flush=True)
+            raise ToolError(
+                "Authentication failed: Invalid API key. "
+                "Please check your API key and try again."
+            )
+
+        # Log successful authentication - only role, not sensitive user details
+        print(f"[AUTH OK] Tool '{tool_name}': Authenticated user with role: {user['role']}", flush=True)
+
+        # Set current user in context for tools to access
+        token = current_user_var.set(user)
+        try:
+            return await call_next(context)
+        finally:
+            current_user_var.reset(token)
+
+
+mcp = FastMCP("ApiKeyDemoServer")
+
+# Add authentication middleware
+mcp.add_middleware(ApiKeyAuthMiddleware(api_key_users=API_KEY_USERS))
+
+
+@mcp.tool
+def echo(message: str) -> str:
+    """Echo back a message. Requires valid API key."""
+    user = get_current_user()
+    return f"Echo from {user['name']}: {message}"
+
+
+@mcp.tool
+def add_numbers(a: int, b: int) -> int:
+    """Add two numbers together. Requires valid API key."""
+    return a + b
+
+
+@mcp.tool
+def whoami() -> dict:
+    """Show who you are based on your API key.
+
+    Returns the user information associated with your API key.
+    """
+    user = get_current_user()
+    return {
+        "authenticated": True,
+        "user": user,
+        "message": f"Hello, {user['name']}! You are authenticated as {user['role']}.",
+    }
+
+
+@mcp.tool
+def get_user_data() -> dict:
+    """Get sample user data. Requires valid API key.
+
+    This demonstrates that the API key was validated successfully
+    and shows personalized data for the authenticated user.
+    """
+    user = get_current_user()
+    return {
+        "server_name": "ApiKeyDemoServer",
+        "authenticated": True,
+        "user": user,
+        "message": f"Welcome back, {user['name']}!",
+        "sample_data": {
+            "items": ["item1", "item2", "item3"],
+            "count": 3,
+        },
+    }
+
+
+@mcp.tool
+def list_valid_keys() -> dict:
+    """List the valid demo API keys (for testing purposes only).
+
+    In a real application, this tool would NOT exist.
+    It's here just to help users test the demo.
+    """
+    return {
+        "note": "These are demo keys for testing. In production, keys would be user-specific.",
+        "valid_keys": {key: user["email"] for key, user in API_KEY_USERS.items()},
+    }
+
+
+if __name__ == "__main__":
+    import sys
+
+    # Default port
+    port = 8006
+
+    # Allow port override via command line
+    if len(sys.argv) > 1:
+        try:
+            port = int(sys.argv[1])
+        except ValueError:
+            print(f"Invalid port: {sys.argv[1]}, using default {port}")
+
+    print(f"Starting API Key Demo MCP server on http://localhost:{port}/mcp")
+    print(f"Valid API key count: {len(API_KEY_USERS)} (use list_valid_keys tool to see them)")
+    print("\nTo test, set your API key in Atlas UI or use the FastMCP client.")
+
+    mcp.run(transport="streamable-http", host="0.0.0.0", port=port)

atlas/mcp/api_key_demo/run.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+# Run the API Key Demo MCP Server
+#
+# Usage:
+#   ./run.sh          - Start on default port 8006
+#   ./run.sh 9000     - Start on custom port 9000
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$(dirname "$(dirname "$SCRIPT_DIR")")")"
+PYTHON="$PROJECT_ROOT/.venv/bin/python"
+
+# Verify python exists
+if [ ! -f "$PYTHON" ]; then
+    echo "Error: Python not found at $PYTHON"
+    echo "Run from project root: uv venv && uv pip install -r requirements.txt"
+    exit 1
+fi
+
+cd "$SCRIPT_DIR"
+
+PORT="${1:-8006}"
+
+echo "========================================"
+echo "API Key Demo MCP Server"
+echo "========================================"
+echo ""
+echo "Add this to your config/overrides/mcp.json:"
+echo ""
+cat << EOF
+{
+  "api_key_demo": {
+    "url": "http://127.0.0.1:${PORT}/mcp",
+    "auth_type": "api_key",
+    "auth_header": "X-API-Key",
+    "auth_prompt": "Enter your API key for the demo server",
+    "groups": ["users"],
+    "description": "Demo server with API key authentication",
+    "short_description": "API Key Auth Demo",
+    "compliance_level": "Public"
+  }
+}
+EOF
+echo ""
+echo "Valid test API keys:"
+echo "  - test123 (developer)"
+echo "  - admin123 (admin)"
+echo "  - demo-api-key-12345 (viewer)"
+echo ""
+echo "========================================"
+echo "Starting server on port $PORT..."
+echo "========================================"
+echo ""
+
+"$PYTHON" main.py "$PORT"

atlas/mcp/basictable/main.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""
+CSV/XLSX Analyzer MCP Server using FastMCP.
+Detects numerical columns, generates basic statistical plots, and returns as Base64.
+"""
+
+import base64
+import io
+from typing import Annotated, Any, Dict
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from fastmcp import FastMCP
+
+# Initialize the MCP server
+mcp = FastMCP("CSV_XLSX_Analyzer")
+
+@mcp.tool
+def analyze_spreadsheet(
+    instructions: Annotated[str, "Instructions for the tool, not used in this implementation"],
+    filename: Annotated[str, "The name of the file (.csv or .xlsx)"],
+    file_data_base64: Annotated[str, "LLM agent can leave blank. Do NOT fill. Framework will fill this."] = ""
+) -> Dict[str, Any]:
+    """
+    Perform comprehensive spreadsheet analysis with automatic data visualization for CSV and Excel files.
+
+    This intelligent data analysis tool provides instant insights into spreadsheet data:
+
+    **File Format Support:**
+    - CSV files (.csv) with various delimiters and encodings
+    - Excel files (.xlsx) including multiple sheets and complex formatting
+    - Automatic format detection and appropriate parsing
+    - Robust handling of different data structures and layouts
+
+    **Data Analysis Capabilities:**
+    - Automatic numerical column detection and classification
+    - Statistical distribution analysis for all numeric data
+    - Data quality assessment and completeness evaluation
+    - Column type identification and validation
+
+    **Visualization Features:**
+    - Auto-generated histograms for all numerical columns
+    - Multi-panel plots showing data distribution patterns
+    - Professional formatting with grid layout optimization
+    - High-resolution PNG output suitable for reports and presentations
+
+    **Data Insights Provided:**
+    - Column count and data type summary
+    - Numerical data distribution patterns
+    - Data range and statistical characteristics
+    - Missing value identification
+    - Outlier detection through visual inspection
+
+    **Smart Processing:**
+    - Handles large datasets efficiently
+    - Automatic plot layout optimization based on column count
+    - Error handling for corrupted or invalid data
+    - Graceful degradation for edge cases
+
+    **Use Cases:**
+    - Initial data exploration and profiling
+    - Data quality assessment before analysis
+    - Quick statistical overview for stakeholder presentations
+    - Dataset validation and structure verification
+    - Automated reporting and data documentation
+
+    **Examples:**
+    - Sales data → Revenue and quantity distribution histograms
+    - Survey responses → Response pattern and demographic distributions
+    - Financial records → Transaction amount and balance distributions
+    - Scientific measurements → Variable distribution and range analysis
+
+    Args:
+        instructions: Analysis instructions or requirements (currently not used in processing)
+        filename: Name of the spreadsheet file (.csv or .xlsx extensions required)
+        file_data_base64: Base64-encoded file content (automatically provided by framework)
+
+    Returns:
+        Dictionary containing:
+        - results: Analysis summary with column and data information
+        - artifacts: High-quality histogram visualization as downloadable PNG
+        - display: Optimized viewer configuration for data visualization
+        - meta_data: Processing statistics and file information
+        Or error message if file cannot be processed or contains no numerical data
+    """
+    try:
+        # Validate file extension
+        ext = filename.lower().split('.')[-1]
+        if ext not in ['csv', 'xlsx']:
+            return {"results": {"error": "Invalid file type. Only .csv or .xlsx allowed."}}
+
+        # Decode file data
+        decoded_bytes = base64.b64decode(file_data_base64)
+        buffer = io.BytesIO(decoded_bytes)
+
+        # Load dataframe
+        if ext == 'csv':
+            df = pd.read_csv(buffer)
+        else:
+            df = pd.read_excel(buffer)
+
+        if df.empty:
+            return {"results": {"error": "File is empty or has no readable content."}}
+
+        # Detect numerical columns
+        num_cols = df.select_dtypes(include=['number']).columns.tolist()
+        if not num_cols:
+            return {"results": {"error": "No numerical columns found for plotting."}}
+
+        # Generate plot
+        plt.figure(figsize=(8, 6))
+        df[num_cols].hist(bins=20, figsize=(10, 8), grid=False)
+        plt.tight_layout()
+
+        # Save to buffer as PNG
+        img_buffer = io.BytesIO()
+        plt.savefig(img_buffer, format='png')
+        plt.close()
+        img_buffer.seek(0)
+
+        # Encode to Base64
+        img_base64 = base64.b64encode(img_buffer.read()).decode('utf-8')
+        img_buffer.close()
+
+        returned_file_names = ["analysis_plot.png"]
+        returned_file_contents = [img_base64]
+
+        return {
+            "results": {
+                "operation": "spreadsheet_analysis",
+                "filename": filename,
+                "numerical_columns": num_cols,
+                "message": f"Detected numerical columns: {', '.join(num_cols)}. Histogram plot generated."
+            },
+            "returned_file_names": returned_file_names,
+            "returned_file_contents": returned_file_contents
+        }
+
+    except Exception as e:
+        # print traceback for debugging
+        import traceback
+        traceback.print_exc()
+        return {"results": {"error": f"Spreadsheet analysis failed: {str(e)}"}}
+
+if __name__ == "__main__":
+    print("Starting CSV/XLSX Analyzer MCP server...")
+    mcp.run()

atlas/mcp/calculator/main.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Calculator MCP Server using FastMCP
+Provides mathematical operations through MCP protocol.
+"""
+
+import math
+import time
+from typing import Any, Dict, Union
+
+from fastmcp import FastMCP
+
+# Initialize the MCP server
+mcp = FastMCP("Calculator")
+
+
+def to_float(value: Union[str, int, float]) -> float:
+    """Convert input to float, handling strings and numbers."""
+    try:
+        return float(value)
+    except (ValueError, TypeError):  # pragma: no cover - simple helper
+        raise ValueError(f"Cannot convert '{value}' to a number")
+
+
+def to_int(value: Union[str, int, float]) -> int:
+    """Convert input to int, handling strings and numbers."""
+    try:
+        return int(float(value))  # Convert to float first to handle "5.0" -> 5
+    except (ValueError, TypeError):  # pragma: no cover - simple helper
+        raise ValueError(f"Cannot convert '{value}' to an integer")
+
+@mcp.tool
+def evaluate(expression: str) -> Dict[str, Any]:
+    """Safely evaluate a wide range of mathematical expressions with comprehensive mathematical functions.
+
+    This calculator tool provides secure mathematical computation capabilities including:
+
+    **Basic Operations:**
+    - Arithmetic: +, -, *, /, //, %, **
+    - Built-in functions: abs(), round(), min(), max(), sum(), pow(), divmod()
+
+    **Mathematical Constants:**
+    - pi, e, tau, inf, nan
+
+    **Trigonometric Functions:**
+    - sin(), cos(), tan(), asin(), acos(), atan(), atan2()
+    - degrees(), radians(), hypot()
+
+    **Hyperbolic Functions:**
+    - sinh(), cosh(), tanh(), asinh(), acosh(), atanh()
+
+    **Exponential & Logarithmic:**
+    - exp(), sqrt(), log(), log10(), log2()
+
+    **Rounding & Numeric Operations:**
+    - ceil(), floor(), trunc(), modf(), copysign(), fabs(), fmod()
+
+    **Combinatorics & Number Theory:**
+    - factorial(), comb(), perm(), gcd(), lcm()
+
+    **Float Validation:**
+    - isfinite(), isinf(), isnan()
+
+    **Security Features:**
+    - Expression length limited to 200 characters
+    - Only safe mathematical functions are allowed
+    - No access to file system, network, or dangerous operations
+    - Sandboxed evaluation environment
+
+    **Examples:**
+    - Basic: "2 + 3 * 4" → 14
+    - Trigonometry: "sin(pi/2)" → 1.0
+    - Logarithms: "log10(100)" → 2.0
+    - Combinatorics: "factorial(5)" → 120
+    - Complex: "sqrt(pow(3, 2) + pow(4, 2))" → 5.0
+
+    Args:
+        expression: Mathematical expression to evaluate (string, max 200 chars)
+
+    Returns:
+        MCP contract shape with results and timing metadata:
+        {
+          "results": {"operation": "evaluate", "expression": str, "result": float},
+          "meta_data": {"is_error": bool, "elapsed_ms": float, "reason": str}
+        }
+    """
+    start = time.perf_counter()
+    expression_str = str(expression)
+    meta: Dict[str, Any] = {}
+
+    # Safety check length
+    if len(expression_str) > 200:
+        meta.update({"is_error": True, "reason": "too_long"})
+        return {
+            "results": {"error": "Expression too long", "expression": expression_str},
+            "meta_data": _finalize_meta(meta, start)
+        }
+
+    allowed_names = {
+        # Built-ins
+        "abs": abs, "round": round, "min": min, "max": max, "sum": sum,
+        "pow": pow, "divmod": divmod,
+        # Constants
+        "pi": math.pi, "e": math.e, "tau": math.tau, "inf": math.inf, "nan": math.nan,
+        # Trigonometric
+        "sin": math.sin, "cos": math.cos, "tan": math.tan,
+        "asin": math.asin, "acos": math.acos, "atan": math.atan, "atan2": math.atan2,
+        "hypot": math.hypot, "degrees": math.degrees, "radians": math.radians,
+        # Hyperbolic
+        "sinh": math.sinh, "cosh": math.cosh, "tanh": math.tanh,
+        "asinh": math.asinh, "acosh": math.acosh, "atanh": math.atanh,
+        # Exponential & logarithmic
+        "exp": math.exp, "sqrt": math.sqrt, "log": math.log, "log10": math.log10, "log2": math.log2,
+        # Rounding & numeric ops
+        "ceil": math.ceil, "floor": math.floor, "trunc": math.trunc, "modf": math.modf,
+        "copysign": math.copysign, "fabs": math.fabs, "fmod": math.fmod,
+        # Combinatorics & number theory
+        "factorial": math.factorial, "comb": math.comb, "perm": math.perm, "gcd": math.gcd, "lcm": math.lcm,
+        # Float checks
+        "isfinite": math.isfinite, "isinf": math.isinf, "isnan": math.isnan
+    }
+
+    try:
+        result = eval(expression_str, {"__builtins__": {}}, allowed_names)
+        payload = {
+            "operation": "evaluate",
+            "expression": expression_str,
+            "result": result
+        }
+        meta.update({"is_error": False})
+        return {"results": payload, "meta_data": _finalize_meta(meta, start)}
+    except Exception as e:  # noqa: BLE001 - broad for safe tool boundary
+        meta.update({"is_error": True, "reason": type(e).__name__})
+        return {
+            "results": {"error": f"Evaluation error: {e}", "expression": expression_str},
+            "meta_data": _finalize_meta(meta, start)
+        }
+
+
+def _finalize_meta(meta: Dict[str, Any], start: float) -> Dict[str, Any]:
+    """Attach timing info and return meta_data dict."""
+    meta = dict(meta)  # shallow copy
+    meta["elapsed_ms"] = round((time.perf_counter() - start) * 1000, 3)
+    return meta
+
+
+
+if __name__ == "__main__":
+    mcp.run()

atlas/mcp/code-executor/execution_engine.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+Execution engine module for code executor.
+Handles safe subprocess execution of Python scripts with resource limits.
+"""
+
+import json
+import logging
+import subprocess
+import sys
+import traceback
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def execute_code_safely(script_path: Path, timeout: int = 30) -> Dict[str, Any]:
+    """
+    Execute Python script safely with resource limits.
+
+    Args:
+        script_path: Path to the script to execute
+        timeout: Maximum execution time in seconds
+
+    Returns:
+        Execution results
+    """
+    try:
+        logger.info(f"Executing script: {script_path} with timeout: {timeout}s")
+
+        # Execute with subprocess for isolation
+        result = subprocess.run(
+            [sys.executable, str(script_path)],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=script_path.parent
+        )
+
+        logger.info(f"Script execution completed with return code: {result.returncode}")
+
+        if result.returncode == 0:
+            # Parse the JSON output from the script
+            try:
+                execution_result = json.loads(result.stdout.strip())
+                if not execution_result.get("success", True):
+                    logger.warning(f"Code execution failed: {execution_result.get('stderr', 'Unknown error')}")
+                    if execution_result.get("error_traceback"):
+                        logger.error(f"User code traceback:\n{execution_result['error_traceback']}")
+                return execution_result
+            except json.JSONDecodeError as e:
+                error_msg = "Failed to parse execution output"
+                logger.error(f"{error_msg}: {str(e)}")
+                logger.error(f"Raw stdout: {result.stdout}")
+                logger.error(f"Raw stderr: {result.stderr}")
+                return {
+                    "stdout": result.stdout,
+                    "stderr": result.stderr,
+                    "success": False,
+                    "error": error_msg,
+                    "error_type": "JSONDecodeError"
+                }
+        else:
+            error_msg = f"Script execution failed with return code {result.returncode}"
+            logger.error(error_msg)
+            logger.error(f"stdout: {result.stdout}")
+            logger.error(f"stderr: {result.stderr}")
+            return {
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "success": False,
+                "error": error_msg,
+                "error_type": "SubprocessError"
+            }
+
+    except subprocess.TimeoutExpired:
+        error_msg = f"Code execution timed out after {timeout} seconds"
+        logger.error(error_msg)
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        return {
+            "stdout": "",
+            "stderr": "",
+            "success": False,
+            "error": error_msg,
+            "error_type": "TimeoutError"
+        }
+    except Exception as e:
+        error_msg = f"Execution error: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        return {
+            "stdout": "",
+            "stderr": "",
+            "success": False,
+            "error": error_msg,
+            "error_type": type(e).__name__
+        }