Algorand

Model Context Protocol (MCP) enables you to supply structured context, tools, and instructions to language models so they can access and operate with blockchain capabilities more effectively. This Algorand MCP Server provides a ready way to interact with the Algorand network from an MCP-enabled workflow, including account and asset handling, transaction creation, and rich state queries. It coordinates server-side Algorand capabilities with client-side agents and tools, so you can build powerful automated agents that work with Algorand data and operations.

How to use

You run the Algorand MCP Server locally or in your environment and connect it to an MCP client. The server exposes resources and tools that a client or agent can invoke to perform Algorand operations, query blockchain state, manage wallets, and sign transactions. You can configure the server with environment variables to point to the Algorand network, Algod and Indexer endpoints, wallet data, and optional DeFi or domain services. When integrated with an MCP client, your agent can request account information, submit transactions, or fetch knowledge resources to guide decisions.

How to install

node -v

Upgrade to 23.6.1 or later if needed!

Then check the Claude or Cursor container folders to have mcp-servers folder (if not create one):

mkdir PATH_ON_YOUR_MACHINE/Claude/mcp-servers
# or for Cursor 
mkdir PATH_ON_YOUR_MACHINE/Cursor/mcp-servers

Then clone this repository under mcp-servers folder and install dependencies:

cd PATH_ON_YOUR_MACHINE/Claude/mcp-servers
# or for Cursor 
cd PATH_ON_YOUR_MACHINE/Cursor/mcp-servers
# Clone the repository
git clone https://github.com/GoPlausible/algorand-mcp.git
cd algorand-mcp
# Install dependencies
npm install
# Build the project
npm run build
# Edit the .env file to set your configurations

And you are done! Now you can open you MCP config and add the server as :

{
  "mcpServers": {
    "algorand-mcp": {
      "command": "node",
      "args": [
        "PATH_ON_YOUR_MACHINE/Claude/mcp-servers/algorand-mcp/packages/server/dist/index.js"
     ],
      "env": {
        "ALGORAND_NETWORK": "testnet",
        "ALGORAND_ALGOD_API": "https://testnet-api.algonode.cloud/v2",
        "ALGORAND_ALGOD": "https://testnet-api.algonode.cloud",
        "ALGORAND_INDEXER_API": "https://testnet-idx.algonode.cloud/v2",
        "ALGORAND_INDEXER": "https://testnet-idx.algonode.cloud",
        "ALGORAND_ALGOD_PORT": "",
        "ALGORAND_INDEXER_PORT": "",
        "ALGORAND_TOKEN": "",
        "ALGORAND_AGENT_WALLET": "problem aim online jaguar upper oil flight stumble mystery aerobic toy avoid file tomato moment exclude witness guard lab opera crunch noodle dune abandon broccoli",
        "NFD_API_URL": "https://api.nf.domains",
        "NFD_API_KEY": "",
        "TINYMAN_ACTIVE": "false",
        "ULTRADE_ACTIVE": "false",
        "VESTIGE_ACTIVE": "false",
        "ULTRADE_API_URL": "https://api.ultrade.io",
        "VESTIGE_API_URL": "https://api.vestigelabs.org",
        "VESTIGE_API_KEY": "",
        "ITEMS_PER_PAGE": "10"

      }
    }
  }
}

Make sure you change the paths to match your local system's paths.

For example on MACOS and Claud, the path would be something like this:

{
  "mcpServers": {
    "algorand-mcp": {
      "command": "node",
      "args": [
        " /Users/YOUR_USERNAME/Library/Application\ Support/Claude/mcp-servers/algorand-mcp/packages/server/dist/index.js"
     ]
    }
  }
}

Additional sections

Project architecture is modular, with a Server Package that provides MCP tools for blockchain interactions, and a Client Package for wallet connections and transaction signing. The server handles account management, asset operations, application interactions, transaction creation and submission, and comprehensive blockchain state queries. The client focuses on wallet management and signing, with browser and Node.js compatibility.

Core implementation aspects include knowledge taxonomy resources, MCP tools for accounts, assets, applications, transactions, and a variety of API tools for algod, indexer, NFDomains, Vestige DeFi analytics, Tinyman AMM, and Ultrade DEX. This enables end-to-end blockchain interactions from an MCP-enabled agent.

Security considerations include managing API endpoints, wallet keys, and tokens through the environment configuration. Disable optional integrations (Vestige, Tinyman, Ultrade) by setting their active flags to false until you need them. Always validate environment values and restrict access to the MCP server. Regularly update dependencies to keep the server secure.

Available tools

create_account

Create a new Algorand account

rekey_account

Rekey an account to a new address

validate_address

Check if an Algorand address is valid

encode_address

Encode a public key to an Algorand address

decode_address

Decode an Algorand address to a public key

make_app_create_txn

Create an application creation transaction

make_app_update_txn

Create an application update transaction

make_app_delete_txn

Create an application delete transaction

make_app_optin_txn

Create an application opt-in transaction

make_app_closeout_txn

Create an application close-out transaction

make_app_clear_txn

Create an application clear state transaction

make_app_call_txn

Create an application call transaction

get_application_address

Get the address for a given application ID

compile_teal

Compile TEAL source code

disassemble_teal

Disassemble TEAL bytecode back to source

make_asset_create_txn

Create an asset creation transaction

make_asset_config_txn

Create an asset configuration transaction

make_asset_destroy_txn

Create an asset destroy transaction

make_asset_freeze_txn

Create an asset freeze transaction

make_asset_transfer_txn

Create an asset transfer transaction

send_raw_transaction

Submit signed transactions to the network

simulate_raw_transactions

Simulate raw transactions

simulate_transactions

Simulate transactions with detailed configuration

make_payment_txn

Create a payment transaction

assign_group_id

Assign a group ID to a list of transactions

sign_transaction

Sign a transaction with a secret key

mnemonic_to_mdk

Convert a mnemonic to a master derivation key

mdk_to_mnemonic

Convert a master derivation key to a mnemonic

secret_key_to_mnemonic

Convert a secret key to a mnemonic

mnemonic_to_secret_key

Convert a mnemonic to a secret key

seed_from_mnemonic

Generate a seed from a mnemonic

mnemonic_from_seed

Generate a mnemonic from a seed

sign_bytes

Sign arbitrary bytes with a secret key

bytes_to_bigint

Convert bytes to a BigInt

bigint_to_bytes

Convert a BigInt to bytes

encode_uint64

Encode a uint64 to bytes

decode_uint64

Decode bytes to a uint64

generate_algorand_uri

Generate an Algorand URI and QR code according to ARC-26 specification