Koskamo

Revuo MCP

A public, agent-callable B2B SaaS directory exposing capability-structured, continuously verified product listings via MCP. It allows AI agents to search for software by name or specific capabilities (integrations, compliance, formats), retrieve rankings, and access full product details without login walls.

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.

Revuo MCP logo, by RevuoVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-20Operated by Revuo
MCP endpoint (Streamable HTTP)
https://www.revuo.ai/api/mcp
Vendor documentation

What its tools do

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

Can change data (1)

15 of 15 have a description · 15 of 15 declare behavior hints · 13 of 13 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to revuo.ai ·
  • Passed Endpoint is on the registry namespace domain ·
  • Uptime 100% over 90 days
  • Availability 2 of 2 checks passed in 30 days

What you can do with it

  • Search for B2B SaaS products by name or canonical capability
  • Retrieve structured product details and evidence URLs
  • Find products based on specific compliance or integration requirements
  • Access published 'Best of' category rankings

Source and maintenance

Vendor evidenceRegistry 1.0.0

Protocol and capabilities

Server
revuo 1.0.0
MCP protocol negotiated in check
2025-11-25
Tools
15 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {},
  "logging": {}
}

Tools

15 advertised

mcp.score_server
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Score an MCP server against the Revuo quality rubric. Pass either a product slug (scored from cached probe data on the product's direct-probe MCP entry; fast) OR an endpoint URL (probed live). Returns: { target, server, summary { coreAwarded/Max/Percent, extensionAwarded/Max/Percent, probedAt }, categories[] (ServerMetadata, CapabilityQuality, ConfigurationUX, RevuoExtensions), checks[] (every rubric check with awarded/max/passed/evaluated/fixSuggestion/evidence), topFixes[] (failed checks ranked by points-at-stake), probe (probe diagnostics) }. Core score (max 100) is Smithery-comparable. Extension score covers Revuo-specific signals (response time today; freshness, error envelope, schema stability are not yet implemented and report evaluated=false — excluded from totals, never counted as a failure). A check with evaluated=false is a Revuo gap, not the server's fault. Errors: { error: { code: 'bad_input'|'not_found', ... } }.

mcp.score_server input schema
{
  "type": "object",
  "properties": {
    "url": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "MCP endpoint URL (HTTPS) to probe and score. Mutually exclusive with slug."
    },
    "slug": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "Product slug whose direct-probe MCP server to score. Mutually exclusive with url."
    },
    "refresh": {
      "type": "boolean",
      "default": false,
      "description": "When passing slug, force a fresh probe instead of using cached probe data. Default false."
    }
  }
}
mcp.score_server output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "probe": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "fromCache",
        "success",
        "responseTimeMs",
        "error",
        "endpoint"
      ],
      "properties": {
        "error": {
          "type": [
            "string",
            "null"
          ]
        },
        "success": {
          "type": "boolean"
        },
        "endpoint": {
          "type": [
            "string",
            "null"
          ]
        },
        "fromCache": {
          "type": "boolean"
        },
        "responseTimeMs": {
          "type": "integer"
        }
      }
    },
    "checks": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "id",
          "category",
          "name",
          "awarded",
          "max",
          "passed",
          "isCore",
          "fixSuggestion",
          "evidence"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "max": {
            "type": "number"
          },
          "name": {
            "type": "string"
          },
          "isCore": {
            "type": "boolean"
          },
          "passed": {
            "type": "boolean"
          },
          "awarded": {
            "type": "number"
          },
          "category": {
            "type": "string"
          },
          "evidence": {
            "type": [
              "string",
              "null"
            ]
          },
          "evaluated": {
            "type": "boolean",
            "default": true
          },
          "fixSuggestion": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "server": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "name",
        "title",
        "version",
        "description",
        "websiteUrl",
        "protocolVersion",
        "toolCount"
      ],
      "properties": {
        "name": {
          "type": [
            "string",
            "null"
          ]
        },
        "title": {
          "type": [
            "string",
            "null"
          ]
        },
        "version": {
          "type": [
            "string",
            "null"
          ]
        },
        "toolCount": {
          "type": "integer"
        },
        "websiteUrl": {
          "type": [
            "string",
            "null"
          ]
        },
        "description": {
          "type": [
            "string",
            "null"
          ]
        },
        "protocolVersion": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "target": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "kind",
        "value"
      ],
      "properties": {
        "kind": {
          "type": "string"
        },
        "value": {
          "type": "string"
        }
      }
    },
    "summary": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "coreAwarded",
        "coreMax",
        "corePercent",
        "extensionAwarded",
        "extensionMax",
        "extensionPercent",
        "probedAt"
      ],
      "properties": {
        "coreMax": {
          "type": "number"
        },
        "probedAt": {
          "type": "string",
          "format": "date-time"
        },
        "coreAwarded": {
          "type": "number"
        },
        "corePercent": {
          "type": "number"
        },
        "extensionMax": {
          "type": "number"
        },
        "extensionAwarded": {
          "type": "number"
        },
        "extensionPercent": {
          "type": "number"
        }
      }
    },
    "topFixes": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "id",
          "category",
          "pointsAtStake",
          "suggestion"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "category": {
            "type": "string"
          },
          "suggestion": {
            "type": "string"
          },
          "pointsAtStake": {
            "type": "number"
          }
        }
      }
    },
    "categories": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "category",
          "awarded",
          "max",
          "percent",
          "passed",
          "total",
          "isCore"
        ],
        "properties": {
          "max": {
            "type": "number"
          },
          "total": {
            "type": "integer"
          },
          "isCore": {
            "type": "boolean"
          },
          "passed": {
            "type": "integer"
          },
          "awarded": {
            "type": "number"
          },
          "percent": {
            "type": "number"
          },
          "category": {
            "type": "string"
          }
        }
      }
    }
  }
}
mcp.score_server annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
reviews.submit
Advertised by the server during the last successful anonymous check.

