# AI Tooling Capability Union (`cynix_dev/ai-tooling-capability-union`) Actor

One normalized dataset for everything an AI agent can call right now: the canonical MCP server registry AND the OpenRouter model catalog, merged under a shared capability taxonomy. Query across both layers by task or capability. Keyless, no proxy.

- **URL**: https://apify.com/cynix\_dev/ai-tooling-capability-union.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

## AI Tooling Capability Union

The "what can my agent call right now" feed. One actor that merges the **canonical MCP server registry** and the **OpenRouter model catalog** into a single normalized dataset under a shared capability taxonomy — so an agent (or a human) can ask one question and get the servers *and* the models that satisfy it, cross-layer.

This is the Tier-3 play: Tier 1 indexed the MCP registry with an agentic matcher; Tier 2 indexed OpenRouter models with change detection. The Union is the novel combination — a single queryable surface over both tool layers, plus a per-capability coverage index that tells an agent exactly what tool surface is available.

### What it does

1. **Fetches both layers** — MCP servers from `registry.modelcontextprotocol.io` (cursor-paginated, deduped by name) and models from `openrouter.ai/api/v1/models` (keyless JSON, 422+ models).
2. **Normalizes** each into one record shape with a shared `capabilities` tag set: `name`, `id`, `description`, `capabilities`, `transport`, `remote_url`, `context_length`, `prompt_price_per_mtok`, `reasoning`, `ref_url`.
3. **Matches** an optional plain-English `taskQuery` across *both* layers using the same intent-aware scoring — a vision model that can call a web-search tool surfaces both the model and the server.
4. **Emits a capability index** — per capability tag, how many MCP servers vs models support it. One row that tells an agent exactly what tool surface is available right now.

### Input example

```json
{
  "taskQuery": "a vision model that can call a web search tool",
  "capabilities": [],
  "includeMcp": true,
  "includeModels": true,
  "maxMcpServers": 300,
  "minMatchScore": 15,
  "capabilityIndex": true
}
```

### Output example (match records, one per layer)

```json
{
  "kind": "match",
  "layer": "mcp",
  "name": "ai.exa/exa",
  "id": "ai.exa/exa",
  "description": "Search the web with embeddings. The Exa MCP server exposes web search as a tool.",
  "capabilities": ["web", "code"],
  "transport": "streamable-http",
  "remote_url": "https://mcp.exa.ai/mcp",
  "context_length": 0,
  "prompt_price_per_mtok": 0,
  "reasoning": false,
  "match_score": 100,
  "matched_on": ["web"],
  "ref_url": "https://registry.modelcontextprotocol.io/ai.exa/exa"
}
```

```json
{
  "kind": "match",
  "layer": "model",
  "name": "Nex AGI: Nex-N2-Mini",
  "id": "nex-agi/nex-n2-mini",
  "description": "A multimodal reasoning model with image understanding.",
  "capabilities": ["reasoning", "function_calling", "json_mode", "vision"],
  "transport": "api",
  "remote_url": "",
  "context_length": 262144,
  "prompt_price_per_mtok": 0.12,
  "reasoning": true,
  "match_score": 100,
  "matched_on": ["vision"],
  "ref_url": "https://openrouter.ai/models/nex-agi/nex-n2-mini"
}
```

Output example (capability index record):

```json
{
  "kind": "capability_index",
  "layer": "index",
  "name": "Capability coverage",
  "description": "Union of 302 MCP servers and 422 models.",
  "coverage": { "vision": { "mcp": 5, "model": 59 }, "web_search_model": { "mcp": 0, "model": 0 } }
}
```

A real run returned **302 MCP servers + 422 models** merged, with **536** cross-layer task matches. The capability index showed `vision: mcp=5, model=59`.

### How to use

1. Open the Actor and paste the JSON input (or use the form fields).
2. Set `taskQuery` to a cross-layer task, or leave it empty to return the full union.
3. Use `capabilities` to hard-filter (AND), or `includeMcp` / `includeModels` to narrow a layer.
4. Click **Start**. Records appear in the default dataset.

### Source notes

OpenRouter's public API does **not** expose modality flags for most models (0/422 carry an `image` modality), so model vision/audio caps are derived from description text — the same way MCP server tags are. The shared taxonomy normalizes `image`→`vision` so a `vision` filter hits both layers. MCP pagination is cursor-based (`?cursor=`); `?offset=` is ignored.

### Pricing

Pay-per-event: a small per-run start fee plus a per-record item fee. Both sources are public keyless JSON — no proxy, no per-call API cost. See the Actor's pricing tab for the current rate.

### Compliance

Reads only publicly published registry/model metadata. No personal data, no login, no platform ToS conflict.

### Support

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

# Actor input Schema

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

Optional plain-English task to match across BOTH layers (MCP servers and models), e.g. 'a vision model that can call a web search tool'. Leave empty to return the full union.

## `capabilities` (type: `array`):

Optional shared capability filter (AND). One or more of: web, search, vision, image, audio, video, api, file, database, email, github, slack, calendar, memory, browser, code, cloud, notification, analytics, reasoning, function\_calling, json\_mode, web\_search, sheet, google. Empty = all.

## `includeMcp` (type: `boolean`):

Include MCP servers from the canonical registry.

## `includeModels` (type: `boolean`):

Include models from the OpenRouter catalog.

## `maxMcpServers` (type: `integer`):

Cap on MCP servers fetched from the registry (the registry is large; full crawl needs a long run timeout). Default 100 keeps requests snappy; 0 = fetch all.

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

For task matching: only push records scoring at or above this threshold (0-100).

## `capabilityIndex` (type: `boolean`):

Emit a 'capability\_index' summary record: per capability tag, how many MCP servers vs models support it. Gives an agent a one-row map of the available tool surface.

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

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

## Actor input object example

```json
{
  "includeMcp": true,
  "includeModels": true,
  "maxMcpServers": 100,
  "minMatchScore": 15,
  "capabilityIndex": true,
  "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/ai-tooling-capability-union").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/ai-tooling-capability-union").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/ai-tooling-capability-union --silent --output-dataset

```

## MCP server setup

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

```

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/tVmzH9lZxl8PrUaOq/builds/LbLnRCxXpAecdJhYA/openapi.json