# MCP Registry Indexer + Capability Matcher (`cynix_dev/mcp-registry-indexer`) Actor

Indexes the canonical MCP registry into RAG-ready records and matches plain-English tasks to the servers that fulfill them. The only Apify actor on the protocol-maintained registry, with an agentic matcher + freshness monitor. Keyless, no proxy.

- **URL**: https://apify.com/cynix\_dev/mcp-registry-indexer.md
- **Developed by:** [Cynix Dev](https://apify.com/cynix_dev) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## MCP Registry Indexer + Capability Matcher

The only Apify actor built on the **canonical, protocol-maintained Model Context Protocol registry** — `registry.modelcontextprotocol.io` — instead of a third-party MCP directory. It turns the living MCP server catalog into clean, RAG-ready records and answers the question every AI-agent builder actually has: *"which MCP server does my agent need for this task?"*

### What it does

1. **Indexes** the full canonical registry into normalized records: server name, title, description, transport (`streamable-http` / `stdio` / `sse`), remote URL, protocol version, auth requirement, and derived capability tags.
2. **Matches** a free-text task (`taskQuery`) to servers using intent-aware synonym expansion (e.g. "search the web and write to a Google Sheet" expands to web/search/google/sheet tokens) and per-field scoring, so the strongest title/tag hits rank first.
3. **Monitors freshness** (optional) — stores a snapshot in the actor KV store and flags servers added or removed since the previous run, so you can detect registry drift or deprecated servers.

### Input example

```json
{
  "taskQuery": "search the web and write the result into a Google Sheet",
  "minMatchScore": 20,
  "includeCapabilities": true,
  "freshnessMonitor": true,
  "maxServers": 300
}
```

Leave `taskQuery` empty to index the whole registry without matching. `maxServers: 0` fetches every server (needs a long run timeout — the registry is large).

### Output example (match record)

```json
{
  "kind": "match",
  "server_name": "ai.exa/exa",
  "server_title": "Exa",
  "description": "Search the web with embeddings. The Exa MCP server exposes web search as a tool.",
  "transport": "streamable-http",
  "remote_url": "https://mcp.exa.ai/mcp",
  "protocol_version": "1.0.0",
  "auth": "unspecified",
  "tags": ["web", "search", "api"],
  "capabilities": ["web", "search", "api"],
  "tools": [],
  "match_score": 60,
  "matched_on": ["search", "web"],
  "registry_url": "https://registry.modelcontextprotocol.io/ai.exa/exa"
}
```

A real run against the live registry (capped at 300 servers) returned **282 unique servers** and **20 task matches**. Top hits for the query above: Exa web search (60), Google Search Console (60), Google News (40), Web Analytics (30). Index records carry `kind: "server"` with the same fields minus `match_score`/`matched_on`.

### How to use

1. Open the Actor and paste the JSON input (use the **Input** tab's JSON editor, or the form fields).
2. Set `taskQuery` to a plain-English task, or leave it empty to just index.
3. Turn on `freshnessMonitor` if you want drift detection between scheduled runs.
4. Click **Start**. Records appear in the default dataset — export to JSON, CSV, or pull via API.

### Source notes

The registry returns **one entry per version**, so a page of 100 entries holds ~68 unique servers — the Actor dedupes by `server.name`, keeping the entry flagged `isLatest`. Pagination is **cursor-based** via `metadata.nextCursor` passed as `?cursor=` (`?offset=` is ignored). Capabilities are derived from the server description (the registry does not expose a `tools` array); `auth` is reported as `unspecified` because the registry does not publish per-server auth requirements.

### Pricing

Pay-per-event (PPE): a small per-run start fee plus a per-record item fee. The source is public, keyless JSON — no proxy, no auth, no per-call API cost. See the Actor's pricing tab for the current rate.

### Compliance

Reads only publicly published registry metadata (server name, description, transport, tool list). No personal data, no login, no platform ToS conflict. For production agent connectivity, prefer the official registry over scraping any single vendor's site.

### Support

Found a bug or need a field added? Open an issue on the Actor's Issues tab.

# Actor input Schema

## `taskQuery` (type: `string`):

Plain-English task to match against MCP server capabilities, e.g. 'search the web and write the result to a Google Sheet'. Leave empty to index the full registry without matching.

## `maxServers` (type: `integer`):

Maximum number of servers to fetch from the registry (the registry is paginated; 0 = fetch all available). Default 100 keeps requests snappy; use 0 only if you need the complete registry and can wait several minutes.

## `minMatchScore` (type: `number`):

For task matching: only push servers with a match score at or above this threshold (0-100). Lower = more (noisier) matches.

## `includeCapabilities` (type: `boolean`):

Include the computed 'capabilities' and 'tools' arrays (enriched from description + tools list) on every record. Adds columns useful for RAG/agent pipelines.

## `freshnessMonitor` (type: `boolean`):

Emit a 'freshness' record comparing this run's server count and a content hash against the previous run (stored in the actor KV store) to detect registry drift / deprecated servers.

## `proxyConfiguration` (type: `object`):

Proxy configuration. Not required for this actor's keyless sources; left for parity.

## Actor input object example

```json
{
  "maxServers": 100,
  "minMatchScore": 20,
  "includeCapabilities": true,
  "freshnessMonitor": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped records

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cynix_dev/mcp-registry-indexer").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "proxyConfiguration": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("cynix_dev/mcp-registry-indexer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call cynix_dev/mcp-registry-indexer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cynix_dev/mcp-registry-indexer"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rpBPuO3XhxisAIXxz/builds/1wmhrmHFkYKUTLSCU/openapi.json