Documentation MCP - Rhombus Developer Documentation

The Model Context Protocol (MCP) is an open standard that creates standardized connections between AI applications and external services. Rhombus provides an MCP server that gives AI tools like Claude Code, Cursor, and Claude Desktop instant access to our complete API documentation.

Info

Quick Access

Rhombus Developer Documentation MCP Server: https://developer.rhombus.com/mcp

Why use the Documentation MCP?

Instant Documentation Access

AI assistants can search and retrieve relevant documentation without leaving your workflow

Always Up-to-Date

Automatically synced with the latest Rhombus API documentation

Context-Aware Assistance

AI tools understand your API and provide accurate, documentation-backed responses

Faster Development

Get answers about endpoints, parameters, and examples instantly while coding

What's included

The Rhombus Documentation MCP provides:

Search Tool: Query the complete Rhombus API documentation
Endpoint Information: Details about all available API endpoints
Code Examples: Access to implementation examples and best practices
Authentication Guide: Information about API keys and authentication methods
Integration Patterns: Video player implementations and advanced use cases

Setup instructions

Choose your AI tool below for setup instructions:

Add MCP to Claude Code

Claude Code makes it simple to add MCP servers with a single command.

Open Terminal
Open your terminal or command prompt
Run MCP Add Command
Execute the following command:
bash
```
claude mcp add --transport http rhombus-docs https://developer.rhombus.com/mcp
```
This adds the Rhombus documentation MCP with the name rhombus-docs.
Verify Installation
The MCP will be immediately available in Claude Code. You can verify by asking:
```
"Search the Rhombus documentation for camera endpoints"
```
Claude Code will now use the MCP to retrieve accurate documentation.

Using the MCP in Claude Code

Once configured, Claude Code will automatically:

Search documentation when you ask API-related questions
Reference specific endpoints when building integrations
Provide code examples from the documentation
Suggest best practices based on official guides

Example queries:

"How do I authenticate with the Rhombus API?"
"Show me camera endpoints for retrieving video"
"What parameters does the access control API accept?"
"How do I implement the video player?"

Add MCP to Claude Desktop

Connect Claude Desktop to Rhombus documentation for instant API reference.

Open Claude Settings
Click on your profile icon in Claude Desktop and select Settings
Navigate to Connectors
Go to the Connectors section in settings
Add Custom Connector
Click Add custom connector and fill in:
- Name: Rhombus Documentation
- URL: https://developer.rhombus.com/mcp
- Type: Model Context Protocol (MCP)
Save and Test
Save the connector and test it by asking:
```
"What camera APIs does Rhombus provide?"
```
Claude will now access the documentation to answer your questions.

Tip

The connector will appear with a small icon next to responses that used the documentation MCP.

Add MCP to Cursor

Integrate Rhombus documentation into Cursor for AI-powered coding assistance.

Open Command Palette
Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
Search for MCP Settings
Type "Open MCP settings" and select it from the list

Add Custom MCP Server

In the MCP settings file, add the Rhombus documentation server:

json

{
  "mcpServers": {
    "rhombus-docs": {
      "url": "https://developer.rhombus.com/mcp",
      "transport": "http"
    }
  }
}

Restart Cursor
Restart Cursor to load the new MCP configuration
Verify Integration
Use Cursor's AI features and ask:
```
"Search Rhombus docs for authentication methods"
```

Using in Cursor Composer

When using Cursor Composer or Chat, the MCP enables:

Automatic documentation lookup during coding
Inline suggestions based on API documentation
Code generation using official examples
Real-time validation against API specifications

Add MCP to VS Code

Configure the Rhombus MCP for use with VS Code AI extensions.

Create MCP Configuration
Create a .vscode/mcp.json file in your workspace root:
bash
```
mkdir -p .vscode
touch .vscode/mcp.json
```

Add Server Configuration

Add the following to .vscode/mcp.json:

json

{
  "mcpServers": {
    "rhombus-docs": {
      "url": "https://developer.rhombus.com/mcp",
      "transport": "http",
      "description": "Rhombus API Documentation"
    }
  }
}

Install MCP-Compatible Extension
Install an AI extension that supports MCP, such as:
- Continue
- Cody
- Other MCP-compatible VS Code extensions
Use in Your Workflow
The MCP will be available to your AI assistant. Ask questions like:
```
"How do I get a list of cameras from Rhombus API?"
```

