Finding Record MCP Server

Ask a chat assistant to write up SEO audit findings so they can be scored, sorted and handed over. Every finding has the same 53 fields, and its priority is computed from six judgments, not asserted.

Add It To Your Assistant

  • Claude
  • ChatGPT
  • Gemini
  • Grok
  • Perplexity
  • Le Chat
  • Meta Muse
  • Manus
  • Copilot
# Connector address
https://mcp.jakelabate.com/finding-record
# Then ask
Help me write up SEO audit findings so they can be scored and put in order. Show me what a finding needs, then check mine one at a time. Do not fill in a field I have not given you.

No sign-in. It checks and scores the findings you send, and keeps nothing.

53

Fields

In every finding, in 9 groups.

6

Judgments

What the priority score is computed from.

33

Register columns

Each with a note for the reader.

5

Tools

None of them changes or stores anything.

How To Add It

  1. In Claude, open Customize, then Connectors, choose Add custom connector and paste the address. Claude's own instructions have the details.
  2. In any other assistant that supports MCP, add the address as a remote MCP server.
  3. Ask it about your findings. The prompt in the box works as it is copied.

What To Ask

  • "How should I write up the findings from this audit?" It returns the record: every field, what it means, who supplies it, and the five questions a finding has to answer. get_record_spec
  • "Is this finding ready to go to the client?" It checks the finding against the record and names what is wrong, what is missing, and which questions are not answered. validate_finding
  • "Here are 30 findings. What do we fix first?" It scores each one, bands them P1 to P4 by their position in the set, and shows the arithmetic behind every score. score_findings
  • "Why is this one P2 and that one P1?" Each score comes with its inputs and its sum, so the answer is an input two people can look at. score_findings
  • "Three of us wrote these. Are any the same finding?" It puts the pairs that read alike side by side, with the words they share. find_duplicates
  • "Give me a spreadsheet of this for the dev team." It returns the register as CSV, with a note under each column header. export_register

What It Returns

4 findings from a made-up shop, sent to score_findings. Two of them wait on the first. This is the server's own answer, run when this page was built.

score_findings.jsonJSON
{
  "findings": [
    {
      "finding": "IDX-001",
      "score": 55,
      "band": "P1",
      "wave": 1,
      "arithmetic": "3 x (5 x 0.75 x 1 x 3) x 1.15 / square root of 0.5 = 54.89, rounded to 55"
    },
    {
      "finding": "SD-001",
      "score": 9,
      "band": "P2",
      "wave": 2,
      "arithmetic": "3 x (4 x 1 x 1 x 1) x 1.1 / square root of 2 = 9.33, rounded to 9"
    },
    {
      "finding": "PERF-001",
      "score": 5,
      "band": "P3",
      "wave": 3,
      "arithmetic": "3 x (3 x 1 x 0.8 x 1) x 1.05 / square root of 2 = 5.35, rounded to 5"
    },
    {
      "finding": "LINK-001",
      "score": 3,
      "band": "P4",
      "wave": 4,
      "arithmetic": "3 x (2 x 1 x 0.8 x 1) x 1.05 / square root of 3 = 2.91, rounded to 3"
    }
  ],
  "how_bands_were_set": "A band is a position among the 4 client-facing findings that were scored: P1 is the top 15%, P2 the next 25%, P3 the next 30%, P4 the rest. Findings that score the same share a band."
}

The first finding scores highest partly because two others cannot start until it lands. That is leverage, and it is read off what depends on what, not typed.

The Record

