Post-Quantum

You can run a Post-Quantum Cryptography MCP Server locally to perform quantum-resistant cryptographic operations via MCP clients. It leverages liboqs to provide key exchange, signatures, hashing, and security analyses aligned with NIST-inspired post-quantum standards, enabling AI agents and tools to experiment with quantum-resistant workflows.

How to use

Set up the server locally and connect an MCP client to perform post-quantum operations. Start the local MCP server, then request key generation, encapsulation, signing, verification, and hashing using the available MCP endpoints. You will interact with the server through the client’s standard MCP call patterns, receiving structured results such as public keys, ciphertexts, shared secrets, signatures, and verification outcomes.

Typical workflow: start the server, choose an algorithm, generate keys, perform encapsulation or decapsulation, sign messages, verify signatures, and assess security properties. You can also query information about specific algorithms and compare security levels. No raw protocol details are required here; you interact through your MCP client’s user-friendly commands and responses.

How to install

# Prerequisites
# - Python 3.10+
# - liboqs shared library
# - uv (recommended) or pip

# 1. Install liboqs on macOS (shared library build)
# Note: build from source to obtain a shared library
git clone --depth 1 --branch 0.15.0 https://github.com/open-quantum-safe/liboqs.git
cd liboqs && mkdir build && cd build
cmake -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX=$HOME/.local ..
make -j4 && make install

# 1. Install liboqs on Ubuntu/Debian
sudo apt-get update
sudo apt-get install liboqs-dev

# 2. Clone and install the MCP server
git clone https://github.com/scottdhughes/post-quantum-mcp.git
cd post-quantum-mcp

# Create virtual environment with Python 3.10+
uv venv --python 3.10 .venv
source .venv/bin/activate

# Install dependencies
uv pip install liboqs-python "mcp>=1.0.0"

# 3. Configure MCP clients (Claude Code and Claude Desktop)
# Claude Code JSON snippet
cat > ~/.claude.json << 'JSON'
{
  "mcpServers": {
    "pqc": {
      "type": "stdio",
      "command": "/path/to/post-quantum-mcp/run.sh",
      "args": [],
      "env": {}
    }
  }
}
JSON

# Claude Desktop JSON snippet
cat > claude_desktop_config.json << 'JSON'
{
  "mcpServers": {
    "pqc": {
      "command": "/path/to/post-quantum-mcp/run.sh"
    }
  }
}
JSON
```]},{

Additional content

Security notes: keys are generated in memory by default. For production use, implement secure key storage according to your threat model. liboqs implementations strive for constant-time operations but may not cover all side-channel threats. Choose algorithms in line with current standards, recognizing that ML-KEM and ML-DSA are NIST-approved, while others may be experimental. Ensure the liboqs version matches the Python bindings you install.

Development and testing commands you might run during integration include running tests, formatting, and type checks. Keep your environment isolated to avoid conflicts with system packages.

Available tools

pqc_list_algorithms

List all available post-quantum algorithms with their NIST mappings and categories (KEMs and signatures).

pqc_algorithm_info

Provide detailed information about a specific algorithm, including key sizes, security level, and performance characteristics.

pqc_generate_keypair

Generate a quantum-resistant key pair for a chosen algorithm, returning base64-encoded public and private keys.

pqc_encapsulate

Perform key encapsulation to create a shared secret using a given public key and algorithm.

pqc_decapsulate

Recover the shared secret from ciphertext using the corresponding secret key.

pqc_sign

Sign a message with a post-quantum signature and return a base64-encoded signature.

pqc_verify

Verify a post-quantum signature against a public key and message.

pqc_hash_to_curve

Hash a message using quantum-safe hash functions and output digests in hex/base64.

pqc_security_analysis

Analyze and report the security properties and equivalence levels of a chosen algorithm.