Set up base gradio server

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

@@ -0,0 +1,305 @@
+# Design Document
+
+## Overview
+
+The hf-eda-mcp system is designed as a Gradio-based MCP server that provides exploratory data analysis tools for HuggingFace datasets. The system leverages Gradio's built-in MCP server capabilities to automatically expose EDA functions as MCP tools, enabling seamless integration with AI assistants and other MCP-compatible systems.
+
+The architecture follows a modular approach where core EDA functionality is implemented as separate Python functions, which are then wrapped in Gradio interfaces and automatically converted to MCP tools through Gradio's native MCP integration.
+
+## Architecture
+
+### High-Level Architecture
+
+```mermaid
+graph TB
+    subgraph "MCP Client (AI Assistant)"
+        A[AI Assistant]
+    end
+    
+    subgraph "hf-eda-mcp Server"
+        B[Gradio App with MCP Server]
+        C[EDA Tools Module]
+        D[Dataset Service]
+        E[HuggingFace Integration]
+    end
+    
+    subgraph "External Services"
+        F[HuggingFace Hub]
+    end
+    
+    A -->|MCP Protocol| B
+    B --> C
+    C --> D
+    D --> E
+    E -->|API Calls| F
+```
+
+### Component Architecture
+
+The system is organized into the following key components:
+
+1. **Gradio MCP Server**: The main application that hosts the MCP server and web interface
+2. **EDA Tools Module**: Core analysis functions for dataset exploration
+3. **Dataset Service**: Handles dataset loading, caching, and metadata retrieval
+4. **HuggingFace Integration**: Manages authentication and API interactions with HF Hub
+
+## Components and Interfaces
+
+### 1. Gradio MCP Server (`src/hf_eda_mcp/server.py`)
+
+**Purpose**: Main application entry point that creates Gradio interfaces for EDA tools and enables MCP server functionality.
+
+**Key Responsibilities**:
+- Initialize Gradio app with MCP server enabled
+- Define Gradio interfaces for each EDA tool
+- Handle MCP protocol communication
+- Manage server configuration and startup
+
+**Interface**:
+```python
+def create_gradio_app() -> gr.Blocks:
+    """Create and configure the main Gradio application with MCP server."""
+    
+def launch_server(port: int = 7860, mcp_server: bool = True) -> None:
+    """Launch the Gradio app with MCP server enabled."""
+```
+
+### 2. EDA Tools Module (`src/hf_eda_mcp/tools/`)
+
+**Purpose**: Contains individual EDA functions that will be exposed as MCP tools.
+
+#### Dataset Metadata Tool (`tools/metadata.py`)
+```python
+def get_dataset_metadata(dataset_id: str, config_name: str = None) -> dict:
+    """
+    Retrieve comprehensive metadata for a HuggingFace dataset.
+    
+    Args:
+        dataset_id: HuggingFace dataset identifier (e.g., 'squad', 'glue')
+        config_name: Optional configuration name for multi-config datasets
+        
+    Returns:
+        Dictionary containing dataset metadata including:
+        - Basic info (size, splits, features)
+        - Configuration details
+        - Download statistics
+        - Dataset card information
+    """
+```
+
+#### Dataset Sampling Tool (`tools/sampling.py`)
+```python
+def get_dataset_sample(
+    dataset_id: str, 
+    split: str = "train", 
+    num_samples: int = 10,
+    config_name: str = None
+) -> dict:
+    """
+    Retrieve a sample of rows from a HuggingFace dataset.
+    
+    Args:
+        dataset_id: HuggingFace dataset identifier
+        split: Dataset split to sample from
+        num_samples: Number of samples to retrieve
+        config_name: Optional configuration name
+        
+    Returns:
+        Dictionary containing sampled data and metadata
+    """
+```
+
+#### Basic Analysis Tool (`tools/analysis.py`)
+```python
+def analyze_dataset_features(
+    dataset_id: str,
+    split: str = "train",
+    sample_size: int = 1000,
+    config_name: str = None
+) -> dict:
+    """
+    Perform basic exploratory analysis on dataset features.
+    
+    Args:
+        dataset_id: HuggingFace dataset identifier
+        split: Dataset split to analyze
+        sample_size: Number of samples to use for analysis
+        config_name: Optional configuration name
+        
+    Returns:
+        Dictionary containing feature analysis results:
+        - Feature types and distributions
+        - Missing value statistics
+        - Summary statistics for numerical features
+        - Unique value counts for categorical features
+    """
+```
+
+### 3. Dataset Service (`src/hf_eda_mcp/services/dataset_service.py`)
+
+**Purpose**: Centralized service for dataset operations, caching, and metadata management.
+
+**Key Responsibilities**:
+- Load datasets from HuggingFace Hub
+- Cache dataset metadata and samples
+- Handle authentication for private datasets
+- Manage dataset configuration and splits
+
+**Interface**:
+```python
+class DatasetService:
+    def __init__(self, cache_dir: str = None, token: str = None):
+        """Initialize dataset service with optional caching and authentication."""
+        
+    def load_dataset_info(self, dataset_id: str, config_name: str = None) -> DatasetInfo:
+        """Load dataset information from HuggingFace Hub."""
+        
+    def load_dataset_sample(self, dataset_id: str, split: str, num_samples: int, config_name: str = None) -> Dataset:
+        """Load a sample from the specified dataset."""
+        
+    def get_cached_metadata(self, dataset_id: str, config_name: str = None) -> dict:
+        """Retrieve cached metadata or fetch if not available."""
+```
+
+### 4. HuggingFace Integration (`src/hf_eda_mcp/integrations/hf_client.py`)
+
+**Purpose**: Handles all interactions with HuggingFace Hub API and datasets library.
+
+**Key Responsibilities**:
+- Authenticate with HuggingFace Hub
+- Fetch dataset information using huggingface_hub
+- Load datasets using datasets library
+- Handle errors and rate limiting
+
+## Data Models
+
+### Dataset Metadata Model
+```python
+from pydantic import BaseModel
+
+class DatasetMetadata(BaseModel):
+    id: str
+    author: str
+    description: str
+    features: Dict[str, str]
+    splits: Dict[str, int]
+    configs: List[str]
+    size_bytes: int
+    downloads: int
+    likes: int
+    tags: List[str]
+    created_at: datetime
+    last_modified: datetime
+```
+
+### Analysis Result Model
+```python
+from pydantic import BaseModel
+
+class FeatureAnalysis(BaseModel):
+    feature_name: str
+    feature_type: str
+    missing_count: int
+    missing_percentage: float
+    unique_count: int
+    statistics: Dict[str, Any]  # Mean, std, min, max for numerical; top values for categorical
+```
+
+### Sample Data Model
+```python
+from pydantic import BaseModel
+
+class DatasetSample(BaseModel):
+    dataset_id: str
+    split: str
+    config_name: str
+    sample_size: int
+    data: List[Dict[str, Any]]
+    schema: Dict[str, str]
+```
+
+## Error Handling
+
+### Error Categories and Handling Strategy
+
+1. **Dataset Not Found Errors**
+   - Return structured error response with suggestions
+   - Log error for monitoring
+   - Provide helpful error messages to users
+
+2. **Authentication Errors**
+   - Handle private dataset access gracefully
+   - Provide clear instructions for authentication
+   - Support both token-based and login-based auth
+
+3. **Network and API Errors**
+   - Implement retry logic with exponential backoff
+   - Cache successful responses to reduce API calls
+   - Provide fallback responses when possible
+
+4. **Data Processing Errors**
+   - Validate input parameters before processing
+   - Handle malformed or unexpected data gracefully
+   - Provide partial results when possible
+
+### Error Response Format
+```python
+from pydantic import BaseModel
+
+class ErrorResponse(BaseModel):
+    error_type: str
+    message: str
+    details: Dict[str, Any]
+    suggestions: List[str]
+```
+
+## Testing Strategy
+
+### Unit Testing
+- Test individual EDA functions with mock datasets
+- Validate data processing and analysis logic
+- Test error handling for various edge cases
+- Mock HuggingFace API calls for consistent testing
+
+### Integration Testing
+- Test Gradio interface creation and MCP tool exposure
+- Validate end-to-end dataset loading and analysis workflows
+- Test authentication and private dataset access
+- Verify MCP protocol compliance
+
+### Performance Testing
+- Test with large datasets to ensure efficient sampling
+- Validate caching mechanisms for repeated requests
+- Monitor memory usage during dataset processing
+- Test concurrent request handling
+
+### Test Data Strategy
+- Use small, well-known public datasets for testing
+- Create mock datasets for edge case testing
+- Test with various dataset formats and configurations
+- Include datasets with missing values and data quality issues
+
+## Configuration and Deployment
+
+### Environment Configuration
+- Support for HuggingFace authentication tokens
+- Configurable cache directory and size limits
+- Adjustable sampling limits and timeouts
+- Optional logging and monitoring configuration
+
+### Deployment Options
+1. **Local Development**: Run as standalone Gradio app
+2. **HuggingFace Spaces**: Deploy as hosted MCP server34. **MCP Client Integration**: Direct integration with MCP-compatible systems
+
+### MCP Server Configuration
+The server will be configured to work with standard MCP clients through Gradio's built-in MCP support:
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp-server": {
+      "url": "https://your-space.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```

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

