Kasava
Back to Blog
Engineering

MCP for Documentation: The Use Case Nobody's Talking About

Ben Gregory-Dec 4, 2025

Introduction

When people talk about MCP (Model Context Protocol), they usually focus on the exciting stuff: browser automation, database queries, file system access. Tools that let AI do things.

But after months of building with Claude Code and MCP, we've discovered the most valuable use case is surprisingly mundane: documentation.

Specifically: keeping up with dependencies that move faster than any human can track.

The Problem: Documentation Drift

Modern software development has a documentation problem. Not that docs don't exist—they do. The problem is they change constantly.

Consider what happens with a fast-moving dependency:

  1. You learn the API from the docs
  2. You build features using that knowledge
  3. The library releases a new version
  4. Your knowledge is now partially outdated
  5. You hit a bug or limitation
  6. You Google it, find a Stack Overflow answer from 6 months ago
  7. That answer references an old API
  8. You waste hours debugging something that's already been fixed

This cycle repeats constantly. And it gets worse as the ecosystem moves faster.

Case Study: Mastra

We use Mastra for AI orchestration in our backend. It's an excellent framework—TypeScript-native, great DX, excellent patterns for agents and workflows.

It's also one of the fastest-moving projects in the AI ecosystem.

How fast? Let's count:

2025 Changelog posts (partial list):

  • November (3)
  • October (2)
  • September (3)
  • August (3)
  • July (5)
  • June(5)
  • May (4)
  • April (3)
  • March (4)
  • February (1)
  • January (4)

That's roughly 35 changelog posts in 11 months. Almost one per week.

Each changelog contains multiple changes. Some are bug fixes. Others are breaking API changes. Many introduce new features that solve problems we were working around.

No human can keep up with this. We tried.

The Traditional Approaches (And Why They Fail)

1. Reading Changelogs

You can subscribe to releases and read every changelog. But:

  • Time-consuming
  • Easy to miss relevant changes
  • Context-switching breaks flow
  • You forget details by the time you need them

2. Periodic Catch-Up

Set aside time weekly to review dependency updates. But:

  • Batching creates knowledge gaps
  • You're always slightly behind
  • Urgent work always takes priority
  • Context is lost between sessions

3. Just Upgrade and Hope

Upgrade dependencies and fix what breaks. But:

  • Reactive, not proactive
  • Misses optimization opportunities
  • Debugging without context is slow
  • New features go unused

4. Rely on AI Training Data

Ask your AI assistant (ChatGPT, Claude, etc.) about the API. But:

  • Training data has a cutoff
  • Fast-moving projects outpace training
  • You get confident but wrong answers
  • Debugging becomes "is this a real API or hallucination?"

None of these work for fast-moving dependencies. We needed something better.

Enter MCP Documentation Servers

MCP servers can do more than execute tools. They can provide documentation directly to your AI assistant, in real-time.

The Mastra team publishes an MCP documentation server:

// .mcp.json
{
  "mcpServers": {
    "mastra": {
      "command": "npx",
      "args": ["-y", "@mastra/mcp-docs-server"]
    }
  }
}

When we ask Claude about Mastra, it doesn't rely on training data. It queries the current documentation.

Me: "How do I set up memory persistence in a Mastra agent?"

Claude: *queries mastra docs server*
"Based on the current Mastra documentation, here's how to configure
memory persistence with the new Memory API..."

The answer reflects the current state of the library, not some snapshot from months ago.

This Enables Faster Dependencies

Here's the insight that changed how we think about MCP:

MCP documentation servers don't just help us keep up with fast-moving dependencies. They enable dependencies to move faster.

This isn't obvious at first. But once you see it, it reframes the entire value proposition.

The Traditional Velocity Ceiling

Without MCP docs, fast-moving dependencies hit a natural limit:

Week 1: Ship breaking changes Week 2: Users upgrade, hit errors, dig through changelogs Week 3: Stack Overflow fills with "how do I migrate?" questions Week 4: Users finally adapt, file bugs, request features Week 5: Maintainers ship fixes

By week 5, the world has moved on. The feedback loop is too slow.

Compare this to dependencies that move slowly:

  • Users have time to read docs carefully
  • Changes are digestible in one sitting
  • Community resources stay current
  • Migration guides have time to be written
  • Training data catches up

The paradox: Fast-moving dependencies need better documentation tooling, but building that tooling takes time away from shipping features.

MCP documentation servers solve this.

How MCP Breaks the Velocity Ceiling

The Mastra team can ship weekly releases because their users can stay current. If every user had to manually track changes, the cognitive burden would be unsustainable. But with MCP docs:

Breaking changes are immediately documented

  • No manual changelog reading required
  • AI assistants handle version-specific queries
  • Users discover issues at the exact moment they're relevant
  • Migration happens incrementally, not in a big-bang upgrade

