Skip to main content
Glama

ResilientDB MCP Server

by rahulkanagaraj786
GitHub
Python
OverviewInspectNewEndpointsSchemaRelated ServersReviewsScore
Need Help?View Source CodeReport Issue

ResilientDB MCP Server

A Model Context Protocol (MCP) server for interacting with ResilientDB, a high-performance blockchain platform. This server allows Large Language Models (LLMs) like Claude to interact with ResilientDB through smart contract operations and GraphQL queries.

Overview

This MCP server bridges the gap between AI agents (like Claude Desktop) and ResilientDB by providing a standardized interface for:

  • Smart Contract Operations: Compile, deploy, and execute smart contracts using ResContract CLI

  • GraphQL Operations: Create accounts, manage transactions, and query data

  • Key-Value Operations: Store and retrieve data using ResilientDB's key-value store

Features

Smart Contract Operations

  • compileContract: Compile smart contracts using ResContract CLI

  • deployContract: Deploy compiled contracts to the ResilientDB blockchain

  • executeContract: Execute contract methods (read/write operations)

  • getContractState: Retrieve the current state of a deployed contract

GraphQL Operations

  • createAccount: Create new accounts in ResilientDB

  • getTransaction: Retrieve transaction details by ID

  • postTransaction: Post new transactions to the blockchain

  • updateTransaction: Update existing transactions

Key-Value Operations

  • get: Retrieve values by key

  • set: Store key-value pairs

Installation

Prerequisites

  • Python 3.11 or higher

  • ResilientDB instance running (see ResilientDB Installation)

  • ResContract CLI installed (for smart contract operations)

  • Access to ResilientDB GraphQL endpoint

Local Installation

  1. Clone the repository:

git clone https://github.com/rahulkanagaraj786/ResilientDB-MCP.git cd ResilientDB-MCP

  1. Install dependencies:

pip install -r requirements.txt

  1. Configure environment variables:

cp .env.example .env # Edit .env with your ResilientDB configuration

  1. Update .env file with your settings:

RESILIENTDB_GRAPHQL_URL=http://localhost:9000/graphql RESCONTRACT_CLI_PATH=rescontract

Docker Installation

  1. Build the Docker image:

docker build -t mcp/resilientdb -f Dockerfile .

  1. Run the container:

docker run -i --rm mcp/resilientdb

Configuration

Environment Variables

Variable

Description

Default

RESILIENTDB_GRAPHQL_URL

GraphQL endpoint URL

http://localhost:9000/graphql

RESCONTRACT_CLI_PATH

Path to ResContract CLI executable

rescontract

RESILIENTDB_API_KEY

Optional API key for authentication

None

RESILIENTDB_AUTH_TOKEN

Optional auth token

None

REQUEST_TIMEOUT

Request timeout in seconds

30

TRANSACTION_POLL_INTERVAL

Polling interval for transactions

1.0

MAX_POLL_ATTEMPTS

Maximum polling attempts

30

Usage with Claude Desktop

Add the MCP server to your Claude Desktop configuration:

  1. Open Claude Desktop settings

  2. Edit the MCP servers configuration file (usually claude_desktop.json)

  3. Add the following configuration:

For Local Installation:

{ "mcpServers": { "resilientdb": { "command": "python", "args": ["/path/to/ResilientDB-MCP/server.py"], "env": { "RESILIENTDB_GRAPHQL_URL": "http://localhost:9000/graphql", "RESCONTRACT_CLI_PATH": "rescontract" } } } }

For Docker Installation:

{ "mcpServers": { "resilientdb": { "command": "docker", "args": ["run", "-i", "--rm", "mcp/resilientdb"] } } }

  1. Restart Claude Desktop

Available Tools

createAccount

Create a new account in ResilientDB.

Parameters:

  • accountId (optional): Account ID. If not provided, server will generate one.

Example:

{ "accountId": "my-account-123" }

compileContract

Compile a smart contract using ResContract CLI.

Parameters:

  • contractPath (required): Path to the contract file

  • outputDir (optional): Output directory for compiled contract

Example:

{ "contractPath": "/path/to/contract.sol", "outputDir": "/path/to/output" }

deployContract

Deploy a compiled smart contract to ResilientDB.

Parameters:

  • contractPath (required): Path to the compiled contract

  • accountId (optional): Account ID for deployment

  • constructorArgs (optional): Constructor arguments

Example:

{ "contractPath": "/path/to/compiled_contract.json", "accountId": "my-account-123", "constructorArgs": ["arg1", "arg2"] }

executeContract

Execute a method on a deployed smart contract.

Parameters:

  • contractAddress (required): Address of the deployed contract

  • methodName (required): Name of the method to execute

  • methodArgs (optional): Method arguments

  • accountId (optional): Account ID for execution

  • transactionType (optional): "call" for read operations, "send" for write operations (default: "call")