Generic MCP Configuration

Most MCP-compatible tools follow a similar pattern:

Connection Details:

Server URL: https://developer.rhombus.com/mcp
Transport: HTTP
Name: rhombus-docs (or your preference)

Configuration Example (JSON):

json

{
  "name": "rhombus-docs",
  "url": "https://developer.rhombus.com/mcp",
  "transport": "http"
}

Supported Tools:

Goose AI
Any MCP-compatible AI assistant
Custom integrations using MCP SDK

Check your tool's documentation for specific MCP configuration instructions.

Available tools

The Rhombus Documentation MCP provides the following tools to AI assistants:

search_rhombus_developer

Search the complete Rhombus documentation

This tool allows AI assistants to search through all documentation pages, including:

API endpoint references
Authentication guides
Implementation examples
Video player documentation
Best practices and tutorials

Example Usage:

Tool: search_rhombus_developer
Query: "camera video streaming endpoints"

Results: Returns relevant documentation snippets with links to full pages. Pass an optional language code (for example es) to search a translated version.

query_docs_filesystem_rhombus_developer

Read documentation pages and OpenAPI specs directly

Runs read-only, shell-like commands against an in-memory filesystem that contains every documentation page (as .mdx) and the OpenAPI specs:

ls / tree to explore the documentation structure
cat / head to read a full page
rg for exact keyword or regex matches

This is how AI assistants read a complete page — there is no separate "get page" tool.

Example Usage:

Tool: query_docs_filesystem_rhombus_developer
Command: head -200 /api-reference/overview.mdx

Results: Returns the raw page content or search matches from the documentation filesystem.

Example workflows

Building a video integration

Ask About Video Endpoints
```
"What endpoints do I need to stream video from a Rhombus camera?"
```
The MCP will search documentation and provide relevant endpoints with descriptions.
Get Implementation Details
```
"Show me how to implement the DashJS video player"
```
Retrieves the complete video player implementation guide with code examples.
Ask About Authentication
```
"How do I authenticate for video streaming?"
```
Provides federated token authentication details and code samples.
Request Specific Examples
```
"Give me a complete JavaScript example for streaming video"
```
Returns working code examples from the documentation.

Exploring access control

Discover Endpoints
```
"List all access control endpoints in the Rhombus API"
```
MCP searches and returns comprehensive list of access control endpoints.
Understand Parameters
```
"What parameters does createAccessGrant accept?"
```
Retrieves detailed parameter documentation for the specific endpoint.
See Examples
```
"Show me an example of creating an access grant"
```
Provides code examples and usage patterns from documentation.

Best practices

Be Specific in Queries

Ask targeted questions about specific endpoints or features for better results

Reference by Name

Mention "Rhombus API" or specific endpoint names to get focused documentation

Request Code Examples

Explicitly ask for code examples when you need implementation help

Follow Up Questions

Ask follow-up questions to drill deeper into specific topics

Troubleshooting

MCP Not Responding

Possible causes:

MCP server URL is incorrect
Network connectivity issues
Tool needs to be restarted

Solutions:

Verify the URL: https://developer.rhombus.com/mcp
Check your internet connection
Restart your AI tool
Re-add the MCP configuration

No Results Found

Try these approaches:

Rephrase your question more specifically
Use exact endpoint names or feature names
Break complex questions into simpler queries
Check if you're asking about a feature that exists in Rhombus API

Outdated Information

The MCP server automatically syncs with the latest documentation. If you suspect outdated information:

The documentation may have been recently updated
Try rephrasing to get different results
Verify against the online documentation

Configuration Not Loading

For command-line tools:

bash

# Remove and re-add the MCP
claude mcp remove rhombus-docs
claude mcp add --transport http rhombus-docs https://developer.rhombus.com/mcp

For GUI tools:

Remove the MCP configuration
Restart the application
Re-add the configuration
Verify the URL is exactly: https://developer.rhombus.com/mcp

Privacy & security

Info

Data Privacy

The MCP server only provides access to public Rhombus API documentation. No private data, API keys, or user information is transmitted through the MCP.

What the MCP provides: