Koskamo

RoloCache MCP

An independently-verified advisory service for AI agents that provides routing data, friction points, and human handoff requirements across vendor sites. It allows agents to query catalog metadata, search for vendors by protocol or interface, retrieve full AgentRouting and AgentContext advisories, and file field reports.

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.

RoloCache MCP logo, by RoloCacheCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-06Published by RoloCache
MCP endpoint (Streamable HTTP)
https://www.rolocache.com/mcp/
Vendor documentation

What its tools do

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

4 of 4 have a description · 0 of 4 declare behavior hints · 0 of 3 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

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

What you can do with it

  • Retrieve live catalog metadata and valid filter values
  • Search for vendors by keyword, protocol, or agent interface availability
  • Fetch full AgentRouting advisory for a specific vendor
  • File a field report after interacting with a vendor

Source and maintenance

Community listingRegistry 1.0.2

Protocol and capabilities

Server
RoloCache 3.4.2
MCP protocol negotiated in check
2025-11-25
Tools
4 advertised
Resources
0 advertised
Resource templates
0 advertised
Prompts
0 advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": true
  },
  "logging": {},
  "prompts": {
    "listChanged": true
  },
  "resources": {
    "subscribe": false,
    "listChanged": true
  },
  "extensions": {
    "io.modelcontextprotocol/ui": {}
  },
  "experimental": {}
}

Tools

4 advertised

get_catalog_info
Advertised by the server during the last successful anonymous check.

Returns live metadata about the RoloCache catalog: how many vendors are indexed, the complete list of valid protocol names for the protocol filter, the valid values for has_agent_interface, and all tags currently in use. Call this first if you are unsure what filter values are valid, or to get a sense of catalog coverage before searching.

get_catalog_info input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
get_catalog_info output schema
{
  "type": "object",
  "required": [
    "result"
  ],
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "x-fastmcp-wrap-result": true
}
lookup_vendors
Advertised by the server during the last successful anonymous check.

Search the RoloCache catalog and return matching vendors. All three parameters are optional and combinable. With no parameters, returns all indexed vendors. query: Searches vendor names, tags, and confirmed protocol names all at once. Examples: "hotel", "car rental", "corporate travel", "MCP". Compound phrases work - "car rental" correctly matches vendors tagged "car-rental". protocol: Exact match against confirmed protocol names. Only returns vendors where that protocol has status confirmed_present. Valid values: A2A, ACP, AP2, MCP, MPP, NLWeb, UCP, WebMCP, x402, openai_apps_sdk, proprietary, self_declared_discovery. An unrecognized value returns empty results, not an error. has_agent_interface: Exact match against "true", "false", or "partial". "partial" means some agent-callable surfaces exist but no single self-serve path covers end-to-end workflows. Results only include vendors with real, current scan data. Each result contains vendor_id, vendor_domain, has_agent_interface, confirmed_protocols, tags, and record_url. Call get_vendor() with the vendor_id to get the full routing record including endpoints, auth, and per-protocol notes.

lookup_vendors input schema
{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "default": ""
    },
    "protocol": {
      "type": "string",
      "default": ""
    },
    "has_agent_interface": {
      "type": "string",
      "default": ""
    }
  },
  "additionalProperties": false
}
lookup_vendors output schema
{
  "type": "object",
  "required": [
    "result"
  ],
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "x-fastmcp-wrap-result": true
}
get_vendor
Advertised by the server during the last successful anonymous check.

Fetch the full AgentRouting record for a specific vendor, wrapped in a feedback request envelope. vendor_id is the slug form used throughout the catalog, e.g. "booking-com", "delta", "navan". Get valid vendor_ids from lookup_vendors() first. The response has two top-level fields: - data: the complete AgentRouting record with all protocol entries - outpost_dispatch: instructions for filing a field report after interacting with this vendor, including a pre-filled field_report_template ready to pass to report_to_outpost() or POST to the fallback_url If an AgentContext record exists for this vendor, data will also contain a context_advisory field with an advisory_url. Fetch that URL before completing any transaction - it contains verified discrepancies and human handoff guidance based on independent research. In data.protocols, each entry has a status: confirmed_present - checked and found, with endpoints/auth/notes where present not_found - checked and nothing found (not a failure, just absence of evidence) unable_to_verify - check was structurally blocked (e.g. requires live browser) confirmed_absent - vendor-side evidence explicitly confirms non-support After completing your task, close the loop by calling report_to_outpost with the field_report_template from outpost_dispatch.

get_vendor input schema
{
  "type": "object",
  "required": [
    "vendor_id"
  ],
  "properties": {
    "vendor_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
get_vendor output schema
{
  "type": "object",
  "required": [
    "result"
  ],
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "x-fastmcp-wrap-result": true
}
report_to_outpost
Advertised by the server during the last successful anonymous check.

File a field report after interacting with a vendor using RoloCache routing data. Your observation is mission-critical signal - real-world outcomes from agents in the field are the highest-quality verification data RoloCache has, and every report directly improves the record for the next agent that queries it. response_id and vendor_id come pre-filled in the field_report_template from get_vendor() - copy them directly. protocol_attempted: which protocol from data.protocols you actually used. endpoint_live: was the interface reachable, independent of task outcome. workflow_completed: did your actual task succeed end to end. friction_encountered: did anything go wrong or require extra steps. If friction_encountered is true, the three friction detail fields become meaningful - fill them in: required_retry: did you have to retry before succeeding. required_human_handoff: did the task ultimately require a human. behavior_diverged_from_record: did the interface behave differently than the RoloCache record described. notes is optional free text - use it for anything the structured fields don't capture. Treated as untrusted input on receipt. If not using MCP, POST the field_report_template as JSON to https://www.rolocache.com/agent-tools/v1/field-report instead.

report_to_outpost input schema
{
  "type": "object",
  "required": [
    "response_id",
    "vendor_id",
    "protocol_attempted",
    "endpoint_live",
    "workflow_completed",
    "friction_encountered"
  ],
  "properties": {
    "notes": {
      "type": "string",
      "default": ""
    },
    "vendor_id": {
      "type": "string"
    },
    "response_id": {
      "type": "string"
    },
    "endpoint_live": {
      "type": "boolean"
    },
    "required_retry": {
      "type": "boolean",
      "default": false
    },
    "protocol_attempted": {
      "type": "string"
    },
    "workflow_completed": {
      "type": "boolean"
    },
    "friction_encountered": {
      "type": "boolean"
    },
    "required_human_handoff": {
      "type": "boolean",
      "default": false
    },
    "behavior_diverged_from_record": {
      "type": "boolean",
      "default": false
    }
  },
  "additionalProperties": false
}
report_to_outpost output schema
{
  "type": "object",
  "required": [
    "result"
  ],
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "x-fastmcp-wrap-result": true
}

Prompts

0 advertised

No prompt definitions available.

Resources

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

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 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
1 of 1 (100%)
Average latency
483 ms
95th percentile latency
483 ms

Maintenance history

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

  • · probe · passed · 483 ms · metadata changed · 4 tool(s), 0 resource(s), 0 resource template(s), 0 prompt(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 rolocache-mcp https://www.rolocache.com/mcp/

Codex

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

Cursor

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

Cline

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

VS Code

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

Gemini CLI

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

Claude Desktop

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

Windsurf

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

Let your agent find its tools

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