Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

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

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}
experimental
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
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 path. Returns each algorithm found with its file and line, the mathematical family and standing of every post-quantum scheme, and a coverage count.

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 -- list_algorithms answers that from the same table and reads no files. It is also the wrong tool for a network endpoint, a running host or a certificate store: it opens files on disk and nothing else.

Coverage is reported as a fraction with a base. files_scanned + unreadable_files + files_skipped_by_type + the linked files in symlinks_not_followed == files_present; a link is not followed and is named, not read. A file that could not be opened is listed, never counted as scanned, because no findings in a file nobody read is not the same as a file that is clean. Files skipped because this tool does not claim their type are counted by extension, so the reader can judge the boundary rather than assume past it.

The owner's own settings apply and are reported, never silent: a .qrp.toml at the root (its excludes are listed under coverage.not_examined as excluded_by_config; its baseline marks rows new or baselined), and qrp:ignore <family> <reason> comments, whose rows move to suppressed with the reason and are counted in coverage.suppressed; a marker past its until=YYYY-MM-DD no longer applies and is listed as expired.

The result also says where this version may miss, read from the finished result without changing any row: operation_closure (the (operation, ecosystem) pairs whose documented spellings this version tests one by one), ecosystems (each ecosystem of the files read, closed, partially closed or not closed against that catalogue), angles (dependency, code and configuration where they disagree), chosen_outside_files.leads (includes and key paths followed to the files read) and where_to_look. None of these enters the findings or their fingerprint, and the CBOM from export_cbom does not carry them.

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 level="full" when the line itself is the thing being examined.

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 scan_repo instead; this tool never looks at a codebase.

An algorithm absent from this table is reported as unknown by a scan, which is not the same as absent from the code.

export_cbomA

Scan one directory and return a CycloneDX 1.6 CBOM that carries its own coverage.

Same reading as scan_repo; a different document. Use this when the result has to leave the machine -- an auditor, a customer, a pipeline artefact -- and scan_repo when a person or an agent is going to read it here.

What the document carries beyond the components: compositions.aggregate states how complete the list is in the schema's own vocabulary, complete only when every file present was examined; properties carries the whole coverage block flattened, including every file not examined with its reason; and each asset carries evidence.occurrences with file, line and matched text.

The coverage block travels as properties because the CycloneDX root object is additionalProperties: false and the format has no field for it. That is the point of emitting it this way rather than a limitation to work around.

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 evidence.occurrences is masked by default, for the reason given on scan_repo and one more: this document is the one built to be sent. An auditor needs the algorithm, the file and the line; the contents of the line are not part of the claim being made.

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.

comparable means nothing that moves the number differs. not_comparable lists which conditions differ, each with what it means, so the reader knows whether to re-run, re-clone or ignore it. unestablished means the blocks do not carry enough to decide -- an unpinned corpus, or an emitter that names no commit -- which is a different situation from a known difference and has a different repair.

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: closed (present before, absent from every file the second run read), still open (and how many only moved lines), relocated to another path (renamed or moved, not fixed), changed (gone from a file in which the second run finds the same family again -- not closed), removed (the whole file is gone from the second tree -- not counted as closed), moved into or out of test code, new, and unverifiable (in a file the second run did not read). A file the second run could not open is never counted as fixed.

To keep the verdict as a file that names the two scans it judged, run qrp-mcp closure BEFORE AFTER --out FILE.

Use it after a fix, to evidence the fix. Do not use it to compare coverage figures between two estates -- compare_coverage answers that. It reads two local files and nothing else.

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 self_seeded_control -- counts by style, by decoy class and by confidence, the seed, the harness digest -- and items, where each line went and its outcome.

Behaviour beyond the annotations: it writes the copy to a temporary directory and removes it afterwards; nothing in path changes and nothing leaves the machine.

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 scan_repo -- and do not read its counts as a statement about the tree's own cryptography: the denominator is what was planted, and the figure never makes claims.control.held true.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.6/5.0

Scored across 6 tools

Disambiguation5/5

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).

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness4/5

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.

Maintenance

ActivityActive
ResponsivenessNo recent community issues