MCP server | Quantum readiness from your agent

The loop

Two servers, one engine. Which you use depends on where the code is.

Where the code is	Which server	What happens to it
Public GitHub or GitLab repository	Hosted, at `/mcp`. Nothing to install.	The archive is fetched and read on our infrastructure, and not kept after the report is produced.
A private repository linked to your account	Hosted, with the activation key.	Read with the token you granted during linking. Findings are filed against your account.
A folder on your own machine	Local, `qr-mcp`, which ships with the offline scanner.	Read in place on your machine. Nothing is uploaded unless you ask, and then only findings.

Either way the sequence is the same. Scan, read the guidance, change the code, scan again. A fix is only proved by scanning again, which is why the verification tools exist rather than a promise.

The hosted endpoint

One URL, streamable HTTP, JSON-RPC 2.0. It answers initialize, tools/list and tools/call, which is everything an MCP client needs.

https://getquantumready.app/mcp

Check it is alive before wiring anything up:

curl -s https://getquantumready.app/mcp \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

You should get eight tools back in JSON. Nothing is installed, and no agent runs on our side.

The tools

Tool	What it does	Key needed
`quantumready_scan_repository` `quantumready_start_repository_scan` `quantumready_continue_repository_scan`	Inventory a repository: algorithms, risk, evidence levels, cryptographic dependencies, prioritised actions, and a report id. On a plan that covers it, eleven language families are read as code rather than only matched, and the report says what that resolved. Takes a public URL, or `owner/name` with a provider for a private repository linked to your account.	Yes
`quantumready_scan_snippet`	Read up to 20,000 characters of code with the real rules. Returns the findings, the score, and a baseline id for verifying the fix later.	No
`quantumready_scan_endpoint`	A real TLS handshake against a hostname: TLS 1.3, the negotiated key exchange group, and the certificate's key and signature algorithms.	Yes
`quantumready_explain_finding`	The remediation detail for anything found: what it is, why it matters, the options and what each costs, before and after code in common languages, the pitfalls, and how to verify. Add a report id and it names the files and lines too.	No
`quantumready_verify_fix`	Scan again after a change and compare with the baseline: what is resolved, what remains, and what the change introduced. This is how a fix gets proved rather than assumed.	Only to re-scan a repository
`quantumready_get_report`	Fetch a report by id, as a readable summary or as raw JSON. Reports are the same ones a shareable link opens.	No
`quantumready_coverage`	What the engine can detect, how many rules and language families, and what is deliberately out of scope.	No
`quantumready_live_stats`	Totals across every scan run here: scans, files, findings, the risk mix, the most common algorithms. Counts only.	No

The scanning tools make an outbound connection or read a repository, so they need an activation key from a free account, sent as the x-qr-activation header. An MCP client cannot answer a bot challenge, and anonymous machine access to a scanner is a door worth keeping shut. The key also means usage is counted against your account, so you can see it.

Scan a project folder on your own machine

The hosted server cannot read your disk, so the folder case needs a server that runs locally. It ships with the offline scanner, uses the same engine, and keeps its baseline on your machine, which means the verify step works with no network at all.

curl -LO https://getquantumready.app/download/quantumready-runner-0.10.7.zip
unzip quantumready-runner-0.10.7.zip
cd quantumready-runner
sh runner/install.sh

That installs two commands: qr-run for scanning from a terminal, and qr-mcp for an agent. Nothing is uploaded unless you call upload_report, and even then only findings travel, never source.

Tool	What it does
`scan_project`	Walk the folder and every git branch, and return the inventory, the risk and the prioritised actions. Saves a baseline so a fix can be proved.
`verify_fix`	Re-scan and compare with that baseline: resolved, remaining, and new since the last scan.
`list_findings`	Algorithm, file, line and risk for each finding, so an assistant can work through them one at a time.
`scan_endpoint`	A real TLS handshake against a hostname, from this machine. This is the one that matters for hosts behind Cloudflare or another proxy, where the hosted scanner reports an empty result because a Worker cannot reach Cloudflare's own address ranges.
`explain_finding`	The same remediation guidance as the hosted server, fetched when there is a network and falling back to a short form when there is not.
`upload_report`	Send findings to your account so the report can be opened, shared or attached to an application.