A finding is one claim, written as a record. Because every finding has the same fields, a set of them can be sorted by score, filtered to an owner, grouped by template and exported, without being retyped.

  • Identity: 4 fields. Which finding this is. ref, title, pillar, raised
  • Scope: 3 fields. How much of the site it touches. urls_affected, templates, markets
  • Evidence: 6 fields. How it is known. measurements, source, collected_from, collected_to, confidence, confidence_reason
  • Impact: 7 fields. What it costs. impact_type, metric_at_risk, quantity_value, quantity_unit, impact_basis, time_horizon, affects
  • Remedy: 8 fields. What to do about it. action, steps, owner, effort_days, dependencies, depends_on, external_blockers, wave
  • Fix risk: 3 fields. How dangerous the fix itself is. blast_radius, failure_likelihood, reversibility
  • Priority inputs: 4 fields. The judgments the score is computed from. severity_weight, reach, confidence_factor, leverage
  • Lifecycle: 5 fields. Where the fix stands. status, verification_method, verify_by, verified_on, closed_note
  • After delivery: 13 fields. What happened once it was handed over. exposure, decision, decided_at, decided_by, decision_note, acceptance_checks, last_check_at, last_check_result, implemented_on, outcome_note, outcome_value, outcome_unit, outcome_measured_on

Each field is supplied one of five ways, which is what tells a person or an assistant what they may fill in.

  • Judged. A human call. The person writing the finding decides it.
  • Imported. Arrives from a crawl or a tool, with where it came from.
  • Controlled. Chosen from the client's own fixed vocabulary: its pillars, templates, markets, owner teams, metrics and units.
  • Derived. Worked out from other fields. Not typed.
  • System. Assigned when the finding is stored: a reference, a date, the result of a check.

get_record_spec returns every field with its type, its allowed values and when it is required.

The Five Questions

The fields answer 5 questions in order. A finding that cannot answer all of them is not finished.

  1. What is wrong? Stated as something a client can disagree with. title
  2. How do you know? Each measurement says what was checked, what came back and when. A confidence below high says why. measurements, source, confidence
  3. What does it cost? A metric at risk, and a number only if one can be stood behind. A number has to say where it came from. impact_type, metric_at_risk
  4. What should be done? An instruction to a named team, in steps an engineer can follow without asking. action, owner, steps
  5. How will you know it worked? Written before the fix, not after. This is the field that separates an audit from a list of opinions. verification_method

The Rules

The rules a finding is held to. validate_finding checks each one that can be checked without judgment, and says what it was not given enough to check.

  • A title is a claim. "Product pages canonicalize to their category" can be agreed or disagreed with. "Canonical issues" cannot.
  • A number says where it came from. When quantity_value is set, impact_basis has to be. The number is what gets quoted back six weeks later.
  • A confidence below high says why. In confidence_reason.
  • The check is written before the fix. verification_method is filled in when the finding is raised, not after something has shipped and needs a check that flatters it.
  • The owner is a team. Not a person. People move. Sent the client's list of teams, the tool checks the owner is one of them.
  • A closed finding says what changed. closed_note is required when status is fixed, verified or accepted risk. verified_on goes with verified, and only with it.
  • The evidence comes before the finding. The window the evidence covers cannot end after the day the finding was raised.
  • A status moves only where it can. From open: in progress, fixed, accepted risk. From fixed: verified, reopened, in progress, accepted risk. From verified: reopened, accepted risk. A finding cannot be verified without having been fixed.

The tools never write a value into a field. A verification method or an owner that nobody agreed to is worse than a blank.

How Priority Is Computed

The priority scoreText
score = 3 x (severity x reach x confidence factor x leverage)
        x risk factor / square root of effort days

risk factor = 1.3 - (blast radius + failure likelihood) / 20
              - reversibility / 20

Six judgments go in. The score comes out, from 0 to 100.

  • Severity, 1 to 5. How bad it is on its own. 1 is cosmetic. 2 is low, mostly hygiene. 3 is medium, real but bounded. 4 is high, clear harm that will not correct itself. 5 is critical, costing traffic or trust now.
  • Reach, 0 to 1. The share of the relevant pages affected: URLs affected over the pages of the templates touched.
  • Confidence factor, 0 to 1. It follows confidence: high is 1, medium is 0.8, low is 0.6.
  • Leverage, 1 to 5. 1 plus the number of findings that cannot start until this one lands.
  • Effort, in days. Chosen from 0.25, 0.5, 1, 2, 3, 5, 8, 13. It sits under a square root: a fix taking four times as long is penalized twice, not four times. Dividing by it outright would recommend nothing but trivia.
  • Fix risk, 0.6 to 1.2. How dangerous the fix itself is. Blast radius: 1 is a single page, or a host that is not production. 2 is one template or one section of the site. 3 is the whole site. Failure likelihood: 1 is a configuration change, hard to get wrong. 2 is a template edit carrying real logic. 3 is a rewrite or a migration. Reversibility: 0 is switched straight back if it goes wrong. 1 is undone, but with work. 2 is permanent once it ships.

