What the Virtuous Docs MCP server is, why it matters for partners building integrations, what your AI tools get access to and what they don’t
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
