Hashing MCP Server

What is MCP-Server-for-Hashing?

MCP-Server-for-Hashing is a Model Context Protocol (MCP) server designed to calculate MD5 and SHA-256 cryptographic hashes. It enables Large Language Models (LLMs) to efficiently process cryptographic requests by providing specific tools for hashing. The project also serves as a comprehensive guide for understanding and building MCP servers, making it valuable for developers interested in agentic AI and integrating custom tools with LLMs.

How to use MCP-Server-for-Hashing?

There are two primary ways to use the MCP-Server-for-Hashing:

Running with Docker (Recommended):
- Pull the Docker image: docker pull kunalpathak13/hashing-mcp-server:latest.
- Configure your MCP client (e.g., VS Code Copilot Chat, Claude Desktop) to use the Docker command. Examples for settings.json (VS Code) and claude_desktop_config.json (Claude Desktop) are provided in the documentation.
- Interact with your MCP client by asking questions that trigger hashing tools, such as "Calculate the MD5 hash of the text 'hello world'" or "What is the SHA256 hash for the string 'MCP is cool!'?"
Running Directly (Python Environment):
- Set up a Python virtual environment (uv venv or python -m venv .venv).
- Install the package: uv pip install hashing-mcp-server or pip install hashing-mcp-server.
- Find the executable path of the installed script (e.g., which hashing-mcp-server on Linux/macOS).
- Configure your MCP client with the absolute path to the executable. Examples for VS Code and Claude Desktop are provided.
- Test the integration by asking your MCP client to perform hashing operations.

For development or contribution, clone the repository, set up a development environment with uv pip install -e ".[dev]", and run the server locally using hashing-mcp-server or python -m hashing_mcp.cli.

Key Features of MCP-Server-for-Hashing

Cryptographic Hashing: Provides tools for calculating MD5 (calculate_md5) and SHA-256 (calculate_sha256) hashes.
Model Context Protocol (MCP) Compliance: Designed to work seamlessly with MCP clients like VS Code Copilot Chat and Claude for Desktop.
Easy Deployment: Supports deployment via Docker for simplified setup and direct execution within a Python environment.
Comprehensive Documentation: Includes guides and tutorials for understanding MCP and building custom MCP servers.
Open Source: Licensed under the MIT License, encouraging community contributions and modifications.

Use Cases of MCP-Server-for-Hashing

LLM Integration: Enables LLMs to perform cryptographic hashing operations directly within their context, useful for data validation, integrity checks, or secure communication within AI applications.
Agentic AI Development: Serves as a practical example and starting point for developers looking to build and integrate custom tools with agentic AI systems.
Educational Tool: Provides a hands-on resource for learning about the Model Context Protocol and how to create MCP-compatible servers.
Automated Data Processing: Can be integrated into workflows where automated hashing of text data is required.

FAQ from MCP-Server-for-Hashing

What is MCP?
- MCP stands for Model Context Protocol, a protocol that allows LLMs to interact with external tools and services. Resources like "Understanding Model Context Protocol & Agentic AI" are provided for further understanding.
How can I build my own MCP Server?
- A simple tutorial on how to build your own MCP Server is available in the project's documentation (docs/tutorial-build-mcp-server.md).
Where can I find the hashing-mcp-server package?
- The Python package is available on PyPI, the Docker image on Docker Hub, and the source code on GitHub. It's also listed on MCP Server Lists like mcp.so.
How to install and use the hashing-mcp-server?
- Detailed instructions for installation and usage via Docker and direct Python environment are provided in the README, including configuration examples for VS Code and Claude Desktop.
What are the prerequisites for running the server?
- For Docker, Docker must be installed and running. For direct execution, Python 3.13+ and a virtual environment tool are required. For development, Git, Python 3.13+, and uv (or pip) are needed.
How do I contribute to the project?
- Instructions for setting up a development environment, running tests, and the release process for maintainers are outlined in the "Contributing / Development Setup" section.

MCP Server for cryptographic hashing