@@ -0,0 +1,60 @@
+# Requirements Document
+
+## Introduction
+
+This document specifies the requirements for hf-eda-mcp, a Model Context Protocol (MCP) server that provides tools for Exploratory Data Analysis (EDA) of datasets hosted on HuggingFace. The system will enable AI assistants to perform structured dataset exploration and analysis through MCP-compatible interfaces.
+
+## Glossary
+
+- **MCP Server**: A server implementation following the Model Context Protocol that provides tools accessible to AI systems
+- **HuggingFace Dataset**: A dataset hosted on the HuggingFace Hub platform
+- **Several EDA Tool**: Functions that perform exploratory data analysis operations on datasets
+- **Dataset Metadata Tool**: Tool to fetch information about a dataset including size, features, splits, and configuration details
+- **Gradio**: A Python library for building web interfaces and applications
+- **Dataset Sample**: A subset of rows from a dataset used for analysis and preview
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a data scientist, I want to retrieve metadata from HuggingFace datasets, so that I can understand the structure and properties of datasets before analysis.
+
+#### Acceptance Criteria
+
+1. WHEN a dataset identifier is provided, THE MCP Server SHALL retrieve comprehensive metadata including dataset size, feature types, splits, and configuration details
+2. THE MCP Server SHALL validate dataset identifiers and return appropriate error messages for invalid or non-existent datasets
+3. THE MCP Server SHALL format metadata in a structured, readable format for AI assistant consumption
+4. THE MCP Server SHALL handle datasets with multiple configurations and return configuration-specific metadata when requested
+
+### Requirement 2
+
+**User Story:** As an AI assistant, I want to access dataset samples through MCP tools, so that I can perform analysis on actual data content.
+
+#### Acceptance Criteria
+
+1. WHEN a dataset sample is requested, THE MCP Server SHALL return a configurable number of rows from the specified dataset
+2. THE MCP Server SHALL support sampling from different dataset splits (train, validation, test)
+3. WHERE a specific configuration is specified, THE MCP Server SHALL return samples from that configuration
+4. THE MCP Server SHALL handle large datasets efficiently by implementing appropriate streaming and sampling strategies
+
+### Requirement 3
+
+**User Story:** As a developer, I want the MCP server to follow standard MCP protocols, so that it can integrate seamlessly with MCP-compatible AI systems.
+
+#### Acceptance Criteria
+
+1. THE MCP Server SHALL implement the standard MCP protocol for tool discovery and execution
+2. THE MCP Server SHALL provide proper tool schemas and descriptions for all available EDA functions
+3. THE MCP Server SHALL handle MCP requests and responses according to protocol specifications
+4. THE MCP Server SHALL support graceful error handling and return appropriate MCP error responses
+
+### Requirement 4
+
+**User Story:** As a data analyst, I want basic exploratory analysis tools, so that I can quickly understand dataset characteristics and quality.
+
+#### Acceptance Criteria
+
+1. THE MCP Server SHALL provide tools to analyze dataset feature distributions and statistics
+2. THE MCP Server SHALL identify missing values and data quality issues in dataset samples
+3. THE MCP Server SHALL generate summary statistics for numerical and categorical features
+4. WHERE applicable, THE MCP Server SHALL detect and report potential data anomalies or inconsistencies

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

