AI Developer Tools MCP Server

Educational reference implementation demonstrating how to build MCP servers as bridges to existing REST APIs.

This MCP server shows how to expose AI development tool intelligence through the Model Context Protocol (MCP) by wrapping a REST API with a conversational interface. It's designed as a learning resource for developers who want to understand the MCP-as-API-bridge pattern.

Architecture: MCP as an API Bridge

This project demonstrates the recommended pattern for MCP servers: wrapping an existing REST API to provide conversational access, rather than building everything from scratch.

The Pattern

graph TB
    subgraph " "
        DB[(Database<br/>PostgreSQL)]
        API[REST API<br/>Business Logic<br/>Auth • Rate Limiting • Caching]
        DB --> API
    end
    
    API --> |JSON| DEV[Direct API Access]
    API --> |Bridge| MCP[MCP Server<br/>~200 lines<br/>Format JSON → NL]
    
    DEV --> DEVS[👨‍💻 Developers<br/>Programmatic Access]
    MCP --> USERS[💬 Users + Claude<br/>Conversational Access]
    
    style DB fill:#e8f5e9,stroke:#43a047
    style API fill:#e3f2fd,stroke:#1976d2,stroke-width:3px
    style DEV fill:#fff3e0,stroke:#f57c00
    style MCP fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    style DEVS fill:#fff3e0,stroke:#f57c00
    style USERS fill:#f3e5f5,stroke:#7b1fa2

Why This Architecture?

Single Source of Truth

All business logic lives in the REST API
Authentication, rate limiting, caching happen once
API changes automatically flow through to MCP

Dual Access Patterns

Developers use API directly for programmatic access
Non-technical users get conversational access via Claude
Same data, different interfaces for different needs

Thin Wrapper

MCP server is ~200 lines of formatting code
Calls existing API endpoints
Transforms JSON responses → natural language
Easy to maintain and extend

What It Does

This MCP server makes AI development tool intelligence accessible through natural conversation with Claude. Instead of manually querying APIs or clicking through dashboards, you can ask:

Example Queries:

"Compare the adoption of OpenAI SDK vs Anthropic SDK"
"What are the fastest-growing AI coding tools this month?"
"Show me the growth history of Cursor over the last 6 months"
"Find all LLM API frameworks with over 5M downloads"

Claude uses the exposed tools to fetch data and present insights in natural language, complete with growth trends, community metrics, and comparative analysis.

What Data Is Exposed:

NPM download statistics (weekly/monthly)
GitHub repository metrics (stars, activity)
Community engagement (Stack Overflow questions, Reddit mentions)
Historical growth trends
Tool metadata (descriptions, categories, package names)

Code Structure

ai-developer-tools-mcp/
├── src/
│   ├── index.js           # MCP server entry point
│   ├── tools/             # MCP tool definitions
│   │   ├── compare.js     # Compare multiple tools
│   │   ├── trending.js    # Get trending tools
│   │   ├── history.js     # Historical data
│   │   └── search.js      # Search/filter tools
│   ├── api/               # API client layer (THE BRIDGE)
│   │   └── client.js      # Simulates REST API calls
│   ├── data/              # Mock data (simulates database)
│   │   └── mock-data.js   # Sample data
│   └── utils/             # Formatters
│       └── formatters.js  # JSON → Natural language
├── test/
│   └── test-tools.js      # Test suite
├── .env.example
├── package.json
└── README.md

Key Layers

1. MCP Tools (src/tools/)

Define what Claude can call
Receive structured parameters from Claude
Call the API client
Return formatted responses

2. API Client (src/api/client.js) ⭐ THE BRIDGE

Simulates REST API calls in this demo
In production: makes real HTTP requests
Handles authentication, errors, timeouts
Returns JSON responses

3. Formatters (src/utils/formatters.js)

Transform JSON → Natural language
Add insights and context
Make data conversational
This is where MCP adds value

4. Mock Data (src/data/mock-data.js)

Simulates database responses
Representative sample data
In production: replaced by real database

Production vs Demo

Demo (This Repo)

API Client (src/api/client.js):

async getToolMetrics(toolId) {
  // Simulate network delay
  await this._simulateNetworkDelay();
  
  // Return mock data
  const data = mockData.getCurrentMetrics(toolId);
  return this._successResponse(data);
}

What it demonstrates:

MCP tool → API client → Data source pattern
Request/response flow
Error handling
Response formatting

Production (vibe-data.com)

API Client:

async getToolMetrics(toolId) {
  // Make real HTTP request
  const response = await fetch(
    `${this.baseURL}/tools/${toolId}/metrics`,
    {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      timeout: this.timeout
    }
  );
  
  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }
  
  return await response.json();
}

What changes:

fetch() instead of mock data
Real authentication headers
Actual timeout handling
Production error handling
Rate limiting
Retry logic

Everything else stays the same:

MCP tool definitions ✓
Response formatters ✓
Tool parameter schemas ✓
MCP server setup ✓

Quick Start

Prerequisites

Node.js 18 or higher
Claude Desktop app (or any MCP-compatible client)

Installation

# Clone the repository
git clone https://github.com/grzetich/ai-developer-tools-mcp.git
cd ai-developer-tools-mcp

# Install dependencies
npm install

# (Optional) Copy and configure environment variables
cp .env.example .env

Running the Server

Option 1: Standalone Testing

# Run the server in stdio mode
npm start

# Or run tests to verify all tools work
npm test

Option 2: Connect to Claude Desktop

Add this configuration to your Claude Desktop config file:

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

{
  "mcpServers": {
    "ai-developer-tools": {
      "command": "node",
      "args": ["/absolute/path/to/ai-developer-tools-mcp/src/index.js"]
    }
  }
}

Restart Claude Desktop. You should see the server listed in the MCP section.

Testing It Works

Ask Claude:

"What are the most popular AI coding tools right now?"

Claude will use the get_trending_tools tool to fetch current data and present it to you.

How The Bridge Pattern Works

Request Flow

sequenceDiagram
    participant User
    participant Claude
    participant MCP as MCP Server<br/>(This Code)
    participant API as REST API<br/>(Mock/Real)
    participant DB as Database<br/>(Mock Data)
    
    User->>Claude: "What's Cursor's growth trend?"
    Claude->>MCP: Call get_tool_history(tool: "cursor")
    MCP->>API: GET /tools/cursor/history
    API->>DB: Query historical data
    DB-->>API: Return data rows
    API-->>MCP: JSON response
    Note over MCP: Format JSON → Natural language
    MCP-->>Claude: "Cursor grew 55% to 8.1M downloads..."
    Claude-->>User: Present formatted answer

Code Example

User asks: "What's Cursor's adoption trend?"

1. Claude decides to call the tool:

{
  "tool": "get_tool_history",
  "arguments": {
    "tool": "cursor",
    "months": 6
  }
}

2. MCP tool receives call:

// src/tools/history.js
async execute(args) {
  const { tool, months } = args;
  
  // Call API client
  const response = await apiClient.getToolHistory(tool, months);
  
  // Format JSON → Natural language
  return formatHistory(response.data, tool, months);
}

3. API client makes request:

// src/api/client.js
async getToolHistory(toolId, months) {
  // In demo: return mock data
  // In production: fetch(`${baseURL}/tools/${toolId}/history?months=${months}`)
  
  const data = mockData.getHistoricalData(toolId, months);
  return this._successResponse({ tool_id: toolId, data });
}

4. Formatter transforms response:

// src/utils/formatters.js
export function formatHistory(apiResponse, toolId, months) {
  const { data } = apiResponse;
  
  let output = `📈 ${toolId.toUpperCase()} - ${months} Month History\n\n`;
  
  data.forEach(point => {
    output += `${point.month}: ${formatNumber(point.downloads)} downloads\n`;
  });
  
  const growth = calculateGrowth(data);
  output += `\n**Growth:** ${growth}% over ${months} months\n`;
  
  return output;
}

5. Claude presents to user: "Based on the data, Cursor has shown strong growth over the last 6 months, with downloads increasing from 5.2M to 8.1M (55.8% growth)..."

Available Tools

1. `compare_tools`

Compare adoption metrics between 2-3 AI developer tools

Parameters:

{
  "tools": ["openai", "anthropic"],
  "time_range": "30d"
}

Returns: Side-by-side comparison with growth indicators and key insights

2. `get_trending_tools`

Get the fastest-growing AI developer tools

Parameters:

{
  "time_range": "30d",
  "limit": 5,
  "category": "llm-api"
}

Returns: Ranked list by growth percentage with current metrics

3. `get_tool_history`

Get historical adoption data for a specific tool

Parameters:

{
  "tool": "cursor",
  "months": 6
}

Returns: Monthly timeline with growth analysis

4. `search_tools`

Search and filter tools by criteria

Parameters:

{
  "category": "llm-api",
  "min_downloads": 10000000,
  "sort_by": "downloads"
}

Returns: Filtered list with full details and summary stats

Migrating to Production

Step 1: Update API Client

Replace mock calls with real HTTP requests:

// src/api/client.js

class ApiClient {
  constructor(baseURL, options = {}) {
    this.baseURL = baseURL;
    this.apiKey = options.apiKey;
    this.timeout = options.timeout || 5000;
  }

  async getToolMetrics(toolId) {
    try {
      const response = await fetch(
        `${this.baseURL}/tools/${toolId}/metrics`,
        {
          headers: {
            'Authorization': `Bearer ${this.apiKey}`,
            'Content-Type': 'application/json'
          },
          signal: AbortSignal.timeout(this.timeout)
        }
      );

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      const data = await response.json();
      return this._successResponse(data);
      
    } catch (error) {
      if (error.name === 'AbortError') {
        return this._errorResponse(408, 'Request timeout');
      }
      return this._errorResponse(500, error.message);
    }
  }
  