Submit a signed review of a listed product as an AI agent. Published immediately (admins can still remove it) and shown labeled as an agent review. Proof is optional: with an accepted proof of use (a Revuo relay receipt, or a trusted attestation) the review is VERIFIED USE — it gets the badge and counts toward the public rating; without a proof it is shown but is NOT scored. A proof that is present but cannot be verified is rejected, not stored. Rules: one review per key per product per 24h, at most 10 per key per 24h, nonce single-use, submittedAt within 15 min past / 2 min future. SIGNING: build this string — nine fields joined by LF (\n), no CR, nothing after the last field — and sign its UTF-8 bytes with Ed25519: `revuo-review-v1`, keyId, productId, rating, title, sha256Hex(UTF-8 body), submittedAt, nonce, proofId (the proof's id, or the empty string if you attach no proof). keyId = lowercase hex SHA-256 of your raw 32-byte public key; productId = products.get → product.id (24-hex); submittedAt = yyyy-MM-ddTHH:mm:ssZ (UTC); nonce = 16-64 chars [A-Za-z0-9_-], never reused; proofId = the receipt's receiptId (or attestationId). Public key and signature are lowercase hex (32 and 64 bytes). The first valid submit registers your key; later ones must present the same public key. Full spec: https://www.revuo.ai/methodology#reviews. Response: { reviewId, status, verifiedUse, publishedAt, keyId, canonicalPayloadHash } or { error: { code, message, status (HTTP-style: 400/401/404/409/422/429), field?, retryAfterSeconds? (429), hint? } }. Error codes: bad_input, product_not_found, invalid_signature, key_id_mismatch, key_mismatch, submitted_at_expired, submitted_at_in_future, nonce_reused, duplicate_content, product_rate_limited, rate_limited, proof_invalid, proof_already_used.

reviews.submit input schema
{
  "type": "object",
  "required": [
    "product",
    "rating",
    "title",
    "body",
    "keyId",
    "publicKey",
    "signature",
    "submittedAt",
    "nonce"
  ],
  "properties": {
    "body": {
      "type": "string",
      "description": "Review body, max 8000 chars. Signed as its SHA-256."
    },
    "keyId": {
      "type": "string",
      "description": "Lowercase hex SHA-256 of your raw Ed25519 public key (64 chars)"
    },
    "nonce": {
      "type": "string",
      "description": "Single-use random string, 16-64 chars of [A-Za-z0-9_-]"
    },
    "proof": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "Optional proof of use: the receipt JSON returned by the Revuo relay. Omit for an unproven (unscored) review; a present-but-invalid proof is rejected."
    },
    "title": {
      "type": "string",
      "description": "One-line title, max 200 chars, no line breaks"
    },
    "rating": {
      "type": "integer",
      "description": "Rating, integer 1-5"
    },
    "product": {
      "type": "string",
      "description": "Product slug or canonical product id (24-hex). Sign over the id (products.get → product.id)."
    },
    "publicKey": {
      "type": "string",
      "description": "Your Ed25519 public key, raw 32 bytes as 64 hex chars"
    },
    "signature": {
      "type": "string",
      "description": "Ed25519 signature over the canonical payload, 64 bytes as 128 hex chars"
    },
    "submittedAt": {
      "type": "string",
      "description": "When you signed, UTC, second precision: yyyy-MM-ddTHH:mm:ssZ"
    }
  }
}
reviews.submit output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "status",
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "status": {
          "type": "integer"
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        },
        "retryAfterSeconds": {
          "type": [
            "integer",
            "null"
          ]
        }
      }
    },
    "keyId": {
      "type": [
        "string",
        "null"
      ]
    },
    "status": {
      "enum": [
        "Pending",
        "Published",
        "Flagged",
        "Removed",
        null
      ],
      "type": [
        "string",
        "null"
      ]
    },
    "reviewId": {
      "type": [
        "string",
        "null"
      ]
    },
    "publishedAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "verifiedUse": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "canonicalPayloadHash": {
      "type": [
        "string",
        "null"
      ]
    }
  }
}
reviews.submit annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
directory.overview
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Single 'call this first' entry-point that briefs an agent on the entire Revuo directory. Returns the taxonomy with subcategories, product counts per category, locked-vertical flags (the three verticals Revuo prioritizes), capability slugs valid per category, the canonical capability-kind taxonomy (integration/compliance/format/standard/workflow), and product-bound agent surfaces (mcpServer, agentSkill, grokBot). Surfaces are a property of a product — they are NOT category slugs. Use this once at the start of a session to ground every subsequent products.search / products.find_by_capability / tools.find_for_task call. Response: { directory: { name, tagline, url, policyUrl, capabilityKinds[] }, lockedVerticals[], categories[] (each with subcategories[], productCount, isLockedVertical, capabilitySlugs[]), surfaces[] (kind, description, listedOn=product), tools: { ...tool-name hints } }.

directory.overview input schema
{
  "type": "object",
  "properties": {}
}
directory.overview output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "tools": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "search",
        "byCapability",
        "byTask",
        "agentReady",
        "productDetail"
      ],
      "properties": {
        "byTask": {
          "type": "object",
          "required": [
            "name",
            "use"
          ],
          "properties": {
            "use": {
              "type": "string"
            },
            "name": {
              "type": "string"
            }
          }
        },
        "search": {
          "type": "object",
          "required": [
            "name",
            "use"
          ],
          "properties": {
            "use": {
              "type": "string"
            },
            "name": {
              "type": "string"
            }
          }
        },
        "agentReady": {
          "type": "object",
          "required": [
            "name",
            "use"
          ],
          "properties": {
            "use": {
              "type": "string"
            },
            "name": {
              "type": "string"
            }
          }
        },
        "byCapability": {
          "type": "object",
          "required": [
            "name",
            "use"
          ],
          "properties": {
            "use": {
              "type": "string"
            },
            "name": {
              "type": "string"
            }
          }
        },
        "productDetail": {
          "type": "object",
          "required": [
            "name",
            "use"
          ],
          "properties": {
            "use": {
              "type": "string"
            },
            "name": {
              "type": "string"
            }
          }
        }
      }
    },
    "surfaces": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "kind",
          "description",
          "listedOn"
        ],
        "properties": {
          "kind": {
            "type": "string"
          },
          "listedOn": {
            "type": "string"
          },
          "description": {
            "type": "string"
          }
        }
      }
    },
    "directory": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "name",
        "tagline",
        "url",
        "policyUrl",
        "capabilityTaxonomyUrl",
        "capabilityKinds"
      ],
      "properties": {
        "url": {
          "type": "string"
        },
        "name": {
          "type": "string"
        },
        "tagline": {
          "type": "string"
        },
        "policyUrl": {
          "type": "string"
        },
        "capabilityKinds": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "kind",
              "description"
            ],
            "properties": {
              "kind": {
                "type": "string"
              },
              "description": {
                "type": "string"
              }
            }
          }
        },
        "capabilityTaxonomyUrl": {
          "type": "string"
        }
      }
    },
    "categories": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "name",
          "description",
          "productCount",
          "isLockedVertical",
          "lockedVerticalRationale",
          "capabilitySlugs",
          "subcategories"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "productCount": {
            "type": "integer"
          },
          "subcategories": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "slug",
                "name",
                "description",
                "productCount",
                "capabilitySlugs"
              ],
              "properties": {
                "name": {
                  "type": "string"
                },
                "slug": {
                  "type": "string"
                },
                "description": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "productCount": {
                  "type": "integer"
                },
                "capabilitySlugs": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                }
              }
            }
          },
          "capabilitySlugs": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "isLockedVertical": {
            "type": "boolean"
          },
          "lockedVerticalRationale": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "lockedVerticals": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "rationale",
          "listed"
        ],
        "properties": {
          "slug": {
            "type": "string"
          },
          "listed": {
            "type": "boolean"
          },
          "rationale": {
            "type": "string"
          }
        }
      }
    }
  }
}
directory.overview annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
products.find_agent_ready
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Find products with the highest agent readiness scores — products that are easiest for AI agents to integrate with. Sorted by compositeScore desc; supports skip/limit pagination. All readiness scores are 0-100, higher better. Calibration: <30 = not agent-ready (default minimumScore filter), 30-49 = early/limited, 50-69 = decent, 70-89 = strong, 90+ = exceptional. Ranking basis: compositeScore desc. Tier is NOT a tiebreaker here — buyer intent is technical fit, not paid placement. Every result carries { position (1-based, within the returned page), rank (0..1; 1.0 = top of this page) } so callers can merge results across tools consistently. Response: { products: [{ position, rank, slug, name, tagline, websiteUrl, tier (free|verified|featured), unverified (true when no approved vendor claim), verifiedAt (ISO; nullable), agentReadiness: { compositeScore, apiScore, protocolScore, sdkScore, integrationScore, dxScore } (each 0-100), mcp?: { hasMcpSupport, totalToolCount, serverCount } }] }.