@@ -0,0 +1,102 @@
+# Implementation Plan
+
+- [x] 1. Set up project structure and dependencies
+  - Create package directory structure following Python best practices
+  - Configure pyproject.toml with required dependencies (gradio, datasets, huggingface_hub)
+  - Set up basic package initialization files
+  - _Requirements: 3.1, 4.1, 4.2_
+
+- [ ] 2. Implement HuggingFace integration layer
+  - [ ] 2.1 Create HuggingFace client wrapper
+    - Write HfClient class to handle authentication and API interactions
+    - Implement dataset info retrieval using huggingface_hub
+    - Add error handling for authentication and network issues
+    - _Requirements: 1.2, 4.3_
+
+  - [ ] 2.2 Implement dataset service with caching
+    - Create DatasetService class for centralized dataset operations
+    - Add metadata caching to reduce API calls
+    - Implement dataset loading and sampling functionality
+    - _Requirements: 1.1, 2.1, 2.2_
+
+- [ ] 3. Create core EDA tools
+  - [ ] 3.1 Implement dataset metadata tool
+    - Write get_dataset_metadata function to retrieve comprehensive dataset information
+    - Format metadata response with dataset size, features, splits, and configuration details
+    - Handle multi-configuration datasets appropriately
+    - _Requirements: 1.1, 1.3, 1.4_
+
+  - [ ] 3.2 Implement dataset sampling tool
+    - Create get_dataset_sample function for retrieving dataset samples
+    - Support different splits (train, validation, test) and configurable sample sizes
+    - Implement efficient sampling strategies for large datasets
+    - _Requirements: 2.1, 2.2, 2.3_
+
+  - [ ] 3.3 Implement basic analysis tool
+    - Write analyze_dataset_features function for exploratory data analysis
+    - Generate feature statistics, missing value analysis, and data quality insights
+    - Handle different data types (numerical, categorical, text) appropriately
+    - _Requirements: 5.1, 5.2, 5.3, 5.4_
+
+- [ ] 4. Create Gradio interfaces and MCP server
+  - [ ] 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
+    - Design interface for feature analysis with configuration options
+    - _Requirements: 3.1, 3.2_
+
+  - [ ] 4.2 Implement main Gradio application
+    - Create main Gradio app that combines all EDA tool interfaces
+    - Enable MCP server functionality using Gradio's built-in MCP support
+    - Configure proper tool descriptions and schemas for MCP exposure
+    - _Requirements: 3.1, 3.2, 3.3_
+
+  - [ ] 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
+    - _Requirements: 4.1, 4.2, 4.4_
+
+- [ ] 5. Implement error handling and validation
+  - [ ] 5.1 Add input validation for all tools
+    - Validate dataset identifiers and configuration names
+    - Check split names and sample size parameters
+    - Provide helpful error messages for invalid inputs
+    - _Requirements: 1.2, 2.1_
+
+  - [ ] 5.2 Implement comprehensive error handling
+    - Handle dataset not found errors with suggestions
+    - Manage authentication errors for private datasets
+    - Add retry logic for network and API failures
+    - _Requirements: 1.2, 4.3_
+
+- [ ]* 5.3 Write unit tests for core functionality
+  - Create tests for HuggingFace client and dataset service
+  - Test EDA tools with mock datasets and various edge cases
+  - Validate error handling and input validation logic
+  - _Requirements: 1.1, 2.1, 5.1_
+
+- [ ] 6. Integration and deployment setup
+  - [ ] 6.1 Create main entry point and CLI
+    - Implement main module for running the server
+    - Add command-line interface for server configuration
+    - Include help documentation and usage examples
+    - _Requirements: 4.1, 4.2_
+
+  - [ ] 6.2 Add deployment configuration
+    - Create configuration for HuggingFace Spaces deployment
+    - Add Docker configuration for containerized deployment
+    - Include MCP client configuration examples
+    - _Requirements: 4.1, 4.2_
+
+  - [ ]* 6.3 Write integration tests
+    - Test end-to-end workflows from MCP client perspective
+    - Validate Gradio interface functionality and MCP tool exposure
+    - Test with real HuggingFace datasets for integration validation
+    - _Requirements: 3.1, 3.2, 3.3_
+
+- [ ]* 7. Documentation and examples
+  - Create comprehensive README with installation and usage instructions
+  - Add example MCP client configurations for popular clients
+  - Include API documentation for all available tools
+  - _Requirements: 4.2_

