qrp-mcp
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
| prompts | {
"listChanged": false
} |
| resources | {
"subscribe": false,
"listChanged": false
} |
| experimental | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| scan_repoA | Inventory the cryptography inside one local directory tree, file by file. Reads source, configuration (nginx.conf, sshd_config, .ini, .toml), CI pipelines,
Terraform and Kubernetes manifests under Use this to answer what a specific project on this machine actually uses. Do not
use it to ask whether this server knows a given algorithm, or to explain how one is
classified without scanning anything -- Coverage is reported as a fraction with a base. The owner's own settings apply and are reported, never silent: a The result also says where this version may miss, read from the finished result
without changing any row: Cost scales with the size of the tree, so a large monorepo takes proportionally longer; there is no cache and no partial mode. Quoted lines are masked by default. Reading happens on this machine, but this
result does not stay on it: it is returned to a model, which is a place the
scanned line has not been before. A secret sharing a line with a finding -- a
token in the call that names the cipher -- would travel with it. Masking keeps
what a reader needs (the algorithm, the file, the line number, the shape of the
call) and removes what nobody asked for. Pass |
| list_algorithmsA | List every algorithm family this server can recognise, and how each is classified. Returns the whole table: family name, classification (classical and quantum-vulnerable, post-quantum, symmetric, hash, or deprecated) and the kind of use it stands for. Reads no files and takes no arguments. Use this to check coverage before trusting a scan -- whether a scheme the project
depends on is one this server knows at all -- or to explain a classification without
scanning. To find what a particular directory uses, use An algorithm absent from this table is reported as |
| export_cbomA | Scan one directory and return a CycloneDX 1.6 CBOM that carries its own coverage. Same reading as What the document carries beyond the components: The coverage block travels as The serial number is derived from the two pins and a digest of the findings, not from where the tree sits, so two runs of the same code over the same corpus that find the same things share it and a different result does not. The timestamp is the tree's commit time (or SOURCE_DATE_EPOCH), so two runs over one unchanged tree give the same bytes; the read window stays in the scan result. The matched text in |
| compare_coverageA | Say whether two scans produced numbers that can be compared at all. Two coverage percentages can differ because the estate moved, because the instrument moved, or because the corpus was collected differently, and the percentages show none of the three. This reads the pins and conditions in both blocks and answers with one of three verdicts.
Use it before putting two coverage figures in one table. Do not use it to compare findings; it reads conditions, not results. |
| prove_closureA | Say which findings a change actually closed, by comparing two saved scans of one tree. First it decides whether the two runs can be compared for closure at all: the same instrument commit, version, rules, file types and exclusions, both trees pinned to a commit and clean, both results quoting lines at the same level. The trees themselves may differ -- that difference is what is measured. If the runs cannot be compared, nothing is reported as closed and the repair is named. Only then does it match every occurrence without its line number: To keep the verdict as a file that names the two scans it judged, run
Use it after a fix, to evidence the fix. Do not use it to compare coverage
figures between two estates -- |
| run_self_seeded_controlA | Plant known lines into a temporary copy of a directory, scan the copy, and say what the scan did with each: robustness on known patterns. 27 cryptographic uses in 9 styles (direct calls, aliased names, names built from
pieces, calls split over lines, shell commands in strings, cert-manager, Terraform,
Java properties, UTF-16 without a byte-order mark) and 18 lines that name an algorithm
without using it (switched-off flags, deny lists, log strings, variable names,
comments, a JWKS key label, an sshd_config removal list) per tree with one language.
Returns Behaviour beyond the annotations: it writes the copy to a temporary directory and
removes it afterwards; nothing in Use it to learn which styles this instrument's silence may be relied on in this tree.
Do not use it to inventory the tree -- that is |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 6 tools
Each tool occupies a distinct slot in the audit lifecycle: inventory (scan_repo), emit (export_cbom), classify (list_algorithms), compare coverage conditions (compare_coverage), compare findings for closure (prove_closure), and validate detection by seeding (run_self_seeded_control). The descriptions go further than most servers, explicitly naming the neighbouring tool and stating when it, not this one, is correct (e.g. scan_repo vs list_algorithms, compare_coverage vs prove_closure, scan_repo vs export_cbom). The one genuine overlap — scan_repo and export_cbom run the same reading — is resolved by an explicit output-consumer distinction (read here vs send off-machine).
All six names are snake_case verb_noun constructions (scan_repo, compare_coverage, export_cbom, list_algorithms, prove_closure, run_self_seeded_control) with no casing or style drift. The single long outlier, run_self_seeded_control, is still the same pattern and is descriptive of what it does.
Six tools is tightly scoped for a crypto-inventory server and each maps to a non-redundant operation rather than a variation of another. Nothing feels padded or missing at the count level.
The lifecycle is well covered: scan, export to a standard format, classify, compare coverage, prove remediation, and self-validate detection, plus the .qrp.toml baseline/ignore mechanism surfaced through scan results. Minor gaps remain — there is no tool to query or page through a saved scan result directly (only the two comparison tools read saved files), and no operation for managing or validating the policy/baseline configuration itself.