A Model Context Protocol (MCP) server for MD5 and SHA-256 hashing. This server enables LLMs to process cryptographic requests efficiently.

Available Tools

The server offers 2 tools:

calculate_md5: Computes the MD5 hash of a given text.
calculate_sha256: Computes the SHA-256 hash of a given text.

The server is designed to be used with MCP clients like VS Code Copilot Chat, Claude for Desktop, and other LLM interfaces that support the Model Context Protocol.

Understand MCP and Build Your Own MCP Server

If you are new to the concept of Model Context Protocol (MCP), then you can use these resources:

What is MCP?
- Understanding Model Context Protocol & Agentic AI
How can I build my own MCP Server?
- Simple tutorial on how to build your own MCP Server
Where to find the hashing-mcp-server package?
- You can find the Python Package on PyPI
- You can find the Docker Image on Docker Hub
- You can find the source code in this GitHub repository
- You can find it also on MCP Server Lists like
  - mcp.so
How to install and use the hashing-mcp-server?
- See the sections below for installation and usage instructions.

Server in action

The gif below shows how the MCP server processes requests and returns the corresponding cryptographic hashes. I have used Claude Desktop as an example, but it works equally well with other MCP clients like VSCode. MCP Server in action

Prerequisites

To Run via Docker: Docker installed and running.
To Run Directly: Python 3.13+ and a virtual environment tool (venv, uv).
To Contribute/Develop: Git, Python 3.13+, uv (recommended) or pip, Docker (optional, for testing build).

Option 1: Running the Server with Docker (Recommended)

This is the simplest way to run the server without managing Python environments directly.

1. Get the Docker Image:

Pull from Docker Hub (Easiest):

docker pull kunalpathak13/hashing-mcp-server:latest

2. Configure Your MCP Client:

Configure your client to use docker run.

VS Code (settings.json):

// In your VS Code settings.json (User or Workspace)
"mcp": {
    "servers": {
        "hashing-docker": { // Use a distinct name if needed
            "command": "docker",
            "args": [
                "run",
                "-i",      // Keep STDIN open for communication
                "--rm",    // Clean up container after exit
                "kunalpathak13/hashing-mcp-server:latest" // Change the tag to your version if needed e.g. "hashing-mcp-server:X.Y.Z"
            ]
        }
    }
}

Claude Desktop (claude_desktop_config.json):

{
	"mcpServers": {
		"hashing-docker": {
			"command": "docker",
			"args": [
				"run",
				"-i",
				"--rm",
				"kunalpathak13/hashing-mcp-server:latest" // Change the tag to your version if needed e.g. "hashing-mcp-server:X.Y.Z"
			]
		}
	}
}

Other Clients: Adapt according to their docs, using docker as the command and run -i --rm IMAGE_NAME as arguments. Refer to their official documentation for precise configuration steps:

3. Test the Integration:

Once configured, interact with your MCP client (VS Code Chat, Claude Desktop, etc.). Ask questions designed to trigger the hashing tools:

"Calculate the MD5 hash of the text 'hello world'"
"What is the SHA256 hash for the string 'MCP is cool!'?"

The client should start the Docker container in the background using the command you provided, send the request, receive the hash result, and display it.

Option 2: Running the Server Directly (Python Environment)

Use this method if you prefer not to use Docker or for development purposes.

1. Set Up Environment & Install:

# Create a dedicated directory and navigate into it
mkdir my_mcp_setup && cd my_mcp_setup

# --- Create & Activate Virtual Environment (Choose ONE method) ---
# Method A: Using uv (Recommended):
uv venv
source .venv/bin/activate # Linux/macOS
# .venv\Scripts\activate # Windows

# Method B: Using standard venv:
# python -m venv .venv
# source .venv/bin/activate # Linux/macOS
# .venv\Scripts\activate # Windows
# ---

# --- Install the package (within the active venv, choose ONE method) ---
# Method A: Using uv:
uv pip install hashing-mcp-server

# Method B: Using pip:
# pip install hashing-mcp-server
# ---

2. Find the Executable Path:

With the virtual environment active, find the full, absolute path to the installed script:

# On Linux/macOS:
which hashing-mcp-server
# Example Output: /home/user/my_mcp_setup/.venv/bin/hashing-mcp-server

# On Windows (Command Prompt/PowerShell):
where hashing-mcp-server
# Example Output: C:\Users\User\my_mcp_setup\.venv\Scripts\hashing-mcp-server.exe

Copy the full path displayed in the output.

3. Configure Your MCP Client:

Use the absolute path you copied in the client configuration.

VS Code (settings.json):

// In your VS Code settings.json (User or Workspace)
"mcp": {
    "servers": {
        // You can name this key anything, e.g., "hasher" or "cryptoTools"
        "hashing": {
            // Paste the full, absolute path you copied here:
            "command": "/full/path/to/your/virtualenv/bin/hashing-mcp-server"
            // No 'args' needed when running the installed script directly
        }
    }
}

(Replace the example path with your actual path)

Claude Desktop (claude_desktop_config.json):

{
	"mcpServers": {
		"hashing": {
			// Paste the full, absolute path you copied here:
			"command": "/full/path/to/your/virtualenv/bin/hashing-mcp-server"
		}
	}
}

(Replace the example path with your actual path)

Other Clients: Follow their specific instructions, providing the full absolute path found in step 2 as the command.

4. Test the Integration:

Once configured, interact with your MCP client (VS Code Chat, Claude Desktop, etc.). Ask questions designed to trigger the hashing tools: - "Use the calculate_md5 tool on 'hello world'." - "Compute the SHA256 hash for the text 'MCP rocks'."

The client should start the server script using the absolute path you provided, send the request, receive the hash result, and display it.

Contributing / Development Setup

Follow these steps if you want to modify the server code or contribute.

1. Clone the Repository:

git clone https://github.com/kanad13/MCP-Server-for-Hashing.git
cd MCP-Server-for-Hashing

2. Set Up Development Environment:

# Create & Activate Virtual Environment (using uv recommended)
uv venv
source .venv/bin/activate # Linux/macOS
# .venv\Scripts\activate # Windows

# Install in editable mode with development dependencies
uv pip install -e ".[dev]"

(This installs the package such that code changes in src/ take effect immediately without reinstalling. It also installs tools defined in [project.optional-dependencies.dev] like pytest)

3. Running Locally During Development: Ensure your development virtual environment is active. You can run the server using:

# Run the installed script (available due to -e flag)
hashing-mcp-server

Or execute the module directly:

python -m hashing_mcp.cli

(You might temporarily configure your MCP client to point to the executable path within this specific development .venv for integrated testing)

4. Running Tests: Ensure your development virtual environment is active:

pytest

Maintainer Tasks: Releasing a New Version

(For project maintainers)

The release process (building, testing, tagging, pushing to PyPI and Docker Hub) is automated by the build_and_push.sh script located in the repository root.

Prerequisites for Running the Script:

You must be inside the activated development virtual environment (source .venv/bin/activate or .venv\Scripts\activate).
Required tools must be available: uv (or pip), twine, git, docker.
Credentials must be configured:
- Docker: Logged in via docker login.
- PyPI: Production API token configured via TWINE_USERNAME=__token__ and TWINE_PASSWORD=pypi-... environment variables or ~/.pypirc.
Push access granted to the target Git repository (origin by default) and the Docker Hub repository (kunalpathak13/hashing-mcp-server by default).

Release Steps:

Ensure the version field in pyproject.toml is updated to the correct new version number.
Commit and push any final code changes to the main branch.
Make the release script executable (one-time setup): chmod +x build_and_push.sh
Activate the virtual environment: source .venv/bin/activate (or equivalent).
Run the script from the repository root: ./build_and_push.sh
The script will perform all steps: build, check, upload to PyPI, build Docker image, tag Docker image (version and latest), push Docker images, create Git tag, push Git tag.
Verify the new package version is live on PyPI and the new Docker tags are available on Docker Hub.

License

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

Acknowledgements

Anthropic & Model Context Protocol Docs