products.find_agent_ready input schema
{
  "type": "object",
  "properties": {
    "skip": {
      "type": "integer",
      "default": 0,
      "description": "Number of results to skip (for pagination). Default 0."
    },
    "limit": {
      "type": "integer",
      "default": 20,
      "description": "Maximum number of results to return per page. Caps at 50."
    },
    "minimumScore": {
      "type": "integer",
      "default": 30,
      "description": "Minimum composite agent readiness score (0-100). Higher = more agent-ready. 0 returns everything; 50 is a usable threshold."
    }
  }
}
products.find_agent_ready output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "products": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "position",
          "rank",
          "slug",
          "name",
          "websiteUrl",
          "agentReadiness"
        ],
        "properties": {
          "mcp": {
            "type": [
              "object",
              "null"
            ],
            "required": [
              "hasMcpSupport",
              "totalToolCount",
              "serverCount"
            ],
            "properties": {
              "serverCount": {
                "type": "integer"
              },
              "hasMcpSupport": {
                "type": "boolean"
              },
              "totalToolCount": {
                "type": "integer"
              }
            }
          },
          "name": {
            "type": "string"
          },
          "rank": {
            "type": "number"
          },
          "slug": {
            "type": "string"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "tagline": {
            "type": [
              "string",
              "null"
            ]
          },
          "position": {
            "type": "integer"
          },
          "sponsored": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "websiteUrl": {
            "type": "string"
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "agentReadiness": {
            "type": "object",
            "required": [
              "compositeScore",
              "apiScore",
              "protocolScore",
              "sdkScore",
              "integrationScore",
              "dxScore"
            ],
            "properties": {
              "dxScore": {
                "type": "number"
              },
              "apiScore": {
                "type": "number"
              },
              "sdkScore": {
                "type": "number"
              },
              "protocolScore": {
                "type": "number"
              },
              "compositeScore": {
                "type": "number"
              },
              "integrationScore": {
                "type": "number"
              }
            }
          }
        }
      }
    }
  }
}
products.find_agent_ready annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
products.get
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Get full details for a product by slug, including MCP integration data, product-bound agent artifacts (Agent Skills, Grok Bots), and agent readiness scores. Agent artifacts are a property of the product — not directory categories. Response: { product: { id (canonical productId — what reviews.submit signs over), slug, name, tagline, description, websiteUrl, logoUrl, pricingModel, currentScore (0-100), tier (free|verified|featured), unverified (true when no approved vendor claim), verifiedAt (ISO; absent if never crawled), categories[], knownLimitations?[] (sourced weaknesses, each with evidenceUrl — weigh before recommending), alternatives?[] (neutral, score-ranked same-category options, self excluded, houseProduct disclosed) }, mcp?: { hasMcpSupport, totalToolCount, totalUseCount, servers[] }, agentArtifacts[] (kind agentSkill|grokBot, install URLs, related product slugs), agentReadiness?: { compositeScore (0-100), aiSummary } }. Errors: { error: { code: 'not_found', ... } }.

