hedera-mcp-platform 1.0.0

package/README.md

@@ -0,0 +1,45 @@
+# Hedera MCP Platform
+
+Complete Hedera ecosystem intelligence platform for AI agents. 8 MCP servers, 24 tools covering HCS, compliance, governance, tokens, identity, contracts, NFTs and cross-chain bridges. Pay per call in HBAR.
+
+## Live Endpoint
+
+https://hedera-mcp-platform-production.up.railway.app/mcp
+
+## Available Tools
+
+### Module 1 � HCS Topic Intelligence
+
+| Tool | Description | Cost |
+|------|-------------|------|
+| hcs_monitor | Topic metadata and recent activity | Free |
+| hcs_query | Natural language query with AI analysis | 0.05 HBAR |
+| hcs_understand | Deep pattern analysis and anomaly detection | 0.50 HBAR |
+
+### Module 2 � Compliance & Audit Trail
+
+| Tool | Description | Cost |
+|------|-------------|------|
+| hcs_write_record | Write tamper-evident compliance record | 2.00 HBAR |
+| hcs_verify_record | Verify record integrity on-chain | 0.50 HBAR |
+| hcs_audit_trail | Full chronological audit history | 1.00 HBAR |
+
+## Setup
+
+npm install
+cp .env.example .env
+npm start
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| HEDERA_ACCOUNT_ID | Your Hedera account (0.0.XXXXXXX) |
+| HEDERA_PRIVATE_KEY | ECDSA private key |
+| HEDERA_NETWORK | testnet or mainnet |
+| OPENAI_API_KEY | For GPT-4o Mini analysis |
+
+## MCP Registry
+
+Listed at: https://registry.modelcontextprotocol.io
+npm: https://www.npmjs.com/package/hedera-mcp-platform

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "hedera-mcp-platform",
+  "version": "1.0.0",
+  "mcpName": "io.github.mountainmystic/hedera-mcp-platform",
+  "description": "Complete Hedera ecosystem intelligence platform for AI agents. 8 MCP servers, 24 tools. Pay per call in HBAR.",
+  "main": "src/index.js",
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mountainmystic/hedera-mcp-platform.git"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js"
+  },
+  "dependencies": {
+    "@hashgraph/sdk": "^2.46.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "openai": "^4.56.0",
+    "dotenv": "^16.4.5",
+    "axios": "^1.7.7"
+  }
+}

package/server.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.mountainmystic/hedera-mcp-platform",
+  "description": "Hedera ecosystem intelligence for AI agents. 6 tools, 2 modules. Pay per call in HBAR.",
+  "repository": {
+    "url": "https://github.com/mountainmystic/hedera-mcp-platform",
+    "source": "github"
+  },
+  "version": "1.0.0",
+  "packages": [
+    {
+      "registryType": "github",
+      "identifier": "mountainmystic/hedera-mcp-platform",
+      "version": "1.0.0",
+      "transport": {
+        "type": "streamable-http",
+        "url": "https://hedera-mcp-platform-production.up.railway.app/mcp"
+      },
+      "environmentVariables": [
+        {
+          "description": "Hedera account ID in format 0.0.XXXXXXX",
+          "isRequired": true,
+          "isSecret": false,
+          "name": "HEDERA_ACCOUNT_ID"
+        },
+        {
+          "description": "Hedera account private key (ECDSA hex format)",
+          "isRequired": true,
+          "isSecret": true,
+          "name": "HEDERA_PRIVATE_KEY"
+        },
+        {
+          "description": "Hedera network: testnet or mainnet",
+          "isRequired": true,
+          "isSecret": false,
+          "name": "HEDERA_NETWORK"
+        },
+        {
+          "description": "OpenAI API key for GPT-4o Mini powered analysis",
+          "isRequired": true,
+          "isSecret": true,
+          "name": "OPENAI_API_KEY"
+        }
+      ]
+    }
+  ]
+}

package/src/index.js