  // ... implement other methods similarly
}

// Configure with environment variables
export const apiClient = new ApiClient(
  process.env.API_BASE_URL || 'https://api.vibe-data.com',
  {
    apiKey: process.env.API_KEY,
    timeout: parseInt(process.env.API_TIMEOUT) || 5000
  }
);

Step 2: Add Authentication

// .env
API_BASE_URL=https://api.vibe-data.com
API_KEY=your_api_key_here
API_TIMEOUT=5000

Step 3: Add Rate Limiting

// src/api/client.js

class ApiClient {
  constructor(baseURL, options = {}) {
    this.baseURL = baseURL;
    this.apiKey = options.apiKey;
    this.rateLimiter = new RateLimiter(options.rateLimit || 100); // 100 requests/min
  }

  async getToolMetrics(toolId) {
    // Wait for rate limit
    await this.rateLimiter.wait();
    
    // Make request...
  }
}

Step 4: Add Retry Logic

async getToolMetrics(toolId, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(/* ... */);
      return response;
    } catch (error) {
      if (i === retries - 1) throw error;
      await this._exponentialBackoff(i);
    }
  }
}

_exponentialBackoff(attempt) {
  const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
  return new Promise(resolve => setTimeout(resolve, delay));
}

Step 5: Test

Everything else (tools, formatters, MCP server) stays the same.

Design Decisions

Why Wrap an API Instead of Direct Database Access?

Separation of Concerns:

API handles business logic, auth, rate limiting
MCP server focuses on conversation formatting
Don't duplicate logic in both places

Security:

API is your security boundary
MCP server doesn't need database credentials
Same security rules apply to all clients

Maintainability:

One codebase for business logic
API changes flow through automatically
MCP layer is thin and simple

Why Format Responses as Text?

Claude Excels at Language:

Language models work best with text, not JSON
No parsing needed - Claude can directly quote or summarize
More flexible - Claude can adapt presentation to context

Better User Experience:

Users see insights, not data structures
Natural conversation flow
Context and interpretation included

Example:

JSON response:

{"downloads": 8100000, "growth_pct": 55.8}

Formatted text:

Cursor grew 55% over the quarter, reaching 8.1M monthly 
downloads, indicating strong developer adoption.

Same data, but one is for machines and one is for humans.

Why One Tool Per Function?

Claude Performs Better:

Clear, focused tools are easier for Claude to choose
Simpler parameter schemas
More predictable behavior

Easier to Maintain:

Each tool has one responsibility
Independent testing
Clear documentation

Composable:

Claude can chain multiple tool calls
"Compare top 3 trending tools" = get_trending + compare_tools

Real-World Use Cases

This pattern works for any product with queryable data:

B2B SaaS

API: Analytics platforms, customer dashboards
MCP: "How's our MRR trending?" "Which customers churned?"

E-commerce

API: Inventory systems, order management
MCP: "What products are low stock?" "Show me returns this week"

Internal Tools

API: Automated reports, integrations
MCP: "Find pending invoices" "Compare Q3 vs Q4 sales"

Contributing

Contributions welcome! This is an educational project, so quality over quantity.

Good Contributions:

Additional tools with clear use cases
Better mock data demonstrating edge cases
Documentation improvements
Examples of production implementations
Testing improvements

Please Open an Issue First to discuss:

Major architectural changes
New dependencies
Breaking changes to tool interfaces

License

MIT License - see LICENSE file for details.

Acknowledgments

Built with the Model Context Protocol by Anthropic
Inspired by real production data platform at Vibe Data
Created as an educational resource for the AI developer community

Learn More

Questions? Issues? Ideas? Open an issue or reach out!

ai-developer-tools-mcp

AI Developer Tools MCP Server

Architecture: MCP as an API Bridge

The Pattern

Why This Architecture?

What It Does

Code Structure

Key Layers

Production vs Demo

Demo (This Repo)

Production (vibe-data.com)

Quick Start

Prerequisites

Installation

Running the Server

Testing It Works

How The Bridge Pattern Works

Request Flow

Code Example

Available Tools

1. compare_tools

2. get_trending_tools

3. get_tool_history

4. search_tools

Migrating to Production

Step 1: Update API Client

Step 2: Add Authentication

Step 3: Add Rate Limiting

Step 4: Add Retry Logic

Step 5: Test

Design Decisions

Why Wrap an API Instead of Direct Database Access?

Why Format Responses as Text?

Why One Tool Per Function?

Real-World Use Cases

B2B SaaS

E-commerce

Internal Tools

Contributing

License

Acknowledgments

Learn More

Reviews

1. `compare_tools`

2. `get_trending_tools`

3. `get_tool_history`

4. `search_tools`