Angular 21 quietly shipped something no other major framework has: an official Model Context Protocol server baked into the Angular CLI. Run ng mcp and your AI assistant — Claude Desktop, Claude Code, Cursor, Copilot in VS Code — gains direct access to Angular's documentation, best-practices guide, project metadata, and migration analyzers.

If you have been following the MCP story from the protocol introduction onward, this is a notable milestone. Frameworks have spent two years arguing about whether to integrate with LLMs. Angular skipped the argument and shipped a server.

This post sets honest expectations: what ng mcp actually exposes, what it doesn't, and where it earns its place in your workflow.

What ng mcp is — in one paragraph #

ng mcp is an MCP server that ships with @angular/cli. When started, it advertises a small set of MCP tools that an AI client can call. Those tools give the model authoritative access to Angular's knowledge (docs, best practices, curated examples) and project context (the apps and libraries in your angular.json). It also exposes opt-in experimental tools that can run ng build, ng test, ng e2e, manage dev servers, and apply code migrations.

It is experimental at the time of writing. Treat it as production-adjacent, not production-blessed.

What you get out of the box #

Start the server with a single command from your Angular project:

ng mcp

That process becomes a stdio MCP server. Whatever AI client you wire to it sees these tools by default:

None of these execute code in your project. None of them mutate files. They are read-only knowledge and analysis tools. That is the entire default surface area.

The experimental tools — opt in deliberately #

There is a second tier, gated behind the --experimental-tool flag:

ng mcp --experimental-tool build,test,devserver

The experimental set is action-oriented:

• build — runs ng build and returns the result
• test — runs unit tests
• e2e — runs end-to-end tests
• devserver.start / devserver.stop / devserver.wait_for_build — manages a development server lifecycle
• modernize — applies code migrations (e.g. control-flow conversions)

These matter because they let the AI close the act → observe loop. Without them, the model can read docs and analyze your project but cannot verify that a change works. With them on, an assistant can propose a refactor, apply a migration, run the test suite, and report what failed — entirely inside one MCP session.

Fair warning: enabling everything gives the model the ability to touch your filesystem and your CI tools. Start with --read-only while you build trust.

Useful flags #

Three command-line options are worth knowing on day one:

A conservative everyday command looks like this:

ng mcp --read-only

A full-power local-dev command looks like this:

ng mcp --experimental-tool build,test,devserver,modernize

Where ng mcp fits — and where it doesn't #

It is easy to assume that an official Angular MCP server means "AI can now see all my components, services, and routes." That is not what this is.

Here is the more accurate mental model:

If you want the AI to read your actual components and services, you pair ng mcp with a filesystem MCP server. They are complementary, not competing.

Why this matters even though it's small #

The tool set is intentionally narrow, and that is the interesting part.

Most framework-AI integrations to date have been scraped or hallucinated — the model knows about Angular because Angular wrote a lot of public docs, and the model read them at some point during training. That breaks the moment Angular ships a new API: the model is confidently wrong because its training data is frozen.

ng mcp flips that. When the model uses search_documentation, it is querying angular.dev right now, not last year's snapshot. When it uses find_examples, the examples come from a curated database the Angular team maintains. When it suggests a migration via onpush_zoneless_migration, the recommendations come from a tool the framework team wrote — not a guess based on a Stack Overflow answer from 2022.

The shape of the tool set is also a signal. Angular chose to expose:

• Knowledge access (docs, examples, best practices)
• Project introspection (project list)
• Migration analysis (zoneless plan)
• Build/test execution (experimental)

This is the framework custodian's view of "AI assistance": keep the model anchored to authoritative sources, give it deterministic project queries, and let it close the act-observe loop on the developer's terms. It is the most conservative useful version of an MCP server a framework can ship, and that is a feature.

A typical conversation #

With ng mcp running and wired into Claude Code, a conversation might go like this:

The model is not guessing — it ran the analyzer tool, got structured output, and produced a plan that maps directly to your code. That is what an MCP server adds over a raw chat box.

When to enable ng mcp — and when to skip it #

Enable it when:

• You're on Angular 20+ and the AI tooling you use already speaks MCP
• You're planning a zoneless or signal-forms migration and want a co-pilot for the audit
• You frequently ask AI assistants about Angular APIs and have been bitten by outdated answers
• Your team is standardizing how engineers use AI in the codebase

Skip it (for now) when:

• You're on an LTS branch of Angular and rarely touch the latest features
• Your AI assistant doesn't yet support MCP servers (most do in 2026, but a few enterprise IDE plugins don't)
• You want fully autonomous code edits — ng mcp is intentionally narrow; pair it with other MCP servers if that's the goal

What's next #

The next post in this series wires ng mcp into the four AI tools developers reach for most: Claude Code, Claude Desktop, Cursor, and GitHub Copilot in VS Code. After that we'll tour the tools in depth, walk through how ng mcp compares to a plain filesystem MCP server, and look at how the picture shifts in Angular 22.

The takeaway from this post is simpler: Angular shipped an official MCP server, it is narrow on purpose, and the narrowness is what makes it trustworthy. Treat it as a knowledge-and-analysis layer for your assistant rather than a remote control for your repo, and it will earn its ng keystrokes.

Try it yourself #

If you have an Angular 20+ project on your machine and Claude Code installed, the smallest possible try-it is two commands:

# in your Angular project
ng mcp --read-only

In another terminal, point Claude Code at it and ask:

That's the handshake working. Everything else in this series builds on it.