Server configuration added

.gitignore

@@ -205,3 +205,6 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# Cache
+cache/

.kiro/specs/hf-eda-mcp-server/tasks.md

@@ -38,7 +38,7 @@
     - Handle different data types (numerical, categorical, text) appropriately
     - _Requirements: 5.1, 5.2, 5.3, 5.4_
 
-- [ ] 4. Create Gradio interfaces and MCP server
+- [x] 4. Create Gradio interfaces and MCP server
   - [x] 4.1 Design Gradio interfaces for each EDA tool
     - Create Gradio interface for metadata retrieval with appropriate input/output components
     - Build interface for dataset sampling with split and sample size controls
@@ -51,7 +51,7 @@
     - Configure proper tool descriptions and schemas for MCP exposure
     - _Requirements: 3.1, 3.2, 3.3_
 
-  - [ ] 4.3 Add server configuration and startup
+  - [x] 4.3 Add server configuration and startup
     - Implement server launch function with configurable parameters
     - Add environment variable support for authentication and configuration
     - Include proper logging and error handling for server operations

CONFIGURATION.md

@@ -0,0 +1,104 @@
+# Configuration Guide
+
+The HF EDA MCP Server uses a centralized configuration system that supports both environment variables and command-line arguments.
+
+## Configuration Module
+
+The configuration is managed by the `src/hf_eda_mcp/config.py` module, which provides:
+
+- `ServerConfig` dataclass with all configuration options
+- Environment variable loading with `ServerConfig.from_env()`
+- Global configuration management with `get_config()` and `set_config()`
+- Logging setup and validation utilities
+
+## Configuration Options
+
+### Server Settings
+- `HF_EDA_PORT` (default: 7860) - Server port
+- `HF_EDA_HOST` (default: 127.0.0.1) - Server host
+- `HF_EDA_MCP_ENABLED` (default: true) - Enable MCP server functionality
+- `HF_EDA_SHARE` (default: false) - Enable public sharing via Gradio
+
+### Authentication
+- `HF_TOKEN` - HuggingFace access token for private datasets
+
+### Logging
+- `HF_EDA_LOG_LEVEL` (default: INFO) - Logging level (DEBUG, INFO, WARNING, ERROR)
+
+### Performance and Caching
+- `HF_EDA_CACHE_DIR` - Directory for caching datasets (optional)
+- `HF_EDA_MAX_CACHE_SIZE` (default: 1000) - Maximum cache size in MB
+- `HF_EDA_MAX_SAMPLE_SIZE` (default: 50000) - Maximum sample size for tools
+- `HF_EDA_MAX_CONCURRENT` (default: 10) - Maximum concurrent requests
+- `HF_EDA_REQUEST_TIMEOUT` (default: 300) - Request timeout in seconds
+
+## How Configuration is Used
+
+### Server Startup
+The server loads configuration from environment variables and applies command-line overrides:
+
+```python
+from hf_eda_mcp.config import ServerConfig
+from hf_eda_mcp.server import launch_server
+
+config = ServerConfig.from_env()
+launch_server(config)
+```
+
+### Tools Integration
+All EDA tools (metadata, sampling, analysis) use the global configuration:
+
+```python
+from hf_eda_mcp.config import get_config
+
+config = get_config()
+# Tools respect config.max_sample_size, config.cache_dir, config.hf_token
+```
+
+### Dataset Service
+The `DatasetService` is initialized with configuration values:
+
+```python
+service = DatasetService(
+    cache_dir=config.cache_dir,
+    token=config.hf_token
+)
+```
+
+## Configuration Priority
+
+1. Command-line arguments (highest priority)
+2. Environment variables
+3. Default values (lowest priority)
+
+## Example Usage
+
+### Environment Variables
+```bash
+export HF_TOKEN="your_token_here"
+export HF_EDA_CACHE_DIR="/tmp/hf-cache"
+export HF_EDA_MAX_SAMPLE_SIZE=25000
+pdm run hf-eda-mcp
+```
+
+### Command Line
+```bash
+pdm run hf-eda-mcp --cache-dir /tmp/cache --max-sample-size 25000 --verbose
+```
+
+### Configuration File
+Copy `config.example.env` to `.env` and modify as needed, then load with:
+```bash
+source .env
+pdm run hf-eda-mcp
+```
+
+## Validation
+
+The configuration system includes validation for:
+- Port ranges (1024-65535)
+- Cache directory permissions
+- Sample size limits
+- Timeout values
+
+Invalid configurations will cause the server to exit with helpful error messages.

MCP_USAGE.md

@@ -88,6 +88,18 @@ pdm run hf-eda-mcp --verbose
 
 # Start without MCP server functionality
 pdm run hf-eda-mcp --no-mcp
