git clone https://github.com/bble/monad-mcp.git

npm install

// Create a new MCP server instance
const server = new McpServer({
  name: "monad-testnet",
  version: "0.0.1",
  // Array of supported tool names that clients can call
  capabilities: ["get-mon-balance"]
});

server.tool(
    // Tool ID 
    "get-mon-balance",
    // Description of what the tool does
    "Get MON balance for an address on Monad testnet",
    // Input schema
    {
        address: z.string().describe("Monad testnet address to check balance for"),
    },
    // Tool implementation
    async ({ address }) => {
        try {
            // Check MON balance for the input address
            const balance = await publicClient.getBalance({
                address: address as `0x${string}`,
            });

            // Return a human friendly message indicating the balance.
            return {
                content: [
                    {
                        type: "text",
                        text: `Balance for ${address}: ${formatUnits(balance, 18)} MON`,
                    },
                ],
            };
        } catch (error) {
            // If the balance check process fails, return a graceful message back to the MCP client indicating a failure.
            return {
                content: [
                    {
                        type: "text",
                        text: `Failed to retrieve balance for address: ${address}. Error: ${
                        error instanceof Error ? error.message : String(error)
                        }`,
                    },
                ],
            };
        }
    }
);

### Add functionality to query NFT count
server.tool(
    // Function identifier
    "get-nft-count",
    // Function description
    "Query the number of NFTs held by an address on the Monad testnet",
    // Parameter definition
    {
        address: z.string().describe("The Monad testnet address to query"),
        nftContract: z.string().describe("NFT contract address")
    },
    // Function implementation
    async ({ address, nftContract }) => {
        try {
            // Call the contract's balanceOf method to get the NFT count
            const balance = await publicClient.readContract({
                address: nftContract as `0x${string}`,
                abi: [
                    {
                        inputs: [{ name: "owner", type: "address" }],
                        name: "balanceOf",
                        outputs: [{ name: "", type: "uint256" }],
                        stateMutability: "view",
                        type: "function"
                    }
                ],
                functionName: "balanceOf",
                args: [address as `0x${string}`]
            });

            // Return the formatted query result
            return {
                content: [
                    {
                        type: "text",
                        text: `The address ${address} holds ${balance.toString()} NFTs in contract ${nftContract}.`,
                    },
                ],
            };
        } catch (error) {
            // Error handling
            return {
                content: [
                    {
                        type: "text",
                        text: `Failed to query NFT count for address ${address}: ${
                        error instanceof Error ? error.message : String(error)
                        }`,
                    },
                ],
            };
        }
    }
);

async function main() {
    // Create a transport layer using standard input/output
    const transport = new StdioServerTransport();
    
    // Connect the server to the transport
    await server.connect(transport);
    
    console.error("Monad testnet MCP Server running on stdio");
}

npm run build

{
  "mcpServers": {
    ...
    "monad-mcp": {
      "command": "node",
      "args": [
        "/<path-to-project>/build/index.js"
      ]
    }
  }
}