Resources / MCP Servers

MCP Servers.

Model Context Protocol (MCP) is Anthropic's open standard for connecting AI models to tools, data, and services. Each server below plugs into Claude Desktop, Claude Code, or any MCP-compatible runtime.

Official Anthropic MCP Servers

filesystemofficial

Read, write, list, and manage local filesystem. Essential for any code-working agent.

npx @modelcontextprotocol/server-filesystem <path>

read_filewrite_filelist_directorycreate_directorymove_filesearch_files

brave-searchofficial

Real-time web search via Brave Search API. Returns titles, URLs, and snippets.

npx @modelcontextprotocol/server-brave-search

Needs:BRAVE_API_KEY

brave_web_searchbrave_local_search

githubofficial

Full GitHub API — repos, files, commits, issues, PRs, branches.

npx @modelcontextprotocol/server-github

Needs:GITHUB_PERSONAL_ACCESS_TOKEN

search_repositoriesget_file_contentscreate_issuelist_commitscreate_pull_request

postgresofficial

Execute queries, inspect schema, list tables on any PostgreSQL database.

npx @modelcontextprotocol/server-postgres <connection-string>

querylist_tablesdescribe_table

sqliteofficial

Full SQLite read/write operations on local .db files.

npx @modelcontextprotocol/server-sqlite <path>

read_querywrite_querycreate_tablelist_tables

puppeteerofficial

Headless browser automation: navigate, screenshot, fill forms, extract DOM.

npx @modelcontextprotocol/server-puppeteer

puppeteer_navigatepuppeteer_screenshotpuppeteer_clickpuppeteer_fillpuppeteer_evaluate

fetchofficial

HTTP GET/POST requests. Web scraping, API calls, form submission.

npx @modelcontextprotocol/server-fetch

fetchfetch_post

memoryofficial

Persistent knowledge graph with entities, relations, and observations.

npx @modelcontextprotocol/server-memory

create_entitiescreate_relationsadd_observationsread_graphsearch_nodes

sequential-thinkingofficial

Forces structured multi-step reasoning with branching.

npx @modelcontextprotocol/server-sequential-thinking

sequentialthinking

Database Integrations

mysqldatabase

Execute queries, inspect schema, manage tables on any MySQL/MariaDB database.

npx @modelcontextprotocol/server-mysql <connection-string>

querylist_tablesdescribe_tableexecute

mongodbdatabase

MongoDB CRUD operations, aggregation pipelines, index management, and collection listing.

npx mcp-server-mongodb <connection-string>

findinsertupdatedeleteaggregatelist_collections

redisdatabase

Full Redis command set: strings, hashes, lists, sets, sorted sets, pub/sub, and key expiry.

npx mcp-server-redis

Needs:REDIS_URL

redis_getredis_setredis_delredis_hsetredis_lpushredis_keys

elasticsearchdatabase

Full-text search, index management, document CRUD, and cluster health on Elasticsearch/OpenSearch.

npx mcp-server-elasticsearch

Needs:ELASTICSEARCH_URLELASTICSEARCH_API_KEY

searchindex_documentget_documentlist_indicescluster_health

supabasedatabase

Supabase database queries, storage, and auth operations.

npx mcp-server-supabase

Needs:SUPABASE_URLSUPABASE_SERVICE_KEY

execute_sqllist_tablesget_storage_files

Productivity Tools

google-driveproductivity

List, read, create, update, and share files and folders in Google Drive.

npx @modelcontextprotocol/server-gdrive

Needs:GOOGLE_CLIENT_IDGOOGLE_CLIENT_SECRET

list_filesread_filecreate_fileupdate_fileshare_file

google-mapsproductivity

Geocoding, route planning, place search, and distance matrix via Google Maps API.

npx @modelcontextprotocol/server-google-maps

Needs:GOOGLE_MAPS_API_KEY

geocodereverse_geocodesearch_placesget_directionsdistance_matrix

obsidianproductivity

Read and write Obsidian vault notes, search by tag, list recent files, and manage frontmatter.

npx mcp-obsidian <vault-path>

read_notewrite_notelist_notessearch_notesget_tags

airtableproductivity

Read and write Airtable bases, tables, records, and fields. Schema introspection included.

npx mcp-airtable

Needs:AIRTABLE_API_KEY

list_baseslist_tablesget_recordscreate_recordupdate_record

notionproductivity

Read/write Notion pages, databases, blocks.

npx mcp-notion-server

Needs:NOTION_API_KEY

get_pagecreate_pageupdate_pagequery_database

linearproductivity

Create, update, transition, and search Linear issues, cycles, and projects.

npx @linear/mcp-server