@@ -0,0 +1,87 @@
+// index.js - Main entry point with stdio and Streamable HTTP transport
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import http from "http";
+import "dotenv/config";
+import { createServer, ALL_TOOLS } from "./server.js";
+import { getCosts } from "./payments.js";
+
+function validateEnv() {
+  const required = ["HEDERA_ACCOUNT_ID", "HEDERA_PRIVATE_KEY", "OPENAI_API_KEY"];
+  const missing = required.filter((key) => !process.env[key]);
+  if (missing.length > 0) {
+    console.error("Missing env vars: " + missing.join(", "));
+    process.exit(1);
+  }
+}
+
+function startHTTPServer() {
+  const port = process.env.PORT || 3000;
+  const httpServer = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://localhost:${port}`);
+
+    if (req.method === "GET" && (url.pathname === "/" || url.pathname === "/health")) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        status: "ok",
+        service: "Hedera MCP Platform",
+        version: "1.0.0",
+        network: process.env.HEDERA_NETWORK,
+        account: process.env.HEDERA_ACCOUNT_ID,
+        modules: ["hcs", "compliance"],
+        tools: ALL_TOOLS.map((t) => t.name),
+        costs: getCosts(),
+        mcp_endpoint: "/mcp",
+        timestamp: new Date().toISOString(),
+      }));
+      return;
+    }
+
+    if (url.pathname === "/mcp") {
+      const server = createServer();
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
+      res.on("close", () => {
+        transport.close();
+        server.close();
+      });
+      await server.connect(transport);
+      await transport.handleRequest(req, res);
+      return;
+    }
+
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found", mcp_endpoint: "/mcp" }));
+  });
+
+  httpServer.listen(port, () => {
+    console.error("HTTP server on port " + port);
+    console.error("Health: http://localhost:" + port + "/");
+    console.error("MCP:    http://localhost:" + port + "/mcp");
+  });
+}
+
+async function main() {
+  validateEnv();
+  const isStdio = !process.env.PORT && process.stdin.isTTY === false;
+
+  if (isStdio) {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Hedera MCP Platform running (stdio)");
+    console.error("Network: " + process.env.HEDERA_NETWORK);
+    console.error("Tools: " + ALL_TOOLS.map(t => t.name).join(", "));
+  } else {
+    startHTTPServer();
+    console.error("Hedera MCP Platform running (HTTP)");
+    console.error("Network: " + process.env.HEDERA_NETWORK);
+    console.error("Tools: " + ALL_TOOLS.map(t => t.name).join(", "));
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/src/modules/compliance/tools.js

@@ -0,0 +1,220 @@
+// compliance/tools.js - Compliance & Audit Trail tool definitions and handlers
+import {
+  Client,
+  AccountId,
+  PrivateKey,
+  TopicMessageSubmitTransaction,
+} from "@hashgraph/sdk";
+import axios from "axios";
+import crypto from "crypto";
+import { chargeForTool } from "../../payments.js";
+
+let hederaClient;
+
+function getClient() {
+  if (!hederaClient) {
+    const network = process.env.HEDERA_NETWORK || "testnet";
+    hederaClient = network === "mainnet" ? Client.forMainnet() : Client.forTestnet();
+    hederaClient.setOperator(
+      AccountId.fromString(process.env.HEDERA_ACCOUNT_ID),
+      PrivateKey.fromStringECDSA(process.env.HEDERA_PRIVATE_KEY)
+    );
+  }
+  return hederaClient;
+}
+
+function getMirrorNodeBase() {
+  return process.env.HEDERA_NETWORK === "mainnet"
+    ? "https://mainnet-public.mirrornode.hedera.com"
+    : "https://testnet.mirrornode.hedera.com";
+}
+
+export const COMPLIANCE_TOOL_DEFINITIONS = [
+  {
+    name: "hcs_write_record",
+    description: "Write a tamper-evident compliance record to the Hedera blockchain. Returns a record ID and transaction proof. Costs 2 HBAR.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic_id: { type: "string", description: "HCS topic ID to write the record to" },
+        record_type: { type: "string", description: "Type of compliance record (e.g. transaction, approval, audit_event)" },
+        entity_id: { type: "string", description: "ID of the entity this record relates to" },
+        data: { type: "object", description: "The compliance data to record (any JSON object)" },
+        api_key: { type: "string", description: "Your AgentLens API key" },
+      },
+      required: ["topic_id", "record_type", "entity_id", "data", "api_key"],
+    },
+  },
+  {
+    name: "hcs_verify_record",
+    description: "Verify a compliance record exists on the Hedera blockchain and has not been tampered with. Costs 0.5 HBAR.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic_id: { type: "string", description: "HCS topic ID where the record was written" },
+        record_id: { type: "string", description: "Record ID returned when the record was written" },
+        api_key: { type: "string", description: "Your AgentLens API key" },
+      },
+      required: ["topic_id", "record_id", "api_key"],
+    },
+  },
+  {
+    name: "hcs_audit_trail",
+    description: "Retrieve the full chronological audit trail for an entity from the Hedera blockchain. Costs 1 HBAR.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic_id: { type: "string", description: "HCS topic ID to query" },
+        entity_id: { type: "string", description: "Entity ID to retrieve audit trail for" },
+        limit: { type: "number", description: "Max records to retrieve (default 50)" },
+        api_key: { type: "string", description: "Your AgentLens API key" },
+      },
+      required: ["topic_id", "entity_id", "api_key"],
+    },
+  },
+];
+
+export async function executeComplianceTool(name, args) {
+  if (name === "hcs_write_record") {
+    const payment = chargeForTool("hcs_write_record", args.api_key);
+    const client = getClient();
+
+    const record = {
+      record_id: crypto.randomUUID(),
+      record_type: args.record_type,
+      entity_id: args.entity_id,
+      data: args.data,
+      written_at: new Date().toISOString(),
+      written_by: process.env.HEDERA_ACCOUNT_ID,
+    };
+
+    const hash = crypto
+      .createHash("sha256")
+      .update(JSON.stringify(record))
+      .digest("hex");
+
+    record.hash = hash;
+
+    const tx = await new TopicMessageSubmitTransaction()
+      .setTopicId(args.topic_id)
+      .setMessage(JSON.stringify(record))
+      .execute(client);
+
+    const receipt = await tx.getReceipt(client);
+
+    return {
+      success: true,
+      record_id: record.record_id,
+      topic_id: args.topic_id,
+      entity_id: args.entity_id,
+      record_type: args.record_type,
+      hash,
+      transaction_id: tx.transactionId.toString(),
+      written_at: record.written_at,
+      verification_note: "This record is permanently stored on the Hedera blockchain and cannot be altered.",
+      payment,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  if (name === "hcs_verify_record") {
+    const payment = chargeForTool("hcs_verify_record", args.api_key);
+    const base = getMirrorNodeBase();
+
+    const response = await axios.get(
+      `${base}/api/v1/topics/${args.topic_id}/messages?limit=100&order=asc`
+    );
+
+    const messages = response.data.messages || [];
+    let foundRecord = null;
+
+    for (const msg of messages) {
+      try {
+        const content = Buffer.from(msg.message, "base64").toString("utf-8");
+        const record = JSON.parse(content);
+        if (record.record_id === args.record_id) {
+          const { hash, ...recordWithoutHash } = record;
+          const computedHash = crypto
+            .createHash("sha256")
+            .update(JSON.stringify(recordWithoutHash))
+            .digest("hex");
+
+          foundRecord = {
+            record_id: record.record_id,
+            record_type: record.record_type,
+            entity_id: record.entity_id,
+            written_at: record.written_at,
+            consensus_timestamp: msg.consensus_timestamp,
+            hash_valid: computedHash === hash,
+            tampered: computedHash !== hash,
+            sequence_number: msg.sequence_number,
+          };
+          break;
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+
+    if (!foundRecord) {
+      return {
+        verified: false,
+        record_id: args.record_id,
+        error: "Record not found on blockchain",
+        payment,
+      };
+    }
+
+    return {
+      verified: true,
+      tampered: foundRecord.tampered,
+      hash_valid: foundRecord.hash_valid,
+      ...foundRecord,
+      payment,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  if (name === "hcs_audit_trail") {
+    const payment = chargeForTool("hcs_audit_trail", args.api_key);
+    const base = getMirrorNodeBase();
+    const limit = args.limit || 50;
+
+    const response = await axios.get(
+      `${base}/api/v1/topics/${args.topic_id}/messages?limit=100&order=asc`
+    );
+
+    const messages = response.data.messages || [];
+    const trail = [];
+
+    for (const msg of messages) {
+      try {
+        const content = Buffer.from(msg.message, "base64").toString("utf-8");
+        const record = JSON.parse(content);
+        if (record.entity_id === args.entity_id) {
+          trail.push({
+            record_id: record.record_id,
+            record_type: record.record_type,
+            written_at: record.written_at,
+            consensus_timestamp: msg.consensus_timestamp,
+            sequence_number: msg.sequence_number,
+            data: record.data,
+          });
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+
+    return {
+      entity_id: args.entity_id,
+      topic_id: args.topic_id,
+      total_records: trail.length,
+      audit_trail: trail.slice(0, limit),
+      payment,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  throw new Error(`Unknown compliance tool: ${name}`);
+}

package/src/modules/hcs/hedera.js

@@ -0,0 +1,29 @@
+// hcs/hedera.js - Hedera mirror node integration
+import axios from "axios";
+
+function getMirrorNodeBase() {
+  const network = process.env.HEDERA_NETWORK || "testnet";
+  return network === "mainnet"
+    ? "https://mainnet-public.mirrornode.hedera.com"
+    : "https://testnet.mirrornode.hedera.com";
+}
+
+export async function getTopicInfo(topicId) {
+  const base = getMirrorNodeBase();
+  const response = await axios.get(`${base}/api/v1/topics/${topicId}`);
+  return response.data;
+}
+
+export async function getTopicMessages(topicId, limit = 50, since = null) {
+  const base = getMirrorNodeBase();
+  let url = `${base}/api/v1/topics/${topicId}/messages?limit=${limit}&order=desc`;
+  if (since) url += `&timestamp=gte:${since}`;
+  const response = await axios.get(url);
+  const messages = response.data.messages || [];
+  return messages.map((msg) => ({
+    sequence_number: msg.sequence_number,
+    consensus_timestamp: msg.consensus_timestamp,
+    content: Buffer.from(msg.message, "base64").toString("utf-8"),
+    payer_account_id: msg.payer_account_id,
+  }));
+}

package/src/modules/hcs/intelligence.js

@@ -0,0 +1,71 @@
+// hcs/intelligence.js - GPT-4o Mini analysis engine
+import OpenAI from "openai";
+
+let openai;
+
+function getOpenAI() {
+  if (!openai) openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+  return openai;
+}
+
+export async function analyzeMessages(messages, query) {
+  const client = getOpenAI();
+  const messagesText = messages
+    .map((m) => `[${m.sequence_number}] ${m.content}`)
+    .join("\n");
+
+  const response = await client.chat.completions.create({
+    model: "gpt-4o-mini",
+    response_format: { type: "json_object" },
+    messages: [
+      {
+        role: "system",
+        content: `You are an AI analyst for Hedera blockchain data.
+Analyze HCS topic messages and answer the user query.
+Respond with JSON: { summary, anomalies, recommended_action, relevant_messages: [{sequence_number, content, relevance_score}] }
+relevance_score is 0.0-1.0. Only include messages with score > 0.5.`,
+      },
+      {
+        role: "user",
+        content: `Query: ${query}\n\nMessages:\n${messagesText}`,
+      },
+    ],
+    max_tokens: 1000,
+  });
+
+  return JSON.parse(response.choices[0].message.content);
+}
+
+export async function deepAnalyze(messages, analysisType) {
+  const client = getOpenAI();
+  const messagesText = messages
+    .map((m) => `[${m.sequence_number}] ${m.content}`)
+    .join("\n");
+
+  const prompts = {
+    anomaly_detection: "Detect unusual patterns, outliers, or suspicious activity.",
+    trend_analysis: "Identify trends, patterns, and changes over time.",
+    entity_extraction: "Extract key entities, actors, and relationships.",
+    risk_assessment: "Assess risks, vulnerabilities, and concerns.",
+  };
+
+  const response = await client.chat.completions.create({
+    model: "gpt-4o-mini",
+    response_format: { type: "json_object" },
+    messages: [
+      {
+        role: "system",
+        content: `You are a deep analyst for Hedera blockchain data.
+${prompts[analysisType]}
+Respond with JSON: { executive_summary, findings: [], risk_level, recommendations: [] }`,
+      },
+      {
+        role: "user",
+        content: `Analyze these HCS messages:\n${messagesText}`,
+      },
+    ],
+    max_tokens: 1500,
+  });
+
+  return JSON.parse(response.choices[0].message.content);
+}

package/src/modules/hcs/tools.js

@@ -0,0 +1,102 @@
+// hcs/tools.js - HCS Topic Intelligence tool definitions and handlers
+import { getTopicInfo, getTopicMessages } from "./hedera.js";
+import { analyzeMessages, deepAnalyze } from "./intelligence.js";
+import { chargeForTool } from "../../payments.js";
+
+export const HCS_TOOL_DEFINITIONS = [
+  {
+    name: "hcs_monitor",
+    description: "Get current status and metadata of any HCS topic - message count, creation time, memo, and recent activity. Free to call.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic_id: { type: "string", description: "Hedera topic ID (e.g. 0.0.8026796)" },
+        api_key: { type: "string", description: "Your AgentLens API key" },
+      },
+      required: ["topic_id", "api_key"],
+    },
+  },
+  {
+    name: "hcs_query",
+    description: "Query an HCS topic with a natural language question. Returns AI-ranked relevant messages and a plain English summary. Costs 0.05 HBAR.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic_id: { type: "string", description: "Hedera topic ID (e.g. 0.0.8026796)" },
+        query: { type: "string", description: "Natural language question about the topic" },
+        limit: { type: "number", description: "Max messages to retrieve (default 50)" },
+        api_key: { type: "string", description: "Your AgentLens API key" },
+      },
+      required: ["topic_id", "query", "api_key"],
+    },
+  },
+  {
+    name: "hcs_understand",
+    description: "Deep pattern analysis of an HCS topic - anomaly detection, trend analysis, entity extraction, or risk assessment. Costs 0.50 HBAR.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic_id: { type: "string", description: "Hedera topic ID" },
+        analysis_type: {
+          type: "string",
+          enum: ["anomaly_detection", "trend_analysis", "entity_extraction", "risk_assessment"],
+          description: "Type of analysis to perform",
+        },
+        lookback_days: { type: "number", description: "Days of history to analyze (default 7, max 30)" },
+        api_key: { type: "string", description: "Your AgentLens API key" },
+      },
+      required: ["topic_id", "analysis_type", "api_key"],
+    },
+  },
+];
+
+export async function executeHCSTool(name, args) {
+  if (name === "hcs_monitor") {
+    const info = await getTopicInfo(args.topic_id);
+    const messages = await getTopicMessages(args.topic_id, 5);
+    return {
+      topic_id: args.topic_id,
+      memo: info.memo,
+      created_timestamp: info.created_timestamp,
+      deleted: info.deleted,
+      recent_message_count: messages.length,
+      latest_message: messages[0] || null,
+      network: process.env.HEDERA_NETWORK,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  if (name === "hcs_query") {
+    const payment = chargeForTool("hcs_query", args.api_key);
+    const messages = await getTopicMessages(args.topic_id, args.limit || 50);
+    const analysis = await analyzeMessages(messages, args.query);
+    return {
+      topic_id: args.topic_id,
+      query: args.query,
+      messages_retrieved: messages.length,
+      messages_relevant: analysis.relevant_messages?.length || 0,
+      summary: analysis.summary,
+      anomalies: analysis.anomalies,
+      recommended_action: analysis.recommended_action,
+      relevant_messages: analysis.relevant_messages || [],
+      payment,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  if (name === "hcs_understand") {
+    const payment = chargeForTool("hcs_understand", args.api_key);
+    const messages = await getTopicMessages(args.topic_id, 100);
+    const analysis = await deepAnalyze(messages, args.analysis_type);
+    return {
+      topic_id: args.topic_id,
+      analysis_type: args.analysis_type,
+      messages_analyzed: messages.length,
+      ...analysis,
+      payment,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  throw new Error(`Unknown HCS tool: ${name}`);
+}

package/src/payments.js

@@ -0,0 +1,49 @@
+// payments.js - Shared HBAR micropayment system for all modules
+
+const COSTS = {
+  // Server 1 - HCS Topic Intelligence
+  hcs_monitor:       { tinybars: 5000000,   hbar: "0.0500" },
+  hcs_query:         { tinybars: 5000000,   hbar: "0.0500" },
+  hcs_understand:    { tinybars: 50000000,  hbar: "0.5000" },
+  // Server 2 - Compliance & Audit Trail
+  hcs_write_record:  { tinybars: 200000000, hbar: "2.0000" },
+  hcs_verify_record: { tinybars: 50000000,  hbar: "0.5000" },
+  hcs_audit_trail:   { tinybars: 100000000, hbar: "1.0000" },
+};
+
+const accounts = new Map();
+
+function getAccount(apiKey) {
+  if (!accounts.has(apiKey)) {
+    accounts.set(apiKey, { balance: 100000000 });
+  }
+  return accounts.get(apiKey);
+}
+
+export function chargeForTool(toolName, apiKey) {
+  const cost = COSTS[toolName];
+  if (!cost) return null;
+
+  const account = getAccount(apiKey);
+  if (account.balance < cost.tinybars) {
+    throw new Error(
+      "Insufficient HBAR balance. Required: " + cost.hbar + " HBAR. Please top up your AgentLens account."
+    );
+  }
+
+  account.balance -= cost.tinybars;
+  const remainingHbar = (account.balance / 100000000).toFixed(4);
+  return {
+    charged_hbar: cost.hbar,
+    remaining_hbar: remainingHbar,
+  };
+}
+
+export function getCosts() {
+  return COSTS;
+}
+
+export function getBalance(apiKey) {
+  const account = getAccount(apiKey);
+  return (account.balance / 100000000).toFixed(4);
+}

package/src/server.js

@@ -0,0 +1,65 @@
+// server.js - MCP server factory, registers all module tools
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { HCS_TOOL_DEFINITIONS, executeHCSTool } from "./modules/hcs/tools.js";
+import { COMPLIANCE_TOOL_DEFINITIONS, executeComplianceTool } from "./modules/compliance/tools.js";
+
+const ALL_TOOLS = [
+  ...HCS_TOOL_DEFINITIONS,
+  ...COMPLIANCE_TOOL_DEFINITIONS,
+];
+
+async function routeTool(name, args) {
+  if (["hcs_monitor", "hcs_query", "hcs_understand"].includes(name)) {
+    return executeHCSTool(name, args);
+  }
+  if (["hcs_write_record", "hcs_verify_record", "hcs_audit_trail"].includes(name)) {
+    return executeComplianceTool(name, args);
+  }
+  throw new Error(`Unknown tool: ${name}`);
+}
+
+export function createServer() {
+  const server = new Server(
+    { name: "hedera-mcp-platform", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: ALL_TOOLS };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    console.error("Tool: " + name);
+    try {
+      const result = await routeTool(name, args);
+      console.error("Done: " + name);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (error) {
+      console.error("Error: " + name + " - " + error.message);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: error.message,
+              tool: name,
+              timestamp: new Date().toISOString(),
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+  });
+
+  return server;
+}
+
+export { ALL_TOOLS };