.kiro/steering/product.md

@@ -0,0 +1,16 @@
+# Product Overview
+
+**hf-eda-mcp** is an MCP (Model Context Protocol) server that provides tools for Exploratory Data Analysis (EDA) of HuggingFace datasets.
+
+## Purpose
+- Enables AI assistants to perform data analysis on HuggingFace datasets
+- Provides structured tools for dataset exploration and visualization
+- Integrates with MCP-compatible AI systems for seamless data analysis workflows
+
+## Target Users
+- Data scientists and researchers working with HuggingFace datasets
+- AI developers building applications that need dataset analysis capabilities
+- Anyone needing programmatic access to dataset exploration tools
+
+## License
+Apache License 2.0 - Open source project encouraging community contributions and commercial use.

.kiro/steering/structure.md

@@ -0,0 +1,49 @@
+# Project Structure
+
+## Current Organization
+```
+hf-eda-mcp/
+├── .git/                   # Git version control
+├── .kiro/                  # Kiro AI assistant configuration
+│   ├── settings/           # Kiro settings (MCP config, etc.)
+│   └── steering/           # AI guidance documents
+├── .vscode/                # VSCode configuration
+├── .gitignore              # Python-focused gitignore
+├── LICENSE                 # Apache 2.0 license
+└── README.md               # Project documentation
+```
+
+## Expected Structure (for MCP server)
+Based on MCP server conventions, the project will likely expand to:
+
+```
+hf-eda-mcp/
+├── scripts/
+├── src/
+│   └── hf_eda_mcp/         # Main package directory
+│       ├── __init__.py     # Package initialization
+│       ├── server.py       # MCP server implementation
+│       └── tools/          # EDA tool implementations
+├── tests/                  # Test suite
+├── docs/                   # Documentation
+├── requirements.txt        # Dependencies (or pyproject.toml)
+└── setup.py               # Package setup (or pyproject.toml)
+```
+
+## Naming Conventions
+- **Package/Module**: Snake_case (hf_eda_mcp)
+- **Classes**: PascalCase (DatasetAnalyzer)
+- **Functions/Variables**: Snake_case (analyze_dataset)
+- **Constants**: UPPER_SNAKE_CASE (DEFAULT_BATCH_SIZE)
+
+## File Organization Principles
+- Keep MCP tools modular and focused
+- Separate data processing logic from MCP server logic
+- Use clear, descriptive names for EDA functions
+- Group related analysis tools together
+- Follow Python package structure best practices
+
+## Configuration Files
+- Use `.kiro/settings/mcp.json` for MCP server configuration
+- Environment variables for sensitive data (API keys, etc.)
+- Support multiple dependency management systems