Needs:LINEAR_API_KEY

create_issuelist_issuesupdate_issuelist_projects

jiraproductivity

Create, update, transition, and search Jira issues, sprints, and projects.

npx mcp-server-jira

Needs:JIRA_HOSTJIRA_EMAILJIRA_API_TOKEN

get_issuecreate_issueupdate_issuetransition_issuesearch_issueslist_projects

DevOps & Infrastructure

gitdevops

Local Git operations: status, diff, log, commit, branch, checkout, push, and merge.

npx @modelcontextprotocol/server-git --repository <path>

git_statusgit_diffgit_loggit_commitgit_branchgit_checkout

dockerdevops

Docker container lifecycle, log tailing, exec, image management, and network inspection.

npx mcp-server-docker

list_containersstart_containerstop_containerget_logsexec_in_containerlist_images

kubernetesdevops

Kubernetes cluster operations: pods, deployments, services, ConfigMaps, logs, and exec.

npx mcp-server-kubernetes

Needs:KUBECONFIG

list_podsget_pod_logsapply_manifestdelete_resourceget_deploymentsexec_in_pod

cloudflaredevops

Manage Cloudflare Workers, KV namespaces, D1 databases, R2 buckets, and DNS records.

npx @cloudflare/mcp-server-cloudflare

Needs:CLOUDFLARE_API_TOKENCLOUDFLARE_ACCOUNT_ID

kv_getkv_putkv_deleteworkers_listd1_querydns_list_records

sentrydevops

Query Sentry for issues, events, releases, and performance data. Triage errors with AI.

npx mcp-server-sentry

Needs:SENTRY_AUTH_TOKENSENTRY_ORG

list_issuesget_issuelist_eventsresolve_issuelist_releases

AI & Search

tavilyai

AI-optimized web search returning clean, structured results. Faster than raw HTML scraping.

npx tavily-mcp

Needs:TAVILY_API_KEY

tavily_searchtavily_extract

stripeai

Stripe customers, subscriptions, invoices, payments.

npx @stripe/agent-toolkit

Needs:STRIPE_SECRET_KEY

create_customerlist_subscriptionscreate_invoiceretrieve_payment_intent

aws-kb-retrievalai

AWS Knowledge Base RAG — retrieve grounded context from Amazon Bedrock Knowledge Bases.

npx @modelcontextprotocol/server-aws-kb-retrieval-server

Needs:AWS_ACCESS_KEY_IDAWS_SECRET_ACCESS_KEYAWS_REGIONKNOWLEDGE_BASE_ID

retrieve

everythingai

Reference implementation and test server. Exercises all MCP primitives: tools, resources, prompts, sampling.

npx @modelcontextprotocol/server-everything

echoaddlongRunningOperationsampleLLMgetTinyImage

Communication

slackcommunication

Post messages, list channels, fetch thread history.

npx mcp-server-slack

Needs:SLACK_BOT_TOKENSLACK_TEAM_ID

list_channelspost_messagereply_to_threadget_channel_history

gmailcommunication

Read, send, search, and label Gmail messages. Draft management and attachment handling.

npx mcp-server-gmail

Needs:GOOGLE_CLIENT_IDGOOGLE_CLIENT_SECRET

list_messagesget_messagesend_emailcreate_draftsearch_messages

telegramcommunication

Send messages and files to Telegram chats and channels via Bot API.

npx mcp-server-telegram

Needs:TELEGRAM_BOT_TOKEN

send_messagesend_documentget_chat_infoget_updates

resendcommunication

Send transactional email via Resend API. Supports React Email templates.

npx mcp-server-resend

Needs:RESEND_API_KEY

send_email

Claude Code Configuration

.claude/mcp.json

Configure multiple MCP servers in a single JSON file at the root of your project or user config.

.claude/mcp.json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Transport Types

stdio Transport

Communicates via stdin/stdout process pipes. Ideal for local tools, CLI scripts, and development environments where the server runs as a child process.

stdio-server.ts

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

// stdio transport: communicates via stdin/stdout
// Perfect for: local tools, CLI scripts, process pipes
// Launch via: claude --mcp "node my-server.js"

const server = new Server(
  { name: 'stdio-server', version: '1.0.0' },
  { capabilities: { tools: {} } }
)

// ... register handlers ...

const transport = new StdioServerTransport()
await server.connect(transport)
// Server is now listening on stdin, writing to stdout

HTTP / SSE Transport

Communicates over HTTP with Server-Sent Events for streaming. Perfect for remote servers, multi-user deployments, and anything requiring authentication.

http-server.ts

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

// HTTP/SSE transport: communicates over HTTP with Server-Sent Events
// Perfect for: remote servers, multi-user, authentication, cloud deployment

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

const server = new Server(
  { name: 'http-server', version: '1.0.0' },
  { capabilities: { tools: {} } }
)

// Require auth header for all requests
app.use((req, res, next) => {
  const token = req.headers['authorization']?.replace('Bearer ', '')
  if (token !== process.env.MCP_SECRET) {
    return res.status(401).json({ error: 'Unauthorized' })
  }
  next()
})

app.post('/mcp', async (req, res) => {
  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined })
  await server.connect(transport)
  await transport.handleRequest(req, res, req.body)
})

app.listen(3000, () => console.log('MCP server running on :3000'))

stdio vs HTTP/SSE — Comparison

Feature	stdio	HTTP / SSE
Communication	stdin / stdout pipes	HTTP POST + Server-Sent Events
Security	Process-level isolation	Network layer, requires auth
Latency	Sub-millisecond (local)	Network RTT (1–50ms typical)
Deployment	Local process only	Cloud, container, serverless
Authentication	OS-level (no extra needed)	Bearer token, API key, mTLS
Multi-user	One user per process	Unlimited concurrent sessions
Best for	Local tools, CLI, dev scripts	Production APIs, team servers

MCP Primitives

MCP defines three primitive types that servers expose to AI clients. Each serves a distinct purpose in the AI-tool interaction model.

⚡ToolsActions / Side Effects

Functions the AI can call. Tools have side effects: they write files, query databases, call APIs, send emails. The model decides when to invoke them based on the task.

tool definition

// MCP Tool — a function the AI can call (actions, side effects)
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: 'send_email',
    description: 'Send an email via Resend API',
    inputSchema: {
      type: 'object',
      properties: {
        to: { type: 'string', description: 'Recipient email address' },
        subject: { type: 'string' },
        body: { type: 'string' },
      },
      required: ['to', 'subject', 'body'],
    },
  }],
}))

📄ResourcesData Sources / Read-Only

Data sources the AI can read. Resources are identified by URI and expose content that the model can include in its context — files, database rows, API responses.

resource definition

// MCP Resource — data the AI can read (files, DB, APIs)
import { ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js'

server.setRequestHandler(ListResourcesRequestSchema, async () => ({
  resources: [{
    uri: 'file:///project/README.md',
    name: 'Project README',
    description: 'Main project documentation',
    mimeType: 'text/markdown',
  }],
}))

server.setRequestHandler(ReadResourceRequestSchema, async (request) => ({
  contents: [{
    uri: request.params.uri,
    mimeType: 'text/markdown',
    text: await fs.readFile(request.params.uri.replace('file://', ''), 'utf-8'),
  }],
}))

💬PromptsReusable Prompt Templates

Parameterized prompt templates stored server-side. The client lists available prompts, selects one, passes arguments, and receives a fully-rendered message array ready to send.

prompt definition

// MCP Prompt — reusable prompt templates with parameters
import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js'

server.setRequestHandler(ListPromptsRequestSchema, async () => ({
  prompts: [{
    name: 'code_review',
    description: 'Review code with specified focus areas',
    arguments: [
      { name: 'language', description: 'Programming language', required: true },
      { name: 'focus', description: 'Review focus: security|performance|readability', required: false },
    ],
  }],
}))

server.setRequestHandler(GetPromptRequestSchema, async (request) => ({
  messages: [{
    role: 'user',
    content: {
      type: 'text',
      text: `Review this ${request.params.arguments?.language} code focusing on ${request.params.arguments?.focus ?? 'all areas'}.`,
    },
  }],
}))

Build Your Own

Build Your Own MCP Server

1Install SDK: npm install @modelcontextprotocol/sdk

2Define tools: Describe name, description, input schema (JSON Schema)

3Handle calls: Return { content: [{ type: "text", text: result }] }

my-mcp-server.ts

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

const server = new Server(
  { name: 'my-mcp-server', version: '1.0.0' },
  { capabilities: { tools: {} } }
)

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: 'my_tool',
    description: 'Does something useful',
    inputSchema: {
      type: 'object',
      properties: {
        input: { type: 'string', description: 'The input value' },
      },
      required: ['input'],
    },
  }],
}))

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === 'my_tool') {
    const { input } = request.params.arguments as { input: string }
    return { content: [{ type: 'text', text: `Processed: ${input}` }] }
  }
  throw new Error(`Unknown tool: ${request.params.name}`)
})

const transport = new StdioServerTransport()
await server.connect(transport)

Claude Desktop Config · claude_desktop_config.json

claude_desktop_config.json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}