Review public MCP servers for registration
- Case study 3
- 150 min
- Optional · 1 case study needed for the certificate
Where we are
In this course, we registered Larkfield's own agents and the tool servers that we wrote. We knew their code, their tools and their data. Now four teams ask to connect MCP servers that other companies wrote, and all four are in the official MCP Registry. In this case study, we review them from published information only: we fill in a registration for each, set a risk tier and the tools it may use, and list what nobody has published.
Case study 3 of 3 · Governing AI Agents: Gateways, Registries and ControlsReview public MCP servers for registration
1. Why agents need platform controls
2. Ask for capabilities, not models
3. Register every agent
4. The model gateway
5. Govern tools and actions
6. Usage, evidence and shadow AI
7. Build, buy and roll out
What you will be able to do
Four teams ask to connect MCP servers that other companies wrote. Review each one before anyone runs it, from what is published: the official registry, a second catalog and the vendor’s own pages. Fill in a registration for each server, with a risk tier, the tools it may use and a decision. Then list what no published source tells you, because that list is the review’s most useful output.
The starter is a small Python project, mcp-intake. It has a fixed copy of the registry and the catalog, our notes from the vendors’ pages, and the commands of this page. It has no registrations: you write them. The finished project has the four reviewed forms and the review report, for when you are stuck. The code is under the MIT licence. Nothing in this case study runs an MCP server, and nothing needs an account or a key.
Before you startWhat to know and to have ready
What you need to know
This case study uses the whole course, on servers that Larkfield did not write. It leans most on:
- The registration form, its risk tiers and the long form, from What a registration holds.
- Data classes, and the rule that payment data never goes to a model, from A capability catalog.
- The tool gateway, which allows only the tools in a registration and keeps its own list of reads and writes, from A gateway for tools.
- Approvals for writes, from Autonomy and approvals as policy.
- What an MCP tool, its annotations and
tools/listare, from the MCP course.
What you need on your computer
- Python 3.12 or newer, and VS Code.
- About 30 MB of free disk space: the packages (PyYAML, pytest and ruff) and the data (4.3 MB).
- A network connection only to install the packages, and for one optional step that reads the live registry.
You do not need the course project ai-estate. The starter carries a copy of its registry checks (estate/registry.py and the configuration they read), unchanged.
Tested on macOS (Apple silicon) with Python 3.12.13. The Windows (PowerShell) and Linux commands are written for you, but the course did not run them.
The situation
Section titled “The situation”Kwame runs Larkfield’s AI platform. Four requests arrive in one week. All four ask to connect a public MCP server to the tool gateway:
| Request | From | Server in the registry | What they want |
|---|---|---|---|
stripe-mcp |
Amira (service) | com.stripe/mcp |
The support workflow looks up payments and refunds through Stripe directly. |
shippo-mcp |
Amira (service) | com.shippo/shippo-mcp |
The support workflow compares rates and buys return labels. |
sentry-mcp |
Tomás (platform) | io.github.getsentry/sentry-mcp |
The platform team’s coding assistant reads production errors. |
notion-mcp |
Mei (data) | com.notion/mcp |
The document assistant reads staff procedures kept in Notion. |
The requests and the people are made up; the servers and everything published about them are real.
Tomás adds a note to his request: “It’s in the official MCP Registry, so it’s been checked. Can we just connect them?” Kwame’s rule is the course’s rule: no registration, no calls. And a registration needs answers that someone else’s server must give.
The objective. For each request, write a registration in the course’s form, signed by a reviewer. It has a risk tier, the tools the server may use, and one decision: refuse, wait or register reads only. Every answer must point to where it is published. Every question without a published answer goes on a list, because the list tells the team what to ask next.
What you will build
Section titled “What you will build”Text description of the diagram
Four inputs feed twelve questions: the request, the registry, a second catalog and the vendor’s pages. Then each published tool is marked read, write, run-any or unknown. The code drafts a registration, and a person reviews and signs it. python -m intake check runs the checks. The result is refuse, wait, or register reads only.
You work in six parts:
| Part | What you do | Command |
|---|---|---|
| 1 | Check the data, and see what the registry publishes at all | verify, coverage, search |
| 2 | The baseline: answer the twelve questions from the registry alone | answer --sources registry |
| 3 | Add a second catalog, then the vendors’ pages | answer, lists |
| 4 | The fair comparison: all four servers, three ways | compare |
| 5 | From answers to a registration: tools, tier, decision, signature | tools, draft, check |
| 6 | End to end on a new request | review, gateway |
The data
Section titled “The data”Three sources, each with its licence:
- The official MCP Registry at
registry.modelcontextprotocol.io, where developers publish their servers’ metadata. Its Terms of Service, section 10, dedicate that metadata to the public domain (CC0 1.0). The project has a fixed copy of the latest version of all 48,606 entries, with only the fields the review reads. The registry is in preview and changes every hour, so the fixed copy keeps your results equal to this page. - Docker’s MCP catalog, a second, independent catalog on GitHub (docker/mcp-registry, MIT). Some of its 328 entries have a list of tools.
- The vendors’ own pages: documentation and, where it is public, source code. We wrote short notes in our own words, with a link for each answer (
data/vendor/*.yaml), and copied only tool names. Check the notes against the pages: pages change.
DATASET.md in the project is the dataset card: the sources, the licences, what we changed and the limits. One limit matters above all: this is published information only. Nobody ran any of these servers.
Set up the project
Section titled “Set up the project”-
Download the starter project from the box at the top of this page. Unzip it into your projects folder, for example
~/projects. You get the foldermcp-intake. -
In VS Code, choose File > Open Folder, and open
mcp-intake. Then open a terminal: Terminal > New Terminal. -
Make and activate a virtual environment, and install the packages:
Terminal window python3 -m venv .venvsource .venv/bin/activatepython -m pip install -r requirements-dev.txtTerminal window python -m venv .venv.venv\Scripts\Activate.ps1python -m pip install -r requirements-dev.txtTerminal window python3 -m venv .venvsource .venv/bin/activatepython -m pip install -r requirements-dev.txt -
Check the data against its checksums, and run the tests:
Terminal window python -m intake verifypython -m pytest -q24 data files match data/SHA256SUMS. When the registry copy was made: data/registry/FETCHED.................. [100%]17 passed in 0.70s
If verify names a changed file, download the starter again: every number on this page comes from these exact files.
Part 1: what the registry publishes
Section titled “Part 1: what the registry publishes”A listing is not a review
Section titled “A listing is not a review”Think of a city’s business register. Before a plumber can list a company there, the city checks that the company exists and who owns it. That check is useful: nobody else can list a company under the plumber’s name. But the city does not check the plumber’s work, the parts used, or what happens to the keys you hand over. Before you let a plumber into your building, you still ask for references, a quote and insurance. The listing tells you who; your own review tells you what.
The MCP Registry works the same way. Its documentation says what it checks. A server’s name starts with a namespace that the publisher must prove it controls. com.stripe means the stripe.com domain, proved by DNS or HTTP; io.github.getsentry means the GitHub account getsentry. For a package, the registry checks that the package names the server. For security scanning of the code, it relies on the package registries (npm, PyPI) and on downstream catalogs. Its terms say that the registry gives no warranty about the servers, and advise you to evaluate each one before you use it.
Text description of the diagram
The registry checks three things: the publisher controls the name, the package belongs to the name, and the entry has the right format. Nobody checked six things for you. They are the tools and which ones write, their data, other services or models, later changes, what the vendor keeps, and the code.
So Tomás is half right. The registry proves who published a server. It does not say what the server may do at Larkfield. That is the registration’s job, and the form of What a registration holds needs answers that only the server’s publisher can give.
Look at every entry once
Section titled “Look at every entry once”Before you review four servers, see what the registry can tell you about any server:
python -m intake coverageOfficial MCP Registry, latest entries: 48,606 (the fixed copy in data/registry/) names a code repository 33,315 (68.5%) a package to run on our machine 18,511 (38.1%) with an exact version 17,168 (35.3%) with a setting marked secret 6,901 (14.2%) a hosted address 31,888 (65.6%) hosted only (nothing to pin) 29,583 (60.9%) a list of tools (publisher's) 336 (0.7%) namespace is a GitHub account 29,231 (60.1%) status deprecated 617 (1.3%)No entry has a field for: the licence, the data returned, read or write per tool, the data kept.Text description of the chart
Six bars, as a share of 48,606 entries. A code repository: 68.5%. A package to run on our own machine: 38.1%. Hosted only, so nothing to pin: 60.9%. A setting marked secret: 14.2%. A tool list, in the publisher’s own notes: 0.7%. The data that the tools return: 0%, because the entry format has no field for it.
What this tells us:
- Most servers are hosted only. For six in ten entries, the server runs on the vendor’s machines, and there is no package. The entry’s version is a label: nothing stops the vendor from changing the tools tomorrow.
- The registry almost never lists tools. Only 0.7% of entries carry a tool list, written by the publisher in a free field. A registration must name its tools, so for almost every server, the tools must come from somewhere else.
- The registry cannot answer some questions at all. No entry says which data its tools return, which tools write, or what the vendor keeps.
One more look, because names mislead. Search for a word:
python -m intake search stripe147 entries mention 'stripe', in 111 namespaces. 33 domain wishpool.app 3 GitHub account CSOAI-ORG 2 GitHub account codespar 2 GitHub account dailyaiagents-cpu 1 domain apithreshold.ai 1 domain augenix.ai 1 domain foodphoto.ai 1 domain kifly.ai ... 103 more namespacesNamespaces on a domain with that word: domain stripe.com147 entries mention Stripe, and only one namespace is Stripe’s own domain. The others are servers that other people wrote, for Stripe or about it. So always review the exact name in the request, com.stripe/mcp, and check that its namespace is the vendor’s. A name that looks right is not enough.
Part 2: the baseline, the registry alone
Section titled “Part 2: the baseline, the registry alone”Twelve questions
Section titled “Twelve questions”A registration of someone else’s server needs twelve answers. Each one maps to a field of the form, or to a decision about it. When nobody has answered one of the five marked *, no decision is possible:
| Question | It fills in |
|---|---|
| Who publishes it, and is that checked? * | from, and whether to trust the rest |
| Where is its code, at which version? | from, and the review of the code |
| Under which licence or terms? | a question for legal, noted in the form |
| Can we pin the exact version we reviewed? | a condition, or “review again when it changes” |
| Where does it run: our machine or the vendor’s? * | the tool gateway’s configuration, and where data goes |
| Which credential does it need? * | the credential, and its scopes |
| Which tools does it have? * | tools |
| Which tools read and which write? | tools, autonomy, and the gateway’s list |
| Which data do its tools return? * | data_classes, risk_tier |
| Which other services or models does it contact? | data_classes, and the gateway rule |
| Can its tools change without a new version? | review_date, and a condition |
| What does the vendor keep, and for how long? | long_form.data_retention |
Each source answers a question with yes (published, and enough to act on), partly (published, but not enough) or not at all.
The baseline run
Section titled “The baseline run”The cheapest review reads only the registry entry. Run it for Stripe:
python -m intake answer stripe-mcp --sources registrycom.stripe/mcp 0.2.4, from: registryyes Who publishes it, and is that checked? * domain stripe.com: the registry checks that the publisher controls itpartly Where is its code, at which version? https://github.com/stripe/agent-toolkit (no commit or tag in the entry)- Under which licence or terms?yes Can we pin the exact version we reviewed? no: hosted only; the entry's version 0.2.4 is a label, not something we can pinyes Where does it run: our machine or the vendor's? * hosted: https://mcp.stripe.com (streamable-http)- Which credential does it need? *- Which tools does it have? *- Which tools read and which write?- Which data do its tools return? *- Which other services or models does it contact?- Can its tools change without a new version?- What does the vendor keep, and for how long?Answered 3 of 12 (1 partly). Unanswered questions that block a decision (*): credential, tools, dataThree answers of twelve. We know that Stripe publishes it, that it runs on Stripe’s machines, and that nothing can be pinned. We do not know its tools, so the form’s tools field would be a guess. Even the repository link is out of date: on GitHub, stripe/agent-toolkit now redirects to stripe/ai. The baseline is fast, and it cannot produce a registration.
Part 3: two more sources
Section titled “Part 3: two more sources”A second catalog
Section titled “A second catalog”Docker’s catalog is a second, independent list, and some of its entries have a tool list. The project matches a catalog entry to a registry entry by address or repository, never by name:
python -m intake show stripe-mcp…Catalog entries that match: 2 stripe-remote: the same address (https://mcp.stripe.com) - tool list kept stripe: the same repository (mcp/stripe)Why not by name? For Sentry, the catalog has an entry called sentry. It is another server: an archived reference server, built from another repository. The project prints it apart, as “with ‘sentry’ in the name but not this server”. A match by name would have reviewed the wrong code.
With the catalog, Stripe’s answers rise from 3 to 6. The catalog adds the credential (OAuth), a list of 25 tools, and a flag: the tool list is dynamic.
The vendors’ own pages
Section titled “The vendors’ own pages”Then the third source: what each vendor publishes about its own server. For Sentry, that is its source code at the exact release that the registry names, 0.42.0. Each tool definition there has its name, its skill group, the scopes it needs and its MCP annotations. With all three sources, Sentry answers 10 of 12:
python -m intake answer sentry-mcpio.github.getsentry/sentry-mcp 0.42.0, from: registry, catalog, vendor…yes Which tools does it have? * 63 tool definitions at tag 0.42.0, each with its skill group and required scopes. Two of them, search_sentry_tools and execute_sentry_tool, find and run any other tool by n……yes Which other services or models does it contact? The AI-powered search tools need an LLM provider (OpenAI, Azure OpenAI, Anthropic or OpenRouter) configured in the server: model calls that do not pass our gateway.…Answered 10 of 12 (2 partly). Unanswered questions that block a decision (*): noneTwo findings that no registry entry could show. A tool that runs any other tool by name makes any allowlist useless. And three of Sentry’s search tools call a language model that the server itself is configured with. Those are model calls with Larkfield’s data that never pass Larkfield’s model gateway: unregistered AI, inside a tool. You met the same problem with the weekly digest in Find unregistered AI.
When two published lists disagree
Section titled “When two published lists disagree”More sources give more answers. Do they give the same answers? Compare the catalog’s tool list with the vendor’s:
python -m intake lists stripe-mcppython -m intake lists notion-mcpcatalog stripe-remote (the same address): 25 tools | vendor: 15 tools | in both: 2 (get_stripe_account_info, search_stripe_documentation)catalog notion-remote (the same address): 8 tools | vendor: 65 tools | in both: 0Two of 25 names agree for Stripe. For Notion, none agree. Both servers are hosted, and their vendors changed the tools after the catalog wrote its list down. The vendor’s own list wins here, because the vendor runs the server. But even the vendor’s page is a description. The final word is the list that the server returns to tools/list, which you get only by connecting to it. That is a test, and this case study runs no server.
Part 4: the fair comparison
Section titled “Part 4: the fair comparison”Now compare the three ways of reviewing on all four requests, under one measure: how many of the twelve questions have a published answer (yes only). The questions are the same, the rule for yes is the same, and the four servers are the same.
python -m intake compareserver registry +catalog +vendor still blocking with all threestripe-mcp 3 6 7 noneshippo-mcp 3 3 4 tools, datasentry-mcp 4 4 10 nonenotion-mcp 3 6 8 noneall four 13 19 29 (of 48 answers)Text description of the chart
Three bars, of 48 questions: the registry alone answers 13; with the catalog, 19; with the vendors’ pages, 29.
Is the comparison fair? It counts answers, not correct answers. The catalog’s tool lists raised the count, and Part 3 showed that they were out of date. So read the measure as “how much did each source let us fill in”, and read the conflicts as a second result. Shippo stays blocked with all three sources: neither the registry, nor the catalog, nor Shippo’s own pages name its tools.
The recommendation for the procedure: read all three sources, in this order, and let the vendor’s own pages win when sources disagree. The registry alone answers about a quarter of the questions, which is too little to register anything. Even with all three sources, 19 of the 48 answers are still missing. That list is a result too.
Part 5: from answers to a registration
Section titled “Part 5: from answers to a registration”Each tool: read, write, run-any or unknown
Section titled “Each tool: read, write, run-any or unknown”The form’s tools field is the allowlist that the tool gateway applies. Before you choose, mark each published tool. A tool is published as read or write when its server says so (Sentry’s annotations). Otherwise the project proposes a kind from the tool’s first word: get, list and search read; create, send and transfer write. It never guesses past that:
python -m intake tools stripe-mcpcom.stripe/mcp: 15 tools, from the vendor list | read 3, run-any 2, unknown 6, write 4 unknown stripe.stripe_api_search the verb 'api' is not in either list unknown stripe.stripe_api_details the verb 'api' is not in either list run-any stripe.stripe_api_read runs any operation by name: an allowlist cannot narrow it run-any stripe.stripe_api_write runs any operation by name: an allowlist cannot narrow it [moves_money] read stripe.get_stripe_account_info proposed from the verb 'get'… write stripe.send_money proposed from the verb 'send' [moves_money]…Remember from A gateway for tools: annotations are hints from the server, not permissions. The platform keeps its own list of reads and writes. Here that list starts from the server’s hints and the names, and a person confirms it. A run-any tool, such as stripe_api_write (“any POST, PATCH, PUT and DELETE method”), is never allowed. One tool name covers every write method among the 152 API methods that Stripe’s page lists, and the gateway sees only the name.
The tier and the decision
Section titled “The tier and the decision”The project drafts a risk tier with the course’s three questions. Can it change money or goods? Does it see personal data? Does a person decide? Two more rules apply to someone else’s server:
- No published tool list means high risk. If you do not know what a server can do, assume the worst.
- Payment data in a tool’s answer is refused. An agent puts each tool’s answer into its context, and it sends that context to a model. Larkfield’s rule says that payment data never goes to a model.
Then one decision per request. Refuse when a rule forbids it. Wait when a blocking question has no answer, and say what to ask. Otherwise register reads only: the read tools that fit the purpose, with every write, run-any and flagged tool held back. A write needs an approval grant and a review of its own, as in Autonomy and approvals as policy.
Draft, review, sign: Sentry
Section titled “Draft, review, sign: Sentry”Write the first draft:
python -m intake draft sentry-mcp --out registrations/sentry-mcp.yamlWrote registrations/sentry-mcp.yaml: decision 'register reads only' (39 read tool(s) allowed; 24 held back (writes, run-any or flagged tools))Open registrations/sentry-mcp.yaml. The draft is complete for the course’s checks, but it is not a decision yet: review: by and notes are empty, and it allows 39 tools. Check it:
python -m intake checksentry-mcp.yaml: 1 problem(s) - [intake] review: a person signs the decision (review.by) and writes why (review.notes)[exit 1]Now review it as Kwame did. The purpose is “read production errors and stack traces”. Tomás’s assistant needs about ten tools for that, not 39:
risk_tier: mediumdata_classes: [personal]tools: [sentry.find_organizations, sentry.find_projects, sentry.find_releases, sentry.get_issue_details, sentry.get_event_stacktrace, sentry.get_issue_breadcrumbs, sentry.get_issue_activity, sentry.get_trace_details, sentry.get_span_details, sentry.get_release_details]autonomy: suggestsintake: decision: register reads only run_args: ['--skills=inspect'] conditions: - Run the npm package @sentry/mcp-server at exactly 0.42.0 on our machine (stdio), not the hosted server, which has no version to pin. - Start it with --skills=inspect, and give it a Sentry token with event:read, project:read and org:read only (the README lists write scopes for the full set). - Configure no LLM provider for the server, so its AI-powered search tools stay off; model calls must go through Larkfield's gateway. - Review again before any version change; the tool list on main already differs from 0.42.0.review: by: usr-kwame notes: Medium, not low, because error events and breadcrumbs can hold customer data. Ten read tools, not 39; add a tool only with a reason that fits the purpose.Read the choices. Medium, not low: error reports and breadcrumbs can hold customer data, so the data class is personal. The package, not the hosted server: the package has a version that we can pin; the hosted server does not. Held back: the run-any tool and the three tools that call another model. Also the replay, user-report and attachment tools, which return more customer data than the purpose needs.
Your turn: the other three
Section titled “Your turn: the other three”Draft, review and sign stripe-mcp, shippo-mcp and notion-mcp in the same way. Before you start, predict each decision.
Check your work
python -m intake checknotion-mcp.yaml: complete (medium risk, 2 tool(s), decision: register reads only)sentry-mcp.yaml: complete (medium risk, 10 tool(s), decision: register reads only)shippo-mcp.yaml: complete (high risk, 0 tool(s), decision: wait)stripe-mcp.yaml: complete (high risk, 0 tool(s), decision: refuse; the course's registry refuses it too)- Stripe: refuse, high. Its tools return payment data, and two of them run any API method. Larkfield’s refunds stay in
orders-mcp, behind the approval grants of the support workflow. - Shippo: wait, high. No published source names its tools, so no tool can be allowed. Ask Shippo, then list the tools in a test against a test account, as in Security review of an MCP integration.
- Notion: register reads only, medium, 2 tools.
notion-searchandnotion-fetch, through a workspace connection that lists only those two. Two tools are held back on purpose. The vendor’s page says thatnotion-ai-searchis callable by name, although it is not intools/list. Andnotion-connector-searchreaches Slack, Google Drive and mail.
Compare your forms with registrations/ in the finished project. A different choice of read tools is fine if review.notes says why.
Common mistake
The form passes the course's checks, and it is still wrong
Symptom: Amira writes her own Stripe form. It allows the two API tools, with autonomy: acts-with-approval and the data class payment. When this case study was first run, the course’s registry checks accepted it:
stripe-amira.yaml: complete (high risk, 2 tool(s), decision: register)Run the same check now:
python -m intake check --course-only registrations/stripe-amira.yamlstripe-amira.yaml: 1 problem(s) - [registry] data class payment: never sent to a model, and a tool's answer goes to the agent's model, so a tool server cannot register it[exit 1]The project’s own checks find two more problems:
stripe-amira.yaml: 3 problem(s) - [registry] data class payment: never sent to a model, and a tool's answer goes to the agent's model, so a tool server cannot register it - [intake] tool stripe.stripe_api_read: runs any operation by name, so the allowlist means nothing - [intake] tool stripe.stripe_api_write: runs any operation by name, so the allowlist means nothing[exit 1]Cause: two causes. First, a gap that this review found in the course project, and that the course then fixed. The payment rule ran only for agents that list capabilities. A tool server lists none, so the rule never ran. But a tool’s answer goes into the agent’s context, and from there to a model. The registry’s check_form (from What a registration holds) now applies the rule to tool servers too, with a test. Second, the registry checks a tool’s name, not what the tool does. It cannot know that stripe_api_read runs any API method: only a review of the published tool list finds that.
Fix: keep the review’s checks next to the registry’s. A gap in your own controls is a finding: report it to the platform owner, with the form that shows it, as this review did.
Part 6: end to end, on a new request
Section titled “Part 6: end to end, on a new request”On Friday, Sam asks for one more server. With AfterShip’s tracking server, the help-desk assistant could tell a support agent where a customer’s parcel is. Run the whole review for it:
python -m intake review aftership-mcp== com.aftership.mcp/tracking-public 1.0.1 (Tracking & Returns)Request: Let the help-desk assistant tell a support agent where a customer's parcel is.…Answered 3 of 12 (0 partly). Unanswered questions that block a decision (*): credential, tools, data-- Tools: 0 published-- Risk tier: high (no published tool list: treat it as the worst case); data class unknown-- Decision: wait: the published information does not say which credential it needs, which tools it has, which data its tools return-- The course's registry checks on the draft: complete-- Still unknown after the sources we read: Where is its code, at which version?; Under which licence or terms?; …The registry says who publishes it (the aftership.com domain) and where it runs. We found no page by AfterShip about this server, and the directories that describe it have unclear terms, so we do not use them. The decision is wait, and the review tells Sam what to ask AfterShip. Tracking numbers and addresses are personal data, so the answer about the data matters most.
For the two servers that you registered, the last step gives the tool gateway its list.
python -m intake gateway# For config/tools.yaml of the course project: the platform's own list of reads and writes.# 'name' is the server's own tool name where the platform's ID differs; 'url' marks a hosted server.# The course's tool gateway reads neither yet: it starts stdio servers and calls tools by their ID.servers: notion: about: 'Notion MCP (hosted, third-party), registered as notion-mcp (official MCP Registry: com.notion/mcp 1.0.1)' url: https://mcp.notion.com/mcp tools: notion_search: {kind: read, name: notion-search} notion_fetch: {kind: read, name: notion-fetch} sentry: … command: [npx, -y, '@sentry/mcp-server@0.42.0', --skills=inspect] tools: find_organizations: {kind: read}…Two more gaps appear, and they belong in the report. The registry’s tool IDs have no hyphens, but Notion’s tool names do, so the gateway needs a map from notion.notion_search to notion-search. And the course’s tool gateway starts local servers only, so a hosted server needs a remote transport in the gateway first. Until it has one, Notion’s registration is complete, but the gateway cannot connect it: the next step is the platform’s, not Notion’s.
Insights and limits
Section titled “Insights and limits”- The registry answers “who”, not “what”. Namespaces are proved, and that is worth a lot: of 147 entries that mention Stripe, one is Stripe’s. But the tools, the data and the writes are not in the entry.
- The unknowns are the deliverable. With all three sources, 19 of the 48 answers were still missing. A good review says which ones, and who must answer them.
- Published lists go stale. The catalog and the vendor’s page shared 2 of Stripe’s tool names, and none of Notion’s. A hosted server has no version to pin, so plan a review whenever its tools change.
- Some tools defeat an allowlist. Run-any tools, hidden tools and tools that call their own model are the first things to look for.
- Limits of this study. Published information only, read at one time. No server was run, so no tool list here is proven. No description was checked for instructions aimed at a model. The vendor notes are our reading of their pages, and the requests are made up.
Responsible use
Section titled “Responsible use”- A decision is Larkfield’s, not a verdict on a product. Each decision follows Larkfield’s own rules, such as “payment data never goes to a model” and “no run-any tools”. It rests on the facts that each vendor had published when the fixed copy was made. Another organisation, or a later review of the current pages, may decide differently. Say “refused under our rules”, never “a bad server”.
- Review the live entry. The fixed copy is for learning. Before a real registration, read the live registry (
python -m intake fetch com.stripe/mcpcompares one entry) and the vendor’s current pages. - Summarise, link, and copy little. Vendor pages belong to their vendors. Write notes in your own words, with a link for each answer, as
data/vendor/*.yamldoes. - Entries name people. Many namespaces are personal GitHub accounts. Count and read entries to review servers; do not profile their publishers.
- Run nothing that you have not reviewed. After this review, the next step is a test in a disposable environment with test accounts, as in the MCP course’s security review. Never use Larkfield’s production credentials.
- No affiliation. Say “data from the Official MCP Registry”, never that you partner with it or that it endorsed your review (its terms, section 6).
Make it a portfolio piece
Section titled “Make it a portfolio piece”This project shows what a platform or security team looks for. It is a repeatable review of third-party software from evidence. A person signs each decision, and a program checks it.
What to put in the repository:
mcp-intake/ README.md what it does, how to run and check it, your decisions table DATASET.md the sources, the licences (CC0, MIT), the changes, the limits LICENSE MIT, for the code requests.yaml your requests (say that they are made up) registrations/ your reviewed forms, each signed in review: by, notes notes/ your own vendor notes, with links docs/review.md the review report: decisions, the comparison, the unknowns, the gaps you found intake/, estate/, config/, tests/- Make a new Git repository from your project folder, and push it to GitHub.
- Review one server that this page did not: pick one from
python -m intake search, add a request torequests.yaml, read the vendor’s pages, and writenotes/<id>.yaml. Add it todocs/review.md. - Make sure that
python -m pytest -qandpython -m intake checkpass from a fresh clone, and say so in the README.
In an interview, say it in two sentences: “I reviewed public MCP servers for an agent platform from published evidence only. I drafted registrations with risk tiers, tool allowlists and a signed decision for each. The most useful output was the list of what no source published, and three gaps in our own controls.”
Knowledge check
Section titled “Knowledge check”Check your understanding
Tomás says: 'It is in the official MCP Registry, so it has been checked.' What did the registry check, and what is still your job?
Show the answer
The registry checked that the publisher controls the namespace: the domain, by DNS or HTTP, or the GitHub account. For a package, it checked that the package names the server. That proves who published the entry. It did not check the tools, the data they return, which ones write, or other services that the server calls. It leaves code scanning to the package registries and catalogs. Those answers fill in the registration, so finding them is the reviewer’s job.
Does your answer have the main points of ours?
Sign in and enroll in the course to save your answers. Every check counts toward the certificate.
Check your understanding
The Docker catalog lists 25 tools for Stripe's hosted server, and Stripe's own page lists 15. Only 2 names agree. Which list goes in the registration, and what would settle it?
Show the answer
The vendor’s own list, because the vendor runs the hosted server and the catalog’s list is older. But a page is still a description. The tools that the server returns to tools/list settle it, and you see them only when you connect, in a test with a test account. A hosted server has no version to pin, so the list can change again. Plan a review when it does, and let the tool gateway refuse every tool that is not registered.
Does your answer have the main points of ours?
Sign in and enroll in the course to save your answers. Every check counts toward the certificate.
Check your understanding
Shippo's registry entry, its docs and its repository name no tools. Amira says: 'Register it with no tools for now, so we can start.' What do you decide, and why?
Show the answer
Wait. A registration with no tools allows nothing, so it would not let Amira start. It would only look like a decision. With no published tool list, the server counts as high risk, and its label purchases cost money and ship goods. Ask Shippo for the tool list and the data terms. Then list the tools in a test against a Shippo test account, and register the read tools, with each write behind an approval grant. Until then, return labels stay in the orders server.
Does your answer have the main points of ours?
Sign in and enroll in the course to save your answers. Every check counts toward the certificate.
Recap
- The registry proves who published a server; it does not say what the server may do. Of 147 entries that mention Stripe, one namespace is Stripe’s.
- For four servers, the registry alone answered 13 of 48 questions. The Docker catalog raised it to 19, and the vendors’ own pages to 29. Sources disagreed on tools, and the vendor’s list won.
- Each tool was marked read, write, run-any or unknown. Run-any tools, hidden tools and tools that call their own model were held back.
- The decisions: Stripe refused (payment data), Shippo waits (no tool list). Sentry is registered with 10 read tools and Notion with 2, each with conditions and a signature.
- The review found three gaps in the platform’s own controls. The payment rule skipped tool servers (now fixed in the course project), tool names can have hyphens, and the tool gateway cannot reach hosted servers.
Next, the final assignment: bring Larkfield’s whole estate under governance, during a replayed month with an outage, a remap request and a runaway agent.
Next: Final assignment