.kiro/steering/tech.md

@@ -0,0 +1,36 @@
+# Technology Stack
+
+## Primary Technologies
+- **Python**: Core programming language
+- **MCP (Model Context Protocol)**: Server framework for AI tool integration
+- **HuggingFace**: Dataset ecosystem and APIs
+
+## Development Environment
+- **Python Package Management**: Supports multiple managers (pdm)
+- **Virtual Environments**: Standard Python venv/virtualenv workflow
+- **IDE**: VSCode with Kiro agent integration
+
+## Key Dependencies
+- HuggingFace libraries (datasets, transformers ecosystem, gradio)
+- MCP server framework (gradio)
+- Data analysis libraries (likely pandas, numpy, matplotlib/seaborn for EDA)
+
+## Common Commands
+```bash
+# Environment setup
+pdm sync
+
+# Testing
+pytest
+# OR
+python -m pytest
+
+# Linting and formatting
+ruff check .
+ruff format .
+```
+
+## MCP Integration
+- Designed to run as an MCP server
+- Provides tools accessible to MCP-compatible AI systems
+- Configuration through standard MCP server protocols

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "kiroAgent.configureMCP": "Enabled"
+}

pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "hf-eda-mcp"
+version = "0.1.0"
+description = "MCP server for EDA on HuggingFace datasets"
+authors = [
+    {name = "Khalil Guetari", email = "khalil.guetari@momentslab.com"},
+]
+dependencies = [
+    "gradio>=5.49.1",
+    "datasets>=4.3.0", 
+    "huggingface_hub>=0.20.0",
+    "pydantic>=2.0.0",
+    "pandas>=2.0.0",
+    "numpy>=1.24.0"
+]
+requires-python = ">=3.13"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
+
+
+[project.scripts]
+hf-eda-mcp = "hf_eda_mcp.server:launch_server"
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.dev-dependencies]
+test = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0"
+]
+lint = [
+    "ruff>=0.1.0",
+    "black>=23.0.0",
+    "mypy>=1.0.0"
+]

src/hf_eda_mcp/__init__.py