Example:

{ "contractAddress": "0x123...", "methodName": "getValue", "transactionType": "call" }

getTransaction

Get transaction details by transaction ID.

Parameters:

  • transactionId (required): Transaction ID to retrieve

Example:

{ "transactionId": "tx-123456" }

postTransaction

Post a new transaction to ResilientDB.

Parameters:

  • data (required): Transaction data as key-value pairs

Example:

{ "data": { "key": "value", "amount": 100 } }

updateTransaction

Update an existing transaction.

Parameters:

  • transactionId (required): Transaction ID to update

  • data (required): Updated transaction data

Example:

{ "transactionId": "tx-123456", "data": { "status": "completed" } }

get

Retrieve a value from ResilientDB by key.

Parameters:

  • key (required): Key to retrieve

Example:

{ "key": "my-key" }

set

Store a key-value pair in ResilientDB.

Parameters:

  • key (required): Key to store

  • value (required): Value to store

Example:

{ "key": "my-key", "value": "my-value" }

getContractState

Get the current state of a deployed smart contract.

Parameters:

  • contractAddress (required): Address of the deployed contract

Example:

{ "contractAddress": "0x123..." }

Architecture

The MCP server acts as a mediator between the MCP host (Claude Desktop) and ResilientDB backend services:

┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │ Claude │────────▶│ MCP Server │────────▶│ ResilientDB │ │ Desktop │ │ (Python) │ │ Backend │ └─────────────┘ └──────────────┘ └─────────────┘ │ ├──▶ GraphQL Client │ (Account, Transaction, KV ops) │ └──▶ ResContract CLI (Smart Contract ops)

Routing Logic

The server automatically routes requests to the appropriate service:

  • Smart Contract Operations → ResContract CLI

  • Data Operations → GraphQL API

  • Hybrid Operations → Tries GraphQL first, falls back to ResContract CLI

Development

Project Structure

ResilientDB-MCP/ ├── server.py # Main MCP server implementation ├── graphql_client.py # GraphQL client for ResilientDB ├── rescontract_client.py # ResContract CLI client ├── config.py # Configuration management ├── requirements.txt # Python dependencies ├── Dockerfile # Docker configuration └── README.md # This file

Running Tests

# Install test dependencies pip install pytest pytest-asyncio # Run tests pytest

Contributing

  1. Fork the repository

  2. Create a feature branch

  3. Make your changes

  4. Submit a pull request

Troubleshooting

ResContract CLI Not Found

If you get an error about ResContract CLI not being found:

  1. Ensure ResContract CLI is installed

  2. Add it to your PATH, or

  3. Set RESCONTRACT_CLI_PATH environment variable to the full path

GraphQL Connection Errors

If you encounter GraphQL connection errors:

  1. Verify ResilientDB is running

  2. Check the RESILIENTDB_GRAPHQL_URL is correct

  3. Ensure network connectivity to the GraphQL endpoint

  4. Check firewall settings

Transaction Timeouts

If transactions timeout:

  1. Increase REQUEST_TIMEOUT in .env

  2. Check ResilientDB blockchain status

  3. Verify network latency

References

License

Apache 2.0 License

Authors

Team 10 - ECS 265 Project

This server cannot be installed

-
security - not tested
F
license - not found
-
quality - not tested

How are these scores calculated?

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

Enables interaction with ResilientDB blockchain through smart contract operations, GraphQL queries, and key-value storage operations.

  1. Overview
    1. Features
      1. Smart Contract Operations
      2. GraphQL Operations
      3. Key-Value Operations
    2. Installation
      1. Prerequisites
      2. Local Installation
      3. Docker Installation
    3. Configuration
      1. Environment Variables
    4. Usage with Claude Desktop
      1. For Local Installation:
      2. For Docker Installation:
    5. Available Tools
      1. createAccount
      2. compileContract
      3. deployContract
      4. executeContract
      5. getTransaction
      6. postTransaction
      7. updateTransaction
      8. get
      9. set
      10. getContractState
    6. Architecture
      1. Routing Logic
    7. Development
      1. Project Structure
      2. Running Tests
      3. Contributing
    8. Troubleshooting
      1. ResContract CLI Not Found
      2. GraphQL Connection Errors
      3. Transaction Timeouts
    9. References
      1. License
        1. Authors

          New MCP Servers

          MCP directory API

          We provide all the information about MCP servers via our MCP API.

          curl -X GET 'https://glama.ai/api/mcp/v1/servers/rahulkanagaraj786/ResilientDB-MCP'

          If you have feedback or need assistance with the MCP directory API, please join our Discord server