MCP Server Publishing: Get Found, Not Just Approved

    1

    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

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    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

    FileChangeWhy
    LICENSEMIT addedWithout one it is formally "all rights reserved" and nobody may use it
    package.jsonRemoved "private": trueIt blocks npm publish, which step 6 needs
    package.jsonAdded mcpName: "io.github.yourlogin/notion-mcp"The official registry requires it, and it must match server.json
    package.jsonFilled repository, homepage, bugs, engines, keywordsThis is what npm and the catalogs index
    README.mdFour relative links repointed at absolute URLsThey 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

    1. Sign in to glama.ai with GitHub, so your login matches maintainers.
    2. Add Server, paste the repository URL (otherwise you wait for the crawler).
    3. Wait for the approval mail — usually minutes.
    4. 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?

    4. glama.json

    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

    StepWhat the agent does with you
    Prior artChecks the catalogs before you spend an evening rebuilding something that exists
    RepositoryLICENSE, removing "private": true, mcpName as io.github.<login>/<name>, the metadata npm and catalogs index, and why README.md is your catalog card
    Extractiongit subtree split out of a monorepo, with the caveat that it does not follow renames
    StartupLazy credentials, plus a tool description on every tool so the quality score survives
    DockerfileThe file the catalog's security and quality checks build from — and those checks gate search visibility
    glama.jsonThe two-line file that lets you claim the listing, and the claim you must redo after every edit
    By handThe web-UI steps no API exposes, handed over as one list instead of one click at a time
    Afterwardsawesome-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.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

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

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    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 to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    • Free with an Agensi account

    Accounts
    GitHub account
    Software
    An MCP server you wrote, in any languageGit on your machineAwesome Servers MCP
    Optional
    npm
    orPyPI account (official registry step)
    Docker (only to test the container locally)

    Four steps happen in the catalog's web UI and cannot be automated: registering the server, waiting for approval, claiming the listing and pasting the Dockerfile. The skill hands you that list in one piece instead of one click at a time.

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    File Scopes

    package.json
    README*.md
    glama.json
    server.json
    Dockerfile
    LICENSE

    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.

    Listed2 days ago

    What's inside

    Frequently Asked Questions

    Pushing to GitHub makes the code public, not findable. Catalogs list what they can inspect and build, and most servers fail that inspection for one reason nobody documents: they exit at startup without an API key. This skill covers what decides whether yours is inspected at all, and the order the steps have to happen in.

    The Glama catalog, npm or PyPI, awesome-mcp-servers and the official MCP registry, in that order, with the reason each one depends on the previous. It is language-agnostic: the requirements are about how your server starts and what metadata it carries, not what it is written in.

    Yes. It covers extracting the folder into its own repository with git subtree split while keeping the history, warns that commits from before a folder rename will not come across, and catches the relative README links that quietly break after the move.

    One SKILL.md, free, that your agent loads when you ask about publishing an MCP server: the ordered path from repository to registry, the file checklists, the startup rule that decides search visibility, a table of symptoms and their causes, and the handful of steps you have to do yourself in a browser.

    Four steps are: registering the server, waiting for the approval mail, claiming the listing and pasting the Dockerfile into the admin UI. No API exposes them, so the skill hands you all four at once instead of pretending to automate them.

    New in LLM Ops

    Free