Algorand MCP Server

MCP Server with Algorand Integration

This server provides blockchain transaction capabilities for the Algorand network along with general utility tools.

Overview

This MCP server provides the following tools to AI assistants:

General Tools

echo: Echo back any message (useful for testing connectivity)
calculate: Perform basic mathematical calculations
get_current_time: Get the current time in any timezone

Algorand Blockchain Tools

generate_algorand_account: Generate a new Algorand account with address and mnemonic
get_account_info: Get account information including balance and assets
send_payment: Send Algo payment transaction
create_asset: Create a new Algorand Standard Asset (ASA)
opt_in_to_asset: Opt into an Algorand Standard Asset
transfer_asset: Transfer an Algorand Standard Asset
get_asset_info: Get information about an asset
get_transaction: Get transaction details by transaction ID

Security Features

Mnemonic Phrase Protection

Encryption: Built-in AES-256-GCM encryption for mnemonic phrases
Secure Storage: Methods for encrypting/decrypting wallet credentials
Memory Safety: Sensitive data is handled securely and not logged

Network Configuration

Testnet Default: Safely defaults to Algorand testnet
Environment-based: Network configuration through environment variables
Production Ready: Supports mainnet for production use

Prerequisites

Node.js 18+
npm or yarn
TypeScript

Installation

Clone or download this project
Install dependencies:
npm install
Copy environment configuration:
cp .env.example .env
Configure your Algorand network in .env (defaults to testnet)

Development

Building the Project

npm run build

Running the Server

npm start

Development Mode

For development with automatic rebuilding:

npm run dev

Configuration

For VSCode

{
  "mcpServers": {
    "algorand-mcp-server": {
      "command": "node",
      "args": ["path/to/your/project/dist/index.js"]
    }
  }
}

For VS Code Debugging

The project includes a .vscode/mcp.json configuration file for debugging within VS Code. You can use this with the MCP extension for VS Code.

Available Tools

echo

Description: Echo back the provided message
Parameters:
- message (string, required): The message to echo back

calculate

Description: Perform basic mathematical calculations
Parameters:
- expression (string, required): Mathematical expression to evaluate

get_current_time

Description: Get the current time in a specified timezone
Parameters:
- timezone (string, optional): Timezone identifier (defaults to UTC)

Project Structure

├── src/
│   └── index.ts          # Main server implementation
├── dist/                 # Compiled JavaScript output
├── .vscode/
│   └── mcp.json         # VS Code MCP configuration
├── .github/
│   └── copilot-instructions.md  # GitHub Copilot instructions
├── package.json          # Node.js package configuration
├── tsconfig.json         # TypeScript configuration
└── README.md            # This file

Development Guide

Adding New Tools

Define the tool schema in the TOOLS array
Create a Zod schema for input validation
Add a case in the CallToolRequestSchema handler
Implement the tool logic with proper error handling

Example Tool Implementation

const MyToolArgsSchema = z.object({
  input: z.string(),
});

// Add to TOOLS array
{
  name: 'my_tool',
  description: 'Description of what the tool does',
  inputSchema: {
    type: 'object',
    properties: {
      input: {
        type: 'string',
        description: 'Input parameter description',
      },
    },
    required: ['input'],
  },
}

// Add to request handler
case 'my_tool': {
  const parsed = MyToolArgsSchema.parse(args);
  // Implement tool logic here
  return {
    content: [
      {
        type: 'text',
        text: `Result: ${parsed.input}`,
      },
    ],
  };
}

Security Considerations

Input validation is performed using Zod schemas
The calculate tool uses eval() for demonstration purposes only - in production, use a safer math evaluation library
Always validate and sanitize inputs before processing

Contributing

Fork the repository
Create a feature branch
Implement your changes with proper tests
Submit a pull request

License

ISC License - see package.json for details

Resources

This server cannot be installed

security - not tested

license - not found

quality - not tested

How are these scores calculated?

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

Enables interaction with the Algorand blockchain network including account management, payments, asset creation and transfers, along with general utility tools. Provides secure mnemonic encryption and supports both testnet and mainnet environments.

Related MCP Servers

Ethereum RPC MCP Server
0xKoda
A
security
A
license
A
quality
Provides tools for AI assistants to interact with the Ethereum blockchain through standard JSON-RPC methods, enabling queries for account balances, gas prices, and smart contract code.
Last updated -
6
8
JavaScript
MIT License
Algorand MCP
GoPlausible
-
security
A
license
-
quality
A comprehensive MCP server for tooling interactions(40+) and resource accessibility(60+) with Algorand blockchain, plus many useful prompts.
Last updated -
4
37
TypeScript
MIT License
Multichain MCP Server
oraichain
-
security
A
license
-
quality
A comprehensive toolkit for building AI agents with blockchain capabilities, enabling interactions with multiple blockchain networks for tasks like wallet management, fund transfers, smart contract interactions, and cross-chain asset bridging.
Last updated -
3
TypeScript
GPL 3.0
Flow MCP
Outblock
A
security
A
license
A
quality
Provides tools for interacting with the Flow blockchain, including Flow balance checking, token balance querying, and Cadence Owned Account information retrieval.
Last updated -
5
112
1
TypeScript
MIT License

View all related MCP servers