Koskamo

ManyCP MCP

An MCP server that automates the submission and synchronization of MCP server listings across dozens of directories, including the official registry, GitHub-based catalogs, and web forms, allowing agents to manage listings via tools like check_listings and submit_server.

Visit ManyCP

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

ManyCP MCP logo, by ManyCPCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-07Published by ManyCP
You need:Authorization: Bearer <key> — create a key at https://manycp.com/app/settingsThe free plan gets the read-only tools (list, check). Paid plans can also add, submit and sync.
MCP endpoint (Streamable HTTP)
https://manycp.com/mcp
Vendor documentation

What its tools do

8 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (4)

Can change data (4)

8 of 8 have a description · 8 of 8 declare behavior hints · 6 of 6 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Check which directories already list a public GitHub repo
  • Submit a new MCP server listing to all supported directories
  • Sync and update existing listings after a new release
  • List all directories and their submission methods

Source and maintenance

Community listingRegistry 1.0.0
mcp-registry: io.github.dayyad/manycp-mcp@1.0.0Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
manycp 1.0.0
MCP protocol negotiated in check
2025-11-25
Tools
8 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Connect ManyCP first: create an API key at https://manycp.com/app/settings and send it as 'Authorization: Bearer <key>'. Until then every tool call answers with this same sentence. ManyCP files a developer's MCP server in every MCP directory and keeps each listing current. It knows 26 directories: 1 direct publish (the official MCP Registry), 11 auto pull request, 1 auto-indexed, 13 assisted (ManyCP prepares every field, a person sends it). Usual path: 1. check_listings {repo_url} shows where a public GitHub repo is already listed. No plan needed. 2. add_server {repo_url} reads the repo and saves a draft listing. 3. get_server {server} shows the listing and the status in each directory. update_listing fixes wording. 4. submit_server {server} files it. Pull requests come from the user's own GitHub account and say they were sent with ManyCP. 5. sync_server {server} re-reads the repo after a release and marks stale listings. Rules: - Never say a listing is live until get_server shows the status live. ManyCP checks before it says so. - ManyCP only opens pull requests for repos the user owns, at most one per repo per directory. - No API key was sent. Read tools (list_directories, list_servers, get_server, check_listings) work on every plan once a key is connected. add_server, update_listing, submit_server, sync_server need a launch credit ($19, once), Starter or Pro. - A tool that cannot finish returns isError true with the next step in plain words. Show that step to the user. - Ask the user before you set consent_star to true.

Tools

8 advertised

list_directories — List MCP directories
Advertised by the server during the last successful anonymous check.
Advertised read-only

List every MCP directory ManyCP can file a server in (26 today). For each one you get: its id (pass ids to submit_server), name and URL, how ManyCP files it (Direct publish, Auto PR, Auto-indexed or Assisted), whether it fits local servers, remote servers or both, whether it must wait for another directory, and what ManyCP does step by step. Read-only, takes no input, works on every plan. Use it to answer 'where can I list my MCP server?' or to pick directory ids for submit_server.

list_directories input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
list_directories annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
list_servers — List my servers
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the MCP servers on this ManyCP account. Each comes with its id and slug (every other tool takes either one as `server`), its repo and version, and a one-line status across the directories that fit it, for example '3 live, 1 PR open, 16 not started'. Read-only, works on every plan. Call this first when the user says 'my server' and you do not know which one they mean. Use get_server for the detail of one.

list_servers input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
list_servers annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
add_server — Add a server from GitHub
Advertised by the server during the last successful anonymous check.
Open-world

Add an MCP server to ManyCP from its public GitHub repo. ManyCP reads the repo (README, package.json or pyproject.toml, server.json, Dockerfile), finds npm, PyPI, Docker and remote endpoints, writes a draft listing (title, short description, categories, tags, tools, install config), saves it, and returns the listing, any warnings, and the plan for every directory that fits. It does not submit anywhere: review the listing, fix it with update_listing, then call submit_server. Adding a repo that is already added is an error that names the existing server. Needs a launch credit ($19 per server, once), Starter (3 servers) or Pro (unlimited).

