MCP Overview - Virtuous API Docs

The Model Context Protocol (MCP) is an open standard that lets AI applications connect to external sources of information. Virtuous hosts an MCP server for these documentation pages — meaning your AI development tools (Claude, Claude Code, Cursor, VS Code, ChatGPT, and others) can search and read the Virtuous API docs directly while helping you build, rather than relying on whatever happened to be in their training data. For partners building integrations against CRM+, Raise, or Volunteer, this is a meaningful upgrade: ask Cursor about the right polling pattern for the Volunteer API while you’re coding, and it can pull the actual, current guidance from these docs instead of guessing.

The Virtuous MCP server

https://docs.virtuous.org/mcp

This URL is what you give to your AI tool. Mintlify hosts the server on Virtuous’s behalf — there’s nothing for you to deploy, run, or maintain. See Connect to the Virtuous MCP Server for setup instructions for Claude, Claude Code, Cursor, VS Code, and other MCP-compatible tools.

Why this matters for partner integrations

A common partner experience: you’re building a Volunteer integration in Cursor. You ask the AI “what’s the right pattern for detecting deleted users?” — and the AI gives you a confident answer based on general REST patterns. But Volunteer has specific quirks (no deletion endpoint, the email-as-primary-key reality, the participation caveat) that change the right answer. Generic guidance leads to integrations that need rework. With the MCP server connected, the AI can search and read the actual Virtuous docs in real time — including pages like Reconciliation Patterns and Detecting User Changes — and give you an answer grounded in the documented patterns.

Without MCP	With MCP
AI answers from training data (may be stale or generic)	AI answers from current Virtuous docs
You copy-paste docs into chat context manually	AI pulls relevant pages automatically as it helps you
AI sometimes confabulates API behavior	AI cites and references the actual documented behavior
Answers are generic REST patterns	Answers reflect Virtuous-specific patterns (the participation gap, the email-change problem, etc.)
Documentation lag — what the AI knows is months behind	Documentation freshness — what the AI reads is what’s published right now

The value compounds for partners specifically because the Virtuous docs include a lot of Virtuous-specific guidance — audit-flagged quirks, defensive parsing patterns, the workflows that work and don’t work — that generic AI training simply doesn’t have.

The two tools your AI tool gets

When you connect to the Virtuous MCP server, the AI tool sees two capabilities it can use:

Tool	What it does
`search_virtuous_api_docs`	Searches across the documentation for relevant content. Returns snippets with titles and direct links. Best for broad or conceptual queries like “how does upsert work for Volunteer users?”
`query_docs_filesystem_virtuous_api_docs`	Runs read-only shell-like commands (`rg`, `grep`, `cat`, `head`, `find`, `tree`, etc.) against a virtual filesystem containing all the docs and the OpenAPI specs. Best for exact keyword matching, structural exploration, or reading specific pages in full

The AI decides which tool to use based on what you’re asking. A high-level question typically uses search; a specific reference need (“show me the exact fields on the Volunteer Users POST endpoint”) typically uses the filesystem tool to read the page directly. See MCP Tools Reference for the full details on both tools.

What’s read and what’s not

This is the most important section on the page. When you connect your AI tool to the Virtuous MCP server, there’s a strict security boundary — what gets accessed is limited and well-defined.

What the server can access

Item	Status
The published Virtuous API documentation pages (the content you’re reading)	✓ Yes — this is what the server serves
The OpenAPI specs published with the documentation	✓ Yes — included in the docs filesystem
Code samples, examples, and reference content inside the published docs	✓ Yes — part of the docs

What the server cannot access

Item	Status
Your local code, files, or projects	✗ No — the server has no access to your machine
Your IDE workspace or open editor buffers	✗ No — the server doesn’t see what you’re editing
Your Virtuous account, customer data, or API tokens	✗ No — this is a documentation server, not an API gateway
Your customers’ nonprofit data	✗ No — none of that is in the docs
Your prompt history or AI conversation contents (by Virtuous or Mintlify)	✗ No — the server only sees the search query and filesystem commands the AI sends it, not your full conversation
Anything on your network or filesystem outside the docs	✗ No — the “filesystem” is a virtualized, in-memory sandbox that contains only the docs
Other partners’ code or integrations	✗ No — partners don’t share an MCP server; everyone connects to the same public server that serves the same public docs

