MyMCPToolsSubmit Server

Guides7 min read

Best MCP Servers for Nuxt Developers in 2026

The top MCP servers for Nuxt.js development. Build Vue-powered full-stack apps faster with AI assistants that understand your composables, server routes, and Nitro backend.

By MyMCPTools Team·May 23, 2026

Nuxt is Vue's answer to Next.js — full-stack rendering, file-based routing, server routes via Nitro, and a composable-first architecture that makes complex Vue apps manageable. MCP servers extend Nuxt's developer experience to your AI assistant, giving it the file structure, schema, and framework context it needs to generate Nuxt code that works with your conventions.

Here are the MCP servers that matter most for Nuxt development in 2026.

1. Filesystem MCP Server — Navigate Nuxt's File-Based Architecture

Nuxt's power comes from its directory conventions — pages/, components/, composables/, server/api/, and middleware/ all have specific behaviors driven by file location. The Filesystem MCP server gives your AI direct access to your project structure so it places new files in the right place and follows your component naming and composable patterns.

Key use cases for Nuxt developers:

Read existing composables/ before generating new ones that follow your state management and API patterns
Inspect server/api/ route handlers to understand your existing API conventions before adding new endpoints
Browse pages/ and layouts/ to correctly extend routing and understand what data each page expects
Navigate plugins/ and middleware/ to correctly wire new global behaviors without breaking existing ones

Best for: All Nuxt developers — the essential server for understanding file-based conventions across a growing app.

2. PostgreSQL MCP Server — Server Route and Nitro API Development

Nuxt's server routes (server/api/) and Nitro backend make it a full-stack framework. When those routes connect to a PostgreSQL database, your AI needs live schema access to generate correct database queries, Drizzle/Prisma models, and server-side data fetching logic.

Key use cases for Nuxt developers:

Generate Drizzle ORM schema definitions that match your actual PostgreSQL table structure
Write Nitro server route handlers with correct column references and join logic
Debug useAsyncData and useFetch data shape mismatches by inspecting actual database output schema
Generate Prisma model definitions from live table inspection for accurate TypeScript types

Best for: Nuxt developers building full-stack apps with PostgreSQL via Drizzle, Prisma, or raw SQL in server routes.

3. Git MCP Server — Track Composable and API Evolution

Nuxt apps evolve through composable refactors, Nuxt 2 to Nuxt 3 migrations, and Nitro API changes. The Git MCP server gives your AI the commit history to understand why your composables are structured the way they are and what migration decisions shaped your current architecture.

Key use cases for Nuxt developers:

Review composable commit history to understand why a specific state management pattern was chosen over Pinia
Inspect Nuxt 2 → Nuxt 3 migration commits to understand which patterns were updated vs left as-is
Check blame on middleware logic when debugging authentication redirect behavior
Review server route commits to understand API versioning decisions and breaking changes

Best for: Nuxt teams maintaining apps through major Nuxt version upgrades or large-scale composable refactors.

4. GitHub MCP Server — Nuxt and Vue Ecosystem Issue Access

The Nuxt and Vue ecosystem moves quickly — Nuxt 4 migration, Vue 3.4+ reactivity improvements, Nitro updates, and evolving module APIs. The GitHub MCP server lets your AI pull issue discussions and changelogs from nuxt/nuxt and vuejs/vue directly, keeping its suggestions accurate for your current version.

Key use cases for Nuxt developers:

Search Nuxt GitHub issues for known bugs before debugging SSR hydration mismatches or useAsyncData caching edge cases
Pull Nuxt 4 migration guide when upgrading from Nuxt 3 to understand compatibility layer changes
Review Nuxt module GitHub discussions when debugging @nuxt/image, @nuxtjs/i18n, or Pinia integration issues
Find Nitro configuration examples from official discussions for edge runtime or serverless deployments

Best for: Nuxt developers navigating ecosystem changes, module upgrades, and Nuxt major version migrations.

5. Docker MCP Server — Nuxt Full-Stack Container Debugging

Full-stack Nuxt apps often run as Docker containers in production — Nuxt app + PostgreSQL + Redis. The Docker MCP server gives your AI visibility into running containers, useful for debugging SSR rendering failures, environment variable configuration, and server route connectivity issues.

Key use cases for Nuxt developers:

Inspect Nuxt server container logs to correlate SSR hydration errors with specific page or API route failures
Debug multi-container compose setups with Nuxt app + PostgreSQL + Redis for session or cache layers
Check environment variable injection for NUXT_PUBLIC_ and private Nitro environment variables
Review server route container logs when debugging Nitro API endpoint behavior in production-like environments

Best for: Nuxt developers running containerized full-stack deployments with multiple dependent services.

6. Brave Search MCP Server — Current Nuxt and Vue Documentation

Nuxt's API surface changes with each major version — Nuxt 3 introduced composables, Nuxt 4 is changing the app directory structure, and Nitro's configuration options expand with each release. Brave Search lets your AI find current Nuxt documentation rather than suggesting deprecated Nuxt 2 patterns.

Key use cases for Nuxt developers:

Look up current useAsyncData and useFetch options for Nuxt 3/4 vs deprecated asyncData from Nuxt 2
Find current Pinia store patterns alongside Nuxt's useState composable for different state management use cases
Research current Nitro route handler syntax and H3 utility functions for your Nuxt version
Check current @nuxt/image configuration options and provider setup for your deployment target

Best for: Nuxt developers keeping up with Nuxt 3/4 changes, Nitro updates, and the evolving Vue 3 ecosystem.

Recommended MCP Stack for Nuxt Developers

Always active: Filesystem, Brave Search, Git
Full-stack with database: PostgreSQL
Ecosystem questions: GitHub
Containerized deployment: Docker

Nuxt's file-based conventions are powerful but require AI to understand exactly where files live and what each directory implies about behavior. Filesystem gives your AI that map. PostgreSQL gives it your data schema for full-stack server route generation. Brave Search keeps it current with Nuxt's fast-moving API. That combination makes AI assistance in a Nuxt project feel like it actually knows your framework.

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

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.

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📘✓

Git

Tools to read, search, and manipulate Git repositories. Full Git operations support.

Brave Search MCP Server

The Brave Search MCP Server is the official server from Brave that gives AI assistants privacy-first web search through the independent Brave Search API — no tracking, no profiling, and results drawn from Brave's own web index rather than Google or Bing. It exposes five distinct tools that map directly to the Brave Search API endpoints: brave_web_search for general queries with pagination, freshness filters, and safe-search controls; brave_local_search for businesses, restaurants, and points of interest with automatic location filtering; brave_news_search for recent articles and current events; brave_image_search for image discovery; and brave_video_search for finding videos across the web. Authentication uses a single BRAVE_API_KEY (free tier available at brave.com/search/api) or a mounted BRAVE_API_KEY_FILE for Docker-secret setups. Install in Claude Desktop, Cursor, Windsurf, or VS Code with one npx command and choose stdio or streamable-HTTP transport. Because Brave operates its own crawler and index, the Brave Search MCP server is a strong choice for developers who want an alternative to Google-dependent search tools, need reproducible non-personalized results, or care about data privacy in agent workflows — Claude can pull fresh web context, verify facts, and research topics without leaking queries to ad-tech pipelines.

PostgreSQL MCP Server

The PostgreSQL MCP server was the Model Context Protocol reference server for Postgres, and it is retired: the source now sits in modelcontextprotocol/servers-archived — a repository GitHub reports as archived, described as "Reference MCP servers that are no longer maintained" — and the npm package @modelcontextprotocol/server-postgres carries a deprecation notice reading "Package no longer supported." It still installs and still runs, which is why most third-party setup articles have not caught up. What it provides is deliberately small: a single tool, query, which executes read-only SQL inside a READ ONLY transaction, plus per-table schema information exposed as MCP resources at postgres://<host>/<table>/schema, with column names and data types discovered from database metadata. There is no index advice, no health check, no separate schema-listing tool, and no write mode. Install is npx @modelcontextprotocol/server-postgres with a postgres:// connection string as the argument. For active work against Postgres, the maintained alternative is Postgres MCP Pro (crystaldba/postgres-mcp), which exposes nine tools including index tuning against hypothetical indexes and a database health check, and has an explicit restricted access mode; if your database is hosted on Supabase or Neon, their platform servers add branching and logs that a raw Postgres connection cannot see. Reach for this archived server only when you want the smallest possible surface — one process, one read-only query tool, nothing else.

Docker MCP Server

The Docker MCP server (ckreiling/mcp-server-docker) gives an AI assistant direct control of a Docker daemon over the Model Context Protocol: containers, images, networks and volumes, as tools rather than shell commands. It is the community server most people mean by "Docker MCP" — distinct from Docker’s own Docker MCP Gateway, which does not manage your containers at all but runs *other* MCP servers inside containers. If you want to ask Claude why the postgres container keeps restarting, you want this one; if you want a single secure endpoint in front of twenty catalog servers, you want the gateway. The tool surface is explicit and small enough to reason about: list_containers, create_container, run_container, recreate_container, start_container, fetch_container_logs, stop_container and remove_container for containers; list_images, pull_image, push_image, build_image and remove_image for images; list_networks / create_network / remove_network and list_volumes / create_volume / remove_volume for the rest. Two resource templates, docker://containers/{id}/logs and docker://containers/{id}/stats, let a client read logs and live stats by container ID or name without a tool call. It also ships a docker_compose prompt that puts the model into a plan-then-apply loop — you describe the containers you want under a project name, the model proposes a concise plan, and nothing runs until you approve it; reopening the prompt with the same project name re-reads the state of everything created under it, which is how you clean up after a lost chat. It runs on the Python Docker SDK’s from_env, so DOCKER_HOST applies: set ssh://user@host and the same server administers a remote engine. Two limits are deliberate and stated by the project — privileged options like --privileged and --cap-add/--cap-drop are not supported, and container configuration passes through the model, so no secrets belong in it.

📚 More from the Blog

Best MCP Servers for Developers in 2026: The Complete Guide

Discover the top MCP servers that every developer should know about. From filesystem access to database queries, these Model Context Protocol servers supercharge your AI coding workflow.

8 min read Guides

Best MCP Servers for Data Engineering: Database, ETL & Analytics

Top MCP servers for data engineers and analysts. Connect your AI to PostgreSQL, BigQuery, Snowflake, and more for AI-powered data workflows.

7 min read Tutorials

Getting Started with MCP: A Beginner's Guide to Model Context Protocol

New to MCP? Learn what Model Context Protocol is, how it works, and how to set up your first MCP server in under 5 minutes. Complete beginner's guide.