Guides8 min read

Best MCP Servers for Node.js & JavaScript Developers in 2026

The top MCP servers for JavaScript and Node.js developers: GitHub integration, database access, browser automation, Redis caching, Stripe payments, and more — all accessible from your AI workflow.

By MyMCPTools Team·

JavaScript developers live across a sprawling ecosystem: npm packages, GitHub repos, PostgreSQL databases, Redis caches, Stripe subscriptions, Vercel deployments, Slack channels. MCP servers give your AI assistant access to all of it — so you can ship without context-switching.

Here are the MCP servers that matter most for Node.js and JavaScript developers.

1. GitHub MCP Server — Your Codebase, AI-Accessible

The GitHub MCP server is table stakes for any developer workflow. It gives your AI assistant direct access to your repositories, pull requests, issues, and code search — without leaving the conversation.

Key capabilities:

  • Read any file in any repo you have access to
  • Create, view, and comment on issues and PRs
  • Search code across all your repositories
  • View commit history and diffs

Node.js workflow: "Review my open PRs and summarize the changes." "Search for all usages of express.Router in the backend repo." "Create an issue: the auth middleware doesn't handle expired JWT tokens."

2. Filesystem MCP Server — Project-Level Context

JavaScript projects are complex directory trees: src/, dist/, node_modules/, config files everywhere. The filesystem MCP server gives your AI assistant the ability to read, write, and navigate your project without copy-pasting.

Key capabilities:

  • Read and write files with encoding support
  • Directory traversal and file search
  • Configurable root directories (lock to your project)
  • Batch file operations

Node.js workflow: "Read my tsconfig.json and suggest strict mode improvements." "Find all files that import from ../utils/auth." "Write a Jest test for the function in src/lib/parser.ts."

3. PostgreSQL MCP Server — Database Queries in Plain English

Most Node.js backends talk to PostgreSQL. The PostgreSQL MCP server exposes your schema and lets your AI run read-only queries — so you can ask questions about your data without writing SQL from memory.

Key capabilities:

  • Schema introspection (tables, columns, types, foreign keys)
  • Read-only query execution
  • Query explanation and optimization hints
  • Multi-database connection support

Node.js workflow: "How many users signed up in the last 7 days?" "Show me the schema for the orders table." "Write a Prisma query that gets all orders with their associated user data."

4. Playwright MCP Server — Browser Automation Without the Setup

Playwright is the standard for Node.js browser automation and end-to-end testing. The Playwright MCP server lets your AI assistant control a browser instance directly — navigating pages, filling forms, extracting content, and running test scenarios.

Key capabilities:

  • Launch and control Chromium, Firefox, or WebKit
  • Navigate URLs and interact with page elements
  • Take screenshots and extract structured content
  • Execute test flows for QA validation

Node.js workflow: "Go to our staging URL and check that the login form submits correctly." "Scrape the pricing table from [competitor URL]." "Run through the signup flow and tell me if anything is broken."

5. Redis MCP Server — Cache and Queue Visibility

Redis is ubiquitous in Node.js stacks — session storage, job queues, rate limiting, pub/sub. The Redis MCP server gives your AI assistant visibility into your cache so you can debug caching issues without opening redis-cli.

Key capabilities:

  • Get, set, and inspect keys
  • View TTLs and expiration times
  • Browse sorted sets, hashes, and lists
  • Flush keys by pattern

Node.js workflow: "Is the user session for user_id 1234 still in cache?" "How many jobs are queued in the BullMQ email queue?" "What's the TTL on the rate-limit key for this IP?"

6. Stripe MCP Server — Payment Context Without Leaving Code

Building subscription billing in Node.js? The Stripe MCP server gives your AI assistant access to your payment data so you can debug webhook events, check subscription states, and verify charge history during development.

Key capabilities:

  • View customers, subscriptions, and payment intents
  • Browse recent charges and refunds
  • Check webhook event logs
  • Inspect product and price configurations

Node.js workflow: "Why did this customer's subscription fail to renew?" "Show me the webhook events from the last hour." "What does the pro_monthly price object look like in the API?"

7. Vercel MCP Server — Deployment Health