Wiring it up

Paste the block for your client. For the hosted server, replace the key with yours from your account page: keys look like ABCDE-FGHIJ-KLMNO. For the local server, give it the folder to work in.

Claude Desktop

In claude_desktop_config.json. On macOS that file lives at ~/Library/Application Support/Claude/.

{
  "mcpServers": {
    "quantumready": {
      "type": "http",
      "url": "https://getquantumready.app/mcp",
      "headers": { "x-qr-activation": "YOUR-ACTIVATION-KEY" }
    },
    "quantumready-project": {
      "command": "qr-mcp",
      "args": ["--path", "/path/to/your/project"]
    }
  }
}

Cursor

In ~/.cursor/mcp.json, then enable it in Settings, MCP.

{
  "mcpServers": {
    "quantumready": {
      "url": "https://getquantumready.app/mcp",
      "headers": { "x-qr-activation": "YOUR-ACTIVATION-KEY" }
    },
    "quantumready-project": {
      "command": "qr-mcp",
      "args": ["--path", "."]
    }
  }
}

VS Code

In .vscode/mcp.json in your workspace, or your user settings.

{
  "servers": {
    "quantumready": {
      "type": "http",
      "url": "https://getquantumready.app/mcp",
      "headers": { "x-qr-activation": "YOUR-ACTIVATION-KEY" }
    },
    "quantumready-project": {
      "type": "stdio",
      "command": "qr-mcp",
      "args": ["--path", "${workspaceFolder}"]
    }
  }
}

Anything else

Any client that speaks MCP works the same way. Hosted: POST JSON-RPC to the endpoint with the key as a header. Local: run qr-mcp over stdio. If a client cannot send headers, leave the key out and the hosted server still offers its six read only tools.

What the loop looks like

A worked example, with the tool calls an assistant would make.

Step	Tool	What comes back
1. Scan the project	`scan_project`	Readiness 27 of 100, critical. Eight findings across five algorithms, including RSA in `src/Signer.java` and MD5 on the same file.
2. Ask how to fix it	`explain_finding`	For RSA: the options and their costs, Java and Python and Node shown before and after, the note that ML-DSA signatures are much larger, and the warning not to keep an RSA fallback.
3. Apply the change	the assistant edits the files	Nothing from us. The developer reviews the diff and approves it.
4. Verify	`verify_fix`	Readiness 100 of 100. Resolved: RSA, MD5 and two ECB findings in `src/Signer.java`. Still present: AES, which is correct because AES is still used. New: ML-DSA, which is the replacement that was just introduced.

That third column is the part that matters. Step four is evidence, not encouragement, and it names the file each finding was in so the result can be checked.

Boundaries

Read only. No tool writes to your account, your repository or your infrastructure. Scanning never changes the target.
We detect, the assistant edits. Remediation guidance describes the change; applying it is between you and your agent, in your editor, under your review.
Private repositories are read through the connection you grant when linking, and only for scans that carry your key. Public ones need nothing.
Folders are read locally. The local server walks your disk and uploads nothing unless you call upload_report.
Hosts behind Cloudflare cannot be measured by the hosted scanner: a Cloudflare Worker cannot open an outbound TCP connection to Cloudflare's own address ranges, which covers every proxied site. Every non proxied host is measured normally. For those, use the local server's scan_endpoint, or qr-run endpoint <host>, either of which probes from your machine and returns a real answer.
An empty result is not a clean bill of health. When a probe reaches nothing, the tools say so and explain why, rather than reporting the protocols as absent.
Rate limited per address at 60 calls per 15 minutes, and the scanning tools also count against your account.
Snippets are not stored. A baseline holds the findings, not the code, and expires after 48 hours.
Reports expire. Fetch what you need rather than treating a report id as an archive.
Independent. Not affiliated with, endorsed by, or acting on behalf of CSA, GovTech, IMDA or MAS.

Scan, fix and verify, from inside your agent