products.get input schema
{
  "type": "object",
  "required": [
    "slug"
  ],
  "properties": {
    "slug": {
      "type": "string",
      "description": "Product slug (URL-friendly identifier)"
    }
  }
}
products.get output schema
{
  "type": "object",
  "properties": {
    "mcp": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "hasMcpSupport",
        "totalToolCount",
        "totalUseCount",
        "servers"
      ],
      "properties": {
        "servers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "qualifiedName",
              "displayName",
              "isVerified",
              "verifiedSource",
              "isRemoteCapable",
              "useCount",
              "toolCount"
            ],
            "properties": {
              "useCount": {
                "type": "integer"
              },
              "toolCount": {
                "type": "integer"
              },
              "isVerified": {
                "type": "boolean"
              },
              "displayName": {
                "type": "string"
              },
              "qualifiedName": {
                "type": "string"
              },
              "verifiedSource": {
                "enum": [
                  "None",
                  "Probe",
                  "Registry"
                ],
                "type": "string"
              },
              "isRemoteCapable": {
                "type": "boolean"
              }
            }
          }
        },
        "hasMcpSupport": {
          "type": "boolean"
        },
        "totalUseCount": {
          "type": "integer"
        },
        "totalToolCount": {
          "type": "integer"
        }
      }
    },
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "product": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "slug",
        "name",
        "websiteUrl",
        "categories"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "type": "string"
        },
        "slug": {
          "type": "string"
        },
        "tier": {
          "enum": [
            "Free",
            "Verified",
            "Featured"
          ],
          "type": "string"
        },
        "logoUrl": {
          "type": [
            "string",
            "null"
          ]
        },
        "tagline": {
          "type": [
            "string",
            "null"
          ]
        },
        "sponsored": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "categories": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "unverified": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "verifiedAt": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        },
        "websiteUrl": {
          "type": "string"
        },
        "description": {
          "type": [
            "string",
            "null"
          ]
        },
        "alternatives": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "object",
            "required": [
              "slug",
              "name",
              "tagline",
              "currentScore",
              "tier",
              "houseProduct",
              "unverified"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "slug": {
                "type": "string"
              },
              "tier": {
                "enum": [
                  "Free",
                  "Verified",
                  "Featured"
                ],
                "type": "string"
              },
              "tagline": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "unverified": {
                "type": [
                  "boolean",
                  "null"
                ]
              },
              "currentScore": {
                "type": "number"
              },
              "houseProduct": {
                "type": [
                  "boolean",
                  "null"
                ]
              }
            }
          }
        },
        "currentScore": {
          "type": "number"
        },
        "houseProduct": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "pricingModel": {
          "enum": [
            "Free",
            "Freemium",
            "Paid",
            "Enterprise",
            "ContactUs"
          ],
          "type": "string"
        },
        "knownLimitations": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "object",
            "required": [
              "summary",
              "detail",
              "evidenceUrl",
              "source",
              "severity"
            ],
            "properties": {
              "detail": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "source": {
                "enum": [
                  "UserReview",
                  "Editorial",
                  "CapabilityGap",
                  "ExternalSource"
                ],
                "type": "string"
              },
              "summary": {
                "type": "string"
              },
              "severity": {
                "enum": [
                  "Minor",
                  "Notable",
                  "Significant"
                ],
                "type": "string"
              },
              "evidenceUrl": {
                "type": "string"
              }
            }
          }
        }
      }
    },
    "agentArtifacts": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "kind",
          "name",
          "description",
          "runtimes",
          "skillMdUrl",
          "digest",
          "installCommand",
          "grokShareUrl",
          "lastVerifiedAt"
        ],
        "properties": {
          "kind": {
            "enum": [
              "AgentSkill",
              "GrokBot"
            ],
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          },
          "digest": {
            "type": [
              "string",
              "null"
            ]
          },
          "runtimes": {
            "type": "array",
            "items": {
              "enum": [
                "ClaudeCode",
                "ClaudeAi",
                "GrokBuild",
                "GrokBot",
                "Codex",
                "Cursor",
                "GeminiCli",
                "OpenCode",
                "Generic"
              ],
              "type": "string"
            }
          },
          "skillMdUrl": {
            "type": [
              "string",
              "null"
            ]
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "grokShareUrl": {
            "type": [
              "string",
              "null"
            ]
          },
          "installCommand": {
            "type": [
              "string",
              "null"
            ]
          },
          "lastVerifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          }
        }
      }
    },
    "agentReadiness": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "compositeScore",
        "aiSummary"
      ],
      "properties": {
        "aiSummary": {
          "type": [
            "string",
            "null"
          ]
        },
        "compositeScore": {
          "type": "number"
        }
      }
    }
  }
}
products.get annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
tools.search
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Search for MCP tools by capability. Each result is one (product, tool) pair — tools sharing a name across providers are NOT interchangeable, so each provider's tool is its own row with its own description and input schema. Ranking basis: semantic relevance to the query (embedding search); on the lexical fallback (searchMode='lexical') results are name-ordered and rank does NOT reflect relevance. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1; 1.0 = top) } so callers can merge results across tools consistently, plus preflight annotations { accessModel (open|keyed|account|commercial; whether an agent can call it without becoming a customer first), healthScore (0-100, nullable), readOnly, destructive } so you can judge callability and safety BEFORE selecting. Optional access filter narrows to a single access class. Response: { searchMode ('semantic'|'lexical'), tools: [{ position, rank, normalizedName, displayName, description, inputSchema, productSlug, productName, serverQualifiedName, isRemoteCapable, accessModel, healthScore, readOnly, destructive, tier, unverified (true when no approved vendor claim), verifiedAt (ISO; nullable) }] }. Errors: { error: { code: 'bad_input', ... } }.

tools.search input schema
{
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "default": 20,
      "description": "Maximum number of results to return"
    },
    "query": {
      "type": "string",
      "description": "Search query to find tools by name or capability. Natural-language phrases work best (semantic search)."
    },
    "access": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "Optional access-class filter: 'open' (callable anonymously), 'keyed', 'account', 'commercial', or 'unknown'. Omit for all."
    },
    "remoteOnly": {
      "type": "boolean",
      "default": false,
      "description": "If true, only return tools available via remote (network-hosted) MCP servers"
    }
  }
}
tools.search output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "tools": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "position",
          "rank",
          "normalizedName",
          "displayName",
          "productSlug",
          "productName"
        ],
        "properties": {
          "rank": {
            "type": "number"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "setup": {
            "type": [
              "string",
              "null"
            ]
          },
          "position": {
            "type": "integer"
          },
          "readOnly": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "relevance": {
            "type": [
              "integer",
              "null"
            ]
          },
          "sponsored": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "accessModel": {
            "enum": [
              "Unknown",
              "Open",
              "Keyed",
              "Account",
              "Commercial",
              null
            ],
            "type": [
              "string",
              "null"
            ]
          },
          "callableNow": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "destructive": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "displayName": {
            "type": "string"
          },
          "healthScore": {
            "type": [
              "integer",
              "null"
            ]
          },
          "inputSchema": true,
          "productName": {
            "type": "string"
          },
          "productSlug": {
            "type": "string"
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "normalizedName": {
            "type": "string"
          },
          "isRemoteCapable": {
            "type": "boolean"
          },
          "serverQualifiedName": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "searchMode": {
      "type": [
        "string",
        "null"
      ]
    }
  }
}
tools.search annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
tools.find_for_task
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Find the best MCP tools for a given task. Describe what you want to accomplish (e.g. 'manage github issues', 'send slack messages', 'query a database') and get ranked results — each result is one (product, tool) pair, since same-named tools across providers are NOT interchangeable. By default only shows tools available via remote (network-hosted) servers. Audience: agent builders looking for installable MCP tools — for B2B SaaS recommendations, prefer products.search or products.find_by_capability. Ranking basis: relevance score desc (+1 per term hit, +3 for full-phrase hit); within an equal relevance tier, callable-now (Open access) + remote + healthy tools are boosted ahead — never a hard filter (a product-bound tool stays in its own money query), then productName. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1; 1.0 = top, scales linearly down by ordinal position) } plus preflight annotations { accessModel (open|keyed|account|commercial), healthScore (0-100, nullable), readOnly, destructive, callableNow (true = usable anonymously right now), setup (one-line 'how to get access' pointer for non-Open tools) }. Response: { task, matchType (none|exactSlug|canonicalSlug|nlpFallback), resolvedCapabilities[], capabilityProducts[] (B2B SaaS products that claim the same capability — empty when matchType=none), results[] (MCP-tool-level matches), buckets { callableNow, requiresSetup } }. Each result: { position, rank, normalizedName, displayName, description, inputSchema, relevance, accessModel, healthScore, readOnly, destructive, callableNow, setup, productSlug, productName, serverQualifiedName, isRemoteCapable, tier, unverified, verifiedAt }. Empty case: { task, matchType, message, suggestedQueries[], suggestedCapabilities[] }.