Most Node.js web apps deploy to Vercel. The Vercel MCP server gives your AI assistant visibility into deployment status, build logs, and function performance — so you can debug a failed deploy without leaving your coding context.

Key capabilities:

  • Check deployment status and build logs
  • View Edge Function and Serverless Function performance
  • Manage environment variables
  • Access Vercel Analytics data

Node.js workflow: "Did the last deploy succeed?" "Are any API routes timing out in production?" "Show me the build log for the failed deployment."

8. Fetch MCP Server — HTTP Requests in Context

The Fetch MCP server gives your AI assistant the ability to make HTTP requests to any URL — REST APIs, internal services, public data sources. It's the Swiss army knife for integrating external services without writing boilerplate.

Key capabilities:

  • GET, POST, PUT, DELETE requests with custom headers
  • Response body extraction (JSON, text, HTML)
  • Auth header support (Bearer tokens, API keys)

Node.js workflow: "Hit our /api/health endpoint and tell me what it returns." "Fetch the latest npm release version for express." "Call the OpenAI API with this prompt and return the response."

9. Linear MCP Server — Issue Tracking in Flow

JavaScript teams at modern startups almost universally use Linear. The Linear MCP server lets your AI assistant browse your backlog, create issues, and update sprint status without you ever opening the Linear app.

Key capabilities:

  • View current cycle and team workload
  • Create and triage issues with priorities
  • Track project status and blockers
  • Search issues by keyword or assignee

Node.js workflow: "Create a Linear issue: the Stripe webhook handler throws a 500 on subscription.updated events." "What's blocking the current sprint?" "Move issue ENG-432 to In Review."

The JavaScript Developer MCP Stack

Start with these three — they solve the most common friction points:

  1. GitHub — code and PR context
  2. Filesystem — project file access
  3. PostgreSQL — database queries

Then add based on your stack: Playwright if you do browser testing, Redis if you have a cache layer, Stripe if you handle payments, Vercel if you deploy there.

Related guides:

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

💻

GitHub MCP Server

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

Auth required📘
📁

Filesystem MCP Server

sandboxed read, write, edit, move and search access to an explicit whitelist of local directories, and it is the reference implementation most other filesystem MCP servers are modelled on. Shipped by Anthropic in the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it is a Node.js server published to npm as @modelcontextprotocol/server-filesystem. The part worth understanding before you install is the access-control model, because there are now two ways to grant directories and they do not compose. Method one is command-line arguments: `npx -y @modelcontextprotocol/server-filesystem /path/one /path/two`. Method two, and the one the maintainers recommend, is MCP Roots — a client that supports the roots protocol sends its roots at initialization, and those roots COMPLETELY REPLACE any directories passed on the command line, then get replaced again on every `notifications/roots/list_changed`. That means allowed directories can change at runtime without restarting the server, but it also means a roots-capable client silently overrides your CLI arguments. If the server starts with no arguments and the client either does not support roots or sends an empty list, initialization throws an error. The tool surface is broad: `read_text_file` (with mutually exclusive `head`/`tail` line windows), `read_media_file` returning base64 image/audio content blocks, `read_multiple_files` which keeps going when individual reads fail, `write_file`, `edit_file`, `create_directory`, `list_directory`, `list_directory_with_sizes`, `move_file`, `search_files`, `directory_tree`, `get_file_info` and `list_allowed_directories`. `edit_file` is the one to learn — it does line-based and multi-line pattern matching with indentation detection and preservation, returns a git-style diff with context, and supports `dryRun: true` so you can preview a change before applying it; the maintainers recommend always running a dry run first. Every operation is refused outside the allowed set, and `list_allowed_directories` is the fastest way to confirm what the server actually believes it can touch.

Local
🌍

Playwright MCP Server (ExecuteAutomation)