Users discover new features automatically

  • Claude: "I notice Mastra now has built-in rate limiting. Want to replace our custom implementation?"
  • This happens organically during development
  • No need to read full changelogs to find what's relevant to your project

Migration paths are visible to AI assistants

  • "How do I migrate from the old Memory API to the new one?"
  • Claude queries current docs and provides step-by-step migration
  • No hunting through GitHub issues or Discord channels

The upgrade cycle accelerates

  • Less friction → more frequent upgrades
  • More frequent upgrades → bugs found faster
  • Bugs found faster → fixes ship faster
  • Fixes ship faster → confidence increases

It's a virtuous cycle: MCP docs → faster user adoption → faster feedback → faster releases → better product.

The Network Effect

The Mastra maintainers get faster feedback because:

  1. Higher adoption of new features

    • Users don't need to actively track releases
    • Features get discovered through natural usage
    • More diverse testing in production environments

  2. Better bug reports

    • Users are on more recent versions
    • Bugs found closer to release date
    • Issues aren't conflated with already-fixed problems

  3. Less support burden

    • Fewer "old API" questions
    • AI assistants handle common migration queries
    • Discord/Issues focus on real problems, not documentation gaps

  4. Clearer signal on what to build

    • Users on current versions provide relevant feature requests
    • Less time spent determining if requests are already addressed
    • Faster iteration on what actually matters

The Competitive Advantage

This creates a moat for projects like Mastra:

  • Ship weekly with confidence
  • Breaking changes are less painful
  • Users stay current automatically
  • Velocity becomes a feature, not a bug
  • "Moves fast" becomes "stays innovative"

The framework that can iterate fastest (while maintaining developer experience) wins.

Setting It Up

Getting current documentation into your AI workflow involves a few different approaches. We use all of them depending on the situation.

Check for Official MCP Servers

Many projects now publish MCP documentation servers. This is the gold standard—direct integration, structured data, optimized for AI consumption.

// .mcp.json
{
  "mcpServers": {
    "mastra": {
      "command": "npx",
      "args": ["-y", "@mastra/mcp-docs-server"]
    },
    "supabase": {
      "type": "http",
      "url": "https://mcp.supabase.com"
    }
  }
}

Check the project's README, docs, or GitHub. Many now advertise MCP support prominently.

Use Context7 for Libraries Without MCP Servers

Not every library has an MCP server yet. For these cases, we use Context7.

What is Context7?

Context7 is a documentation aggregation platform specifically designed for AI-assisted development. It:

  • Indexes 58,000+ libraries and frameworks
  • Keeps documentation current (updated daily to weekly)
  • Provides docs in AI-friendly formats
  • Works with any AI assistant (Cursor, Claude, ChatGPT, etc.)
  • Offers both copy-paste and chat interfaces

Example libraries on Context7:

  • Next.js (569K tokens, updated every 5 days)
  • Vercel AI SDK (792K tokens, updated every 4 days)
  • Tailwind CSS (317K tokens, updated weekly)
  • Better Auth (418K tokens, updated regularly)
  • Virtually any popular library

The difference from web search:

Web search (Firecrawl, etc.) can find documentation, but Context7 is purpose-built for AI consumption:

  • Pre-processed for optimal AI parsing
  • Consistent formatting across libraries
  • Updated on a schedule (not just when you search)
  • Includes code examples and snippets
  • Shows when docs were last updated

The Future: Infrastructure-Level Documentation

The second piece to being able to iterate fast is not just making sure your users have access to new docs. It's making sure that you actually have new docs that reflect your current codebase. For this, we're seeing some new developments that monitor code changes and proactively update documentation.

Example: Mintlify Autopilot

Mintlify has built a system that makes documentation stay current automatically:

  • Monitors your codebase for user-facing changes
  • Detects when docs need updates the moment you ship code
  • Generates context-aware drafts based on your codebase and existing docs
  • Surfaces updates to your team via PR comments and agent panels
  • Keeps humans in the loop while automating the workflow

The combination of auto-updating docs (Mintlify) + AI-consumable formats (MCP) + AI assistants (Claude) creates a seamless workflow where documentation never lags behind code.

Conclusion

MCP isn't just about giving AI tools. It's about giving AI knowledge—current, accurate, up-to-date knowledge.

For fast-moving dependencies, this transforms the development experience. No more version confusion. No more outdated answers. No more fear of upgrades.

If you're building with AI-assisted tools, prioritize MCP documentation servers for your key dependencies. The productivity gains are substantial.

And if you maintain an open-source project: consider publishing an MCP docs server. Your users—and their AI assistants—will thank you.

We build Kasava with Mastra and Claude Code. The combination of current documentation and AI assistance has become essential to our workflow. See what we're building →