Build & List Your Tool

I want to build an MCP server for the Context Marketplace using the CoinGecko API.

1. Use context7 to fetch the CoinGecko API documentation
2. Follow the mcp-builder-template.md workflow:
   - PHASE 1: Discover all endpoints
   - PHASE 2: Generate discovery questions (STOP for my review)
   - PHASE 3: Design and implement tools after I approve

Focus on "giga-brained" tools that combine multiple endpoints to answer
questions users couldn't easily answer with raw API calls.

pnpm add @modelcontextprotocol/sdk express
pnpm add @ctxprotocol/sdk
pnpm add -D @types/express

// MCP spec compliant server (see: modelcontextprotocol.io/specification)
const TOOLS = [{
  name: "get_gas_price",
  description: "Get current gas prices for any EVM chain",
  inputSchema: {
    type: "object",
    properties: {
      chainId: { type: "number", description: "EVM chain ID" },
    },
  },
  outputSchema: {  // 👈 Required by Context
    type: "object",
    properties: {
      gasPrice: { type: "number" },
      unit: { type: "string" },
    },
    required: ["gasPrice", "unit"],
  },
}];

// In your tool handler
return {
  content: [{ type: "text", text: JSON.stringify(data) }],  // Backward compat
  structuredContent: data,  // 👈 Required by Context
};

import express from "express";
import { createContextMiddleware } from "@ctxprotocol/sdk";

const app = express();
app.use(express.json());

// 1 line of code to secure your endpoint & handle payments
app.use("/mcp", createContextMiddleware());

// ...

// Why this middleware matters:
// 1. Verifies that requests are signed by the Context Platform (preventing free-riding)
// 2. Injects user context (if requested)
// 3. Handles payment verification automatically

return {
  content: [
    { type: "text", text: "Analysis complete. Here's the chart:" }
  ],
  structuredContent: {
    summary: "Market analysis shows bullish signals...",
    // Host your images and return URLs
    chart_url: "https://your-cdn.com/charts/eth-analysis-12345.png",
    chart_alt: "ETH price chart with support levels marked"
  }
};

{
  "type": "object",
  "properties": {
    "summary": {
      "type": "string",
      "description": "Text summary of the analysis"
    },
    "chart_url": {
      "type": "string",
      "format": "uri",
      "description": "URL to the hosted chart image"
    },
    "chart_alt": {
      "type": "string",
      "description": "Accessible description of the image"
    }
  },
  "required": ["summary", "chart_url"]
}

# Test your endpoint (assuming it's running on localhost:3000)
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/list",
    "id": 1
  }'

// ❌ BAD: Schema says number, but you return string
outputSchema: { temperature: { type: "number" } }
structuredContent: { temperature: "72" }  // GUILTY - schema mismatch!

// ✅ GOOD: Output matches schema exactly
outputSchema: { temperature: { type: "number" } }
structuredContent: { temperature: 72 }  // Valid

┌─────────────────────────────────────────────────────────────────────┐
│                    DATA BROKER'S JOB (offline)                      │
│                                                                     │
│  1. Run heavy queries on your data source (30 min timeout - OK)    │
│  2. Pre-compute valuable insights ("wallets that sold tops")       │
│  3. Store results in your own database                             │
│  4. Update daily/hourly via cron jobs                              │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────────┐
│                    MCP TOOL (instant)                               │
│                                                                     │
│  User: "What are the smart money wallets holding?"                 │
│  Tool: SELECT * FROM my_precomputed_smart_money LIMIT 10           │
│  Response: < 1 second ✅                                            │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

// ❌ BAD: Raw SQL tool (timeout-prone, no moat)
{
  name: "run_sql",
  description: "Run any SQL against blockchain data"
  // This is a demo, not a product
}

// ✅ GOOD: Pre-computed insight tools
{
  name: "get_smart_money_wallets",
  description: "Get top 100 wallets that historically timed market tops",
  // Data broker pre-computes this daily, serves instantly
}

{
  name: "get_whale_holdings",
  description: "Current holdings of known whale wallets",
  // Pre-computed hourly, instant response
}

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import express from "express";
import { createContextMiddleware } from "@ctxprotocol/sdk";

const app = express();
app.use(express.json());

// Secure endpoint with Context middleware
app.use("/mcp", createContextMiddleware());

// Define tools with outputSchema
const TOOLS = [{
  name: "get_gas_price",
  description: "Get current gas prices",
  inputSchema: {
    type: "object",
    properties: {
      chainId: { type: "number", description: "EVM chain ID" },
    },
  },
  outputSchema: {
    type: "object",
    properties: {
      gasPrice: { type: "number" },
      unit: { type: "string" },
    },
    required: ["gasPrice", "unit"],
  },
}];

// Standard MCP server setup
const server = new Server(
  { name: "my-gas-tool", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: TOOLS,
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const data = await fetchGasData(request.params.arguments.chainId);
  
  return {
    content: [{ type: "text", text: JSON.stringify(data) }],
    structuredContent: data,
  };
});

app.listen(3000, () => {
  console.log("MCP server running on port 3000");
});

import { createSignatureRequest, wrapHandshakeResponse } from "@ctxprotocol/sdk";

// In your tool handler
if (needsUserSignature) {
  return wrapHandshakeResponse(
    createSignatureRequest({
      domain: { name: "MyProtocol", version: "1", chainId: 1 },
      types: { Order: [{ name: "amount", type: "uint256" }] },
      primaryType: "Order",
      message: { amount: 1000 },
      meta: { description: "Place order", protocol: "MyProtocol" },
    })
  );
}