ExecuteAutomation's Playwright MCP Server is a community-maintained browser automation server (5,500+ GitHub stars) distinct from Microsoft's official microsoft/playwright-mcp — it leans further into test generation and visual workflows rather than pure accessibility-tree navigation. Beyond standard navigate/click/fill/screenshot tools, it can generate Playwright test code from a live browsing session, scrape full page content and structured data, execute arbitrary JavaScript in the page context, and drive API testing (GET/POST/PUT/PATCH/DELETE requests) alongside the browser tools. A standout feature is 143 real device presets for responsive testing — a single call like playwright_resize({ device: "iPhone 13" }) swaps in the correct viewport, user-agent, touch support, and device pixel ratio, and natural-language prompts like "test on iPad landscape" work directly through Claude. Install via `npm install -g @executeautomation/playwright-mcp-server`, Smithery, mcp-get, or the one-line `claude mcp add --transport stdio playwright npx @executeautomation/playwright-mcp-server` for Claude Code; VS Code one-click installers are also published. No API keys are required — it launches and drives a local Chromium/Firefox/WebKit browser directly. Choose this over Microsoft's official server when you specifically need auto-generated Playwright test scripts, JS execution, or device-emulation testing; choose Microsoft's for pure lightweight accessibility-tree page navigation. One maintenance fact the listings omit, checked against GitHub and npm on 2026-08-15: this repository has not been pushed since 2025-12-13 and npm 1.0.12 was published 2025-12-12, with 32 issues open. It is neither archived nor deprecated, so nothing warns you at install time — it installs, connects and works while its Playwright dependency drifts, whereas Microsoft's server ships continuously. Weigh the codegen, 143-preset device emulation and HTTP request tools against running an eight-month-old build. Note also that headless defaults to false on playwright_navigate, so it opens a visible browser window unless told otherwise, and that stdio-mode logging goes only to ~/playwright-mcp-server.log to keep the JSON-RPC stream clean.

Local📘
🗄️

Redis MCP Server

The Redis MCP Server (redis/mcp-redis) is Redis's own natural-language interface for agentic applications, letting an AI client read and write Redis data over the Model Context Protocol. Note which one you install: the server most tutorials still point at is Anthropic's reference implementation, which now lives in modelcontextprotocol/servers-archived, and its npm package @modelcontextprotocol/server-redis is explicitly marked "Package no longer supported" with a last publish of 2025-04-25. The maintained server is a Python package instead, run with uvx --from redis-mcp-server@latest, and it covers far more of Redis than the reference one did: string, hash, list, set and sorted-set tools; JSON document tools; pub/sub with stateful channel and pattern subscriptions; Streams tools including consumer-group create, read, acknowledge and destroy; vector index management and vector search through the query engine; a docs search tool; and a server-management tool for database info. Connection is a redis:// or rediss:// URL passed as --url, or the REDIS_HOST/REDIS_PORT/REDIS_PWD/REDIS_SSL environment variables, with Redis Cluster mode behind REDIS_CLUSTER_MODE and EntraID service-principal, managed-identity and default-credential auth flows for Azure Managed Redis. There is no --read-only flag: the documented way to stop an agent writing is a Redis ACL user (ACL SETUSER readonlyuser on >pw ~* +@read -@write). Ships as a PyPI package, a GitHub install via uvx, and an official mcp/redis Docker image; stdio transport only.

Local📘
💰

Stripe MCP Server

The Stripe MCP server is Stripe's official Model Context Protocol integration, and the first thing to know is that it is not a package you install — it is a remote server Stripe hosts at https://mcp.stripe.com, and the documented connection mechanism is OAuth, not an API key. For Claude Code that is `claude mcp add --transport http stripe https://mcp.stripe.com/` followed by `claude /mcp` to complete consent; Cursor and VS Code take the bare URL, and ChatGPT accepts it as a custom connector on Pro, Plus, Business, Enterprise and Education accounts. An administrator has to enable MCP access in the Dashboard first, separately for sandbox and for live mode, which is the usual cause of a connection that refuses to authorise. Rather than one tool per endpoint, four generic tools carry most of the surface — stripe_api_search, stripe_api_details, stripe_api_read and stripe_api_write — so the tool schemas do not consume the context window, alongside dedicated create_refund, get_stripe_account_info, stripe_report, stripe_implementation_planner and search_stripe_documentation tools, plus a Treasury balance summary in public preview. Supported API methods span customers, charges, refunds, PaymentIntents, Checkout Sessions, invoices, subscriptions, coupons, promotion codes, products, prices, payment links, disputes, webhook endpoints, balance and balance transactions, payouts, tax settings and registrations, and Issuing. Clients that cannot do OAuth pass a restricted API key as a bearer token; Connect platforms acting as a connected account must use a restricted key plus a Stripe-Account header, since OAuth cannot express that. Sessions are revocable from Dashboard user settings under OAuth sessions, and Stripe recommends human confirmation of tools given prompt-injection risk.

