Deployment on hf spaces

.dockerignore

@@ -0,0 +1,65 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# PDM
+.pdm-python
+.pdm-build/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Documentation
+docs/_build/
+
+# Environment files
+.env
+.envrc
+
+# Cache
+cache/
+__pycache__/
+.ruff_cache/
+
+# Logs
+*.log
+scripts.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Kiro
+.kiro/
+
+# Development files
+scripts/playground/
+tests/

.gitignore

@@ -207,4 +207,8 @@ marimo/_lsp/
 __marimo__/
 
 # Cache
-cache/
+cache/
+
+# Docker
+docker-compose.override.yml
+.docker/

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

@@ -57,7 +57,7 @@
     - Include proper logging and error handling for server operations
     - _Requirements: 4.1, 4.2, 4.4_
 
-- [ ] 5. Implement error handling and validation
+- [x] 5. Implement error handling and validation
   - [x] 5.1 Add input validation for all tools
     - Validate dataset identifiers and configuration names
     - Check split names and sample size parameters
@@ -77,13 +77,13 @@
   - _Requirements: 1.1, 2.1, 5.1_
 
 - [ ] 6. Integration and deployment setup
-  - [ ] 6.1 Create main entry point and CLI
+  - [x] 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
+  - [x] 6.2 Add deployment configuration
     - Create configuration for HuggingFace Spaces deployment
     - Add Docker configuration for containerized deployment
     - Include MCP client configuration examples

Dockerfile

@@ -0,0 +1,53 @@
+# Multi-stage build for hf-eda-mcp server
+FROM python:3.13-slim as builder
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install PDM
+RUN pip install --no-cache-dir pdm
+
+# Copy dependency files
+COPY pyproject.toml pdm.lock* ./
+
+# Install dependencies
+RUN pdm install --prod --no-lock --no-editable
+
+# Production stage
+FROM python:3.13-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy installed dependencies from builder
+COPY --from=builder /app/.venv /app/.venv
+
+# Copy application code
+COPY src/ ./src/
+COPY README.md LICENSE ./
+
+# Set environment variables
+ENV PATH="/app/.venv/bin:$PATH"
+ENV PYTHONUNBUFFERED=1
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+
+# Expose Gradio port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health', timeout=5)"
+
+# Run the MCP server
+CMD ["python", "-m", "hf_eda_mcp"]

README.md

@@ -1,2 +1,55 @@
-# hf-eda-mcp
-An MCP server providing tools for EDA for HuggingFace datasets
+---
+title: HF EDA MCP Server
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# HF EDA MCP Server
+
+An MCP (Model Context Protocol) server that provides tools for Exploratory Data Analysis (EDA) of HuggingFace datasets.
+
+## Features
+
+- **Dataset Metadata**: Retrieve comprehensive information about HuggingFace datasets
+- **Dataset Sampling**: Get samples from any dataset split for quick exploration
+- **Feature Analysis**: Perform basic EDA including statistics, missing values, and distributions
+
+## Usage
+
+This Space runs as an MCP server that can be accessed by MCP-compatible AI assistants.
+
+### MCP Client Configuration
+
+Add this server to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "url": "https://YOUR-USERNAME-hf-eda-mcp.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+Replace `YOUR-USERNAME` with your HuggingFace username.
+
+### Available Tools
+
+1. **get_dataset_metadata**: Get detailed information about a dataset
+2. **get_dataset_sample**: Retrieve sample rows from a dataset
+3. **analyze_dataset_features**: Perform exploratory analysis on dataset features
+
+## Authentication
+
+For private datasets, set the `HF_TOKEN` secret in your Space settings.
+
+## License
+
+Apache License 2.0

app.py

@@ -0,0 +1,23 @@
+"""
+HuggingFace Spaces entry point for hf-eda-mcp server.
+
+This file is used when deploying to HuggingFace Spaces.
+It imports and launches the main Gradio application.
+"""
+
+import os
+import sys
+
+# Add src directory to path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from hf_eda_mcp.server import create_gradio_app
+
+# Create and launch the Gradio app
+if __name__ == "__main__":
+    app = create_gradio_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

docs/deployment/DEPLOYMENT.md