Severity and effort are never assumed: without both there is no score. When another input is missing, reach, confidence factor and leverage count as 1 and each fix-risk input as the middle of its scale (2, 2, 1), and the answer says so each time.

The same inputs always give the same order. When someone argues with the order, the argument is about one input that two people can look at.

How Bands Are Set

A band is a position inside its own audit, not a fixed score. It is the share of the client-facing findings that score the same or lower.

  • P1: Do this first. The top 15% of the audit.
  • P2: Scheduled work. The next 25% of the audit.
  • P3: Do alongside. The next 30% of the audit.
  • P4: Monitor. The rest of the audit.

Cutting at fixed scores meant only a finding that was severe, high in leverage and near total in reach ever reached P1, so an audit where nothing was catastrophic read as though nothing mattered. The band answers what to do first here. The score is what compares one audit with another.

Findings that score the same always share a band. Internal findings are not ranked against, so they cannot push a client-facing finding up. With one finding, or a set that all scores the same, there is nothing to rank against and fixed cuts are used: P1 at 80 or more, P2 at 55 or more, P3 at 30 or more.

How Duplicates Are Found

An audit written in passes, by several people or by a model, collects the same finding twice. find_duplicates compares the words of titles and fixes, weighted by how rare each word is in the set, and returns the pairs that read alike with the words they share.

  • 0.5 or more. Likely the same finding, or one fix written as two findings.
  • 0.3 to 0.5. Worth a second look.

It is a short list to read side by side, not a verdict. Two findings can share words and be different problems, and the same problem can be written in different words and be missed.

The Register

The register is one row per finding, highest score first, as CSV, a Markdown table or JSON. Each column carries a note, printed under its header, because a bare header such as Reach tells a reader who was not in the audit nothing.

  • Ref. Permanent ID for this finding.
  • Finding. What is wrong, stated as a claim you can agree or disagree with.
  • Priority. Position in this audit: P1 do first, P2 scheduled, P3 alongside, P4 monitor.
  • Score. 0 to 100, computed.
  • Status. Where the fix stands right now.
  • Owner. The team that can make this change. A team, not a person.
  • Effort, days. Engineering days, estimated.
  • Wave. Roadmap phase.
  • URLs affected. URLs with the problem.
  • Templates. Which page templates are hit. A template problem is one fix.
  • What it costs. The exposure, and where that number came from.
  • The fix. What to do, written as an instruction to the owner.
  • How it will be verified. The check that proves it fixed. Written before the fix, not after.
  • Verify by. When to run that check.

Those 14 are on by default. 19 more can be added: Pillar, Markets, Kind of harm, Metric at risk, Exposure, When it bites, Confidence, Data window, Sources, Steps, Blocked by, External blockers, Severity, Reach, Leverage, Fix risk, Decision, Verified on, What changed.

Internal findings are left out unless asked for. A cell that a spreadsheet would run as a formula is written as text.

The 5 Tools

  • get_record_spec Returns the record an SEO audit finding is written as.
  • validate_finding Checks one finding against the record.
  • score_findings Computes the priority of each finding in a set and puts them in order.
  • find_duplicates Finds pairs of findings that may be the same finding written twice, or two findings that one fix would close.
  • export_register Turns a set of findings into the register.

Where It Comes From

This is the record AuditBuilder stores, with its scoring ported line for line and checked against the scores of its sample audit. The connector keeps nothing. AuditBuilder is where findings are stored, with their history, the client's decisions and the checks that confirm a fix.

From A Register To Shipped Fixes

A scored register tells you what to fix first and why. Getting each fix owned, shipped and verified against the check written for it is the work. That is what an engagement is for.