This MCP server provides AI agents with version-pinned access to NVIDIA CUDA-Q documentation, API references, runnable examples, and execution target information, preventing version skew.
Search documentation: search_docs returns ranked, excerpted documentation results with breadcrumbs and canonical URLs.
Fetch full pages: get_page retrieves a complete documentation page as clean markdown.
Resolve API symbols: find_api pinpoints exact Python or C++ API symbols with kind, doc URL, and excerpt.
Find runnable examples: search_examples locates complete CUDA-Q example programs from the matching release.
List execution targets: list_targets enumerates all 24 CUDA-Q execution targets (simulators, hardware, clouds) with selection guidance.
Version-pinned answers: Defaults to your installed CUDA-Q version and falls back to latest if a specific version is unavailable.
Offline and local: Uses SQLite full-text search with BM25 ranking, no API keys, no embeddings, and works offline once the index is downloaded.
Client integration: Easily integrates with MCP-capable AI clients such as Claude Code, Cursor, and VS Code.
Provides access to NVIDIA CUDA-Q documentation, API reference, and runnable examples, enabling AI agents to search and retrieve quantum computing SDK information with version-pinned accuracy.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@cudaq-docs-mcp Show me a runnable CUDA-Q example for quantum teleportation"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server that serves NVIDIA CUDA-Q documentation, API reference, and runnable examples to AI agents: version-pinned to the cudaq you actually have installed.
Community project, not affiliated with or endorsed by NVIDIA. CUDA-Q is a trademark of NVIDIA Corporation.
Quantum SDKs move faster than model training data. Ask an AI assistant to write CUDA-Q code and it answers from whatever it memorized: renamed APIs, retired target names, install steps for a version you do not run. The failure is version skew, and it lands where onboarding matters most: the first ten minutes.
This server gives any MCP-capable agent the current answer instead. Documentation search, exact API symbol resolution, complete runnable examples, and a backend-selection guide, all served from an index of the docs that match your installed cudaq package. No API keys and no embeddings: SQLite full-text search with BM25 ranking, on your machine, offline once the index exists.
Related MCP server: ws-mcp
Register the server with your client; on first use it downloads a prebuilt index (a couple of megabytes) automatically. Building locally is only needed for versions without a prebuilt asset:
uvx cudaq-docs-mcp build --version 0.14.0Claude Code
claude mcp add cudaq-docs -- uvx cudaq-docs-mcpClaude Desktop (claude_desktop_config.json), Cursor (.cursor/mcp.json), or any client that takes a JSON server map:
{
"mcpServers": {
"cudaq-docs": {
"command": "uvx",
"args": ["cudaq-docs-mcp"]
}
}
}VS Code (.vscode/mcp.json):
{
"servers": {
"cudaq-docs": {
"type": "stdio",
"command": "uvx",
"args": ["cudaq-docs-mcp"]
}
}
}Prefer pip? pip install cudaq-docs-mcp and use cudaq-docs-mcp as the command.
Tool | What it returns |
| Ranked doc excerpts with breadcrumbs and canonical URLs |
| One full documentation page as clean markdown |
| Exact Python or C++ symbol, kind, doc URL, and an excerpt |
| Complete runnable programs from the CUDA-Q repository at the matching release |
| All 24 execution targets: simulators, hardware providers, and clouds, with selection snippets and when-to-use guidance |
Resources: cudaq://versions (installed and indexed versions) and cudaq://llms.txt (CUDA-Q's own llms.txt for the served version).
Every tool resolves its docs version in this order:
An explicit version argument ("0.15.0", "latest")
The installed cudaq package, detected from distribution metadata (cudaq is never imported)
latest
Indexes are per-version. When a pinned index is missing the server says so in the response and serves latest instead, with the one command that fixes it. Skew becomes visible instead of silent.
CUDA-Q publishes the raw material: a Sphinx inventory (objects.inv) listing every page and API symbol, markdown mirrors of each docs page, a per-version llms.txt, and example sources in the repository. This server builds on that groundwork:
objects.inv is the crawl manifest and the API symbol table: no scraping heuristics
each markdown mirror is cleaned of theme chrome, code blocks are rebuilt with their language, and heading anchors are preserved for deep links
pages are chunked by heading and indexed in SQLite FTS5 (porter stemming, BM25 ranking)
examples, snippets, and application sources are fetched from the GitHub release tag that matches the docs version
The whole index is one SQLite file per version in your cache directory (cudaq-docs-mcp info shows where). A nightly workflow rebuilds the latest index so refreshes stay a download, not a build.
cudaq-docs-mcp # serve MCP on stdio (what clients run)
cudaq-docs-mcp build # build the index for your installed cudaq, else latest
cudaq-docs-mcp build --version 0.15.0
cudaq-docs-mcp info # cache location, indexed versions, detected cudaqSet CUDAQ_DOCS_MCP_AUTOBUILD=1 to build automatically on first use, and CUDAQ_DOCS_MCP_CACHE to relocate the cache.
Prebuilt indexes for pinned release versions, not just latest
An eval set of real developer questions, with published retrieval scores
CUDA-QX library docs
Issues and PRs are welcome. Commits need a DCO sign-off (git commit -s); see CONTRIBUTING.md. Built in the open with Claude Code.
Apache-2.0. Documentation content belongs to NVIDIA Corporation & Affiliates, originates from the Apache-2.0 licensed NVIDIA/cuda-quantum repository, and every served result links back to the canonical page. See NOTICE.
Resolve a CUDA-Q API symbol to its canonical definition and doc URL.
Args: name: Symbol name, full or partial: "sample", "cudaq.observe", "qvector", "set_target". language: "python" or "cpp" to filter; omit for both. version: Docs version. Defaults to the installed cudaq version.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| version | No | ||
| language | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explains parameter defaults and filtering behavior, but does not disclose how partial matches are resolved (e.g., whether multiple results are returned) or the exact output structure beyond 'canonical definition and doc URL.' This leaves some ambiguity for the agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: one clear purpose sentence plus a compact Args list. It is front-loaded and contains no filler. Every line adds value, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple lookup tool with no output schema, the description is mostly complete: it covers all parameters and gives the core outcome. However, it lacks detail about the return format or how to handle ambiguous partial matches, which would be useful for the agent to know. Still, it is complete enough for a straightforward resolve operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate fully. It does: each parameter is clearly explained with examples (name), allowed values and default behavior (language), and default versioning (version). This goes well beyond the bare schema titles and provides rich, actionable semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific and actionable purpose: 'Resolve a CUDA-Q API symbol to its canonical definition and doc URL.' This clearly distinguishes the tool from siblings like search_docs (which presumably searches docs more broadly) by focusing on resolving a specific symbol to its authoritative definition and documentation URL.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly states the tool's function and parameter behaviors (e.g., 'omit for both', 'Defaults to the installed cudaq version'), giving the reader enough context to decide when to use it. However, it does not explicitly mention when not to use it or suggest alternative tools such as search_docs or get_page, so it stops short of full exclusions or alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one documentation page as clean markdown.
Args: path: Page path as returned by search_docs, for example "using/quick_start" or "using/backends/sims/svsims". version: Docs version. Defaults to the installed cudaq version.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | ||
| version | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the output format ('clean markdown') and default version, but does not mention error behavior, permissions, or read-only status.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: a one-sentence summary followed by a clear Args block with examples. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple fetch tool, the description covers purpose, parameters, and return format. It lacks error handling or edge-case details, but is sufficient for typical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description explains both parameters in detail, including examples for the path and the default behavior for version, adding significant meaning beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Fetch one documentation page as clean markdown', with a specific verb and resource, and it distinguishes itself from sibling tools like search_docs or find_api.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It does not explicitly say when to use this tool vs alternatives, but it provides clear context by mentioning the path comes from search_docs and the version defaults to the installed cudaq version, implying a workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List CUDA-Q execution targets (backends) with guidance on choosing.
Covers simulators (CPU, GPU state vector, tensor network, noisy, dynamics), quantum hardware providers, and cloud aggregators, each with selection snippets and doc URLs. Call this when deciding where to run a kernel or when the user names a provider.
Args: category: Optional filter: "simulator", "hardware", or "cloud".
| Name | Required | Description | Default |
|---|---|---|---|
| category | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It explains the content coverage (simulators, hardware, cloud) and that entries include selection snippets and doc URLs, but it does not describe the return format, potential side effects, or whether data is fetched remotely. This is an acceptable disclosure for a simple listing tool but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well structured: a concise one-sentence summary, an explanatory paragraph with the supported categories and guidance, a clear usage trigger, and a compact Args section. Every sentence adds value and the most important information appears first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity tool with one optional parameter and no output schema, the description covers purpose, when to use it, what categories are included, and the parameter semantics. It is sufficient for an agent to select and invoke the tool correctly without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description fully compensates by documenting the 'category' parameter with its allowed values: 'simulator', 'hardware', or 'cloud'. This adds meaningful semantics beyond the bare schema, which only shows a nullable string with a default of null.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and the resource ('CUDA-Q execution targets (backends)') and adds that it provides guidance on choosing. It distinguishes itself from sibling documentation/search tools by focusing on available execution backends.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage guidance: 'Call this when deciding where to run a kernel or when the user names a provider.' It does not mention when not to use it or name alternatives, but the context is clear enough for the common cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the NVIDIA CUDA-Q documentation and return ranked excerpts.
Use this before answering any CUDA-Q question from memory: the platform moves quickly and memorized APIs are often stale. Each result carries a breadcrumb, an excerpt, and the canonical doc URL to cite.
Args: query: Natural language or keywords, for example "run kernel on GPU state vector" or "quantinuum credentials". version: Docs version such as "0.15.0" or "latest". Defaults to the installed cudaq version. limit: Maximum number of results (default 5).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | ||
| version | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the result format (breadcrumb, excerpt, canonical doc URL) and the version fallback behavior. It implies read-only operation but does not explicitly state safety, rate limits, or other behavioral traits beyond what is already in the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a clear purpose statement, a usage directive, and a concise parameter breakdown. Every sentence serves a purpose, and the structure is front-loaded with the key information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers all essential aspects: purpose, when to use, parameter semantics, and the result format. It even explains the version default behavior. For a search tool with no output schema, this is a complete and self-sufficient description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero descriptions, but the description fully compensates with an 'Args' section that explains each parameter: query (with natural language examples), version (format and default to installed cudaq version), and limit (maximum results, default 5). This adds significant meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Search') and identifies the resource ('NVIDIA CUDA-Q documentation') and what it returns ('ranked excerpts'). This clearly distinguishes it from sibling tools like get_page and find_api, which focus on page retrieval and API lookup respectively.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use the tool: 'Use this before answering any CUDA-Q question from memory', with a rationale about the platform moving quickly. It does not explicitly name alternatives or exclusion conditions, but the primary use case is clearly communicated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find complete, runnable CUDA-Q example programs.
Sources are the example, snippet, and application files shipped in the CUDA-Q repository at the matching release. Prefer adapting these over writing kernels from memory.
Args: query: What the example should show, for example "GHZ state", "VQE", or "noise model". language: "python" or "cpp" to filter; omit for both. version: Docs version. Defaults to the installed cudaq version. limit: Maximum number of examples (default 3).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | ||
| version | No | ||
| language | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden. It adds some behavioral context by explaining the source of examples ('shipped in the CUDA-Q repository at the matching release') and that results are 'complete, runnable.' However, it does not describe return format, pagination, or failure modes, leaving gaps typical of a search tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with a clear opening sentence, a brief source/usage note, and a parameter list. It is not as lean as a two-sentence ideal, but every section earns its place given the absent schema descriptions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema or annotations, but the description covers purpose, source, usage preference, and all parameters. It lacks an explicit description of the return value, but the phrase 'Find complete, runnable CUDA-Q example programs' suggests the actual code is returned, making it reasonably complete for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description's Args section is essential. It explains each parameter meaningfully: query with examples ('GHZ state', 'VQE'), language filter, version default, and limit default. This fully compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Find complete, runnable CUDA-Q example programs,' which clearly states the verb (find) and resource (example programs). It distinguishes this tool from siblings like search_docs, find_api, and get_page by focusing specifically on examples with a stated preference for adapting them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'Prefer adapting these over writing kernels from memory.' It also clarifies the source and version matching. However, it does not explicitly state when not to use this tool or name alternatives, falling just short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct resource: docs search, page retrieval, API symbol resolution, example search, and target listing. The two search tools are clearly separated by corpus (docs vs examples), and get_page complements search_docs by fetching full pages.
All tool names follow a consistent verb_noun snake_case pattern: search_docs, get_page, find_api, search_examples, list_targets. The verbs and nouns are descriptive and predictable.
Five tools is well-scoped for a documentation server, covering discovery (search), retrieval (get_page), reference (find_api), examples, and backend selection without unnecessary bloat.
The tool set covers the primary ways users interact with CUDA-Q docs: searching for answers, reading full pages, looking up APIs, finding runnable examples, and selecting execution targets. There are no obvious gaps that would cause dead ends.
Search NVIDIA CUDA documentation and code samples from AI coding agents.
Team docs served to AI agents over MCP - search, Markdown reads, version pinning, read audit.
Agentic search over your Dewey document collections from any MCP-compatible client.
Query any docs site via MCP. Submit a URL, ask questions, get cited answers.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/rogerawong/cudaq-docs-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