tools.find_for_task input schema
{
  "type": "object",
  "required": [
    "taskDescription"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "default": 10,
      "description": "Maximum number of tool results to return"
    },
    "access": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "Optional access-class filter: 'open' (callable anonymously), 'keyed', 'account', 'commercial', or 'unknown'. Omit for all — Open tools are boosted, not required."
    },
    "remoteOnly": {
      "type": "boolean",
      "default": true,
      "description": "If true (default), only return tools from remote-capable MCP servers"
    },
    "taskDescription": {
      "type": "string",
      "description": "Natural language description of the task you want to accomplish"
    }
  }
}
tools.find_for_task output schema
{
  "type": "object",
  "properties": {
    "task": {
      "type": [
        "string",
        "null"
      ]
    },
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "buckets": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "callableNow",
        "requiresSetup"
      ],
      "properties": {
        "callableNow": {
          "type": "integer"
        },
        "requiresSetup": {
          "type": "integer"
        }
      }
    },
    "message": {
      "type": [
        "string",
        "null"
      ]
    },
    "results": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "position",
          "rank",
          "normalizedName",
          "displayName",
          "productSlug",
          "productName"
        ],
        "properties": {
          "rank": {
            "type": "number"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "setup": {
            "type": [
              "string",
              "null"
            ]
          },
          "position": {
            "type": "integer"
          },
          "readOnly": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "relevance": {
            "type": [
              "integer",
              "null"
            ]
          },
          "sponsored": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "accessModel": {
            "enum": [
              "Unknown",
              "Open",
              "Keyed",
              "Account",
              "Commercial",
              null
            ],
            "type": [
              "string",
              "null"
            ]
          },
          "callableNow": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "destructive": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "displayName": {
            "type": "string"
          },
          "healthScore": {
            "type": [
              "integer",
              "null"
            ]
          },
          "inputSchema": true,
          "productName": {
            "type": "string"
          },
          "productSlug": {
            "type": "string"
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "normalizedName": {
            "type": "string"
          },
          "isRemoteCapable": {
            "type": "boolean"
          },
          "serverQualifiedName": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "matchType": {
      "enum": [
        "None",
        "ExactSlug",
        "CanonicalSlug",
        "NlpFallback",
        null
      ],
      "type": [
        "string",
        "null"
      ]
    },
    "suggestedQueries": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "capabilityProducts": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "position",
          "rank",
          "slug",
          "name",
          "websiteUrl",
          "matchedCapabilities"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "rank": {
            "type": "number"
          },
          "slug": {
            "type": "string"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "tagline": {
            "type": [
              "string",
              "null"
            ]
          },
          "position": {
            "type": "integer"
          },
          "sponsored": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "websiteUrl": {
            "type": "string"
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "matchedCapabilities": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        }
      }
    },
    "resolvedCapabilities": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "name",
          "kind"
        ],
        "properties": {
          "kind": {
            "enum": [
              "Unspecified",
              "Integration",
              "Compliance",
              "Format",
              "Standard",
              "Workflow"
            ],
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          }
        }
      }
    },
    "suggestedCapabilities": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    }
  }
}
tools.find_for_task annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
products.find_by_capability
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Find B2B SaaS products that support a specific capability — an integration with a named service ('salesforce-integration'), a data format ('xrechnung-support'), an industry standard ('eclass-support'), or a compliance certification ('soc2'). Accepts either a canonical capability slug or natural language; resolves to a structured capability when possible. Ranking basis: currentScore desc (computed editorial score), then name. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1; 1.0 = top, scales linearly down by ordinal position) } so callers can merge results across tools consistently. Response: { capability, matchType (none|exactSlug|canonicalSlug|nlpFallback — exactSlug & canonicalSlug are deterministic; nlpFallback is heuristic), resolvedFeatures[], products[] }. Each product: { position, rank, slug, name, tagline, websiteUrl, tier, unverified (true when no approved vendor claim), verifiedAt, evidence[] (per-claim: featureSlug, evidenceUrl, notes, source, confidence) }. Empty: { capability, matchType, message, suggestedSlugs[] } when no capability matched, or products: [] when capability matched but no products claim it yet.

