dell-unity-mcp-server

sachdev27/dell-unity-mcp-server

3.2

If you are the rightful owner of dell-unity-mcp-server and would like to certify it and/or have it hosted online, please leave a comment on the right or send an email to dayong@mcphub.com.

Dell Unity MCP Server is a Model Context Protocol server designed for Dell Unity storage arrays, enabling seamless interaction with AI assistants and automation platforms.

Tools
3
Resources
0
Prompts
0

Dell Unity MCP Server

PyPI version PyPI downloads CI Python Version License: MIT Code style: black Ruff

A Model Context Protocol (MCP) server for Dell Unity storage arrays that automatically generates tools from OpenAPI specifications with a credential-free architecture. Enables AI assistants like Claude and automation platforms like n8n to interact with Unity storage systems.

✨ Features

FeatureDescription
🔄 Automatic Tool GenerationDynamically generates 359+ MCP tools from Dell Unity OpenAPI specs
🔐 Credential-Free ArchitectureNo stored credentials - pass host/username/password with each tool call
🌐 Multi-Host SupportManage multiple Unity arrays from a single server
🛡️ Configurable OperationsGET-only by default, configurable to enable POST/DELETE
🔌 Multiple TransportsHTTP/SSE for n8n, stdio for Claude Desktop
📊 Health MonitoringBuilt-in health checks and metrics endpoints
🐳 Docker ReadyProduction-ready container images

📋 Table of Contents

🚀 Quick Start

# Clone and install
git clone https://github.com/sachdev27/dell-unity-mcp-server.git
cd dell-unity-mcp-server
pip install -e .

# Run HTTP/SSE server (for n8n)
export LOCAL_OPENAPI_SPEC_PATH="./openapi.json"
python -m uvicorn unity_mcp.http_server:app --host 0.0.0.0 --port 8000

# Or run stdio server (for Claude Desktop)
python -m unity_mcp.main

📦 Installation

From Source

From PyPI (Recommended)

pip install dell-unity-mcp-server

From Source

# Clone the repository
git clone https://github.com/sachdev27/dell-unity-mcp-server.git
cd dell-unity-mcp-server

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On macOS/Linux
# venv\Scripts\activate   # On Windows

# Install in development mode
pip install -e ".[dev]"

Using Docker

# Build the image
docker build -t dell-unity-mcp-server .

# Run with SSE transport (GET-only by default)
docker run -p 8000:8000 dell-unity-mcp-server

# Run with full access (GET, POST, DELETE)
docker run -p 8000:8000 -e ALLOWED_HTTP_METHODS="GET,POST,DELETE" dell-unity-mcp-server

Requirements

  • Python: 3.10, 3.11, 3.12, or 3.13
  • Dell Unity: Any supported version with REST API enabled (v5.x recommended)

⚙️ Configuration

Environment Variables

VariableDescriptionDefault
LOCAL_OPENAPI_SPEC_PATHPath to OpenAPI specification (required)-
LOG_LEVELLogging level (DEBUG, INFO, WARNING, ERROR)INFO
HTTP_SERVER_PORTHTTP server port8000
ALLOWED_HTTP_METHODSComma-separated list of allowed methodsGET
UNITY_HOSTDefault Unity hostname (optional)-
UNITY_TLS_VERIFYVerify TLS certificatesfalse
REQUEST_TIMEOUTRequest timeout in milliseconds30000
MAX_RETRIESMaximum retry attempts3

Example .env File

# Required
LOCAL_OPENAPI_SPEC_PATH=/app/openapi.json

# Server Configuration
HTTP_SERVER_PORT=8000
LOG_LEVEL=INFO

# HTTP Methods (GET = read-only, add POST,DELETE for write operations)
ALLOWED_HTTP_METHODS=GET

# Optional Unity defaults
# UNITY_HOST=unity.example.com
# UNITY_TLS_VERIFY=false

Configuring HTTP Methods

By default, the server only exposes GET operations (read-only). To enable write operations:

# Read-only (default) - 359 tools
export ALLOWED_HTTP_METHODS="GET"

# Full access - 777 tools
export ALLOWED_HTTP_METHODS="GET,POST,PUT,PATCH,DELETE"

⚠️ Important: Unity credentials are NOT stored in configuration. They are passed securely with each tool call.

📖 Usage

HTTP/SSE Mode (for n8n and Web Clients)

# Using uvicorn
python -m uvicorn unity_mcp.http_server:app --host 0.0.0.0 --port 8000

# Using the main module
python -m unity_mcp.main --mode http

The server provides:

  • SSE Endpoint: http://localhost:8000/sse
  • Health Check: http://localhost:8000/health
  • Readiness Check: http://localhost:8000/ready
  • Liveness Check: http://localhost:8000/live
  • Metrics: http://localhost:8000/metrics

stdio Mode (for Claude Desktop)

# Using Python module
python -m unity_mcp.main

Docker Compose

# docker-compose.yml
version: '3.8'
services:
  unity-mcp:
    build: .
    ports:
      - "8000:8000"
    environment:
      - ALLOWED_HTTP_METHODS=GET
      - LOG_LEVEL=INFO
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
# Start the server
docker-compose up -d

# View logs
docker-compose logs -f

# Stop the server
docker-compose down

🔗 Integration

n8n AI Agent

  1. Add an MCP Client node to your n8n workflow
  2. Configure the connection:
    • Transport: SSE
    • URL: http://localhost:8000/sse
  3. The 359+ Unity tools will be available to AI agents

Claude Desktop

Add to your Claude Desktop configuration (claude_desktop_config.json):

{
  "mcpServers": {
    "dell-unity": {
      "command": "/path/to/venv/bin/python",
      "args": ["-m", "unity_mcp.main"],
      "env": {
        "LOCAL_OPENAPI_SPEC_PATH": "/path/to/openapi.json"
      }
    }
  }
}

Custom MCP Clients

import asyncio
from mcp import ClientSession
from mcp.client.sse import sse_client

async def main():
    async with sse_client("http://localhost:8000/sse") as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools = await session.list_tools()
            print(f"Found {len(tools.tools)} tools")

            # Get system information
            result = await session.call_tool("systemCollectionQuery", {
                "host": "unity.example.com",
                "username": "admin",
                "password": "password",
                "fields": "id,name,model,serialNumber"
            })
            print(result)

            # Get all LUNs
            result = await session.call_tool("lunCollectionQuery", {
                "host": "unity.example.com",
                "username": "admin",
                "password": "password",
                "fields": "id,name,sizeTotal,pool",
                "per_page": 100
            })
            print(result)

asyncio.run(main())

🔧 Available Tools

The server dynamically generates 359+ tools (GET-only) or 777+ tools (full access) from the Unity OpenAPI specification.

Authentication Parameters

Every tool requires these authentication parameters:

ParameterTypeDescription
hoststringUnity hostname or IP
usernamestringUnity username
passwordstringUnity password

Tool Categories

CategoryExample ToolsDescription
StoragelunCollectionQuery, poolCollectionQueryLUN and pool management
SystemsystemCollectionQuery, licenseCollectionQuerySystem information
NetworkipInterfaceCollectionQuery, fcPortCollectionQueryNetwork configuration
File ServicesnasServerCollectionQuery, fileSystemCollectionQueryFile storage
ProtectionsnapCollectionQuery, replicationSessionCollectionQueryData protection
MonitoringalertCollectionQuery, eventCollectionQueryAlerts and events
Host AccesshostCollectionQuery, hostLUNCollectionQueryHost management

Query Parameters

All collection endpoints support Unity query parameters:

{
  "host": "unity.example.com",
  "username": "admin",
  "password": "password",
  "fields": "id,name,sizeTotal,health",
  "filter": "name lk 'prod*'",
  "per_page": 100,
  "page": 1,
  "compact": "true"
}

Unity Filter Syntax

Unity uses a specific filter syntax for queries:

OperatorDescriptionExample
eqEqualsfilter=severity eq 4
neNot equalsfilter=health.value ne 5
ltLess thanfilter=sizeTotal lt 1073741824
gtGreater thanfilter=sizeTotal gt 1073741824
lkLike (wildcard)filter=name lk 'prod*'
andLogical ANDfilter=severity eq 4 and state eq 2

🏗️ Architecture

Credential-Free Design

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   AI Client     │────▶│   MCP Server    │────▶│   Dell Unity    │
│ (Claude/n8n)    │     │ (No Credentials)│     │    Array        │
└─────────────────┘     └─────────────────┘     └─────────────────┘
         │                      │
         │   Tool Call with     │   Per-Request
         │   Credentials        │   Authentication
         ▼                      ▼
    {host, user, pass}      Basic Auth Header

Key Design Principles

  • No Stored Credentials: Server starts without any Unity connection
  • Per-Request Auth: Each tool call includes host/username/password
  • Fresh Sessions: New API client created for each request
  • Multi-Host Ready: Easily manage multiple Unity arrays
  • Configurable Access: Control which HTTP methods are exposed

Module Structure

unity_mcp/
├── __init__.py          # Package initialization and version
├── api_client.py        # Async Unity API client with retry logic
├── config.py            # Configuration management with validation
├── exceptions.py        # Custom exception hierarchy
├── http_server.py       # HTTP/SSE transport server
├── logging_config.py    # Structured logging configuration
├── main.py              # stdio transport entry point
├── server.py            # Core MCP server with tool handlers
└── tool_generator.py    # OpenAPI parser and tool generator

🧪 Development

Setup Development Environment

# Clone and install with dev dependencies
git clone https://github.com/sachdev27/dell-unity-mcp-server.git
cd dell-unity-mcp-server
python -m venv venv
source venv/bin/activate
pip install -e ".[dev]"

Running Tests

# Run all tests
pytest

# Run with verbose output
pytest -v

# Run with coverage
pytest --cov=unity_mcp --cov-report=html

# Run specific test file
pytest tests/test_tool_generator.py -v

Code Quality

# Format code
black unity_mcp tests

# Lint code
ruff check unity_mcp tests

# Type checking
mypy unity_mcp

# Security scan
bandit -r unity_mcp

Building

# Build distribution packages
python -m build

# Build Docker image
docker build -t dell-unity-mcp-server .

🤝 Contributing

Contributions are welcome!

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the file for details.

📚 Additional Resources


Made with ❤️ for the storage automation community