Auth required📘
☁️

Vercel MCP Server

The Vercel MCP server is a powerful Model Context Protocol integration that allows AI assistants like Claude, Cursor, and Cline to interact directly with your Vercel infrastructure. It exposes essential platform capabilities as AI-callable tools, meaning you can manage projects, trigger deployments, inspect build logs, and configure custom domains via natural language prompts. For frontend developers and DevOps teams working within the Vercel ecosystem, this eliminates the need to constantly context-switch between an IDE, terminal, and the Vercel dashboard. You can simply ask your AI agent to "check the status of the latest production deployment", "fetch the build logs for the staging environment and identify the Next.js hydration error", or "list all environment variables for the current project". By bridging the gap between your codebase and your hosting platform, the Vercel MCP server turns your AI assistant into an embedded DevOps engineer capable of diagnosing build failures and managing serverless deployments in real time. Vercel ships this as an official hosted (remote) MCP server at https://mcp.vercel.com — there is no package to install locally. Connect an MCP client to that URL and authenticate through the browser-based OAuth flow, which scopes access to the Vercel teams and projects your account can already reach rather than a long-lived Personal Access Token. For example, add it to Claude Code with `claude mcp add --transport http vercel https://mcp.vercel.com`, then complete the OAuth consent screen; the repo vercel/vercel-mcp-overview is the official public overview of this server, with full docs at vercel.com/docs/mcp/vercel-mcp.

Auth required📘
🌐

Fetch

Web content fetching and conversion for efficient LLM usage. Extract readable content from any URL.

Local
💬

Slack MCP Server

The Slack MCP server (built by Ivan Korotovsky) connects AI assistants like Claude, Cursor, and Windsurf directly to Slack workspaces, enabling conversational access to your team communication channels without requiring workspace admin approval for a bot install. Its standout feature is a "no permission" stealth mode — it authenticates using your own personal Slack session tokens (xoxc/xoxd, or a stored browser session) rather than requiring a Slack App with OAuth scopes, so it works even in locked-down workspaces where you cannot create bots. It also supports full OAuth Bot Token auth and Enterprise/GovSlack deployments for teams that prefer a conventional app install. Tools exposed include reading channel and DM/group-DM history with smart pagination, searching messages across the workspace, posting messages and thread replies, listing channels and users, and adding reactions. Common use cases include automating standups by posting summaries directly to team channels, searching past Slack conversations to surface decisions or context, monitoring specific channels for keywords or alerts, and drafting replies to thread discussions — all from natural-language prompts. Supports both Stdio and SSE transports plus proxy configuration for corporate networks. Install with: `npx slack-mcp-server@latest --transport stdio`. A separate official-style integration exists from Zencoder (@zencoderai/slack-mcp-server) for teams that prefer standard Bot Token OAuth over session-token auth. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline.

Local📘
📋

Linear MCP Server

The Linear MCP server connects your AI assistant directly to Linear's project management platform via an officially hosted remote endpoint at mcp.linear.app — no local installation required. This is Linear's own first-party server, authenticated with OAuth 2.1 and centrally managed so you always run the latest version without updates. Available tools let you search issues by keyword, team, cycle, or filter; create new issues with title, description, and assignee; update status, priority, labels, and comments; and navigate Linear's project and cycle structure. In Claude Code, add it with: `claude mcp add --transport http linear-server https://mcp.linear.app/mcp`, then run /mcp to complete the OAuth flow. For older clients, use the mcp-remote bridge for backwards compatibility. Claude Desktop and Claude.ai users can connect via Settings > Connectors. Cursor and Codex have native support via their MCP config. Linear is used by thousands of engineering and product teams to plan, track, and ship software — the Linear MCP server brings that data into every AI-powered workflow without copy-paste or context-switching.

Auth required📘

📚 More from the Blog