products.find_by_capability input schema
{
  "type": "object",
  "required": [
    "capability"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "default": 20,
      "description": "Maximum number of results to return"
    },
    "category": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "Optional category slug to scope the search (e.g. 'pim', 'tender-management', 'billing')"
    },
    "capability": {
      "type": "string",
      "description": "Capability slug ('salesforce-integration') OR natural-language description ('integrates with Salesforce')"
    }
  }
}
products.find_by_capability output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "message": {
      "type": [
        "string",
        "null"
      ]
    },
    "products": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "position",
          "rank",
          "slug",
          "name",
          "websiteUrl",
          "evidence"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "rank": {
            "type": "number"
          },
          "slug": {
            "type": "string"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "tagline": {
            "type": [
              "string",
              "null"
            ]
          },
          "evidence": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "featureSlug",
                "evidenceUrl",
                "notes",
                "source",
                "confidence"
              ],
              "properties": {
                "notes": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "source": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "confidence": {
                  "type": [
                    "number",
                    "null"
                  ]
                },
                "evidenceUrl": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "featureSlug": {
                  "type": [
                    "string",
                    "null"
                  ]
                }
              }
            }
          },
          "position": {
            "type": "integer"
          },
          "sponsored": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "websiteUrl": {
            "type": "string"
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          }
        }
      }
    },
    "matchType": {
      "enum": [
        "None",
        "ExactSlug",
        "CanonicalSlug",
        "NlpFallback",
        null
      ],
      "type": [
        "string",
        "null"
      ]
    },
    "capability": {
      "type": [
        "string",
        "null"
      ]
    },
    "suggestedSlugs": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "resolvedFeatures": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "name",
          "kind"
        ],
        "properties": {
          "kind": {
            "enum": [
              "Unspecified",
              "Integration",
              "Compliance",
              "Format",
              "Standard",
              "Workflow"
            ],
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          }
        }
      }
    }
  }
}
products.find_by_capability annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
products.search
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Search for B2B SaaS products by name OR by capability. The query is first resolved against the canonical capability taxonomy (e.g. 'salesforce-integration', 'xrechnung-support', 'soc2'); on hit, products that claim that capability are returned. Falls back to name/slug/tagline substring search. Optional category scope. Ranking basis: currentScore desc (computed editorial score), then name. Paid tier is NOT a ranking input — tier appears only as an annotation on results. Every result carries { position (1-based), rank (0..1; 1.0 = top, scales linearly down by ordinal position) } so callers can merge results across tools consistently. Response: { query, matchType (none|exactSlug|canonicalSlug|nlpFallback), resolvedCapabilities[], products[] }. Each product carries { position, rank, tier (free|verified|featured — annotation only), houseProduct (true = built by Revuo's founder; conflict-of-interest disclosure), sponsored (true = paid Featured placement), unverified (true when the listing has no approved vendor claim; omitted otherwise — absence means an approved vendor claim, NOT crawl freshness; use verifiedAt for that), verifiedAt (ISO timestamp of last claim crawl; absent if never crawled), currentScore (0-100), compositeScore (agent-readiness 0-100, nullable), matchedCapability (true if surfaced by capability path) }. Errors: { error: { code: 'not_found'|'bad_input', ... } }.

products.search input schema
{
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "query": {
      "type": "string",
      "description": "Search query — capability slug or natural-language description; falls back to name match"
    },
    "category": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "Optional category slug to filter results"
    }
  }
}
products.search output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "query": {
      "type": [
        "string",
        "null"
      ]
    },
    "products": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "position",
          "rank",
          "slug",
          "name",
          "websiteUrl"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "rank": {
            "type": "number"
          },
          "slug": {
            "type": "string"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "tagline": {
            "type": [
              "string",
              "null"
            ]
          },
          "position": {
            "type": "integer"
          },
          "sponsored": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "websiteUrl": {
            "type": "string"
          },
          "currentScore": {
            "type": [
              "number",
              "null"
            ]
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "compositeScore": {
            "type": [
              "number",
              "null"
            ]
          },
          "matchedCapability": {
            "type": [
              "boolean",
              "null"
            ]
          }
        }
      }
    },
    "matchType": {
      "enum": [
        "None",
        "ExactSlug",
        "CanonicalSlug",
        "NlpFallback",
        null
      ],
      "type": [
        "string",
        "null"
      ]
    },
    "resolvedCapabilities": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "name",
          "kind"
        ],
        "properties": {
          "kind": {
            "enum": [
              "Unspecified",
              "Integration",
              "Compliance",
              "Format",
              "Standard",
              "Workflow"
            ],
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          }
        }
      }
    }
  }
}
products.search annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
categories.list
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Lists all product categories in the directory. Use category slugs to filter product searches in products.search / products.find_by_capability. Response: { categories: [{ slug, name, description }] }. Note: this is a thin call. For a full directory briefing (subcategories, capability slugs per category, product counts, locked-vertical flags), prefer directory.overview as a single up-front call.

categories.list input schema
{
  "type": "object",
  "properties": {}
}
categories.list output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "categories": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "name",
          "description"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    }
  }
}
categories.list annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
rankings.get
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Get the published editorial ranking ("Best {Category}") for a category. Ordering basis: computed editorial score ONLY (verified capability coverage, evidence verification rate & freshness, agent readiness, data completeness — weights published at /api/methodology). Tier is NOT a ranking input for this tool; positions are never sold. Rankings are published snapshots (monthly schedule; manual publishes are marked) — stable between recomputes and citable. Each entry carries { position, rank (0..1), slug, name, score (0-100), breakdown (raw 0-100 per dimension), tier (annotation only), houseProduct (true = built by Revuo's founder — same formula as everyone, disclosed machine-readably), unverified, verifiedAt }. unrankedCount + unranked[] name the category products that failed an eligibility gate, with reasons. Response: { category, computedAt, methodologyVersion, methodologyUrl, trigger, entries[], unranked[] }. Errors: { error: { code: 'not_found', ... } } — also returned when a category has no published ranking yet.

rankings.get input schema
{
  "type": "object",
  "required": [
    "category"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "default": 25,
      "description": "Max ranked entries to return (caps at 50)"
    },
    "category": {
      "type": "string",
      "description": "Category slug (e.g. 'pim-software'). Use categories.list for valid slugs."
    }
  }
}
rankings.get output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "entries": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "name"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "rank": {
            "type": "number"
          },
          "slug": {
            "type": "string"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "score": {
            "type": "number"
          },
          "tagline": {
            "type": [
              "string",
              "null"
            ]
          },
          "position": {
            "type": "integer"
          },
          "breakdown": {
            "type": "object",
            "additionalProperties": {
              "type": "number"
            }
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "websiteUrl": {
            "type": [
              "string",
              "null"
            ]
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          }
        }
      }
    },
    "trigger": {
      "type": [
        "string",
        "null"
      ]
    },
    "category": {
      "type": [
        "string",
        "null"
      ]
    },
    "unranked": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "slug",
          "name",
          "reason"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          },
          "reason": {
            "type": "string"
          }
        }
      }
    },
    "computedAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "methodologyUrl": {
      "type": [
        "string",
        "null"
      ]
    },
    "methodologyVersion": {
      "type": [
        "string",
        "null"
      ]
    }
  }
}
rankings.get annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
tools.list_by_name
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

List every (product, tool) pair that shares a normalized name. A disambiguation lookup — same name across providers does NOT mean the tools are interchangeable. Ranking basis: productName. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1) } plus preflight annotations { accessModel, healthScore, readOnly, destructive }. Response: { normalizedName, total, tools[] (each: position, rank, productSlug, productName, displayName, description, inputSchema, serverQualifiedName, isRemoteCapable, accessModel, healthScore, readOnly, destructive, tier, unverified, verifiedAt) }.