add_server input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "repo_url"
  ],
  "properties": {
    "repo_url": {
      "type": "string",
      "maxLength": 300,
      "minLength": 3,
      "description": "The public GitHub repo: https://github.com/owner/name, or just owner/name."
    }
  }
}
add_server annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
get_server — Get a server and its listings
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get one server's full listing and its status in every directory that fits it. Status is one of: live (ManyCP confirmed the listing exists), pr_open (a pull request is waiting on maintainers), submitted (sent, waiting), in_progress, queued, needs_update (the listing is behind the latest version), action_required (the user must do something, the reason is included), rejected, skipped, or not_started. Also returns links: pull requests, live listing pages, the dashboard page. Read-only, works on every plan. `server` accepts an id, a slug, a GitHub repo, or the exact name.

get_server input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "server"
  ],
  "properties": {
    "server": {
      "type": "string",
      "maxLength": 300,
      "minLength": 1,
      "description": "Which server: its id (srv_...), its slug, its GitHub repo (https://github.com/owner/name or owner/name), or its exact name. list_servers shows them all."
    }
  }
}
get_server annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
update_listing — Edit a listing
Advertised by the server during the last successful anonymous check.

Edit the listing ManyCP sends to every directory. Send only the fields you want to change; the rest stay as they are. Fields: title (max 100 characters), short_description (max 100 characters, because the official MCP Registry rejects longer), description (long text, Markdown is fine), categories (up to 5 ids), tags (up to 15, lowercase words), tools (the FULL list of {name, description}, it replaces the old list), homepage_url (an empty string clears it). Saves at once. Directories that already list the server keep their current text until the next sync or submit. Version, packages and repo come from GitHub and cannot be edited here. Needs a launch credit, Starter or Pro.

update_listing input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "server"
  ],
  "properties": {
    "tags": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 40,
        "minLength": 1
      },
      "maxItems": 15,
      "description": "Up to 15 short lowercase tags, like 'weather' or 'postgres'. Replaces the current tags."
    },
    "title": {
      "type": "string",
      "maxLength": 100,
      "description": "Display name, max 100 characters. Empty string clears it."
    },
    "tools": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name",
          "description"
        ],
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 100,
            "minLength": 1,
            "description": "The tool's name exactly as the server exposes it."
          },
          "description": {
            "type": "string",
            "maxLength": 500,
            "description": "What the tool does, one or two sentences."
          }
        }
      },
      "maxItems": 100,
      "description": "The complete list of tools. It replaces the current list, so include the ones that stay."
    },
    "server": {
      "type": "string",
      "maxLength": 300,
      "minLength": 1,
      "description": "Which server: its id (srv_...), its slug, its GitHub repo (https://github.com/owner/name or owner/name), or its exact name. list_servers shows them all."
    },
    "categories": {
      "type": "array",
      "items": {
        "enum": [
          "aggregators",
          "browser-automation",
          "cloud-platforms",
          "code-execution",
          "communication",
          "databases",
          "data-science",
          "developer-tools",
          "file-systems",
          "finance",
          "knowledge-memory",
          "location",
          "marketing",
          "monitoring",
          "productivity",
          "research",
          "search",
          "security",
          "social-media",
          "version-control",
          "other"
        ],
        "type": "string"
      },
      "maxItems": 5,
      "description": "Up to 5 category ids. Replaces the current categories."
    },
    "description": {
      "type": "string",
      "maxLength": 5000,
      "description": "The long description, max 5000 characters. Markdown is fine."
    },
    "homepage_url": {
      "type": "string",
      "maxLength": 300,
      "description": "A full http(s) URL. Empty string clears it."
    },
    "short_description": {
      "type": "string",
      "maxLength": 100,
      "description": "One plain sentence, max 100 characters. Say what it does and for whom. Empty string clears it."
    }
  }
}
update_listing annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
check_listings — Check where a repo is listed
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Check which MCP directories already list a public GitHub repo. 10 of the 26 directories have a public lookup, so those come back listed or missing (with the listing URL when listed) and the rest come back unknown. No login and no ManyCP server needed, works on every plan and on repos you do not own. Results are cached for about 10 minutes. Use it before add_server to show the gap, or after submit_server to see what went live.