What the AI tool sends to the server

When the AI decides to use one of the two tools, it sends:

The search query (for search_virtuous_api_docs)
The shell-like command (for query_docs_filesystem_virtuous_api_docs)

The AI tool does not send your full conversation, your code, your local files, or your IDE state to the Virtuous MCP server. It sends just the query or command it wants to run against the docs.

What’s the trust model?

Question	Answer
Is the server reading my code?	No. It only serves Virtuous documentation content.
Is the server reading what I’m asking the AI?	Only the specific search queries and commands the AI sends it — not your full prompt or conversation.
Could Virtuous see what I’m searching for?	Aggregate analytics may be available to Virtuous and Mintlify to understand usage patterns. Don’t put sensitive information (customer data, API tokens, etc.) into prompts that get translated into MCP queries. This is standard practice for any AI tool.
Is there authentication?	The Virtuous docs MCP server serves public documentation — no authentication is required to connect.
Could a bad actor abuse this?	The server only returns Virtuous documentation content. The most a bad actor could do is run search queries against the docs, which is equivalent to using the public docs website directly.

Practical recommendation

Treat the MCP server connection as equivalent to giving your AI tool access to the public Virtuous documentation website. That’s effectively what it is. You wouldn’t worry about putting the public docs URL in your AI tool’s context — and there’s nothing more privileged in the MCP server than what’s already on the public docs site.

MCP vs. other AI tools you might use

A few clarifications on what MCP is and isn’t:

Approach	What it is
MCP for the Virtuous docs (this)	Your AI tool reads the Virtuous documentation in real time while helping you
AI training data	The AI knows what it learned at training time — may be months old, may not include Virtuous specifics
Copy-pasting docs into your AI prompt	You manually select docs content and paste it; AI uses it. MCP automates this.
Virtuous’s APIs (CRM+, Raise, Volunteer)	The APIs you build against. MCP is for the documentation, not for the APIs themselves. Connecting to the docs MCP server doesn’t let the AI call Virtuous APIs.
A theoretical Virtuous API MCP server	Would let the AI call Virtuous APIs on a customer’s behalf. This doesn’t exist today. The MCP server documented here is for docs only.

How to think about MCP and your workflow

MCP works best when it’s always-on background help rather than something you consciously invoke. Once connected to your IDE or AI tool of choice:

Pattern	How it works
”AI as documentation-aware pair programmer”	You’re coding; you ask questions; the AI consults the docs when relevant. You don’t have to ask it to.
”AI as architecture sounding board”	You ask design questions (“should I use webhooks or polling for X?”); the AI pulls relevant Best Practices pages
”AI as quick reference”	You ask spec questions (“what fields does POST /users require?”); the AI reads the relevant page
”AI as integration debug helper”	You paste an error; the AI searches docs for relevant guidance

The shift from “manually look something up in docs” to “ask the AI, which looks things up in docs for you” is small in any individual moment but adds up — and the answers stay correct as the docs evolve.

When MCP isn’t the right answer

MCP is great for documentation lookup. It’s not a substitute for:

Need	Use this instead
Calling Virtuous APIs from your application	Use the actual API directly with your Bearer token / OAuth credentials
Getting customer-specific data	Use the API directly
Generating code that interacts with Virtuous	The AI can help generate code; you still run it against the real API
Real-time data (e.g., “what’s my customer’s current rate limit usage?”)	Not in docs; not available via MCP
Production support escalation	Reach out to your Partner Manager or Support

The MCP server is a read-only documentation companion, not a runtime integration tool.

Where to go next

Connect to the Virtuous MCP Server

Setup instructions for Claude, Claude Code, Cursor, VS Code, and other MCP-compatible tools.

Using MCP for Integration Development

Practical patterns for using MCP while you build integrations — prompting, workflows, combining with other tools.

MCP Tools Reference

The two tools the server exposes, with examples of when and how each is used.

Integration Pathway

The end-to-end workflow for technology partners — MCP fits naturally throughout the development phases.

​The Virtuous MCP server

​Why this matters for partner integrations

​The two tools your AI tool gets

​What’s read and what’s not

​What the server can access

​What the server cannot access

​What the AI tool sends to the server

​What’s the trust model?

​Practical recommendation

​MCP vs. other AI tools you might use

​How to think about MCP and your workflow

​When MCP isn’t the right answer

​Where to go next