Overview

The Cheqd MCP Server (part of the cheqd/mcp-toolkit) is a lightweight Model Context Protocol (MCP) server implementation and toolkit that enables AI agents to perform identity-centric operations on the cheqd network. It exposes structured MCP endpoints that let agents manage decentralized identifiers (DIDs), issue and revoke verifiable credentials (VCs), and consult trust registries — all through standardized, reproducible “model context” interactions.

This toolkit is useful when you want to integrate secure identity workflows into AI agents or applications (for example, prompting an LLM to request a credential issuance or to verify a credential against a trust registry). It supports running a hosted remote MCP server, a local one via npx, or containerized deployment with docker-compose — making it easy to prototype and productionize DID/VC flows for agent-driven systems.

Features

MCP server scaffold that implements Model Context Protocol endpoints for identity workflows
Tool integrations (e.g., credo) to manage DIDs, schemas, credential definitions, and issuance/revocation flows
Support for remote hosted server, local NPX startup, and docker-compose deployment
Environment-driven configuration for flexible deployments and CI/CD
Example configurations for connecting to MCP servers from desktop agents (e.g., Claude Desktop, Cursor)
Designed for developer extensibility and integration in AI-driven automation

Prerequisites

Node.js 20+ (recommended)
pnpm 8+ (for development)
Basic TypeScript / Node.js experience
Familiarity with MCP concepts and decentralized identity (DIDs, VCs) is helpful but not required

Installation / Configuration

Quick examples for connecting or running the MCP server.

Connect to the hosted remote MCP server (no local setup)

Add to your Claude Desktop or Cursor config:

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

Run a local server using NPX

You can run the server locally and pass configuration via environment variables:

{
  "mcpServers": {
    "cheqd": {
      "command": "npx",
      "args": ["-y", "@cheqd/mcp-toolkit-server"],
      "env": {
        "TOOLS": "credo",
        "PORT": "5000",
        "CREDO_NAME": "faber"
      }
    }
  }
}

Run via docker-compose

Use the provided docker/docker-compose.yml and an env file:

# from repo root (example)
cp docker/env.example docker/.env
# edit docker/.env then:
docker compose -f docker/docker-compose.yml up --build

Environment Variables

Common environment variables used by the toolkit:

Variable	Purpose	Example
TOOLS	Comma-separated toolkit names to load (e.g., credo)	“credo”
PORT	Port where the MCP server listens	“5000”
CREDO_PORT	Port for the Credo agent	“3000”
CREDO_NAME	Credo agent name	“faber”
CREDO_ENDPOINT	External endpoint for Credo	“http://faber:3000”
CREDO_CHEQD_TESTNET_MNEMONIC	Testnet mnemonic for cheqd interactions	“your-mnemonic-phrase”
TRAIN_ENDPOINT	TRAIN trust-registry endpoint	“https://dev-train.trust-scheme.de/tcr/v1/”

Adjust these via your process manager, NPX config, or docker env file.

Available Tools / Resources

@cheqd/mcp-toolkit — core server and toolkit loader for MCP
@cheqd/mcp-toolkit-credo — Credo integration to handle DID lifecycle, schema/creddef, issuance and revocation using @openwalletfoundation/credo-ts
Hosted remote MCP server: https://remote-mcp.cheqd.io/mcp (suitable for demos / quick experimentation)
GitHub repo with examples and docker compose: https://github.com/cheqd/mcp-toolkit

Use Cases

AI-driven DID management: an agent can create and manage DIDs programmatically, rotate keys, and perform DID-authenticated operations via MCP calls.
Credential issuance workflows: an LLM-powered assistant triggers a VC issuance flow (select schema, produce credential data, request issuance), and the toolkit (credo) issues and returns VC artifacts.
Verification and trust checks: before accepting a credential, an agent can validate signatures and consult TRAIN trust registries to confirm an issuer is trusted.
Credential revocation and lifecycle: automated revocation when policy conditions are met (e.g., certificate expiry, policy violation), and letting agents query revocation status via MCP.
Integration into chat/agent platforms: connect Claude Desktop, Cursor, or other agent runtimes to the MCP server to enable identity tasks as part of conversational flows.

Example: Issue a credential via MCP

Agent composes a model context request containing credential subject data.
MCP server forwards the request to the credo tool.
Credo creates a credential, signs it with the issuer DID, and returns the VC to the agent.

Development

Quick dev steps:

# install pnpm if needed
npm install -g pnpm

# clone and prepare
git clone https://github.com/cheqd/mcp-toolkit.git
cd mcp-toolkit
pnpm install
pnpm build

The repo contains examples and a docker directory for containerized deployments.

Notes & Next Steps

This toolkit is modular: add or remove tools by changing the TOOLS env value.
For production, secure your endpoints, manage secrets (mnemonics) with a vault, and configure TLS.
See the repository for up-to-date examples, release notes, and contributors: https://github.com/cheqd/mcp-toolkit

This guide should help you get a Cheqd MCP Server running and integrated into AI agent workflows for decentralized identity and verifiable credentials.

Cheqd MCP Server for AI DID Workflows