check_listings input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "repo_url"
  ],
  "properties": {
    "repo_url": {
      "type": "string",
      "maxLength": 300,
      "minLength": 3,
      "description": "The public GitHub repo: https://github.com/owner/name, or just owner/name."
    }
  }
}
check_listings annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
submit_server — Submit a server to directories
Advertised by the server during the last successful anonymous check.
Open-world

File a saved server in MCP directories. Per directory the result says what happened. Direct publish (the official MCP Registry) publishes for real. Auto PR forks the target repo and opens a pull request from the user's GitHub account. Auto-indexed just waits for its source. Assisted directories get every field prepared plus a link, and a person finishes them (on Pro, ManyCP staff can). Leave `directories` out to send to every directory that fits and is ready, or pass ids from list_directories to pick some. ManyCP opens at most one pull request per repo per directory, so repeating the call is safe. A directory is only called live after ManyCP confirms it. The first submit of a server takes one launch credit ($19, bought once) unless a subscription covers it. Before the directories, ManyCP also opens ONE pull request on the user's own repo (never a fork) with the files directories look for: .mcp.json, glama.json, gemini-extension.json, server.json and the mcpName marker. cursor.directory, Glama and the Gemini CLI gallery wait until the user merges it, and the result says so. If the user has not allowed pull requests yet, the result is an error with a link they open once to grant GitHub access, then you call this again. Set consent_star to true only after the user agrees to let ManyCP star punkpeye/awesome-remote-mcp-servers on their GitHub account, because that list rejects pull requests from accounts that have not starred it.

submit_server input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "server"
  ],
  "properties": {
    "server": {
      "type": "string",
      "maxLength": 300,
      "minLength": 1,
      "description": "Which server: its id (srv_...), its slug, its GitHub repo (https://github.com/owner/name or owner/name), or its exact name. list_servers shows them all."
    },
    "directories": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 80,
        "minLength": 1
      },
      "maxItems": 60,
      "description": "Directory ids from list_directories, like 'official-mcp-registry'. Omit to send to every directory that fits and is ready."
    },
    "consent_star": {
      "type": "boolean",
      "description": "True only if the user said yes to ManyCP starring punkpeye/awesome-remote-mcp-servers for them. Default false."
    }
  }
}
submit_server annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
sync_server — Sync a server with GitHub
Advertised by the server during the last successful anonymous check.
Open-world

Re-read a server's GitHub repo right now: latest release or tag, package version, README, description, topics. If the version or listing changed, ManyCP updates the saved listing, marks directories that list an older version as needs_update, and starts update runs where a directory supports it (the official registry gets the new version; pull-request directories get an update PR only when the entry text changed). If nothing changed it says so. Paid plans also sync on their own (Pro every hour, Starter every day), so use this to sync now, for example right after a release. Needs a launched server or a paid plan.

sync_server input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "server"
  ],
  "properties": {
    "server": {
      "type": "string",
      "maxLength": 300,
      "minLength": 1,
      "description": "Which server: its id (srv_...), its slug, its GitHub repo (https://github.com/owner/name or owner/name), or its exact name. list_servers shows them all."
    }
  }
}
sync_server annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
820 ms
95th percentile latency
820 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 820 ms · metadata changed · 8 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http manycp-mcp https://manycp.com/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add manycp-mcp --url https://manycp.com/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable manycp-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "manycp-mcp": {
      "url": "https://manycp.com/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "manycp-mcp": {
      "type": "streamableHttp",
      "url": "https://manycp.com/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start manycp-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "manycp-mcp": {
      "type": "http",
      "url": "https://manycp.com/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http manycp-mcp https://manycp.com/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://manycp.com/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "manycp-mcp": {
      "serverUrl": "https://manycp.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like ManyCP MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 8,313