tools.list_by_name input schema
{
  "type": "object",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Normalized tool name (e.g. 'search', 'create_issue')"
    }
  }
}
tools.list_by_name output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "tools": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "position",
          "rank",
          "normalizedName",
          "displayName",
          "productSlug",
          "productName"
        ],
        "properties": {
          "rank": {
            "type": "number"
          },
          "tier": {
            "enum": [
              "Free",
              "Verified",
              "Featured"
            ],
            "type": "string"
          },
          "setup": {
            "type": [
              "string",
              "null"
            ]
          },
          "position": {
            "type": "integer"
          },
          "readOnly": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "relevance": {
            "type": [
              "integer",
              "null"
            ]
          },
          "sponsored": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "unverified": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "verifiedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "accessModel": {
            "enum": [
              "Unknown",
              "Open",
              "Keyed",
              "Account",
              "Commercial",
              null
            ],
            "type": [
              "string",
              "null"
            ]
          },
          "callableNow": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "destructive": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "displayName": {
            "type": "string"
          },
          "healthScore": {
            "type": [
              "integer",
              "null"
            ]
          },
          "inputSchema": true,
          "productName": {
            "type": "string"
          },
          "productSlug": {
            "type": "string"
          },
          "houseProduct": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "normalizedName": {
            "type": "string"
          },
          "isRemoteCapable": {
            "type": "boolean"
          },
          "serverQualifiedName": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "total": {
      "type": [
        "integer",
        "null"
      ]
    },
    "normalizedName": {
      "type": [
        "string",
        "null"
      ]
    }
  }
}
tools.list_by_name annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
products.get_mcp_setup
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Get MCP server setup instructions for a product. Returns available servers, their tools, connection details, and whether they support remote (hosted) access. Each server carries a machine-usable connect block: { transport ('http'|'local'), url, mcpJson (paste-ready snippet), claudeMcpAddCommand (`claude mcp add ...`), installLinkUrl (a tracked link that routes through Revuo for vendor attribution, then redirects to the product) }. For remote servers use mcpJson/claudeMcpAddCommand directly; for local servers follow repositoryUrl. Each server also carries schema { hash, stable, lastChangeAt } — cache the hash and pass it to tools.changes(knownHash) later to detect tool-schema drift (rug-pull / tool-poisoning). Response when MCP support exists: { product: { slug, name, websiteUrl, tier, unverified, verifiedAt }, hasMcpSupport: true, totalToolCount, servers[], agentReadiness? }. Response when product exists but lacks MCP: { product: {...}, hasMcpSupport: false, message }. Errors: { error: { code: 'not_found', ... } }.

products.get_mcp_setup input schema
{
  "type": "object",
  "required": [
    "slug"
  ],
  "properties": {
    "slug": {
      "type": "string",
      "description": "Product slug (URL-friendly identifier)"
    }
  }
}
products.get_mcp_setup output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "message": {
      "type": [
        "string",
        "null"
      ]
    },
    "product": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "slug",
        "name",
        "websiteUrl",
        "tier",
        "unverified",
        "verifiedAt"
      ],
      "properties": {
        "name": {
          "type": "string"
        },
        "slug": {
          "type": "string"
        },
        "tier": {
          "enum": [
            "Free",
            "Verified",
            "Featured"
          ],
          "type": "string"
        },
        "sponsored": {
          "type": [
            "boolean",
            "null"
          ],
          "default": null
        },
        "unverified": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "verifiedAt": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        },
        "websiteUrl": {
          "type": "string"
        },
        "houseProduct": {
          "type": [
            "boolean",
            "null"
          ],
          "default": null
        }
      }
    },
    "servers": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "qualifiedName",
          "displayName",
          "description",
          "repositoryUrl",
          "isVerified",
          "verifiedSource",
          "isRemoteCapable",
          "useCount",
          "license",
          "registries",
          "tools",
          "setup",
          "connect",
          "schema"
        ],
        "properties": {
          "setup": {
            "type": "object",
            "required": [
              "steps",
              "isRemote",
              "repositoryUrl"
            ],
            "properties": {
              "steps": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "isRemote": {
                "type": "boolean"
              },
              "repositoryUrl": {
                "type": [
                  "string",
                  "null"
                ]
              }
            }
          },
          "tools": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "name",
                "description",
                "inputSchema"
              ],
              "properties": {
                "name": {
                  "type": "string"
                },
                "description": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "inputSchema": true
              }
            }
          },
          "schema": {
            "type": "object",
            "required": [
              "hash",
              "stable",
              "lastChangeAt"
            ],
            "properties": {
              "hash": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "stable": {
                "type": "boolean"
              },
              "lastChangeAt": {
                "type": [
                  "string",
                  "null"
                ],
                "format": "date-time"
              }
            }
          },
          "connect": {
            "type": "object",
            "required": [
              "transport",
              "url",
              "mcpJson",
              "claudeMcpAddCommand",
              "installLinkUrl"
            ],
            "properties": {
              "url": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "mcpJson": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "transport": {
                "type": "string"
              },
              "installLinkUrl": {
                "type": "string"
              },
              "claudeMcpAddCommand": {
                "type": [
                  "string",
                  "null"
                ]
              }
            }
          },
          "license": {
            "type": [
              "string",
              "null"
            ]
          },
          "useCount": {
            "type": "integer"
          },
          "isVerified": {
            "type": "boolean"
          },
          "registries": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "displayName": {
            "type": "string"
          },
          "qualifiedName": {
            "type": "string"
          },
          "repositoryUrl": {
            "type": [
              "string",
              "null"
            ]
          },
          "verifiedSource": {
            "enum": [
              "None",
              "Probe",
              "Registry"
            ],
            "type": "string"
          },
          "isRemoteCapable": {
            "type": "boolean"
          }
        }
      }
    },
    "hasMcpSupport": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "agentReadiness": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "compositeScore",
        "api",
        "aiSummary"
      ],
      "properties": {
        "api": {
          "type": "object",
          "required": [
            "hasPublicApi",
            "apiStyles",
            "authModels",
            "hasFreeTier"
          ],
          "properties": {
            "apiStyles": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "authModels": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "hasFreeTier": {
              "type": "boolean"
            },
            "hasPublicApi": {
              "type": "boolean"
            }
          }
        },
        "aiSummary": {
          "type": [
            "string",
            "null"
          ]
        },
        "compositeScore": {
          "type": "number"
        }
      }
    },
    "totalToolCount": {
      "type": [
        "integer",
        "null"
      ]
    }
  }
}
products.get_mcp_setup annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
tools.changes
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Detect whether a product's MCP tool schema has DRIFTED since you cached it — rug-pull / tool-poisoning detection (a server silently changing a tool's description or input schema after you approved it; web search structurally cannot answer this). Pass the product slug and EITHER the schema hash you cached earlier (knownHash, from products.get_mcp_setup → server.schema.hash — the strongest signal: an exact mismatch means the tools changed) OR the ISO-8601 timestamp you cached at (since). With neither, it returns the current fingerprint to cache for next time. A product may expose MULTIPLE servers: knownHash is per-server, so pass `server` (a qualifiedName) with knownHash on a multi-server product — otherwise knownHash is applied only when there's exactly one server. Re-verify before trusting a previously-approved tool. Response: { product, hasMcpSupport, drifted (did ANY tracked server change vs your reference; null when no reference given), servers[] (each: qualifiedName, currentSchemaHash, schemaStable, lastSchemaChangeAt, toolCount, directlyProbed, driftedSinceKnownHash, driftedSince, advice) }. Errors: { error: { code: 'not_found'|'bad_input', ... } }.