@@ -0,0 +1,11 @@
+"""
+HuggingFace EDA MCP Server package.
+
+A Model Context Protocol (MCP) server that provides tools for 
+Exploratory Data Analysis (EDA) of datasets hosted on HuggingFace.
+"""
+
+from .server import create_gradio_app, launch_server
+
+__version__ = "0.1.0"
+__all__ = ["create_gradio_app", "launch_server"]

src/hf_eda_mcp/__main__.py

@@ -0,0 +1,46 @@
+"""
+Main entry point for the hf-eda-mcp server.
+
+This module allows the package to be run as a module using:
+python -m hf_eda_mcp
+"""
+
+import argparse
+import sys
+from .server import launch_server
+
+
+def main():
+    """Main entry point with command line argument parsing."""
+    parser = argparse.ArgumentParser(
+        description="HuggingFace EDA MCP Server",
+        prog="hf-eda-mcp"
+    )
+    
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7860,
+        help="Port to run the server on (default: 7860)"
+    )
+    
+    parser.add_argument(
+        "--no-mcp",
+        action="store_true",
+        help="Disable MCP server functionality"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        launch_server(port=args.port, mcp_server=not args.no_mcp)
+    except KeyboardInterrupt:
+        print("\nServer stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error starting server: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

src/hf_eda_mcp/integrations/__init__.py

@@ -0,0 +1,8 @@
+"""
+Integration module for external services.
+
+This package contains integration classes for HuggingFace Hub
+and other external services.
+"""
+
+__all__ = []

src/hf_eda_mcp/integrations/hf_client.py

@@ -0,0 +1,7 @@
+"""
+HuggingFace client wrapper for API interactions.
+
+This module will be implemented in task 2.1.
+"""
+
+# Placeholder - will be implemented in task 2.1

src/hf_eda_mcp/server.py

@@ -0,0 +1,30 @@
+"""
+Main Gradio application with MCP server functionality.
+
+This module provides the main entry point for the hf-eda-mcp server,
+creating Gradio interfaces for EDA tools and enabling MCP server functionality.
+"""
+
+import gradio as gr
+
+
+def create_gradio_app() -> gr.Blocks:
+    """Create and configure the main Gradio application with MCP server."""
+    # Placeholder implementation - will be expanded in later tasks
+    with gr.Blocks(title="HF EDA MCP Server") as app:
+        gr.Markdown("# HuggingFace EDA MCP Server")
+        gr.Markdown("MCP server for exploratory data analysis of HuggingFace datasets.")
+
+    return app
+
+
+def launch_server(port: int = 7860, mcp_server: bool = True) -> None:
+    """Launch the Gradio app with MCP server enabled."""
+    app = create_gradio_app()
+
+    # Launch with MCP server enabled
+    app.launch(server_port=port, share=False, show_error=True)
+
+
+if __name__ == "__main__":
+    launch_server()

src/hf_eda_mcp/services/__init__.py

@@ -0,0 +1,8 @@
+"""
+Services module for dataset operations and integrations.
+
+This package contains service classes for dataset management, caching,
+and external API integrations.
+"""
+
+__all__ = []

src/hf_eda_mcp/services/dataset_service.py

@@ -0,0 +1,7 @@
+"""
+Dataset service for centralized dataset operations and caching.
+
+This module will be implemented in task 2.2.
+"""
+
+# Placeholder - will be implemented in task 2.2

src/hf_eda_mcp/tools/__init__.py

@@ -0,0 +1,7 @@
+"""
+EDA tools module for HuggingFace datasets.
+
+This package contains individual EDA functions that will be exposed as MCP tools.
+"""
+
+__all__ = []

src/hf_eda_mcp/tools/analysis.py

@@ -0,0 +1,7 @@
+"""
+Basic analysis tool for exploratory data analysis.
+
+This module will be implemented in task 3.3.
+"""
+
+# Placeholder - will be implemented in task 3.3

src/hf_eda_mcp/tools/metadata.py

@@ -0,0 +1,7 @@
+"""
+Dataset metadata tool for retrieving HuggingFace dataset information.
+
+This module will be implemented in task 3.1.
+"""
+
+# Placeholder - will be implemented in task 3.1

src/hf_eda_mcp/tools/sampling.py

@@ -0,0 +1,7 @@
+"""
+Dataset sampling tool for retrieving dataset samples.
+
+This module will be implemented in task 3.2.
+"""
+
+# Placeholder - will be implemented in task 3.2