Cheqd MCP Toolkit

What is Cheqd MCP Toolkit about?

The toolkit offers a configurable MCP server that AI agents can use to interact with the Cheqd network for identity‑related workflows, such as DID management, credential issuing, and trust‑registry verification.

How to use Cheqd MCP Toolkit?

1. Prerequisites: Node.js 20+, pnpm 8+, basic TypeScript knowledge.
2. Install dependencies:

   pnpm install
   pnpm build
   

3. Run a server – three options are supported:
   • Remote server – add the provided JSON snippet to Claude Desktop or Cursor config; no local setup required.
   • Local server via NPX – execute an NPX command with environment variables (see serverConfig example).
   • Local server via Docker‑Compose – use the docker-compose.yml in the docker folder together with env.example.
4. Configure tools via the TOOLS environment variable (e.g., credo).

Key features of Cheqd MCP Toolkit

• Configurable MCP server deployment (NPX or Docker).
• Integrated toolkits, currently @cheqd/mcp-toolkit-credo, for DID & credential operations.
• Environment‑driven setup for ports, agent names, endpoints, and testnet mnemonic.
• Ready‑to‑use remote MCP endpoint for quick prototyping.
• Comprehensive documentation and CI badges indicating release stability.

Use cases of Cheqd MCP Toolkit

• Building AI‑driven identity agents that issue, verify, and revoke verifiable credentials.
• Rapid prototyping of trust‑registry interactions for compliance and credential trust.
• Testing decentralized identity workflows on Cheqd testnet without managing infrastructure.
• Integrating with Claude Desktop or Cursor to give large language models direct access to DID services.

FAQ from the Cheqd MCP Toolkit

Q: Do I need to run a local server? A: No. You can connect to the hosted remote MCP server by adding the JSON config to your client.

Q: Which toolkits are available? A: Currently only credo (via @cheqd/mcp-toolkit-credo) is provided, but the TOOLS variable allows future extensions.

Q: How do I set my testnet credentials? A: Set CREDO_CHEQD_TESTNET_MNEMONIC in the environment to your 12‑word mnemonic.

Q: Can I run the server in Docker? A: Yes, copy env.example to .env, adjust variables, then execute docker compose -f docker/docker-compose.yml up.

Q: What ports are used? A: CREDO_PORT for the Credo agent (default 3000) and PORT for the MCP server (default 5000).

Cheqd MCP Toolkit

ℹ️ Overview

The @cheqd/mcp-toolkit is a modular framework built around the Model Context Protocol (MCP) which allows AI agents to interact with the Cheqd network. MCP standardizes AI agent interactions by providing a structured way to handle identity-related workflows. This toolkit enables AI agents to securely manage decentralized identities (DIDs), verifiable credentials, and trust registries, making it an essential component for AI-driven identity systems. This repository allows developers to configure and deploy an MCP server with the available toolkits.

🌐 Remote MCP Server

For the quickest way to get started, you can connect to our hosted MCP server. Simply add the following configuration to your Claude Desktop or Cursor settings file:

• For Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows)

• For Cursor: .cursor/mcp.json

{
    "mcpServers": {
        "cheqd-mcp": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://remote-mcp.cheqd.io/mcp"
            ],
        }
    }
}

The remote option requires no local setup and provides immediate access to cheqd identity tools.

Prerequisites

• Node.js 20 or higher
• pnpm 8 or higher
• Basic knowledge of TypeScript and MCP

📦 Packages

@cheqd/mcp-toolkit

The @cheqd/mcp-toolkit package allows you to configure and host an MCP (Model Context Protocol) server within an environment. It integrates with tools from this repository to provide a customizable infrastructure for managing identity-related operations.

Features:

• Configurable MCP server setup
• Integration with various tools from this repository

Usage Options

1. Remote Server (Easiest)

Connect to our hosted MCP server - no local setup required:

{
    "mcpServers": {
        "cheqd-mcp": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://remote-mcp.cheqd.io/mcp"
            ],
        }
    }
}

2. Local server via NPX

Use this to run the Cheqd MCP Server locally and pass your own environment variables.

{
    "mcpServers": {
        "cheqd": {
            "command": "npx",
            "args": [
                "-y",
                "@cheqd/mcp-toolkit-server"
            ],
            "env": {
                "TOOLS": "credo,<other available tools>",
                ...
            }
        }
    }
}

3. Local Server via docker-compose

Use the env.example file and update the appropriate variables.

{
  "mcpServers": {
    "cheqd-docker-compose": {
      "command": "docker",
      "args": [
        "compose",
        "-f",
        "/path/to/repo/mcp-toolkit/docker/docker-compose.yml",
        "run",
        "--rm",
        "-p", 
        "3000:3000",
        "--name",
        "faber",
        "-T",
        "mcp-server"
      ]
    }
  }
}

@cheqd/mcp-toolkit-credo

The @cheqd/mcp-toolkit-credo package is one of the toolkits that integrate with @openwalletfoundation/credo-ts, allowing an AI agent to manage DIDs and verifiable credentials. It provides tools for:

• Issuing and revoking credentials
• Schema and credential definition management
• DID-based authentication
• TRAIN for trust registry verification

🌍 Environment Variables

TOOLS="credo"       # Comma separated list of Tools, as of now only 'credo'
CREDO_PORT="3000"   # Port on which the Credo agent will run
CREDO_NAME="faber"  # Name of the Credo Agent
CREDO_ENDPOINT="http://faber:3000"    # Endpoint which Credo Agent is accessible externally
CREDO_CHEQD_TESTNET_MNEMONIC="your-mnemonic-phrase"   # Your Testnet mnemonic phrase
TRAIN_ENDPOINT="https://dev-train.trust-scheme.de/tcr/v1/"    # The TRAIN endpoint for verification of trust registry 
PORT="5000"   # The Port where the Remote MCP Server will run

Developer Options

Development Setup

1. Install pnpm

If you don't already have pnpm installed:

npm install -g pnpm

2. Clone the repository

git clone https://github.com/cheqd/mcp-toolkit.git
cd mcp-toolkit

3. Install dependencies

pnpm install

4. Build the packages

pnpm build

📚 Documentation

For comprehensive details on the Cheqd MCP Toolkit, usage examples, and AI agent integrations, please refer to our official documentation:

👉 MCP Documentation on cheqd.io

The documentation covers advanced topics including:

• Architecture and design of MCP
• Integrating MCP with AI agents
• Real-world use cases and patterns
• Security and trust model
• Deployment recommendations

💬 Community

Our Discord server is the primary chat channel for our open-source community, software developers, and node operators.

Please reach out to us there for discussions, help, and feedback on the project.

🙋 Find us elsewhere