MCP Server Publishing: Get Found, Not Just Approved
Getting it found is where people quietly lose: a server can be approved by a catalog, have its own page, and still match no search query at all.
Free
Works with the AI Agents you already use
MCP Server Publishing: Get Found, Not Just Approved
Example session with this skill installed
I finished an MCP server for the Notion API — it's a folder inside my tools monorepo and it works in Claude Code. I want it in the Glama catalog and the official MCP registry so other people can actually find it. Where do I start?
- Read your context and instructions
- Compiled the mcp server publishing
Summary
Two things decide whether anyone finds this server, and neither is on the registry's checklist: it has to live in its own repository, and it has to start
without a Notion token. Everything else is metadata. Here is the order, and what I changed.
1. Out of the monorepo, with its history
git subtree split -P servers/notion -b split-notion-mcp
Heads up: git subtree does not follow renames. servers/notion was notion/ until last March, so commits before that rename will not come across. Name the new repository notion-mcp — the provider plus mcp is what people type into catalog search.
2. The change that actually matters
Your index.ts reads NOTION_TOKEN at module load and calls process.exit(1) when it is missing. Catalogs discover your tools by
running the server: initialize, then tools/list. With that exit, inspection fails, the listing shows no tools, and the server never appears in search results.
// before — dies during inspection
const token = process.env.NOTION_TOKEN;
if (!token) process.exit(1);
// after — starts, lists tools, fails only when actually used
function notionToken(): string {
const token = process.env.NOTION_TOKEN;
if (!token) throw new Error("NOTION_TOKEN is not set");
return token;
}
Verified the way the catalog will: started it with the variable absent and sent initialize and tools/list. Both answer; all six tools come back. Two of them had no description — added, since undescribed tools drag the quality score down.
3. Repository files
| File | Change | Why |
|---|---|---|
LICENSE | MIT added | Without one it is formally "all rights reserved" and nobody may use it |
package.json | Removed "private": true | It blocks npm publish, which step 6 needs |
package.json | Added mcpName: "io.github.yourlogin/notion-mcp" | The official registry requires it, and it must match server.json |
package.json | Filled repository, homepage, bugs, engines, keywords | This is what npm and the catalogs index |
README.md | Four relative links repointed at absolute URLs | They pointed at monorepo siblings that no longer exist |
README.md is what the catalog renders as your card, so that file is your listing.
4. glama.json
{
"$schema": "https://glama.ai/mcp/schemas/server.json",
"maintainers": ["yourlogin"]
}
The schema knows only maintainers — there is no description or category field to fill. It exists so you can claim the listing. If you edit this file later, the claim has to be made again; the catalog will not notice on its own.
5. Dockerfile
Written to the repository root. The catalog's security and quality checks build from it, and
only servers that pass them show up in search. It gets pasted into the admin UI as well — the catalog does not read it from your repo.
Your turn — the web UI, in one sitting
- Sign in to glama.ai with GitHub, so your login matches
maintainers. - Add Server, paste the repository URL (otherwise you wait for the crawler).
- Wait for the approval mail — usually minutes.
- On the server page: Admin → Claim, then Admin → Dockerfile, paste the file.
Then give it an hour. Not graded straight after approval is normal; still Not graded a day later means the image build is failing, and Admin will say why.
Afterwards, in this order
awesome-mcp-servers — a one-line PR, but their rules want a Glama quality badge, so it comes after the catalog.
npm — the official registry stores metadata only, the package itself must live somewhere.
The official registry — server.json plus the mcp-publisher CLI; the name must start with io.github.yourlogin/, the description must be 100 characters or shorter, and the tag must be semver (v1.0.0), or publishing fails validation.
Want me to draft the server.json and the registry description now, so it is under the limit before you tag a release?
Connects securely to your tools. The creator never sees your data.
About this skill
Building an MCP server is the easy half. Getting it found is where people quietly lose: a server can be approved by a catalog, have its own page, and still match no search query at all.
This skill is that publishing path, in the order the steps actually depend on each other. It was written from servers that went through it, not from documentation.
The rule that breaks most listings
A catalog works out what your server can do by running it: initialize, then tools/list. A server that demands an API key at startup exits, inspection fails, no tools are extracted, and it never enters search results — however good it is. The fix is to read credentials lazily, inside the tool call, so the server still starts and returns an honest tool list without them.
That one requirement is documented nowhere, and it is the reason most "approved but invisible" servers stay invisible.
What it covers
| Step | What the agent does with you |
|---|---|
| Prior art | Checks the catalogs before you spend an evening rebuilding something that exists |
| Repository | LICENSE, removing "private": true, mcpName as io.github.<login>/<name>, the metadata npm and catalogs index, and why README.md is your catalog card |
| Extraction | git subtree split out of a monorepo, with the caveat that it does not follow renames |
| Startup | Lazy credentials, plus a tool description on every tool so the quality score survives |
| Dockerfile | The file the catalog's security and quality checks build from — and those checks gate search visibility |
| glama.json | The two-line file that lets you claim the listing, and the claim you must redo after every edit |
| By hand | The web-UI steps no API exposes, handed over as one list instead of one click at a time |
| Afterwards | awesome-mcp-servers (needs a Glama badge first), npm or PyPI, then the official registry — 100-character description limit, semantic version tags |
How to read what comes back
Not graded an hour after approval is normal; a day later means the image build is failing. "Tools not extracted" is not "no tools" — it usually means the Dockerfile checks have not run yet, or that the server never started without a key. Attributes like hosting:local-only are plumbing, and the topical categories you see on the site do not exist in the API, so nobody can promise you one.
Pitfalls it names outright
Approved but never returned by search. npm publish refusing because private is still set. README links pointing nowhere after extraction. A claim that silently stops applying. A release the registry rejects over a non-semver tag or a description one character too long. A catalog card rendered in the wrong language because the card reads README.md, not README.en.md.
Who it is for
Anyone who has written an MCP server in any language and wants it installed by people who have never heard of them. It is agent-agnostic: the steps are the same in Claude Code, Cursor, Codex CLI or a plain terminal.
What it will not do
It will not publish for you. Registering the server, claiming the listing and pasting the Dockerfile happen in a web UI, by a human — the skill tells your agent to hand you that list in one piece, with nothing invented in between. It also will not write your server, and it does not promise a quality score: it removes the reasons you would not get one.
This is knowledge, not automation. Registering a server, claiming the listing and pasting the Dockerfile happen by hand in the catalog's web UI, and approval times and quality scores are the catalog's call, not the skill's. It also will not write your MCP server or review its code - it prepares what is around the code so the server can be found.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Free forever
No account required to browse
Trust & safety
Security scan
Security scan passed 2 days ago
- Free with an Agensi account
Requires
Permissions
File Scopes
The skill only touches publication metadata in your own repository - package.json, README, Dockerfile, glama.json, server.json, LICENSE - and runs the git, npm and docker commands you approve. Network access is for catalog lookups and publishing. It never reads your credentials: its advice is to keep them out of the client config and pass them as environment variables at launch.