+
+# Start with custom host (listen on all interfaces)
+pdm run hf-eda-mcp --host 0.0.0.0
+
+# Start with public sharing enabled
+pdm run hf-eda-mcp --share
+
+# Start with custom cache directory
+pdm run hf-eda-mcp --cache-dir /path/to/cache
+
+# Start with custom maximum sample size
+pdm run hf-eda-mcp --max-sample-size 100000
 ```
 
 ### Server Modes
@@ -96,8 +108,48 @@ The server provides both a web interface and MCP server functionality in a singl
 
 ### Environment Variables
 
+The server supports comprehensive configuration via environment variables:
+
+#### Authentication
 - `HF_TOKEN`: HuggingFace access token for private datasets (optional)
 
+#### Server Configuration
+- `HF_EDA_PORT`: Server port (default: 7860)
+- `HF_EDA_HOST`: Server host (default: 127.0.0.1)
+- `HF_EDA_MCP_ENABLED`: Enable MCP server functionality (default: true)
+- `HF_EDA_SHARE`: Enable public sharing via Gradio (default: false)
+
+#### Logging Configuration
+- `HF_EDA_LOG_LEVEL`: Logging level - DEBUG, INFO, WARNING, ERROR (default: INFO)
+
+#### Performance and Caching
+- `HF_EDA_CACHE_DIR`: Directory for caching datasets (optional)
+- `HF_EDA_MAX_CACHE_SIZE`: Maximum cache size in MB (default: 1000)
+- `HF_EDA_MAX_SAMPLE_SIZE`: Maximum sample size for analysis (default: 50000)
+- `HF_EDA_MAX_CONCURRENT`: Maximum concurrent requests (default: 10)
+- `HF_EDA_REQUEST_TIMEOUT`: Request timeout in seconds (default: 300)
+
+### Configuration Examples
+
+#### Production Configuration
+```bash
+export HF_TOKEN="your_token_here"
+export HF_EDA_HOST="0.0.0.0"
+export HF_EDA_PORT="8080"
+export HF_EDA_LOG_LEVEL="WARNING"
+export HF_EDA_CACHE_DIR="/var/cache/hf-eda"
+export HF_EDA_MAX_CONCURRENT="20"
+pdm run hf-eda-mcp
+```
+
+#### Development Configuration
+```bash
+export HF_TOKEN="your_token_here"
+export HF_EDA_LOG_LEVEL="DEBUG"
+export HF_EDA_CACHE_DIR="./cache"
+pdm run hf-eda-mcp --verbose
+```
+
 ## Example Usage
 
 Once connected to an MCP client, you can use the tools like this:

config.example.env

@@ -0,0 +1,27 @@
+# HuggingFace EDA MCP Server Configuration Example
+# Copy this file to .env and modify as needed
+# All settings can also be passed as command-line arguments
+
+# Authentication
+HF_TOKEN=your_huggingface_token_here
+
+# Server Configuration
+HF_EDA_PORT=7860
+HF_EDA_HOST=127.0.0.1
+HF_EDA_MCP_ENABLED=true
+HF_EDA_SHARE=false
+
+# Logging Configuration
+HF_EDA_LOG_LEVEL=INFO
+
+# Performance and Caching
+# Cache directory for dataset metadata and samples
+HF_EDA_CACHE_DIR=./cache
+# Maximum cache size in MB
+HF_EDA_MAX_CACHE_SIZE=1000
+# Maximum sample size for analysis and sampling tools
+HF_EDA_MAX_SAMPLE_SIZE=50000
+# Maximum concurrent requests
+HF_EDA_MAX_CONCURRENT=10
+# Request timeout in seconds
+HF_EDA_REQUEST_TIMEOUT=300

pyproject.toml

@@ -23,7 +23,7 @@ build-backend = "pdm.backend"
 
 
 [tool.pdm.scripts]
-hf-eda-mcp = "python -m hf_eda_mcp"
+hf-eda-mcp = {cmd="python -m hf_eda_mcp", env_file= ".env"}
 hf_client_playground = "python -m scripts.playground.hf_client_playground"
 
 [tool.pdm]

src/hf_eda_mcp/__main__.py

@@ -7,6 +7,7 @@ python -m hf_eda_mcp
 
 import argparse
 import sys
+from .config import ServerConfig
 from .server import launch_server
 
 
@@ -18,21 +19,36 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
-  python -m hf_eda_mcp                    # Start server on default port 7860
+  python -m hf_eda_mcp                    # Start server with default settings
   python -m hf_eda_mcp --port 8080       # Start server on port 8080
   python -m hf_eda_mcp --no-mcp          # Start without MCP server functionality
   python -m hf_eda_mcp --share           # Create public shareable link
+  python -m hf_eda_mcp --host 0.0.0.0    # Listen on all interfaces
 
 Environment Variables:
-  HF_TOKEN    HuggingFace access token for private datasets
+  HF_TOKEN                    HuggingFace access token for private datasets
+  HF_EDA_PORT                 Server port (default: 7860)
+  HF_EDA_HOST                 Server host (default: 127.0.0.1)
+  HF_EDA_MCP_ENABLED          Enable MCP server (default: true)
+  HF_EDA_SHARE                Enable public sharing (default: false)
+  HF_EDA_LOG_LEVEL            Logging level (default: INFO)
+  HF_EDA_CACHE_DIR            Cache directory for datasets
+  HF_EDA_MAX_SAMPLE_SIZE      Maximum sample size (default: 50000)
+  HF_EDA_MAX_CONCURRENT       Max concurrent requests (default: 10)
+  HF_EDA_REQUEST_TIMEOUT      Request timeout in seconds (default: 300)
         """
     )
     
     parser.add_argument(
         "--port",
         type=int,
-        default=7860,
-        help="Port to run the server on (default: 7860)"
+        help="Port to run the server on (overrides HF_EDA_PORT)"
+    )
+    
+    parser.add_argument(
+        "--host",
+        type=str,
+        help="Host to bind the server to (overrides HF_EDA_HOST)"
     )
     
     parser.add_argument(
@@ -50,32 +66,53 @@ Environment Variables:
     parser.add_argument(
         "--verbose", "-v",
         action="store_true",
-        help="Enable verbose logging"
+        help="Enable verbose logging (DEBUG level)"
+    )
+    
+    parser.add_argument(
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        help="Set logging level (overrides HF_EDA_LOG_LEVEL)"
+    )
+    
+    parser.add_argument(
+        "--cache-dir",
+        type=str,
+        help="Directory for caching datasets (overrides HF_EDA_CACHE_DIR)"
+    )
+    
+    parser.add_argument(
+        "--max-sample-size",
+        type=int,
+        help="Maximum sample size for analysis (overrides HF_EDA_MAX_SAMPLE_SIZE)"
     )
     
     args = parser.parse_args()
     
-    # Configure logging level
+    # Load base configuration from environment
+    config = ServerConfig.from_env()
+    
+    # Override with command line arguments
+    if args.port is not None:
+        config.port = args.port
+    if args.host is not None:
+        config.host = args.host
+    if args.no_mcp:
+        config.mcp_server = False
+    if args.share:
+        config.share = True
     if args.verbose:
-        import logging
-        logging.getLogger().setLevel(logging.DEBUG)
-        logging.getLogger("hf_eda_mcp").setLevel(logging.DEBUG)
+        config.log_level = "DEBUG"
+    if args.log_level:
+        config.log_level = args.log_level
+    if args.cache_dir:
+        config.cache_dir = args.cache_dir
+    if args.max_sample_size is not None:
+        config.max_sample_size = args.max_sample_size
     
     try:
-        print(f"🚀 Starting HuggingFace EDA MCP Server...")
-        print(f"📊 Available tools: get_dataset_metadata, get_dataset_sample, analyze_dataset_features")
-        print(f"🌐 Web interface will be available at: http://localhost:{args.port}")
-        if not args.no_mcp:
-            print(f"🔗 MCP server functionality enabled")
-        if args.share:
-            print(f"🌍 Public sharing enabled")
-        print()
-        
-        launch_server(
-            port=args.port, 
-            mcp_server=not args.no_mcp,
-            share=args.share
-        )
+        # Launch server with configuration
+        launch_server(config)
     except KeyboardInterrupt:
         print("\n👋 Server stopped by user")
         sys.exit(0)

src/hf_eda_mcp/config.py

@@ -0,0 +1,164 @@
+"""
+Configuration management for the HF EDA MCP Server.
+
+This module provides configuration classes and utilities for managing
+server settings, authentication, caching, and performance parameters.
+"""
+
+import os
+import logging
+import sys
+from typing import Optional, Dict, Any
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ServerConfig:
+    """Configuration class for the HF EDA MCP Server."""
+
+    # Server settings
+    port: int = 7860
+    host: str = "127.0.0.1"
+    mcp_server: bool = True
+    share: bool = False
+
+    # Authentication settings
+    hf_token: Optional[str] = None
+
+    # Logging settings
+    log_level: str = "INFO"
+    log_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    # Cache settings
+    cache_dir: Optional[str] = None
+    max_cache_size: int = 1000  # MB
+
+    # Performance settings
+    max_sample_size: int = 50000
+    max_concurrent_requests: int = 10
+    request_timeout: int = 300  # seconds
+
+    # Additional Gradio settings
+    gradio_settings: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_env(cls) -> "ServerConfig":
+        """Create configuration from environment variables."""
+        config = cls()
+
+        # Server settings
+        config.port = int(os.getenv("HF_EDA_PORT", config.port))
+        config.host = os.getenv("HF_EDA_HOST", config.host)
+        config.mcp_server = os.getenv("HF_EDA_MCP_ENABLED", "true").lower() == "true"
+        config.share = os.getenv("HF_EDA_SHARE", "false").lower() == "true"
+
+        # Authentication
+        config.hf_token = os.getenv("HF_TOKEN")
+
+        # Logging
+        config.log_level = os.getenv("HF_EDA_LOG_LEVEL", config.log_level).upper()
+
+        # Cache settings
+        config.cache_dir = os.getenv("HF_EDA_CACHE_DIR")
+        config.max_cache_size = int(
+            os.getenv("HF_EDA_MAX_CACHE_SIZE", config.max_cache_size)
+        )
+
+        # Performance settings
+        config.max_sample_size = int(
+            os.getenv("HF_EDA_MAX_SAMPLE_SIZE", config.max_sample_size)
+        )
+        config.max_concurrent_requests = int(
+            os.getenv("HF_EDA_MAX_CONCURRENT", config.max_concurrent_requests)
+        )
+        config.request_timeout = int(
+            os.getenv("HF_EDA_REQUEST_TIMEOUT", config.request_timeout)
+        )
+
+        return config
+
+
+def setup_logging(config: ServerConfig) -> logging.Logger:
+    """Set up logging configuration."""
+    # Configure root logger
+    logging.basicConfig(
+        level=getattr(logging, config.log_level),
+        format=config.log_format,
+        handlers=[
+            logging.StreamHandler(sys.stdout),
+        ],
+    )
+
+    # Create logger for this module
+    logger = logging.getLogger(__name__)
+
+    # Set specific log levels for external libraries
+    logging.getLogger("gradio").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+    return logger
+
+
+def validate_config(config: ServerConfig) -> None:
+    """Validate server configuration and log warnings for potential issues."""
+    logger = logging.getLogger(__name__)
+
+    # Validate port range
+    if not (1024 <= config.port <= 65535):
+        logger.warning(
+            f"Port {config.port} may require elevated privileges or be invalid"
+        )
+
+    # Check cache directory
+    if config.cache_dir:
+        try:
+            os.makedirs(config.cache_dir, exist_ok=True)
+            if not os.access(config.cache_dir, os.W_OK):
+                logger.error(f"Cache directory {config.cache_dir} is not writable")
+                raise PermissionError(
+                    f"Cannot write to cache directory: {config.cache_dir}"
+                )
+        except Exception as e:
+            logger.error(
+                f"Failed to create/access cache directory {config.cache_dir}: {e}"
+            )
+            raise
+
+    # Validate performance settings
+    if config.max_sample_size > 100000:
+        logger.warning(
+            f"Large max_sample_size ({config.max_sample_size}) may cause memory issues"
+        )
+
+    if config.request_timeout < 30:
+        logger.warning(
+            f"Short request timeout ({config.request_timeout}s) may cause failures for large datasets"
+        )
+
+    # Check authentication
+    if not config.hf_token:
+        logger.warning(
+            "No HuggingFace token configured - only public datasets will be accessible"
+        )
+        logger.info("Set HF_TOKEN environment variable to access private datasets")
+    else:
+        logger.info("HuggingFace token configured - private datasets accessible")
+
+
+# Global configuration instance
+_global_config: Optional[ServerConfig] = None
+
+
+def get_config() -> ServerConfig:
+    """Get the global configuration instance."""
+    global _global_config
+    if _global_config is None:
+        _global_config = ServerConfig.from_env()
+    return _global_config
+
+
+def set_config(config: ServerConfig) -> None:
+    """Set the global configuration instance."""
+    global _global_config
+    _global_config = config

src/hf_eda_mcp/server.py

@@ -6,26 +6,22 @@ creating Gradio interfaces for EDA tools and enabling MCP server functionality.
 """
 
 import gradio as gr
-import os
-import logging
+import sys
+from typing import Optional
+
+# Import configuration
+from hf_eda_mcp.config import ServerConfig, setup_logging, validate_config, set_config
 
 # Import EDA tools - these will be automatically exposed as MCP tools
 from hf_eda_mcp.tools.metadata import get_dataset_metadata
 from hf_eda_mcp.tools.sampling import get_dataset_sample
 from hf_eda_mcp.tools.analysis import analyze_dataset_features
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-
-
 
 # These functions will be automatically exposed as MCP tools when mcp_server=True
 
 
-def create_gradio_app() -> gr.Blocks:
+def create_gradio_app(config: ServerConfig) -> gr.Blocks:
     """Create and configure the main Gradio application with MCP server."""
 
     # Create main app with MCP tool interfaces
@@ -55,14 +51,14 @@ def create_gradio_app() -> gr.Blocks:
                 fn=get_dataset_metadata,
                 inputs=[
                     gr.Textbox(
-                        label="dataset_id", 
+                        label="dataset_id",
                         placeholder="e.g., imdb, squad, glue",
-                        info="HuggingFace dataset identifier"
+                        info="HuggingFace dataset identifier",
                     ),
                     gr.Textbox(
-                        label="config_name", 
+                        label="config_name",
                         placeholder="e.g., cola, sst2 (optional)",
-                        info="Configuration name for multi-config datasets"
+                        info="Configuration name for multi-config datasets",
                     ),
                 ],
                 outputs=gr.JSON(label="Dataset Metadata"),
@@ -81,9 +77,9 @@ def create_gradio_app() -> gr.Blocks:
                 fn=get_dataset_sample,
                 inputs=[
                     gr.Textbox(
-                        label="dataset_id", 
+                        label="dataset_id",
                         placeholder="e.g., imdb, squad, glue",
-                        info="HuggingFace dataset identifier"
+                        info="HuggingFace dataset identifier",
                     ),
                     gr.Dropdown(
                         choices=["train", "validation", "test", "dev", "val"],
@@ -101,9 +97,9 @@ def create_gradio_app() -> gr.Blocks:
                         info="Number of samples to retrieve (max: 10000 for MCP)",
                     ),
                     gr.Textbox(
-                        label="config_name", 
+                        label="config_name",
                         placeholder="e.g., cola, sst2 (optional)",
-                        info="Configuration name for multi-config datasets"
+                        info="Configuration name for multi-config datasets",
                     ),
                 ],
                 outputs=gr.JSON(label="Dataset Sample"),
@@ -122,9 +118,9 @@ def create_gradio_app() -> gr.Blocks:
                 fn=analyze_dataset_features,
                 inputs=[
                     gr.Textbox(
-                        label="dataset_id", 
+                        label="dataset_id",
                         placeholder="e.g., imdb, squad, glue",
-                        info="HuggingFace dataset identifier"
+                        info="HuggingFace dataset identifier",
                     ),
                     gr.Dropdown(
                         choices=["train", "validation", "test", "dev", "val"],
@@ -142,9 +138,9 @@ def create_gradio_app() -> gr.Blocks:
                         info="Number of samples to use for analysis (max: 50000 for MCP)",
                     ),
                     gr.Textbox(
-                        label="config_name", 
+                        label="config_name",
                         placeholder="e.g., cola, sst2 (optional)",
-                        info="Configuration name for multi-config datasets"
+                        info="Configuration name for multi-config datasets",
                     ),
                 ],
                 outputs=gr.JSON(label="Analysis Results"),
@@ -193,8 +189,11 @@ def create_gradio_app() -> gr.Blocks:
                 ### Server Status
                 
                 - **MCP Tools**: 3 tools available
-                - **Authentication**: {"✅ Token configured" if os.getenv("HF_TOKEN") else "⚠️ No token (public datasets only)"}
+                - **Authentication**: {"✅ Token configured" if config.hf_token else "⚠️ No token (public datasets only)"}
                 - **MCP Schema**: Available at `/gradio_api/mcp/schema`
+                - **Cache Directory**: {config.cache_dir or "Default system cache"}
+                - **Max Sample Size**: {config.max_sample_size:,}
+                - **Request Timeout**: {config.request_timeout}s
                 """
             )
 
@@ -202,56 +201,131 @@ def create_gradio_app() -> gr.Blocks:
 
 
 def launch_server(
-    port: int = 7860, mcp_server: bool = True, share: bool = False
+    config: Optional[ServerConfig] = None,
+    port: Optional[int] = None,
+    mcp_server: Optional[bool] = None,
+    share: Optional[bool] = None,
 ) -> None:
     """
     Launch the Gradio app with MCP server enabled.
 
     Args:
-        port: Port to run the server on (default: 7860)
-        mcp_server: Whether to enable MCP server functionality (default: True)
-        share: Whether to create a public shareable link (default: False)
+        config: Server configuration object. If None, loads from environment
+        port: Port to run the server on (overrides config)
+        mcp_server: Whether to enable MCP server functionality (overrides config)
+        share: Whether to create a public shareable link (overrides config)
     """
-    logger.info(f"Starting HF EDA MCP Server on port {port}")
-    logger.info(f"MCP server enabled: {mcp_server}")
+    # Load configuration
+    if config is None:
+        config = ServerConfig.from_env()
 
-    # Check for HuggingFace token
-    hf_token = os.getenv("HF_TOKEN")
-    if hf_token:
-        logger.info("HuggingFace token found - private datasets accessible")
-    else:
-        logger.warning("No HuggingFace token found - only public datasets accessible")
+    # Override config with explicit parameters
+    if port is not None:
+        config.port = port
+    if mcp_server is not None:
+        config.mcp_server = mcp_server
+    if share is not None:
+        config.share = share
+
+    # Set global configuration for tools to use
+    set_config(config)
+    
+    # Set up logging
+    logger = setup_logging(config)
+
+    logger.info("=" * 60)
+    logger.info("🚀 Starting HuggingFace EDA MCP Server")
+    logger.info("=" * 60)
+
+    # Validate configuration
+    try:
+        validate_config(config)
+    except Exception as e:
+        logger.error(f"Configuration validation failed: {e}")
+        sys.exit(1)
+
+    # Log configuration
+    logger.info("Server configuration:")
+    logger.info(f"  - Host: {config.host}")
+    logger.info(f"  - Port: {config.port}")
+    logger.info(f"  - MCP server enabled: {config.mcp_server}")
+    logger.info(f"  - Share enabled: {config.share}")
+    logger.info(f"  - Log level: {config.log_level}")
+    logger.info(f"  - Cache directory: {config.cache_dir or 'Default system cache'}")
+    logger.info(f"  - Max sample size: {config.max_sample_size:,}")
+    logger.info(f"  - Request timeout: {config.request_timeout}s")
+    logger.info(f"  - Max concurrent requests: {config.max_concurrent_requests}")
 
     # Create the Gradio app
-    app = create_gradio_app()
-    logger.info("Created Gradio application with EDA tools")
+    try:
+        logger.info("Creating Gradio application with EDA tools...")
+        app = create_gradio_app(config)
+        logger.info("✅ Gradio application created successfully")
+    except Exception as e:
+        logger.error(f"Failed to create Gradio application: {e}")
+        logger.exception("Full traceback:")
+        sys.exit(1)
 
     # Configure launch parameters
     launch_kwargs = {
-        "server_port": port,
-        "share": share,
+        "server_name": config.host,
+        "server_port": config.port,
+        "share": config.share,
         "show_error": True,
         "quiet": False,
         "show_api": True,  # Enable API documentation
+        "max_threads": config.max_concurrent_requests,
     }
 
+    # Add additional Gradio settings from config
+    launch_kwargs.update(config.gradio_settings)
+
     # Add MCP server configuration
-    if mcp_server:
+    if config.mcp_server:
         launch_kwargs["mcp_server"] = True
-        logger.info("MCP server functionality enabled")
-        logger.info("MCP tools will be available at /gradio_api/mcp/schema")
-        logger.info("3 EDA tools will be exposed: get_dataset_metadata, get_dataset_sample, analyze_dataset_features")
+        logger.info("🔗 MCP server functionality enabled")
+        logger.info("📊 MCP tools available:")
+        logger.info("  - get_dataset_metadata: Retrieve dataset information")
+        logger.info("  - get_dataset_sample: Sample data from datasets")
+        logger.info("  - analyze_dataset_features: Perform EDA analysis")
+        logger.info(
+            f"🌐 MCP schema available at: http://{config.host}:{config.port}/gradio_api/mcp/schema"
+        )
     else:
-        logger.info("Running in web-only mode (MCP disabled)")
+        logger.info("🌐 Running in web-only mode (MCP disabled)")
 
     # Launch the server
     try:
-        logger.info("Launching Gradio application...")
+        logger.info("🚀 Launching Gradio application...")
+        logger.info(f"🌐 Web interface: http://{config.host}:{config.port}")
+        if config.share:
+            logger.info("🌍 Public sharing enabled - shareable link will be generated")
+
+        logger.info("=" * 60)
+        logger.info("Server is starting... Press Ctrl+C to stop")
+        logger.info("=" * 60)
+
         app.launch(**launch_kwargs)
+
+    except KeyboardInterrupt:
+        logger.info("👋 Server stopped by user (Ctrl+C)")
+        sys.exit(0)
+    except OSError as e:
+        if "Address already in use" in str(e):
+            logger.error(f"❌ Port {config.port} is already in use")
+            logger.info(
+                "💡 Try using a different port with --port or HF_EDA_PORT environment variable"
+            )
+        else:
+            logger.error(f"❌ Network error: {e}")
+        sys.exit(1)
     except Exception as e:
-        logger.error(f"Failed to launch server: {e}")
-        raise
+        logger.error(f"❌ Failed to launch server: {e}")
+        logger.exception("Full traceback:")
+        sys.exit(1)
 
 
 if __name__ == "__main__":
-    launch_server()
+    # Load configuration from environment and launch server
+    config = ServerConfig.from_env()
+    launch_server(config)

src/hf_eda_mcp/tools/analysis.py

@@ -9,6 +9,7 @@ import logging
 import statistics
 from typing import Optional, Dict, Any, List
 from collections import Counter
+from hf_eda_mcp.config import get_config
 from hf_eda_mcp.services.dataset_service import DatasetService, DatasetServiceError
 from hf_eda_mcp.integrations.hf_client import DatasetNotFoundError, AuthenticationError
 
@@ -17,17 +18,20 @@ logger = logging.getLogger(__name__)
 # Global dataset service instance
 _dataset_service: Optional[DatasetService] = None
 
-# Constants for analysis
+# Default constants (can be overridden by config)
 DEFAULT_ANALYSIS_SAMPLE_SIZE = 1000
-MAX_ANALYSIS_SAMPLE_SIZE = 50000
 MAX_UNIQUE_VALUES_TO_SHOW = 20
 
 
 def get_dataset_service() -> DatasetService:
-    """Get or create the global dataset service instance."""
+    """Get or create the global dataset service instance using current config."""
     global _dataset_service
     if _dataset_service is None:
-        _dataset_service = DatasetService()
+        config = get_config()
+        _dataset_service = DatasetService(
+            cache_dir=config.cache_dir,
+            token=config.hf_token
+        )
     return _dataset_service
 
 
@@ -531,8 +535,12 @@ def validate_analysis_inputs(
     if sample_size <= 0:
         raise ValueError("sample_size must be positive")
 
-    if sample_size > MAX_ANALYSIS_SAMPLE_SIZE:
-        raise ValueError(f"sample_size cannot exceed {MAX_ANALYSIS_SAMPLE_SIZE}")
+    # Get max sample size from config
+    config = get_config()
+    max_sample_size = config.max_sample_size
+    
+    if sample_size > max_sample_size:
+        raise ValueError(f"sample_size cannot exceed {max_sample_size}")
 
     # Validate config_name
     if config_name is not None:

src/hf_eda_mcp/tools/metadata.py

@@ -7,6 +7,7 @@ HuggingFace datasets including size, features, splits, and configuration details
 
 import logging
 from typing import Optional, Dict, Any
+from hf_eda_mcp.config import get_config
 from hf_eda_mcp.services.dataset_service import DatasetService, DatasetServiceError
 from hf_eda_mcp.integrations.hf_client import DatasetNotFoundError, AuthenticationError
 
@@ -17,10 +18,14 @@ _dataset_service: Optional[DatasetService] = None
 
 
 def get_dataset_service() -> DatasetService:
-    """Get or create the global dataset service instance."""
+    """Get or create the global dataset service instance using current config."""
     global _dataset_service
     if _dataset_service is None:
-        _dataset_service = DatasetService()
+        config = get_config()
+        _dataset_service = DatasetService(
+            cache_dir=config.cache_dir,
+            token=config.hf_token
+        )
     return _dataset_service
 
 

src/hf_eda_mcp/tools/sampling.py

@@ -7,6 +7,7 @@ with support for different splits, configurable sample sizes, and streaming for
 
 import logging
 from typing import Optional, Dict, Any, List
+from hf_eda_mcp.config import get_config
 from hf_eda_mcp.services.dataset_service import DatasetService, DatasetServiceError
 from hf_eda_mcp.integrations.hf_client import DatasetNotFoundError, AuthenticationError
 
@@ -15,17 +16,19 @@ logger = logging.getLogger(__name__)
 # Global dataset service instance
 _dataset_service: Optional[DatasetService] = None
 
-# Constants for sampling limits
-MAX_SAMPLE_SIZE = 10000  # Maximum samples to prevent memory issues
+# Default constants (can be overridden by config)
 DEFAULT_SAMPLE_SIZE = 10
-VALID_SPLITS = {'train', 'validation', 'test', 'dev', 'val'}
+VALID_SPLITS = {"train", "validation", "test", "dev", "val"}
 
 
 def get_dataset_service() -> DatasetService:
-    """Get or create the global dataset service instance."""
+    """Get or create the global dataset service instance using current config."""
     global _dataset_service
     if _dataset_service is None:
-        _dataset_service = DatasetService()
+        config = get_config()
+        _dataset_service = DatasetService(
+            cache_dir=config.cache_dir, token=config.hf_token
+        )
     return _dataset_service
 
 
@@ -34,22 +37,22 @@ def get_dataset_sample(
     split: str = "train",
     num_samples: int = DEFAULT_SAMPLE_SIZE,
     config_name: Optional[str] = None,
-    streaming: bool = True
+    streaming: bool = True,
 ) -> Dict[str, Any]:
     """
     Retrieve a sample of rows from a HuggingFace dataset.
-    
+
     This function efficiently samples data from datasets with support for different
     splits and configurable sample sizes. It uses streaming by default for large
     datasets to minimize memory usage and loading time.
-    
+
     Args:
         dataset_id: HuggingFace dataset identifier (e.g., 'imdb', 'squad', 'glue')
         split: Dataset split to sample from (default: 'train')
         num_samples: Number of samples to retrieve (default: 10, max: 10000)
         config_name: Optional configuration name for multi-config datasets
         streaming: Whether to use streaming mode for efficient loading (default: True)
-        
+
     Returns:
         Dictionary containing sampled data and metadata:
         - dataset_id: Original dataset identifier
@@ -60,31 +63,33 @@ def get_dataset_sample(
         - data: List of sample dictionaries
         - schema: Dictionary describing the dataset features/columns
         - sample_info: Additional information about the sampling process
-        
+
     Raises:
         ValueError: If inputs are invalid (empty dataset_id, invalid split, etc.)
         DatasetNotFoundError: If dataset or split doesn't exist
         AuthenticationError: If dataset is private and authentication fails
         DatasetServiceError: If sampling fails for other reasons
-        
+
     Example:
         >>> # Basic sampling
         >>> sample = get_dataset_sample("imdb", split="train", num_samples=5)
         >>> print(f"Got {sample['num_samples']} samples from {sample['dataset_id']}")
         >>> for i, row in enumerate(sample['data']):
         ...     print(f"Sample {i+1}: {list(row.keys())}")
-        
+
         >>> # Multi-config dataset sampling
-        >>> sample = get_dataset_sample("glue", split="validation", 
+        >>> sample = get_dataset_sample("glue", split="validation",
         ...                           num_samples=3, config_name="cola")
         >>> print(f"Schema: {sample['schema']}")
     """
     # Input validation
     validate_sampling_inputs(dataset_id, split, num_samples, config_name)
-    
-    logger.info(f"Sampling {num_samples} rows from dataset: {dataset_id}, "
-                f"split: {split}" + (f", config: {config_name}" if config_name else ""))
-    
+
+    logger.info(
+        f"Sampling {num_samples} rows from dataset: {dataset_id}, "
+        f"split: {split}" + (f", config: {config_name}" if config_name else "")
+    )
+
     try:
         # Get dataset service and load sample
         service = get_dataset_service()
@@ -93,33 +98,40 @@ def get_dataset_sample(
             split=split,
             num_samples=num_samples,
             config_name=config_name,
-            streaming=streaming
+            streaming=streaming,
         )
-        
+
         # Enhance the response with additional metadata
-        sample_data['sample_info'] = {
-            'streaming_used': streaming,
-            'sampling_strategy': 'sequential_head',  # We take first N samples
-            'max_sample_size': MAX_SAMPLE_SIZE,
-            'truncated': sample_data['num_samples'] < sample_data['requested_samples']
+        config = get_config()
+        sample_data["sample_info"] = {
+            "streaming_used": streaming,
+            "sampling_strategy": "sequential_head",  # We take first N samples
+            "max_sample_size": config.max_sample_size,
+            "truncated": sample_data["num_samples"] < sample_data["requested_samples"],
         }
-        
+
         # Add data preview information
-        if sample_data['data']:
-            first_sample = sample_data['data'][0]
-            sample_data['sample_info']['preview'] = {
-                'columns': list(first_sample.keys()) if isinstance(first_sample, dict) else [],
-                'first_sample_types': {
+        if sample_data["data"]:
+            first_sample = sample_data["data"][0]
+            sample_data["sample_info"]["preview"] = {
+                "columns": list(first_sample.keys())
+                if isinstance(first_sample, dict)
+                else [],
+                "first_sample_types": {
                     k: type(v).__name__ for k, v in first_sample.items()
-                } if isinstance(first_sample, dict) else {}
+                }
+                if isinstance(first_sample, dict)
+                else {},
             }
-        
+
         # Add summary
-        sample_data['summary'] = _generate_sample_summary(sample_data)
-        
-        logger.info(f"Successfully sampled {sample_data['num_samples']} rows from {dataset_id}")
+        sample_data["summary"] = _generate_sample_summary(sample_data)
+
+        logger.info(
+            f"Successfully sampled {sample_data['num_samples']} rows from {dataset_id}"
+        )
         return sample_data
-        
+
     except (DatasetNotFoundError, AuthenticationError):
         # Re-raise these specific errors as-is
         raise
@@ -132,23 +144,23 @@ def get_dataset_sample_with_indices(
     dataset_id: str,
     indices: List[int],
     split: str = "train",
-    config_name: Optional[str] = None
+    config_name: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     Retrieve specific samples by their indices from a HuggingFace dataset.
-    
+
     This function allows for targeted sampling by specifying exact row indices.
     Note: This requires loading the dataset in non-streaming mode.
-    
+
     Args:
         dataset_id: HuggingFace dataset identifier
         indices: List of row indices to retrieve
         split: Dataset split to sample from (default: 'train')
         config_name: Optional configuration name for multi-config datasets
-        
+
     Returns:
         Dictionary containing the requested samples and metadata
-        
+
     Raises:
         ValueError: If inputs are invalid
         DatasetServiceError: If sampling fails
@@ -156,116 +168,119 @@ def get_dataset_sample_with_indices(
     # Input validation
     if not indices or not isinstance(indices, list):
         raise ValueError("indices must be a non-empty list")
-    
+
     if not all(isinstance(i, int) and i >= 0 for i in indices):
         raise ValueError("All indices must be non-negative integers")
-    
-    if len(indices) > MAX_SAMPLE_SIZE:
-        raise ValueError(f"Too many indices requested. Maximum: {MAX_SAMPLE_SIZE}")
-    
+
+    config = get_config()
+    if len(indices) > config.max_sample_size:
+        raise ValueError(
+            f"Too many indices requested. Maximum: {config.max_sample_size}"
+        )
+
     validate_sampling_inputs(dataset_id, split, len(indices), config_name)
-    
+
     logger.info(f"Sampling {len(indices)} specific indices from dataset: {dataset_id}")
-    
+
     try:
         from datasets import load_dataset
-        
+
         # Load dataset without streaming to access by index
         dataset = load_dataset(
-            dataset_id,
-            name=config_name,
-            split=split,
-            streaming=False
+            dataset_id, name=config_name, split=split, streaming=False
         )
-        
+
         # Validate indices are within bounds
         max_index = max(indices)
         if max_index >= len(dataset):
-            raise ValueError(f"Index {max_index} is out of bounds for dataset with {len(dataset)} rows")
-        
+            raise ValueError(
+                f"Index {max_index} is out of bounds for dataset with {len(dataset)} rows"
+            )
+
         # Get samples by indices
         samples = [dataset[i] for i in indices]
-        
+
         # Get dataset info for schema
         service = get_dataset_service()
         dataset_info = service.load_dataset_info(dataset_id, config_name)
-        
+
         # Prepare response
         sample_data = {
-            'dataset_id': dataset_id,
-            'config_name': config_name,
-            'split': split,
-            'num_samples': len(samples),
-            'requested_indices': indices,
-            'data': samples,
-            'schema': dataset_info.get('features', {}),
-            'sample_info': {
-                'sampling_strategy': 'by_indices',
-                'streaming_used': False,
-                'indices_requested': len(indices)
-            }
+            "dataset_id": dataset_id,
+            "config_name": config_name,
+            "split": split,
+            "num_samples": len(samples),
+            "requested_indices": indices,
+            "data": samples,
+            "schema": dataset_info.get("features", {}),
+            "sample_info": {
+                "sampling_strategy": "by_indices",
+                "streaming_used": False,
+                "indices_requested": len(indices),
+            },
         }
-        
-        sample_data['summary'] = _generate_sample_summary(sample_data)
-        
+
+        sample_data["summary"] = _generate_sample_summary(sample_data)
+
         return sample_data
-        
+
     except Exception as e:
         logger.error(f"Failed to sample by indices from {dataset_id}: {str(e)}")
         raise DatasetServiceError(f"Failed to sample by indices: {str(e)}")
 
 
 def validate_sampling_inputs(
-    dataset_id: str,
-    split: str,
-    num_samples: int,
-    config_name: Optional[str] = None
+    dataset_id: str, split: str, num_samples: int, config_name: Optional[str] = None
 ) -> None:
     """
     Validate inputs for dataset sampling.
-    
+
     Args:
         dataset_id: Dataset identifier to validate
         split: Split name to validate
         num_samples: Number of samples to validate
         config_name: Optional configuration name to validate
-        
+
     Raises:
         ValueError: If any input is invalid
     """
     # Validate dataset_id
     if not dataset_id or not isinstance(dataset_id, str):
         raise ValueError("dataset_id must be a non-empty string")
-    
+
     dataset_id = dataset_id.strip()
     if not dataset_id:
         raise ValueError("dataset_id cannot be empty or whitespace")
-    
+
     # Validate split
     if not split or not isinstance(split, str):
         raise ValueError("split must be a non-empty string")
-    
+
     split = split.strip().lower()
     if not split:
         raise ValueError("split cannot be empty or whitespace")
-    
+
     # Note: We don't strictly enforce VALID_SPLITS as datasets may have custom split names
-    
+
     # Validate num_samples
     if not isinstance(num_samples, int):
         raise ValueError("num_samples must be an integer")
-    
+
     if num_samples <= 0:
         raise ValueError("num_samples must be positive")
-    
-    if num_samples > MAX_SAMPLE_SIZE:
-        raise ValueError(f"num_samples cannot exceed {MAX_SAMPLE_SIZE}")
-    
+
+    # Get max sample size from config
+    config = get_config()
+    max_sample_size = config.max_sample_size
+
+    if num_samples > max_sample_size:
+        raise ValueError(f"num_samples cannot exceed {max_sample_size}")
+
     # Validate config_name
     if config_name is not None:
         if not isinstance(config_name, str):
             raise ValueError("config_name must be a string")
-        
+
         config_name = config_name.strip()
         if not config_name:
             raise ValueError("config_name cannot be empty or whitespace")
@@ -274,57 +289,59 @@ def validate_sampling_inputs(
 def _generate_sample_summary(sample_data: Dict[str, Any]) -> str:
     """Generate a human-readable summary of the sample data."""
     summary_parts = []
-    
+
     # Basic info
     summary_parts.append(f"Dataset: {sample_data.get('dataset_id', 'Unknown')}")
     summary_parts.append(f"Split: {sample_data.get('split', 'Unknown')}")
-    
-    if sample_data.get('config_name'):
+
+    if sample_data.get("config_name"):
         summary_parts.append(f"Config: {sample_data['config_name']}")
-    
+
     # Sample info
-    num_samples = sample_data.get('num_samples', 0)
-    requested = sample_data.get('requested_samples', num_samples)
-    
+    num_samples = sample_data.get("num_samples", 0)
+    requested = sample_data.get("requested_samples", num_samples)
+
     if num_samples == requested:
         summary_parts.append(f"Samples: {num_samples}")
     else:
         summary_parts.append(f"Samples: {num_samples}/{requested} (truncated)")
-    
+
     # Schema info
-    schema = sample_data.get('schema', {})
+    schema = sample_data.get("schema", {})
     if schema:
         summary_parts.append(f"Columns: {len(schema)}")
-    
+
     # Sampling strategy
-    sample_info = sample_data.get('sample_info', {})
-    strategy = sample_info.get('sampling_strategy', 'unknown')
-    if strategy == 'by_indices':
+    sample_info = sample_data.get("sample_info", {})
+    strategy = sample_info.get("sampling_strategy", "unknown")
+    if strategy == "by_indices":
         summary_parts.append("Strategy: by indices")
-    elif strategy == 'sequential_head':
+    elif strategy == "sequential_head":
         summary_parts.append("Strategy: first N rows")
-    
+
     return " | ".join(summary_parts)
 
 
-def get_available_splits(dataset_id: str, config_name: Optional[str] = None) -> List[str]:
+def get_available_splits(
+    dataset_id: str, config_name: Optional[str] = None
+) -> List[str]:
     """
     Get available splits for a dataset.
-    
+
     Args:
         dataset_id: HuggingFace dataset identifier
         config_name: Optional configuration name
-        
+
     Returns:
         List of available split names
-        
+
     Raises:
         DatasetServiceError: If unable to retrieve split information
     """
     try:
         service = get_dataset_service()
         metadata = service.load_dataset_info(dataset_id, config_name)
-        return list(metadata.get('splits', {}).keys())
+        return list(metadata.get("splits", {}).keys())
     except Exception as e:
         logger.error(f"Failed to get splits for {dataset_id}: {str(e)}")
-        raise DatasetServiceError(f"Failed to get available splits: {str(e)}")
+        raise DatasetServiceError(f"Failed to get available splits: {str(e)}")