⏱️ Time: 25 minutes | 📊 Level: Beginner to Intermediate | 🛠️ Stack: TypeScript + LunarCrush API

TL;DR: Learn how to wrap any REST API into an MCP (Model Context Protocol) server so any LLM can use it natively. We’ll use LunarCrush API as our example, but this pattern works for ANY REST API. Plus: combine multiple APIs, add custom tools, and make it work with any MCP client (Claude Desktop, VS Code, custom agents, and more).

• Build time: 25 minutes
• Lines of code: ~150 lines
• Key tech: TypeScript + @modelcontextprotocol/sdk
• Language agnostic: One server works for ALL clients
• ROI potential: $500-2000/integration as a service

---

What You’ll Build

By the end of this tutorial, you’ll have:

1. A working MCP server wrapping the LunarCrush API
2. Custom tools beyond what the official MCP offers
3. The pattern to wrap ANY REST API into MCP
4. Multi-API combination (optional: add Fear & Greed, DEX data)
5. LLM integration for conversational queries (Claude, agents, IDE extensions)
6. Language agnostic: Your TypeScript server works with Python, Go, Rust—any language with JSON-RPC support. Write once, use everywhere.

Want the full code? Skip to The LLM Shortcut to generate it with any LLM, or follow along step-by-step below.

Example conversations after setup:

You: "What's the Galaxy Score for Bitcoin?"
AI:  "Bitcoin's Galaxy Score is 72.5, indicating strong social health.
It's ranked #1 by AltRank with 24h price change of +3.2%."

You: "Compare Bitcoin, Ethereum, and Solana"
AI:  [calls compare_topics] "Here's the comparison:
BTC: Galaxy 72.5, Rank #1, +3.2%
ETH: Galaxy 68.2, Rank #3, +2.1%
SOL: Galaxy 74.1, Rank #2, +5.4%
Solana is showing the strongest social momentum today."

You: "Show me whale activity on Solana"
AI:  [calls get_whale_posts] "3 accounts with 100K+ followers posted about SOL:
@whale1 (500K): 'SOL looking strong here'
@whale2 (250K): 'Accumulating on this dip'
Smart money sentiment: Bullish"

---

Table of Contents

Understanding MCP

1. What is REST? What is MCP?
2. REST vs MCP: When to Use Which
3. Why Build a Custom MCP Server?
4. Transport Types: stdio vs Streamable HTTP
5. Can I Use MCP Without an LLM?

Building Your Server

1. Prerequisites
2. Step 1: Project Setup
3. Step 2: Define Your Tools
4. Step 3: Implement Handlers
5. Step 4: Wire Up the Server
6. Step 5: Test with Claude Desktop

Advanced Topics

1. Step 6: Add Custom Tools
2. Step 7: Combine Multiple APIs
3. Custom Metrics: Crowd, Whales, Conviction
4. Can I Wrap Another MCP Server?
5. The LLM Shortcut
6. Compatibility: Other LLMs

Reference

1. ROI & Monetization
2. Troubleshooting
3. FAQ
4. Glossary

---

What is a REST API? What is MCP? {#what-is-rest-what-is-mcp}

Before we build, let’s understand what we’re working with.

REST API (Representational State Transfer)

A REST API is how most web services expose their data. You make HTTP requests to URLs (endpoints) and get data back.

# Example: Get Bitcoin data from LunarCrush REST API
curl -H "Authorization: Bearer YOUR_KEY" \
"https://lunarcrush.com/api4/public/topic/bitcoin/v1"

# Response: JSON data
{
"topic": "bitcoin",
"galaxy_score": 72.5,
"alt_rank": 1,
"price": 104250.00,
...
}

REST is the backbone of the internet. Every major service has one: Twitter, Stripe, GitHub, LunarCrush, DeFiLlama, etc.

MCP (Model Context Protocol)

MCP is the standard for connecting AI to external data and tools. Think of it as a universal adapter between LLMs and your data. It uses JSON-RPC 2.0 over various transports (stdio for local, Streamable HTTP for production).

The key insight: MCP is a protocol, not a language - your server can be written in any language, and any client that speaks the protocol can use it.

Your MCP server doesn’t store data—it’s a translator layer that receives requests from AI clients, calls the REST API for fresh data, and transforms it for LLM consumption.

Instead of writing custom code for each app, you build ONE MCP server and it works everywhere.

┌─────────────────────────────────────────────────────────┐
│                    YOUR MCP SERVER                       │
│  ┌─────────────────────────────────────────────────┐   │
│  │  Tools:                                          │   │
│  │  - get_topic(topic) → "What's Bitcoin's score?" │   │
│  │  - list_coins(sort) → "Top 10 by Galaxy Score"  │   │
│  │  - compare(a, b)    → "Compare BTC vs ETH"      │   │
│  └─────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘
↑                    ↑                    ↑
Desktop Apps         CLI Tools           IDE Extensions

---

REST vs MCP: When to Use Which {#rest-vs-mcp}

Aspect	REST API	MCP Server
Discovery	Must read docs	Self-describing (tools advertise capabilities)
Integration	Reimplement per app	Build once, works everywhere
AI/LLM Support	None (manual prompting)	Native
Schema	Manual definition	Type-safe, auto-validated
Updates	Change every app	Update one file
Future-Proof	API changes break all clients	Abstraction layer absorbs changes
Workflow	Re-read docs for every use case	Read docs once, then just ask questions
Accessibility	Requires coding for every use	Non-devs use existing servers, vibe coders let LLMs generate code
Best For	Web/mobile apps, public APIs	AI assistants, agents, IDE extensions

---

Why Build a Custom MCP Server? {#why-build-custom-mcp}

LunarCrush already has an official MCP server. So why build your own?

Reasons to Use the Official MCP Server

✅ Quick start - works immediately

✅ Maintained by LunarCrush team

✅ All endpoints available

✅ Proper error handling built-in

Official LunarCrush MCP:

• https://lunarcrush.ai/mcp?key=${LUNARCRUSH_API_KEY} (MCP Connector)

#Streamable HTTP
{
"mcpServers": {
"LunarCrush": {
"type": "http",
"url": "https://lunarcrush.ai/mcp",
"headers": {
"Authorization": "Bearer LUNARCRUSH_API_KEY"
}
}
}
}

#Server-Sent Events (SSE)
{
"mcpServers": {
"LunarCrush": {
"type": "sse",
"url": "https://lunarcrush.ai/sse",
"headers": {
"Authorization": "Bearer 3vvy05ke69voekr3cc492l5lijm8ys4f7mw14lzd5"
}
}
}
}

Reasons to Build Your Own

Reason	Example
Combine multiple APIs	LunarCrush + Other API in One server. Consider adding Kalshi, Fear & Greed Index, Hyperliquid, or DEX data
Filter to only what you need	3 tools instead of 11 = less token usage, simpler prompts
Add custom calculations	get_whale_posts - filter to high-follower accounts
Custom return format	Official returns markdown only; yours can offer JSON + markdown
Add caching	Reduce API calls, save money
Custom naming	Your brand, your tool names
Add tools that don’t exist	whale_filter, alert_threshold, sector_analysis
Business logic	Pre-process data, add your own analysis
Multi-tenant	Add your own auth layer

Custom Tools We’ll Build (Not in Official MCP)

The official LunarCrush MCP has 11 tools. In this tutorial, we’ll add 2 custom tools that don’t exist:

Tool	What It Does
compare_topics	Compare 2-5 topics side-by-side in one call
get_whale_posts	Filter posts to only high-follower accounts

Full implementation in Step 2 and Step 3.

---

Transport Types: stdio vs Streamable HTTP {#transport-types}

MCP supports multiple transport types. Choose based on your deployment:

Transport Comparison

Transport	How It Works	Best For	Difficulty
stdio	Process communication via stdin/stdout	Local MCP clients	Easiest
Streamable HTTP	HTTP + optional SSE streaming in one	Production servers, remote access	Medium

Note: The older "HTTP+SSE" transport (separate endpoints for HTTP and SSE) was replaced by Streamable HTTP in 2025. Streamable HTTP combines both—SSE is still used for streaming, just within the same transport.

Which Should You Use?

Local Development / Desktop Apps → stdio (start here)
Deployed Server / Production → Streamable HTTP (handles both sync + streaming)

Difficulty Levels by Transport

stdio (Easiest - Start Here)

• No networking code needed
• Works immediately with local MCP clients
• Perfect for local development and personal use
• Limitation: Only works on same machine

Streamable HTTP (Medium - For Production)

• Requires server hosting (Vercel, Railway, Fly.io)
• Need to handle authentication
• Can be accessed from anywhere
• Supports both sync responses AND streaming (one transport does both)
• Good for team/public MCP servers

In this tutorial, we’ll use stdio (simplest, works with local MCP clients). The pattern is identical for Streamable HTTP—just swap the transport class.

When Do You Need Streaming?

Streamable HTTP handles this automatically. It uses regular HTTP for fast responses and upgrades to SSE when needed:

Scenario	What Happens
Tool returns in <30s	Normal HTTP response
Tool takes >30s	Auto-upgrades to SSE for progress
Real-time data feeds	SSE streaming

For most MCP servers: Just use Streamable HTTP. It does the right thing automatically.

---

Can I Use MCP Without an LLM? {#mcp-without-llm}

Yes. MCP is just JSON-RPC 2.0. You can call MCP servers from regular code:

// Call MCP server directly from Node.js (no LLM needed)
import { Client } from '@modelcontextprotocol/sdk/client/index.js';

const client = new Client({ name: 'my-app', version: '1.0.0' });

// Call a tool directly
const result = await client.callTool({
name: 'get_topic',
arguments: { topic: 'bitcoin' }
});

console.log(result); // JSON data, no LLM involved

Use cases without LLM:

• Automated scripts that need consistent tool interfaces
• Testing MCP servers before connecting to an LLM
• Building dashboards that consume MCP data
• Scheduled data collection

---

Prerequisites {#prerequisites}

• Node.js 18+ (download)
• Basic TypeScript knowledge (or JavaScript - TypeScript is optional)
• Claude Desktop installed (download)
• LunarCrush API key (get one here - use code JAMAALBUILDS for 15% off)

Optional (for combining APIs):

• Fear & Greed Index (free, no key needed)
• DeFiLlama API (free, no key needed)
• DexScreener API (free, no key needed)
• Hyperliquid API (free, no key needed)

---

Step 1: Project Setup {#step-1-project-setup}

Create a new project with the MCP SDK:

📄 Terminal

# Create project directory
mkdir lunarcrush-mcp-custom
cd lunarcrush-mcp-custom

# Initialize Node.js project
npm init -y

# Install dependencies
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node

# Initialize TypeScript
npx tsc --init

📄 tsconfig.json (replace contents)

{
"compilerOptions": {
"target": "ES2022",
"module": "Node16",
"moduleResolution": "Node16",
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"declaration": true
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist"]
}

📄 package.json (add/update these fields)

{
"name": "lunarcrush-mcp-custom",
"version": "1.0.0",
"type": "module",
"main": "dist/index.js",
"bin": {
"lunarcrush-mcp": "./dist/index.js"
},
"scripts": {
"build": "tsc",
"start": "node dist/index.js",
"dev": "tsc --watch"
},
"files": ["dist"]
}

Create the project structure:

lunarcrush-mcp-custom/
├── src/
│   ├── index.ts          # MCP server entry point
│   ├── tools.ts          # Tool definitions (what LLM can do)
│   ├── handlers.ts       # API call handlers (actual logic)
│   └── api-client.ts     # REST API wrapper (reusable)
├── package.json
├── tsconfig.json
└── .env                  # API keys (don't commit!)

📄 .env (create this file)

LUNARCRUSH_API_KEY=your_api_key_here
# Get your key: https://lunarcrush.com/developers/api/authentication (use JAMAALBUILDS for 15% off)

📄 .gitignore (important: don’t commit secrets!)

node_modules/
dist/
.env

---

Step 2: Define Your Tools {#step-2-define-your-tools}

Tools are the capabilities your MCP server exposes. Each tool has:

• name: What the LLM calls it (e.g., get_topic)
• description: Helps the LLM understand WHEN to use it (critical for good AI behavior)
• inputSchema: JSON Schema defining parameters

Let’s define tools - including custom ones that go beyond the official MCP:

📄 src/tools.ts

import { z } from 'zod';

/**
* Tool Definitions
*
* These tell the LLM what capabilities are available.
* Good descriptions = better AI tool selection.
*
* We're including:
* 1. Standard tools (similar to official MCP)
* 2. Custom tools (our value-add)
*/

export const tools = [
// ============================================
// STANDARD TOOLS (mirror official MCP basics)
// ============================================

{
name: 'get_topic',
description: `Get comprehensive social metrics for any topic (crypto, stock, brand, person, etc.).

Returns: Galaxy Score (0-100 health), AltRank (1-4000, lower=better),
sentiment (% positive), social volume, price data if available.

Use this when user asks about a specific topic's current state.
Examples: "How is Bitcoin doing?", "What's the sentiment on Solana?", "Tell me about NVIDIA"`,
inputSchema: {
type: 'object' as const,
properties: {
topic: {
type: 'string',
description: 'Topic name: "bitcoin", "ethereum", "nvidia", "elon musk", etc.'
},
format: {
type: 'string',
enum: ['json', 'markdown'],
default: 'markdown',
description: 'Output format: markdown (readable) or json (for processing)'
}
},
required: ['topic']
}
},

{
name: 'list_cryptocurrencies',
description: `Get a sorted list of cryptocurrencies by various metrics.

Sort options: galaxy_score, alt_rank, percent_change_24h, market_cap, social_dominance

Use for discovery: "What are the top coins?", "Which cryptos are trending?",
"Best performing coins today"`,
inputSchema: {
type: 'object' as const,
properties: {
sort: {
type: 'string',
enum: ['galaxy_score', 'alt_rank', 'percent_change_24h', 'market_cap', 'social_dominance'],
description: 'How to sort the list'
},
limit: {
type: 'number',
description: 'Number of results (default: 10, max: 100)'
},
sector: {
type: 'string',
description: 'Filter by sector: "defi", "meme", "ai", "layer-1", "layer-2", etc.'
},
format: {
type: 'string',
enum: ['json', 'markdown'],
default: 'json',
description: 'Output format (json default for lists)'
}
},
required: []
}
},

// ============================================
// CUSTOM TOOLS (our value-add - not in official MCP!)
// ============================================

{
name: 'compare_topics',
description: `Compare 2-5 topics side by side. Returns key metrics for each in a comparison table.

Use when user wants to compare assets: "Compare BTC vs ETH",
"Which is better: Solana or Avalanche?", "Bitcoin vs Ethereum vs Solana comparison"

This tool is NOT in the official LunarCrush MCP - it's our custom addition!`,
inputSchema: {
type: 'object' as const,
properties: {
topics: {
type: 'array',
items: { type: 'string' },
minItems: 2,
maxItems: 5,
description: 'List of topics to compare'
},
format: {
type: 'string',
enum: ['json', 'markdown'],
default: 'markdown',
description: 'Output format'
}
},
required: ['topics']
}
},

{
name: 'get_whale_posts',
description: `Get posts only from high-follower accounts (whales/influencers).

Filters out noise to show only what influential accounts are saying.
Default: 100k+ followers. Adjust min_followers as needed.

Use when user wants influencer opinions: "What are whales saying about Bitcoin?",
"Influential accounts on Solana"`,
inputSchema: {
type: 'object' as const,
properties: {
topic: {
type: 'string',
description: 'Topic name'
},
min_followers: {
type: 'number',
description: 'Minimum follower count (default: 100000)'
},
limit: {
type: 'number',
description: 'Number of posts (default: 10)'
},
format: {
type: 'string',
enum: ['json', 'markdown'],
default: 'markdown',
description: 'Output format'
}
},
required: ['topic']
}
},

];

// ============================================
// Zod Schemas for Runtime Validation
// ============================================

// Format enum used across all schemas
const FormatSchema = z.enum(['json', 'markdown']);

export const GetTopicSchema = z.object({
topic: z.string().min(1),
format: FormatSchema.default('markdown')
});

export const ListCryptocurrenciesSchema = z.object({
sort: z.enum(['galaxy_score', 'alt_rank', 'percent_change_24h', 'market_cap', 'social_dominance']).default('galaxy_score'),
limit: z.number().min(1).max(100).default(10),
sector: z.string().optional(),
format: FormatSchema.default('json')  // Lists default to JSON
});

export const CompareTopicsSchema = z.object({
topics: z.array(z.string()).min(2).max(5),
format: FormatSchema.default('markdown')
});

export const GetWhalePostsSchema = z.object({
topic: z.string().min(1),
min_followers: z.number().default(100000),
limit: z.number().min(1).max(50).default(10),
format: FormatSchema.default('markdown')
});

Why detailed descriptions matter: The LLM reads these descriptions to decide WHICH tool to use. Better descriptions = smarter tool selection.

---

Step 3: Implement Handlers {#step-3-implement-handlers}

Handlers call the REST API and transform responses. Two files: api-client.ts (reusable fetcher) and handlers.ts (tool logic).

📄 src/api-client.ts

const API_KEY = process.env.LUNARCRUSH_API_KEY;
const BASE = 'https://lunarcrush.com/api4/public';

export async function fetchLunarCrush<T = any>(endpoint: string): Promise<T> {
const res = await fetch(`${BASE}${endpoint}`, { headers: { 'Authorization': `Bearer ${API_KEY}` } });
if (!res.ok) throw new Error(`API error ${res.status}`);
return res.json();
}

export const fmt = {
num: (n: number) => !n ? '0' : n >= 1e9 ? `${(n/1e9).toFixed(1)}B` : n >= 1e6 ? `${(n/1e6).toFixed(1)}M` : n >= 1e3 ? `${(n/1e3).toFixed(1)}K` : String(n),
pct: (n: number) => n != null ? `${n > 0 ? '+' : ''}${n.toFixed(2)}%` : 'N/A',
sentiment: (s: number) => s > 60 ? '🟢 Bullish' : s < 40 ? '🔴 Bearish' : '🟡 Neutral'
};

📄 src/handlers.ts - Pattern shown for one handler (all 4 follow same structure):

import { fetchLunarCrush, fmt } from './api-client.js';
import { GetTopicSchema, CompareTopicsSchema, /* ...other schemas */ } from './tools.js';

export async function handleGetTopic(args: unknown) {
const { topic, format } = GetTopicSchema.parse(args);
const d = await fetchLunarCrush(`/topic/${encodeURIComponent(topic)}/v1`);

return format === 'json'
? { topic: d.topic, galaxy_score: d.galaxy_score, alt_rank: d.alt_rank, sentiment: d.sentiment, price: d.close, change_24h: d.percent_change_24h }
: `## ${d.topic?.toUpperCase()}\n**Galaxy Score:** ${d.galaxy_score}/100 | **AltRank:** #${d.alt_rank} | ${fmt.sentiment(d.sentiment)}\n**Price:** $${d.close?.toLocaleString()} (${fmt.pct(d.percent_change_24h)})`;
}

// Custom tool example: compare multiple topics in parallel
export async function handleCompareTopics(args: unknown) {
const { topics, format } = CompareTopicsSchema.parse(args);
const results = await Promise.all(topics.map(t => fetchLunarCrush(`/topic/${encodeURIComponent(t)}/v1`).catch(() => ({ topic: t, error: true }))));

return format === 'json'
? results.map((d: any) => ({ topic: d.topic, galaxy_score: d.galaxy_score, alt_rank: d.alt_rank, price: d.close }))
: `## Comparison: ${topics.join(' vs ')}\n| Metric | ${topics.join(' | ')} |\n|--------|${topics.map(() => '------').join('|')}|\n| Galaxy | ${results.map((d: any) => d.galaxy_score?.toFixed(1) || 'N/A').join(' | ')} |`;
}

// Router maps tool names to handlers
export async function handleToolCall(name: string, args: unknown) {
const handlers: Record<string, Function> = {
get_topic: handleGetTopic, list_cryptocurrencies: handleListCryptocurrencies,
compare_topics: handleCompareTopics, get_whale_posts: handleGetWhalePosts,
};
if (!handlers[name]) throw new Error(`Unknown tool: ${name}`);
return handlers[name](args);
}

All 4 Handlers Summary

Handler	Endpoint	Pattern
handleGetTopic	/topic/{topic}/v1	Parse → Fetch → JSON or Markdown
handleListCryptocurrencies	/coins/list/v2	Parse → Fetch with sort/filter → table
handleCompareTopics	Multiple parallel fetches	Promise.all() → comparison table
handleGetWhalePosts	Posts + filter	Fetch → filter by followers → list

💡 Full code: Use The LLM Shortcut to generate complete handlers for your API.

---

Step 4: Wire Up the Server {#step-4-wire-up-the-server}

Now let’s create the MCP server that connects everything:

📄 src/index.ts

#!/usr/bin/env node

/**
* Custom LunarCrush MCP Server
*
* Features:
* - Standard tools (get_topic, list_coins, etc.)
* - Custom tools (compare, whales)
* - Optimized responses for LLM consumption
* - Works with any MCP client (desktop apps, CLI tools, IDE extensions)
*/

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ListToolsRequestSchema,
ErrorCode,
McpError
} from '@modelcontextprotocol/sdk/types.js';

// For Streamable HTTP instead of Stdio:

// import express from 'express';
//import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';


import { tools } from './tools.js';
import { handleToolCall } from './handlers.js';

// Server metadata
const SERVER_INFO = {
name: 'lunarcrush-mcp-custom',
version: '1.0.0',
description: 'Custom LunarCrush MCP server with extended tools'
};

// Create MCP server
const server = new Server(
SERVER_INFO,
{
capabilities: {
tools: {},
// Can also add:
// resources: {},  // For exposing data files
// prompts: {},    // For prompt templates
}
}
);

// ============================================
// REQUEST HANDLERS
// ============================================

/**
* List available tools
*
* Called by MCP client to discover what tools are available.
* The LLM uses this to understand what it can do.
*/
server.setRequestHandler(ListToolsRequestSchema, async () => {
console.error(`[MCP] Listing ${tools.length} tools`);
return { tools };
});

/**
* Execute a tool
*
* Called when the LLM decides to use a tool.
* We route to the appropriate handler and return results.
*/
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;

console.error(`[MCP] Tool call: ${name}`);
console.error(`[MCP] Arguments: ${JSON.stringify(args)}`);

try {
// Execute the tool
const result = await handleToolCall(name, args);

console.error(`[MCP] Success: ${name}`);

// Return result as text content
// Handlers return string (markdown) or object (JSON) - handle both
return {
content: [
{
type: 'text',
text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
}
]
};

} catch (error) {
// Handle errors gracefully
const message = error instanceof Error ? error.message : 'Unknown error';
console.error(`[MCP] Error in ${name}: ${message}`);

// Return error to LLM (it can try to recover or inform user)
return {
content: [
{
type: 'text',
text: JSON.stringify({
error: true,
message,
tool: name
}, null, 2)
}
],
isError: true
};
}
});

// ============================================
// SERVER STARTUP
// ============================================

async function main() {
// OPTION 1: stdio transport (local MCP clients)
const transport = new StdioServerTransport();
await server.connect(transport);

// OPTION 2: Streamable HTTP (for web deployment)

// const PORT = process.env.PORT || 3000;
// const app = express();
// app.use(express.json());
//
// const transport = new StreamableHTTPServerTransport({
//   sessionIdGenerator: () => crypto.randomUUID(),
// });
// await server.connect(transport);  // Same pattern - connect server to transport

// app.get('/health', (req, res) => res.send('ok'));
// app.post('/mcp', async (req, res) => {
//   await transport.handleRequest(req, res, req.body);
// });
//
// app.listen(PORT, () => console.error(`MCP server on http://localhost:${PORT}/mcp`));

// Log to stderr (stdout is reserved for MCP protocol)
console.error('═'.repeat(50));
console.error(`${SERVER_INFO.name} v${SERVER_INFO.version}`);
console.error(`Running on stdio transport`);
console.error(`Tools available: ${tools.length}`);
console.error('═'.repeat(50));
}

// Start server
main().catch((error) => {
console.error('Fatal error:', error);
process.exit(1);
});

Build and test:

# Build TypeScript
npm run build

# Test that it runs (should show startup message then wait for input)
LUNARCRUSH_API_KEY=your_key node dist/index.js

# You should see:
# ══════════════════════════════════════════════════
# lunarcrush-mcp-custom v1.0.0
# Running on stdio transport
# Tools available: 4
# ══════════════════════════════════════════════════

Press Ctrl+C to stop.

---

Step 5: Test with Claude Desktop {#step-5-test-with-claude-desktop}

Add your server to Claude Desktop:

📄 macOS: ~/Library/Application Support/Claude/claude_desktop_config.json 📄 Windows: %APPDATA%\Claude\claude_desktop_config.json

{
"mcpServers": {
"lunarcrush-custom": {
"command": "node",
"args": ["/FULL/PATH/TO/lunarcrush-mcp-custom/dist/index.js"],
"env": {
"LUNARCRUSH_API_KEY": "your_api_key_here"
}
}
}
}

Important: Use the FULL absolute path to your dist/index.js file.

Restart Claude Desktop (quit and reopen).

Test these prompts:

"What's the Galaxy Score for Bitcoin?"

"Compare Bitcoin, Ethereum, and Solana"

"What's the sentiment on ETH right now?"

"What are whales saying about Solana?"

Top 5 memecoins by social dominance

---

Step 6: Add Custom Tools (Beyond Official MCP) {#step-6-custom-tools}

We already added 2 custom tools in Steps 2-3. To add more:

1. tools.ts: Add tool definition with name, description, inputSchema
2. tools.ts: Add Zod schema for validation
3. handlers.ts: Add handler function (parse → fetch → return JSON or markdown)
4. handlers.ts: Add to router object

Ideas for more custom tools:

Tool	What It Does
check_alert_conditions	Watchlist items exceeding thresholds
sentiment_shift	Rapid sentiment changes (trend reversal)
analyze_sector	Aggregated metrics for DeFi, AI, Memes, etc.
top_creators	Most influential creators for a topic
get_news	Top news articles for a topic

---

Step 7: Combine Multiple APIs {#step-7-combine-apis}

The real power of custom MCP: combine data from multiple sources.

Example: Add Fear & Greed Index

📄 src/api-client.ts (add this function)

/**
* Fear & Greed Index API (free, no key needed)
* https://alternative.me/crypto/fear-and-greed-index/
*/
export async function fetchFearGreed(): Promise<{
value: number;
classification: string;
timestamp: string;
}> {
const response = await fetch('https://api.alternative.me/fng/?limit=1');
const data = await response.json();

return {
value: parseInt(data.data[0].value),
classification: data.data[0].value_classification,
timestamp: new Date(data.data[0].timestamp * 1000).toISOString()
};
}

📄 src/tools.ts (add tool definition)

{
name: 'get_market_sentiment',
description: `Get overall market sentiment combining Fear & Greed Index with LunarCrush data.

Returns: Fear & Greed score (0-100), classification (Extreme Fear to Extreme Greed),
plus Bitcoin Galaxy Score for correlation.

Use for: "What's the market sentiment?", "Is the market fearful?", "Market overview"`,
inputSchema: {
type: 'object' as const,
properties: {},
required: []
}
}

📄 src/handlers.ts (add handler)

import { fetchLunarCrush, fetchFearGreed } from './api-client.js';

export async function handleMarketSentiment(args: unknown) {
// Fetch both in parallel
const [fearGreed, btcData] = await Promise.all([
fetchFearGreed(),
fetchLunarCrush('/topic/bitcoin/v1')
]);

return {
fear_greed: {
value: fearGreed.value,
classification: fearGreed.classification,
interpretation: fearGreed.value <= 25 ? 'Extreme Fear - potential buying opportunity'
: fearGreed.value <= 45 ? 'Fear - caution warranted'
: fearGreed.value <= 55 ? 'Neutral'
: fearGreed.value <= 75 ? 'Greed - caution warranted'
: 'Extreme Greed - potential selling opportunity'
},
bitcoin_social: {
galaxy_score: btcData.galaxy_score?.toFixed(1),
sentiment: btcData.sentiment,
social_dominance: btcData.social_dominance?.toFixed(2) + '%'
},
combined_signal: getCombinedSignal(fearGreed.value, btcData.galaxy_score, btcData.sentiment),
timestamp: fearGreed.timestamp
};
}

function getCombinedSignal(fearGreed: number, galaxyScore: number, sentiment: number): string {
// Custom logic combining multiple data sources
const fearGreedBullish = fearGreed <= 30;
const socialBullish = galaxyScore >= 60 && sentiment >= 60;

if (fearGreedBullish && socialBullish) {
return 'STRONG_OPPORTUNITY: Extreme fear but social metrics strong';
}
if (fearGreedBullish && !socialBullish) {
return 'CAUTION: Fear present but social metrics weak';
}
if (!fearGreedBullish && socialBullish) {
return 'TRENDING: Greed rising with strong social backing';
}
return 'NEUTRAL: Mixed signals';
}

Other APIs You Could Combine

API	What It Adds	Example Tool
DeFiLlama	DEX volume, TVL, yields	get_dex_volume, get_tvl
DexScreener	Token pairs, liquidity, new listings	get_token_pairs, get_new_listings
Hyperliquid	Perps funding rates, open interest	get_funding_rates, get_positions
Glassnode	On-chain metrics	get_onchain_metrics
NewsAPI	News headlines	get_crypto_news
Your own DB	Portfolio, alerts, history	get_my_portfolio

---

Custom Metrics: Crowd, Whales, Conviction {#custom-metrics}

Beyond standard metrics, you can add custom tools for derived analytics:

Example Custom Tools

// Crowd sentiment (aggregate small accounts)
{
name: 'get_crowd_sentiment',
description: 'Get sentiment from retail/crowd (accounts <10K followers)',
// Filter posts by follower count, aggregate sentiment
}

// Whale consensus (what big accounts think)
{
name: 'get_whale_consensus',
description: 'Get sentiment from whale accounts (100K+ followers)',
// Filter for high-follower accounts, weight by influence
}

// Conviction score (custom calculation)
{
name: 'calculate_conviction',
description: 'Calculate conviction score combining multiple signals',
// Combine: Galaxy Score trend + AltRank movement + sentiment
}

These tools don’t exist in the official MCP - they’re YOUR value-add.

---

Can I Wrap Another MCP Server? {#wrap-mcp}

Yes—and it’s easier than wrapping REST. If an official MCP server exists, wrap it instead of the REST API:

Approach	Work Required
Wrap REST API	Write handlers for each endpoint
Wrap MCP Server	Just proxy + add custom tools

Example: Wrap the official LunarCrush MCP (11 tools) and add your own custom tools like get_whale_posts:

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';

// Connect to the official LunarCrush MCP as a client
const lunarClient = new Client({ name: 'custom-lunar', version: '1.0.0' });
const transport = new SSEClientTransport(
new URL('https://lunarcrush.ai/sse'),
{ headers: { Authorization: `Bearer ${process.env.LUNARCRUSH_API_KEY}` } }
);
await lunarClient.connect(transport);

// Proxy tools through your server
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;

// YOUR CUSTOM TOOLS
if (name === 'get_whale_posts') {
return handleGetWhalePosts(args);
}

// OPTIONAL: FILTER OUT TOOLS YOU DON'T WANT OR NEED (reduces token usage)
if (name === 'Post') {
// Don't need post lookups - block to save tokens
throw new McpError(ErrorCode.InvalidRequest, 'Post tool disabled');
}
if (name === 'List') {
// Don't need list lookups - creating own categories
throw new McpError(ErrorCode.InvalidRequest, 'List tool disabled');
}

// PROXY EVERYTHING ELSE to official MCP
return lunarClient.callTool({ name, arguments: args });
});

Why filter tools?

• Each tool definition consumes tokens in the LLM’s context
• 11 tools → ~500 tokens just for tool descriptions
• Block tools you don’t need → smaller context → cheaper + faster

Result: 11 official tools - 2 blocked + 1 custom = 10 tools total, optimized for your use case.

Best practice: If an MCP server exists for your API, wrap it. Only build from REST if no MCP exists or you need complete control.

---

The LLM Shortcut: Generate MCP Servers Automatically {#the-llm-shortcut}

Here’s the secret: use an LLM to BUILD the MCP server for you.

The Prompt That Works

I want to create an MCP server that wraps this REST API:

[Paste your API documentation here - OpenAPI spec is best]

Create a TypeScript MCP server using @modelcontextprotocol/sdk that:

1. Has these specific tools: [list the endpoints you want]
2. Uses Zod for input validation
3. Transforms responses to be LLM-friendly (remove noise, highlight key data)
4. Includes proper error handling
5. Uses this file structure:
- src/index.ts (server setup)
- src/tools.ts (tool definitions)
- src/handlers.ts (API call handlers)
- src/api-client.ts (REST API wrapper)

Include package.json and tsconfig.json.

For LunarCrush Specifically

LunarCrush offers LLM-friendly docs at https://lunarcrush.com/api4?format=markdown - paste it directly into LLM with the prompt above.

Time savings: 25 minutes manual → 5 minutes with LLM assistance.

Extend This With AI

Paste these prompts into Claude or ChatGPT to add features:

Add Database Caching:

"Modify my MCP handlers to cache API responses in SQLite for 60 seconds. Add a get_cached_stats tool that shows cache hit rate and last update times"

Add Sector Analysis:

"Create a new analyze_sector tool that fetches the top 10 coins in a sector (DeFi, AI, Memes) and returns aggregated metrics: average Galaxy Score, total social volume, best/worst performers"

---

ROI & Monetization {#roi-monetization}

For yourself: Save 5-10 hours/week if you regularly work with APIs + AI. "What’s trending in crypto?" → instant answer from any MCP-enabled AI.

As a service:

Complexity	Scope	Price Range
Simple	1 API, 3-5 tools	$500-1,000
Medium	1 API, 10+ tools, custom logic	$1,000-2,000
Complex	Multiple APIs, auth, caching	$2,000-5,000
Enterprise	Multi-tenant, monitoring, SLA	$5,000-10,000+

Where to find clients: Reddit (r/ClaudeAI, r/LocalLLaMA), Twitter #BuildInPublic, Anthropic Discord, Upwork/Fiverr, direct outreach to companies with APIs but no MCP.

Pitch angles:

• "Your API is great, but it’s invisible to AI. Let me make it AI-native."
• "Your competitors have MCP servers. Your users are asking Claude about them, not you."
• "One MCP server = every AI client. Claude, VS Code, custom agents—all from one build."
• "Stop writing integration docs. Let AI discover your API automatically."
• "Your API + MCP = developers can build with you 10x faster using AI assistants."

Distribution: Package your server for your language’s ecosystem (npm for TypeScript, PyPI for Python, etc.) so users can install with one command and add to their MCP config.

Break-even math (if reselling with LunarCrush Builder plan at $300/mo):

• At $25/user → 12 users = break-even
• At $50/user → 6 users = break-even
• At $100/user → 3 users = break-even

Comparison

Approach	Build Time	Reusability	LLM Native	Flexibility
Manual prompts with API calls	0	❌ None	❌ No	❌ Limited
Function calling per app	30 min/app	❌ Per app	⚠️ Partial	⚠️ App-specific
Official MCP server	5 min	✅ All clients	✅ Full	❌ Fixed tools
Custom MCP server	25 min once	✅ All clients	✅ Full	✅ Unlimited

---

Troubleshooting {#troubleshooting}

Error	Cause	Solution
spawn ENOENT	Wrong path in Claude config	Use absolute path to dist/index.js
401 Unauthorized	Invalid or missing API key	Check LUNARCRUSH_API_KEY in env
429 Too Many Requests	Rate limit exceeded	Add caching, upgrade plan with JAMAALBUILDS
Server not showing in Claude	Config syntax error	Validate JSON, restart Claude Desktop
Cannot find module	TypeScript not compiled	Run npm run build
Tools not appearing	Missing capabilities	Ensure tools: {} in server capabilities
ECONNREFUSED	API server down	Check LunarCrush status, try later
Zod validation error	Invalid input from LLM	Check tool descriptions are clear

Pro tip: Check Claude Desktop logs:

• macOS: ~/Library/Logs/Claude/
• Windows: %APPDATA%\Claude\logs\

---

FAQ {#faq}

Q: Can I use JavaScript instead of TypeScript? A: Yes! Remove type annotations and change file extensions to .js. TypeScript just adds safety.

Q: Does this work with ChatGPT? A: Not directly - MCP is Anthropic’s protocol. But your handler code can be adapted for OpenAI function calling with minimal changes.

Q: Is one server enough for all my AI tools? A: Yes! MCP is protocol-based. One server running on stdio or HTTP serves any MCP client—desktop apps, CLI tools, IDE extensions, and custom agents.

Q: How do I add authentication to my MCP server? A: For local use (stdio), credentials come from environment variables. For HTTP deployment, add auth middleware before the MCP handlers.

Q: Can I deploy this to a server instead of running locally? A: Yes! Use StreamableHTTPServerTransport instead of StdioServerTransport and deploy to any Node.js hosting (Vercel, Railway, Fly.io).

Q: Do I need to write MCP servers in TypeScript? A: No! MCP has official SDKs for Python and TypeScript. The protocol is language-agnostic - any language that can do JSON-RPC works.

---

Glossary {#glossary}

• MCP (Model Context Protocol): Anthropic’s open standard for connecting AI to external data and tools. Uses JSON-RPC 2.0.
• REST API: Standard web API architecture using HTTP methods (GET, POST, etc.) to interact with resources.
• Tool: A capability exposed by an MCP server that LLMs can call (like a function).
• Handler: The code that executes when a tool is called - makes API requests, processes data, returns results.
• Transport: How the MCP server communicates (stdio for local, Streamable HTTP for production).
• JSON-RPC: A stateless, lightweight remote procedure call protocol using JSON.
• Galaxy Score: LunarCrush’s 0-100 metric measuring social engagement health for any topic.
• AltRank: LunarCrush’s performance ranking (1 = best) combining social and market metrics.
• Zod: TypeScript-first schema validation library used for input validation.

---

Resources

• MCP Documentation
• MCP TypeScript SDK
• MCP Python SDK
• LunarCrush API Docs

🚀 Ready for real-time data? Use code JAMAALBUILDS for 15% off the LunarCrush Builder plan when you need higher rate limits.

---

About the Author

Built something cool with this tutorial? Share it!

• 🐦 Tag @jamaalbuilds on Twitter
• 💬 Join the discussion in LunarCrush Discord

#LunarCrushBuilder #MCP - Show off what you built!