gentic news

Posted on May 22 • Originally published at gentic.news

MCP Crosses 9,400 Servers; Build Your Own in TypeScript

#ai #opensource #programming #machinelearning

MCP crossed 9,400 servers. Build a database introspection server in TypeScript. SDK handles protocol framing and capability negotiation.

Key facts

MCP crossed 9,400 registered servers in early May 2026.
Protocol uses JSON-RPC 2.0 with three capability types.
SDK handles protocol framing, message routing, negotiation.
QA Claude Skill open-sourced with 24 production-grade skills.
Spec Driven Development plugin available at sermakarevich/sddw.

The Model Context Protocol (MCP) crossed 9,400 registered servers in early May 2026. Every one of those servers unlocks a new capability inside Claude Code — file access, database queries, API calls, custom tool chains. Building your own MCP server is the fastest way to make Claude Code understand your stack, your data, and your workflows. This guide walks you through a complete, working server in TypeScript from zero to a running integration.

MCP is a JSON-RPC 2.0-based protocol that lets Claude Code call external tools, read resources, and use pre-built prompt templates. The server you build runs as a local process. Claude Code spawns it via stdio or connects via HTTP+SSE. The protocol has three capability types: tools (functions Claude can call), resources (data Claude can read), and prompts (reusable templates). You will build a server that exposes all three.

Key Takeaways

MCP crossed 9,400 servers.
Build a database introspection server in TypeScript.
SDK handles protocol framing and capability negotiation.

What We Are Building

A database introspection server. Claude Code will be able to: list tables in a SQLite database (tool), read table schemas (resource), and use a pre-built prompt template for generating migration scripts. By the end you will have a fully functional MCP server you can extend for any data source.

Project Setup

mkdir mcp-db-server && cd mcp-db-server
npm init -y
npm install @modelcontextprotocol/sdk better-sqlite3 zod
npm install -D typescript @types/node @types/better-sqlite3 tsx
npx tsc --init --target ES2022 --module Node16 --moduleResolution Node16 --strict --outDir dist

The @modelcontextprotocol/sdk package handles all protocol framing, message routing, and capability negotiation. You write handlers; the SDK handles the wire protocol.

Server Entry Point

// src/index.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import {
  CallToolRequestSchema,
  ListResourcesRequestSchema,
  ListToolsRequestSchema,
  ReadResourceRequestSchema,
  GetPromptRequestSchema,
  ListPromptsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js'
import Database from 'better-sqlite3'
import { z } from 'zod'
import path from 'node:path'

const server = new Server(
  { name: 'db-introspection-server', version: '1.0.0' },
  {
    capabilities: {
      tools: {},
      resources: {},
      prompts: {},
    },
  }
)

const DB_PATH = process.env.DB_PATH ?? path.join(process.cwd(), 'dev.sqlite')
const db = new Database(DB_PATH, { readonly: true })

export { server, db }

Defining Tools

Tools are functions Claude Code can invoke. Each tool has a name, description, and a JSON Schema for its input parameters. The SDK validates inputs against the schema before calling your handler.

// src/tools.ts
import { server, db } from './index.js'
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js'

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: 'list_tables',
      description: 'List all tables in the SQLite database with row counts',
      inputSchema: {
        type: 'object',
        properties: {},
        required: [],
      },
    },
    {
      name: 'query_table',
      description: 'Run a SELECT query on a specific table (read-only)',
      inputSchema: {
        type: 'object',
        properties: {
          table: {
            type: 'string',
            description: 'Name of the table to query',
          },
          limit: {
            type: 'number',
            description: 'Maximum number of rows to return',
            default: 100,
          },
        },
        required: ['table'],
      },
    },
  ],
}))

Unique Take: The MCP Ecosystem Is a Developer Moats Strategy

The 9,400 registered server count is not just a metric of adoption — it signals a strategic moat for Anthropic. Every custom MCP server built by a developer ties their workflow deeper into Claude Code, creating switching costs that rival those of VS Code extensions for Microsoft. Unlike API calls, MCP servers run locally, giving developers control over data and latency. This architecture makes Claude Code a platform, not just a chatbot, and the 9,400 figure is likely to accelerate as more teams build internal tools.

QA Claude Skill: 24 Production-Grade Skills Open-Sourced

A separate open-source project, QA Claude Skill, provides 24 production-grade QA skills for Claude Code covering test design, automation, performance, security, mutation testing, and more. The skills are MIT licensed for non-commercial use and generalize across teams via a config.json file. Examples include bug-report (RIDER format with JIRA integration), test-master (generates test pyramids and coverage gaps), and mutation-testing (runs mutmut on Python backends). Each skill activates on natural language triggers, reducing the need for manual prompt engineering.

Spec Driven Development Approach

Another approach gaining traction is Spec Driven Development (SDD), which decomposes tasks across two dimensions: first generating specs in multiple steps (requirements, code analysis, design), then splitting tasks into subtasks and implementing them one by one. The approach clears context between every step to keep costs low and focus high. A Claude plugin for SDD is available on GitHub at sermakarevich/sddw.

What to watch

Watch for Anthropic's upcoming developer conference in June 2026, where the company is expected to announce MCP server marketplace and enterprise licensing tiers. The 9,400 server count will likely double by year-end if the platform strategy succeeds.

Originally published on gentic.news

DEV Community