@@ -0,0 +1,300 @@
+# Deployment Guide
+
+This guide covers different deployment options for the hf-eda-mcp server.
+
+## Table of Contents
+
+- [Local Development](#local-development)
+- [Docker Deployment](#docker-deployment)
+- [HuggingFace Spaces](#huggingface-spaces)
+- [Production Considerations](#production-considerations)
+
+---
+
+## Local Development
+
+### Prerequisites
+
+- Python 3.13+
+- PDM (Python package manager)
+- HuggingFace account (optional, for private datasets)
+
+### Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/your-username/hf-eda-mcp.git
+cd hf-eda-mcp
+```
+
+2. Install dependencies:
+```bash
+pdm install
+```
+
+3. Configure environment variables:
+```bash
+cp config.example.env .env
+# Edit .env and add your HF_TOKEN if needed
+```
+
+4. Run the server:
+```bash
+pdm run hf-eda-mcp
+```
+
+The server will start on `http://localhost:7860` with MCP enabled.
+
+---
+
+## Docker Deployment
+
+### Build the Image
+
+```bash
+docker build -t hf-eda-mcp:latest .
+```
+
+### Run with Docker
+
+```bash
+docker run -d \
+  --name hf-eda-mcp-server \
+  -p 7860:7860 \
+  -e HF_TOKEN=your_token_here \
+  -v hf-cache:/app/cache \
+  hf-eda-mcp:latest
+```
+
+### Run with Docker Compose
+
+1. Create a `.env` file with your configuration:
+```bash
+HF_TOKEN=your_token_here
+```
+
+2. Start the service:
+```bash
+docker-compose up -d
+```
+
+3. View logs:
+```bash
+docker-compose logs -f
+```
+
+4. Stop the service:
+```bash
+docker-compose down
+```
+
+### Docker Configuration Options
+
+Environment variables you can set:
+
+- `HF_TOKEN`: HuggingFace API token
+- `GRADIO_SERVER_NAME`: Server host (default: `0.0.0.0`)
+- `GRADIO_SERVER_PORT`: Server port (default: `7860`)
+- `HF_HOME`: Cache directory for HuggingFace
+- `MCP_SERVER_ENABLED`: Enable MCP server (default: `true`)
+
+---
+
+## HuggingFace Spaces
+
+### Deployment Steps
+
+1. **Create a new Space**:
+   - Go to https://huggingface.co/spaces
+   - Click "Create new Space"
+   - Choose "Gradio" as the SDK
+   - Select SDK version 5.49.1 or higher
+
+2. **Upload files**:
+   ```bash
+   # Copy files to Spaces directory
+   cp -r src/ spaces/
+   cp README.md LICENSE spaces/
+   
+   # Initialize git in spaces directory
+   cd spaces
+   git init
+   git remote add origin https://huggingface.co/spaces/YOUR-USERNAME/hf-eda-mcp
+   ```
+
+3. **Configure the Space**:
+   - Copy `spaces/README.md` as the Space's README
+   - Ensure `spaces/app.py` is set as the app file
+   - Add `spaces/requirements.txt` for dependencies
+
+4. **Set secrets** (for private datasets):
+   - Go to Space settings
+   - Add `HF_TOKEN` as a secret
+
+5. **Deploy**:
+   ```bash
+   git add .
+   git commit -m "Initial deployment"
+   git push origin main
+   ```
+
+### Space Configuration
+
+The Space will automatically:
+- Install dependencies from `requirements.txt`
+- Run `app.py` as the entry point
+- Expose the MCP server at `/gradio_api/mcp/sse`
+
+### Accessing the Space
+
+Your MCP server will be available at:
+```
+https://YOUR-USERNAME-hf-eda-mcp.hf.space/gradio_api/mcp/sse
+```
+
+---
+
+## Production Considerations
+
+### Security
+
+1. **Authentication**:
+   - Use environment variables for sensitive data
+   - Never commit tokens to version control
+   - Rotate tokens regularly
+
+2. **Access Control**:
+   - Consider implementing rate limiting
+   - Use HTTPS for all connections
+   - Validate all input parameters
+
+3. **Secrets Management**:
+   - Use Docker secrets or environment files
+   - For Spaces, use the built-in secrets feature
+   - Consider using a secrets manager (AWS Secrets Manager, HashiCorp Vault)
+
+### Performance
+
+1. **Caching**:
+   - Enable persistent cache volumes
+   - Configure appropriate cache sizes
+   - Monitor cache hit rates
+
+2. **Resource Limits**:
+   - Set memory limits in Docker
+   - Configure appropriate timeouts
+   - Monitor CPU and memory usage
+
+3. **Scaling**:
+   - Use load balancers for multiple instances
+   - Consider horizontal scaling for high traffic
+   - Monitor response times and adjust resources
+
+### Monitoring
+
+1. **Logging**:
+   - Configure structured logging
+   - Use log aggregation tools (ELK, Splunk)
+   - Monitor error rates
+
+2. **Metrics**:
+   - Track request counts and latencies
+   - Monitor cache performance
+   - Set up alerts for errors
+
+3. **Health Checks**:
+   - Implement health check endpoints
+   - Configure container health checks
+   - Set up uptime monitoring
+
+### Backup and Recovery
+
+1. **Data Backup**:
+   - Backup cache volumes regularly
+   - Document configuration settings
+   - Version control all code
+
+2. **Disaster Recovery**:
+   - Document deployment procedures
+   - Test recovery processes
+   - Maintain rollback capabilities
+
+---
+
+## Deployment Checklist
+
+### Pre-Deployment
+
+- [ ] All tests passing
+- [ ] Dependencies up to date
+- [ ] Security scan completed
+- [ ] Documentation updated
+- [ ] Environment variables configured
+- [ ] Secrets properly managed
+
+### Deployment
+
+- [ ] Build successful
+- [ ] Health checks passing
+- [ ] MCP endpoints accessible
+- [ ] Tools functioning correctly
+- [ ] Logs being collected
+- [ ] Monitoring configured
+
+### Post-Deployment
+
+- [ ] Verify all tools work
+- [ ] Check performance metrics
+- [ ] Monitor error rates
+- [ ] Test with MCP clients
+- [ ] Document any issues
+- [ ] Update runbooks
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Server won't start**:
+   - Check Python version (3.13+ required)
+   - Verify all dependencies installed
+   - Check port availability
+   - Review logs for errors
+
+2. **MCP connection fails**:
+   - Verify server is running
+   - Check firewall settings
+   - Confirm correct URL/port
+   - Test with curl or browser
+
+3. **Dataset access errors**:
+   - Verify HF_TOKEN is set
+   - Check token permissions
+   - Confirm dataset exists
+   - Test with public dataset first
+
+4. **Performance issues**:
+   - Check cache configuration
+   - Monitor resource usage
+   - Reduce sample sizes
+   - Enable caching
+
+### Getting Help
+
+- Check logs: `docker logs hf-eda-mcp-server`
+- Review documentation: See `MCP_USAGE.md`
+- Open an issue: GitHub repository
+- Community support: HuggingFace forums
+
+---
+
+## Next Steps
+
+After deployment:
+
+1. Configure MCP clients (see `deployment/mcp-client-examples.md`)
+2. Test all tools with various datasets
+3. Set up monitoring and alerts
+4. Document any custom configurations
+5. Share your Space with the community!

docs/deployment/QUICKSTART.md

@@ -0,0 +1,148 @@
+# Quick Start Guide
+
+Get hf-eda-mcp running in minutes!
+
+## Choose Your Deployment Method
+
+### 🚀 Option 1: Local Development (Fastest)
+
+```bash
+# Install dependencies
+pdm install
+
+# Set up environment (optional for public datasets)
+cp config.example.env .env
+# Edit .env and add HF_TOKEN if needed
+
+# Run the server
+pdm run hf-eda-mcp
+```
+
+Server runs at: `http://localhost:7860`
+
+---
+
+### 🐳 Option 2: Docker (Recommended for Production)
+
+```bash
+# Build the image
+docker build -t hf-eda-mcp:latest .
+
+# Run the container
+docker run -d \
+  --name hf-eda-mcp-server \
+  -p 7860:7860 \
+  -e HF_TOKEN=your_token_here \
+  hf-eda-mcp:latest
+```
+
+Or use Docker Compose:
+
+```bash
+# Create .env file with HF_TOKEN
+echo "HF_TOKEN=your_token_here" > .env
+
+# Start the service
+docker-compose up -d
+```
+
+Server runs at: `http://localhost:7860`
+
+---
+
+### ☁️ Option 3: HuggingFace Spaces (Easiest for Sharing)
+
+1. Create a new Gradio Space on HuggingFace
+2. Copy files from `spaces/` directory to your Space
+3. Set `HF_TOKEN` as a secret in Space settings (if needed)
+4. Push to deploy
+
+Your server will be at: `https://YOUR-USERNAME-hf-eda-mcp.hf.space`
+
+---
+
+## Connect an MCP Client
+
+### Kiro IDE
+
+Add to `.kiro/settings/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "command": "pdm",
+      "args": ["run", "hf-eda-mcp"],
+      "disabled": false
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "command": "python",
+      "args": ["-m", "hf_eda_mcp"],
+      "env": {
+        "PYTHONPATH": "/path/to/hf-eda-mcp/src"
+      }
+    }
+  }
+}
+```
+
+---
+
+## Test the Server
+
+### Using the Web Interface
+
+1. Open `http://localhost:7860` in your browser
+2. Try the tools with a sample dataset like "squad"
+
+### Using an MCP Client
+
+Ask your AI assistant:
+
+```
+"Get metadata for the squad dataset"
+"Show me 5 samples from the train split of squad"
+"Analyze the features of the squad dataset"
+```
+
+---
+
+## Common Issues
+
+**Server won't start?**
+- Check Python version: `python --version` (need 3.13+)
+- Install dependencies: `pdm install`
+
+**Can't access private datasets?**
+- Set `HF_TOKEN` in your `.env` file
+- Get token from: https://huggingface.co/settings/tokens
+
+**Port 7860 already in use?**
+- Change port: `GRADIO_SERVER_PORT=8080 pdm run hf-eda-mcp`
+
+---
+
+## Next Steps
+
+- 📖 Read the full [Deployment Guide](DEPLOYMENT.md)
+- 🔧 See [MCP Client Examples](mcp-client-examples.md)
+- 📚 Check [MCP Usage Documentation](../MCP_USAGE.md)
+
+---
+
+## Need Help?
+
+- Check logs: `docker logs hf-eda-mcp-server` (Docker)
+- Review documentation in `docs/`
+- Open an issue on GitHub

docs/deployment/mcp-client-examples.md

@@ -0,0 +1,295 @@
+# MCP Client Configuration Examples
+
+This document provides configuration examples for connecting various MCP clients to the hf-eda-mcp server.
+
+## Table of Contents
+
+- [Kiro IDE](#kiro-ide)
+- [Claude Desktop](#claude-desktop)
+- [Custom MCP Client](#custom-mcp-client)
+- [Environment Variables](#environment-variables)
+
+---
+
+## Kiro IDE
+
+### Workspace Configuration
+
+Create or edit `.kiro/settings/mcp.json` in your workspace:
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "command": "docker",
+      "args": [
+        "run",
+        "--rm",
+        "-i",
+        "-p", "7860:7860",
+        "--env-file", ".env",
+        "hf-eda-mcp:latest"
+      ],
+      "env": {
+        "HF_TOKEN": "${HF_TOKEN}"
+      },
+      "disabled": false,
+      "autoApprove": [
+        "get_dataset_metadata",
+        "get_dataset_sample",
+        "analyze_dataset_features"
+      ]
+    }
+  }
+}
+```
+
+### User-Level Configuration
+
+Edit `~/.kiro/settings/mcp.json` for global configuration:
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "command": "pdm",
+      "args": ["run", "hf-eda-mcp"],
+      "env": {
+        "HF_TOKEN": "your_token_here"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+### Using HuggingFace Spaces
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "url": "https://your-username-hf-eda-mcp.hf.space/gradio_api/mcp/sse",
+      "disabled": false,
+      "autoApprove": ["get_dataset_metadata"]
+    }
+  }
+}
+```
+
+---
+
+## Claude Desktop
+
+### Configuration File Location
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+### Local Server Configuration
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "command": "python",
+      "args": ["-m", "hf_eda_mcp"],
+      "env": {
+        "HF_TOKEN": "your_token_here",
+        "PYTHONPATH": "/path/to/hf-eda-mcp/src"
+      }
+    }
+  }
+}
+```
+
+### Docker Configuration
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "command": "docker",
+      "args": [
+        "run",
+        "--rm",
+        "-i",
+        "-p", "7860:7860",
+        "-e", "HF_TOKEN=your_token_here",
+        "hf-eda-mcp:latest"
+      ]
+    }
+  }
+}
+```
+
+### HuggingFace Spaces Configuration
+
+```json
+{
+  "mcpServers": {
+    "hf-eda-mcp": {
+      "url": "https://your-username-hf-eda-mcp.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+---
+
+## Custom MCP Client
+
+### Python Client Example
+
+```python
+import asyncio
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+async def main():
+    # Connect to local server
+    server_params = StdioServerParameters(
+        command="python",
+        args=["-m", "hf_eda_mcp"],
+        env={"HF_TOKEN": "your_token_here"}
+    )
+    
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write) as session:
+            # Initialize the connection
+            await session.initialize()
+            
+            # List available tools
+            tools = await session.list_tools()
+            print("Available tools:", tools)
+            
+            # Call a tool
+            result = await session.call_tool(
+                "get_dataset_metadata",
+                arguments={"dataset_id": "squad"}
+            )
+            print("Result:", result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### JavaScript/TypeScript Client Example
+
+```typescript
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+async function main() {
+  const transport = new StdioClientTransport({
+    command: "python",
+    args: ["-m", "hf_eda_mcp"],
+    env: {
+      HF_TOKEN: process.env.HF_TOKEN
+    }
+  });
+
+  const client = new Client({
+    name: "hf-eda-client",
+    version: "1.0.0"
+  }, {
+    capabilities: {}
+  });
+
+  await client.connect(transport);
+
+  // List tools
+  const tools = await client.listTools();
+  console.log("Available tools:", tools);
+
+  // Call a tool
+  const result = await client.callTool({
+    name: "get_dataset_metadata",
+    arguments: {
+      dataset_id: "squad"
+    }
+  });
+  console.log("Result:", result);
+
+  await client.close();
+}
+
+main().catch(console.error);
+```
+
+---
+
+## Environment Variables
+
+### Required Variables
+
+- `HF_TOKEN`: HuggingFace API token (optional for public datasets, required for private datasets)
+
+### Optional Variables
+
+- `HF_HOME`: Directory for HuggingFace cache (default: `~/.cache/huggingface`)
+- `HF_DATASETS_CACHE`: Directory for datasets cache
+- `TRANSFORMERS_CACHE`: Directory for transformers cache
+- `GRADIO_SERVER_NAME`: Server host (default: `0.0.0.0`)
+- `GRADIO_SERVER_PORT`: Server port (default: `7860`)
+- `MCP_SERVER_ENABLED`: Enable MCP server (default: `true`)
+
+### Example .env File
+
+```bash
+# HuggingFace Authentication
+HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# Cache Configuration
+HF_HOME=/path/to/cache
+HF_DATASETS_CACHE=/path/to/cache/datasets
+TRANSFORMERS_CACHE=/path/to/cache/transformers
+
+# Server Configuration
+GRADIO_SERVER_NAME=0.0.0.0
+GRADIO_SERVER_PORT=7860
+MCP_SERVER_ENABLED=true
+```
+
+---
+
+## Deployment Options Comparison
+
+| Option | Pros | Cons | Best For |
+|--------|------|------|----------|
+| **Local (PDM)** | Fast, easy debugging | Requires Python setup | Development |
+| **Docker** | Isolated, reproducible | Requires Docker | Production, CI/CD |
+| **HF Spaces** | Hosted, no maintenance | Limited control | Public sharing |
+
+---
+
+## Troubleshooting
+
+### Connection Issues
+
+1. **Server not starting**: Check logs for errors, verify dependencies installed
+2. **Authentication failed**: Verify `HF_TOKEN` is set correctly
+3. **Port already in use**: Change `GRADIO_SERVER_PORT` to a different port
+
+### Tool Execution Issues
+
+1. **Dataset not found**: Verify dataset ID is correct on HuggingFace Hub
+2. **Permission denied**: Ensure `HF_TOKEN` has access to private datasets
+3. **Timeout errors**: Increase timeout settings or use smaller sample sizes
+
+### Docker Issues
+
+1. **Image build fails**: Ensure all dependencies in `pyproject.toml` are compatible
+2. **Container exits immediately**: Check logs with `docker logs hf-eda-mcp-server`
+3. **Cache not persisting**: Verify volume mounts in `docker-compose.yml`
+
+---
+
+## Additional Resources
+
+- [MCP Protocol Documentation](https://modelcontextprotocol.io/)
+- [Gradio MCP Integration](https://www.gradio.app/guides/gradio-and-mcp)
+- [HuggingFace Hub Documentation](https://huggingface.co/docs/hub/index)
+- [Project Repository](https://github.com/your-username/hf-eda-mcp)

requirements.txt

@@ -0,0 +1,9 @@
+# HuggingFace Spaces requirements
+# Generated from pyproject.toml for Spaces deployment
+
+gradio[mcp]>=5.49.1
+datasets>=4.3.0
+huggingface_hub>=0.20.0
+pydantic>=2.0.0
+pandas>=2.0.0
+numpy>=1.24.0

src/hf_eda_mcp/services/dataset_service.py

@@ -15,8 +15,7 @@ from datasets import load_dataset
 from datasets.utils.logging import disable_progress_bar
 
 from hf_eda_mcp.integrations.hf_client import (
-    HfClient, 
-    HfClientError, 
+    HfClient,
     DatasetNotFoundError,
     AuthenticationError,
     NetworkError
@@ -25,7 +24,6 @@ from hf_eda_mcp.error_handling import (
     retry_with_backoff,
     RetryConfig,
     log_error_with_context,
-    format_error_response
 )
 
 logger = logging.getLogger(__name__)