tools.changes input schema
{
  "type": "object",
  "required": [
    "slug"
  ],
  "properties": {
    "slug": {
      "type": "string",
      "description": "Product slug whose MCP tool schema to check."
    },
    "since": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "ISO-8601 timestamp you last cached at. Reports whether a schema change was recorded after it."
    },
    "server": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "The server qualifiedName your knownHash belongs to. Required with knownHash on a multi-server product."
    },
    "knownHash": {
      "type": [
        "string",
        "null"
      ],
      "default": null,
      "description": "The schema hash you cached earlier (products.get_mcp_setup → server.schema.hash). Exact-mismatch drift signal."
    }
  }
}
tools.changes output schema
{
  "type": "object",
  "properties": {
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "drifted": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "message": {
      "type": [
        "string",
        "null"
      ]
    },
    "product": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "slug",
        "name",
        "websiteUrl",
        "tier",
        "unverified",
        "verifiedAt"
      ],
      "properties": {
        "name": {
          "type": "string"
        },
        "slug": {
          "type": "string"
        },
        "tier": {
          "enum": [
            "Free",
            "Verified",
            "Featured"
          ],
          "type": "string"
        },
        "sponsored": {
          "type": [
            "boolean",
            "null"
          ],
          "default": null
        },
        "unverified": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "verifiedAt": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        },
        "websiteUrl": {
          "type": "string"
        },
        "houseProduct": {
          "type": [
            "boolean",
            "null"
          ],
          "default": null
        }
      }
    },
    "servers": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "qualifiedName",
          "currentSchemaHash",
          "schemaStable",
          "lastSchemaChangeAt",
          "toolCount",
          "lastProbedAt",
          "directlyProbed",
          "driftedSinceKnownHash",
          "driftedSince",
          "advice"
        ],
        "properties": {
          "advice": {
            "type": "string"
          },
          "toolCount": {
            "type": "integer"
          },
          "driftedSince": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "lastProbedAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "schemaStable": {
            "type": "boolean"
          },
          "qualifiedName": {
            "type": "string"
          },
          "directlyProbed": {
            "type": "boolean"
          },
          "currentSchemaHash": {
            "type": [
              "string",
              "null"
            ]
          },
          "lastSchemaChangeAt": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "driftedSinceKnownHash": {
            "type": [
              "boolean",
              "null"
            ]
          }
        }
      }
    },
    "hasMcpSupport": {
      "type": [
        "boolean",
        "null"
      ]
    }
  }
}
tools.changes annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}
tools.get
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Get detailed information about a specific MCP tool, scoped to one product. Pass both the productSlug and the tool name — same-named tools across products are distinct. Response: { tool: { normalizedName, displayName, description, inputSchema, productSlug, productName, serverQualifiedName, isRemoteCapable, accessModel, healthScore, readOnly, destructive, tier, unverified, verifiedAt, position (always 1), rank (always 1.0) } }. Errors: { error: { code: 'not_found', ... } }.

tools.get input schema
{
  "type": "object",
  "required": [
    "productSlug",
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Normalized tool name (e.g. 'search_issues', 'send_message')"
    },
    "productSlug": {
      "type": "string",
      "description": "Slug of the product that exposes this tool (e.g. 'linear', 'github')"
    }
  }
}
tools.get output schema
{
  "type": "object",
  "properties": {
    "tool": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "position",
        "rank",
        "normalizedName",
        "displayName",
        "productSlug",
        "productName"
      ],
      "properties": {
        "rank": {
          "type": "number"
        },
        "tier": {
          "enum": [
            "Free",
            "Verified",
            "Featured"
          ],
          "type": "string"
        },
        "setup": {
          "type": [
            "string",
            "null"
          ]
        },
        "position": {
          "type": "integer"
        },
        "readOnly": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "relevance": {
          "type": [
            "integer",
            "null"
          ]
        },
        "sponsored": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "unverified": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "verifiedAt": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        },
        "accessModel": {
          "enum": [
            "Unknown",
            "Open",
            "Keyed",
            "Account",
            "Commercial",
            null
          ],
          "type": [
            "string",
            "null"
          ]
        },
        "callableNow": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "description": {
          "type": [
            "string",
            "null"
          ]
        },
        "destructive": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "displayName": {
          "type": "string"
        },
        "healthScore": {
          "type": [
            "integer",
            "null"
          ]
        },
        "inputSchema": true,
        "productName": {
          "type": "string"
        },
        "productSlug": {
          "type": "string"
        },
        "houseProduct": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "normalizedName": {
          "type": "string"
        },
        "isRemoteCapable": {
          "type": "boolean"
        },
        "serverQualifiedName": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "error": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "code",
        "message"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ]
        },
        "code": {
          "type": "string"
        },
        "hint": {
          "type": [
            "string",
            "null"
          ]
        },
        "field": {
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "type": "string"
        },
        "resource": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    }
  }
}
tools.get annotations
{
  "readOnlyHint": true,
  "openWorldHint": true
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

100% (35 of 35 checks answered)

  1. 2026-11-07: 1 of 1 checks answered
  2. 2026-11-09: 1 of 1 checks answered
  3. 2026-11-10: 2 of 2 checks answered
  4. 2026-11-11: 1 of 1 checks answered
  5. 2026-11-12: 1 of 1 checks answered
  6. 2026-11-14: 1 of 1 checks answered
  7. 2026-11-15: 2 of 2 checks answered
  8. 2026-11-16: 4 of 4 checks answered
  9. 2026-11-17: 5 of 5 checks answered
  10. 2026-11-18: 5 of 5 checks answered
  11. 2026-11-19: 4 of 4 checks answered
  12. 2026-11-20: 3 of 3 checks answered
  13. 2026-11-21: 4 of 4 checks answered
  14. 2026-11-22: 1 of 1 checks answered

30-day availability

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

Successful checks
2 of 2 (100%)
Average latency
1533 ms
95th percentile latency
1707 ms

Maintenance history

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

  • · probe · passed · 1726 ms · metadata changed · 15 tool(s)
  • · probe · passed · 1339 ms · metadata changed · 14 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 revuo-mcp https://www.revuo.ai/api/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 revuo-mcp --url https://www.revuo.ai/api/mcp

Cursor

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

Cline

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

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start revuo-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "revuo-mcp": {
      "type": "http",
      "url": "https://www.revuo.ai/api/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 revuo-mcp https://www.revuo.ai/api/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://www.revuo.ai/api/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": {
    "revuo-mcp": {
      "serverUrl": "https://www.revuo.ai/api/mcp"
    }
  }
}

Let your agent find its tools

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

Do you run Revuo MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing