# Claude Code setup Source: https://docs.cloudmcp.run/ai-tools/claude-code Configure Claude Code for your documentation workflow Claude Code is Anthropic's official CLI tool. This guide will help you set up Claude Code to help you write and maintain your documentation. ## Prerequisites * Active Claude subscription (Pro, Max, or API access) ## Setup 1. Install Claude Code globally: ```bash theme={null} npm install -g @anthropic-ai/claude-code ``` 2. Navigate to your docs directory. 3. (Optional) Add the `CLAUDE.md` file below to your project. 4. Run `claude` to start. ## Create `CLAUDE.md` Create a `CLAUDE.md` file at the root of your documentation repository to train Claude Code on your specific documentation standards: ```markdown theme={null} # Mintlify documentation ## Working relationship - You can push back on ideas-this can lead to better documentation. Cite sources and explain your reasoning when you do so - ALWAYS ask for clarification rather than making assumptions - NEVER lie, guess, or make up information ## Project context - Format: MDX files with YAML frontmatter - Config: docs.json for navigation, theme, settings - Components: Mintlify components ## Content strategy - Document just enough for user success - not too much, not too little - Prioritize accuracy and usability of information - Make content evergreen when possible - Search for existing information before adding new content. Avoid duplication unless it is done for a strategic reason - Check existing patterns for consistency - Start by making the smallest reasonable changes ## Frontmatter requirements for pages - title: Clear, descriptive page title - description: Concise summary for SEO/navigation ## Writing standards - Second-person voice ("you") - Prerequisites at start of procedural content - Test all code examples before publishing - Match style and formatting of existing pages - Include both basic and advanced use cases - Language tags on all code blocks - Alt text on all images - Relative paths for internal links ## Git workflow - NEVER use --no-verify when committing - Ask how to handle uncommitted changes before starting - Create a new branch when no clear branch exists for changes - Commit frequently throughout development - NEVER skip or disable pre-commit hooks ## Do not - Skip frontmatter on any MDX file - Use absolute URLs for internal links - Include untested code examples - Make assumptions - always ask for clarification ``` # Cursor setup Source: https://docs.cloudmcp.run/ai-tools/cursor Configure Cursor for your documentation workflow Use Cursor to help write and maintain your documentation. This guide shows how to configure Cursor for better results on technical writing tasks and using Mintlify components. ## Prerequisites * Cursor editor installed * Access to your documentation repository ## Project rules Create project rules that all team members can use. In your documentation repository root: ```bash theme={null} mkdir -p .cursor ``` Create `.cursor/rules.md`: ````markdown theme={null} # Mintlify technical writing rule You are an AI writing assistant specialized in creating exceptional technical documentation using Mintlify components and following industry-leading technical writing practices. ## Core writing principles ### Language and style requirements - Use clear, direct language appropriate for technical audiences - Write in second person ("you") for instructions and procedures - Use active voice over passive voice - Employ present tense for current states, future tense for outcomes - Avoid jargon unless necessary and define terms when first used - Maintain consistent terminology throughout all documentation - Keep sentences concise while providing necessary context - Use parallel structure in lists, headings, and procedures ### Content organization standards - Lead with the most important information (inverted pyramid structure) - Use progressive disclosure: basic concepts before advanced ones - Break complex procedures into numbered steps - Include prerequisites and context before instructions - Provide expected outcomes for each major step - Use descriptive, keyword-rich headings for navigation and SEO - Group related information logically with clear section breaks ### User-centered approach - Focus on user goals and outcomes rather than system features - Anticipate common questions and address them proactively - Include troubleshooting for likely failure points - Write for scannability with clear headings, lists, and white space - Include verification steps to confirm success ## Mintlify component reference ### Callout components #### Note - Additional helpful information Supplementary information that supports the main content without interrupting flow #### Tip - Best practices and pro tips Expert advice, shortcuts, or best practices that enhance user success #### Warning - Important cautions Critical information about potential issues, breaking changes, or destructive actions #### Info - Neutral contextual information Background information, context, or neutral announcements #### Check - Success confirmations Positive confirmations, successful completions, or achievement indicators ### Code components #### Single code block Example of a single code block: ```javascript config.js const apiConfig = { baseURL: 'https://api.example.com', timeout: 5000, headers: { 'Authorization': `Bearer ${process.env.API_TOKEN}` } }; ``` #### Code group with multiple languages Example of a code group: ```javascript Node.js const response = await fetch('/api/endpoint', { headers: { Authorization: `Bearer ${apiKey}` } }); ``` ```python Python import requests response = requests.get('/api/endpoint', headers={'Authorization': f'Bearer {api_key}'}) ``` ```curl cURL curl -X GET '/api/endpoint' \ -H 'Authorization: Bearer YOUR_API_KEY' ``` #### Request/response examples Example of request/response documentation: ```bash cURL curl -X POST 'https://api.example.com/users' \ -H 'Content-Type: application/json' \ -d '{"name": "John Doe", "email": "john@example.com"}' ``` ```json Success { "id": "user_123", "name": "John Doe", "email": "john@example.com", "created_at": "2024-01-15T10:30:00Z" } ``` ### Structural components #### Steps for procedures Example of step-by-step instructions: Run `npm install` to install required packages. Verify installation by running `npm list`. Create a `.env` file with your API credentials. ```bash API_KEY=your_api_key_here ``` Never commit API keys to version control. #### Tabs for alternative content Example of tabbed content: ```bash brew install node npm install -g package-name ``` ```powershell choco install nodejs npm install -g package-name ``` ```bash sudo apt install nodejs npm npm install -g package-name ``` #### Accordions for collapsible content Example of accordion groups: - **Firewall blocking**: Ensure ports 80 and 443 are open - **Proxy configuration**: Set HTTP_PROXY environment variable - **DNS resolution**: Try using 8.8.8.8 as DNS server ```javascript const config = { performance: { cache: true, timeout: 30000 }, security: { encryption: 'AES-256' } }; ``` ### Cards and columns for emphasizing information Example of cards and card groups: Complete walkthrough from installation to your first API call in under 10 minutes. Learn how to authenticate requests using API keys or JWT tokens. Understand rate limits and best practices for high-volume usage. ### API documentation components #### Parameter fields Example of parameter documentation: Unique identifier for the user. Must be a valid UUID v4 format. User's email address. Must be valid and unique within the system. Maximum number of results to return. Range: 1-100. Bearer token for API authentication. Format: `Bearer YOUR_API_KEY` #### Response fields Example of response field documentation: Unique identifier assigned to the newly created user. ISO 8601 formatted timestamp of when the user was created. List of permission strings assigned to this user. #### Expandable nested fields Example of nested field documentation: Complete user object with all associated data. User profile information including personal details. User's first name as entered during registration. URL to user's profile picture. Returns null if no avatar is set. ### Media and advanced components #### Frames for images Wrap all images in frames: Main dashboard showing analytics overview Analytics dashboard with charts #### Videos Use the HTML video element for self-hosted video content: Embed YouTube videos using iframe elements: #### Tooltips Example of tooltip usage: API #### Updates Use updates for changelogs: ## New features - Added bulk user import functionality - Improved error messages with actionable suggestions ## Bug fixes - Fixed pagination issue with large datasets - Resolved authentication timeout problems ## Required page structure Every documentation page must begin with YAML frontmatter: ```yaml --- title: "Clear, specific, keyword-rich title" description: "Concise description explaining page purpose and value" --- ``` ## Content quality standards ### Code examples requirements - Always include complete, runnable examples that users can copy and execute - Show proper error handling and edge case management - Use realistic data instead of placeholder values - Include expected outputs and results for verification - Test all code examples thoroughly before publishing - Specify language and include filename when relevant - Add explanatory comments for complex logic - Never include real API keys or secrets in code examples ### API documentation requirements - Document all parameters including optional ones with clear descriptions - Show both success and error response examples with realistic data - Include rate limiting information with specific limits - Provide authentication examples showing proper format - Explain all HTTP status codes and error handling - Cover complete request/response cycles ### Accessibility requirements - Include descriptive alt text for all images and diagrams - Use specific, actionable link text instead of "click here" - Ensure proper heading hierarchy starting with H2 - Provide keyboard navigation considerations - Use sufficient color contrast in examples and visuals - Structure content for easy scanning with headers and lists ## Component selection logic - Use **Steps** for procedures and sequential instructions - Use **Tabs** for platform-specific content or alternative approaches - Use **CodeGroup** when showing the same concept in multiple programming languages - Use **Accordions** for progressive disclosure of information - Use **RequestExample/ResponseExample** specifically for API endpoint documentation - Use **ParamField** for API parameters, **ResponseField** for API responses - Use **Expandable** for nested object properties or hierarchical information ```` # Windsurf setup Source: https://docs.cloudmcp.run/ai-tools/windsurf Configure Windsurf for your documentation workflow Configure Windsurf's Cascade AI assistant to help you write and maintain documentation. This guide shows how to set up Windsurf specifically for your Mintlify documentation workflow. ## Prerequisites * Windsurf editor installed * Access to your documentation repository ## Workspace rules Create workspace rules that provide Windsurf with context about your documentation project and standards. Create `.windsurf/rules.md` in your project root: ````markdown theme={null} # Mintlify technical writing rule ## Project context - This is a documentation project on the Mintlify platform - We use MDX files with YAML frontmatter - Navigation is configured in `docs.json` - We follow technical writing best practices ## Writing standards - Use second person ("you") for instructions - Write in active voice and present tense - Start procedures with prerequisites - Include expected outcomes for major steps - Use descriptive, keyword-rich headings - Keep sentences concise but informative ## Required page structure Every page must start with frontmatter: ```yaml --- title: "Clear, specific title" description: "Concise description for SEO and navigation" --- ``` ## Mintlify components ### Callouts - `` for helpful supplementary information - `` for important cautions and breaking changes - `` for best practices and expert advice - `` for neutral contextual information - `` for success confirmations ### Code examples - When appropriate, include complete, runnable examples - Use `` for multiple language examples - Specify language tags on all code blocks - Include realistic data, not placeholders - Use `` and `` for API docs ### Procedures - Use `` component for sequential instructions - Include verification steps with `` components when relevant - Break complex procedures into smaller steps ### Content organization - Use `` for platform-specific content - Use `` for progressive disclosure - Use `` and `` for highlighting content - Wrap images in `` components with descriptive alt text ## API documentation requirements - Document all parameters with `` - Show response structure with `` - Include both success and error examples - Use `` for nested object properties - Always include authentication examples ## Quality standards - Test all code examples before publishing - Use relative paths for internal links - Include alt text for all images - Ensure proper heading hierarchy (start with h2) - Check existing patterns for consistency ```` # Create Plant Source: https://docs.cloudmcp.run/api-reference/endpoint/create POST /plants Creates a new plant in the store # Delete Plant Source: https://docs.cloudmcp.run/api-reference/endpoint/delete DELETE /plants/{id} Deletes a single plant based on the ID supplied # Get Plants Source: https://docs.cloudmcp.run/api-reference/endpoint/get GET /plants Returns all plants from the system that the user has access to # New Plant Source: https://docs.cloudmcp.run/api-reference/endpoint/webhook WEBHOOK /plant/webhook Information about a new plant added to the store # Introduction Source: https://docs.cloudmcp.run/api-reference/introduction Example section for showcasing API endpoints If you're not looking to build API reference documentation, you can delete this section by removing the api-reference folder. ## Welcome There are two ways to build API documentation: [OpenAPI](https://mintlify.com/docs/api-playground/openapi/setup) and [MDX components](https://mintlify.com/docs/api-playground/mdx/configuration). For the starter kit, we are using the following OpenAPI specification. View the OpenAPI specification file ## Authentication All API endpoints are authenticated using Bearer tokens and picked up from the specification file. ```json theme={null} "security": [ { "bearerAuth": [] } ] ``` # The uptake curve: ChatGPT’s remote MCP support and what it means for AI‑tool adoption Source: https://docs.cloudmcp.run/blog/chatgpt-remote-mcp ChatGPT now speaks the Model Context Protocol (MCP) via custom connectors. Here’s what that unlocks for teams—and how we make deployments effortless on Cloud MCP. ChatGPT now supports **custom connectors that follow the Model Context Protocol (MCP)**, letting you attach your own remote MCP servers to everyday chats. In practice, that means the assistant can securely reach into your SaaS apps or internal systems and **do** things—search logs, open tickets, update records—without bespoke plugins for each service. OpenAI’s Help Center documents plan availability (Pro and Business/Enterprise/Edu) and the basics of enabling and using custom connectors. ([OpenAI Help Center][1]) If MCP is new to you, think of it as **USB‑C for AI tools**. It’s a vendor‑neutral way for assistants to discover a server’s **tools** (actions), **resources** (data), and **prompts** (reusable workflows) using a consistent schema. OpenAI’s Agents SDK and Anthropic’s documentation both use the USB‑C analogy to emphasize portability across clients. Build one MCP server and you can reuse it in multiple assistants. ([OpenAI GitHub Pages][2]) ### What actually changed ChatGPT’s UI can now call **remote MCP servers** you register as custom connectors, bringing the protocol from developer‑only plumbing into day‑to‑day chats. On the API side, OpenAI’s **hosted MCP tool** (in the Responses API) also connects models directly to remote MCP servers, with options like `allowed_tools` for trimming the action surface and optional **human approval** for sensitive writes. For teams standardizing on OpenAI, you now have UI **and** API paths that speak the same open protocol. ([OpenAI Cookbook][3]) ### Why it matters for adoption * **One server, many assistants.** MCP’s purpose is interop. Instead of writing custom adapters for each assistant, you publish an MCP server once and plug it into different clients—including ChatGPT. That lowers integration costs and shortens proof‑of‑value cycles. ([Anthropic][4]) * **Actionable, not just informational.** With read/write tools, teams can move from “summarize what you found” to **“file this ticket and link the incident”**—with approval gates where needed. ([OpenAI Cookbook][3]) * **A clearer security model.** Modern MCP emphasizes **Streamable HTTP** transport (HTTP + optional SSE for streaming) and a normative **OAuth 2.1** flow for HTTP transports. That makes remote servers a first‑class, cloud‑friendly target that slots into existing identity and policy. ([Model Context Protocol][5]) ### Quick start for teams (safely) 1. **Start read‑only.** Register a connector that exposes search/reporting tools; monitor usage and results quality. (In ChatGPT, open a chat → *Tools* → *Use connectors*.) ([OpenAI Help Center][1]) 2. **Add one write tool with approvals.** Use an approval step or a callback to gate state‑changing actions until you trust the server. The Agents SDK shows this pattern explicitly. ([OpenAI GitHub Pages][2]) 3. **Harden your server.** Follow MCP’s authorization guidance and harden transports: validate the **Origin** header to resist DNS‑rebinding, scope tokens tightly, and avoid token passthrough. ([Model Context Protocol][6]) 4. **Mind compatibility.** If you see “this MCP server doesn’t implement our specification,” it often means required tools for certain workflows (e.g., `search` and `fetch`) are missing—fix the server, not the prompt. ([OpenAI Help Center][1]) ### What to watch next As more vendors publish MCP servers, expect **catalogs** of approved servers within organizations and better **RBAC** and audit controls around who can add and use connectors. Meanwhile, the protocol continues to mature around Streamable HTTP and OAuth 2.1, which should make security reviews more predictable. ([Model Context Protocol][5]) *** ## How this fits into **our** workflow on CloudMCP.run We built **Cloud MCP** to remove the deployment drag so your team can focus on what the assistant *does*, not where the server runs. In minutes, you can deploy **any MCP server**—from our registry **or straight from NPM, PyPI, or GitHub**—with real‑time validation and flexible environment variables. We provision and run the server for you and hand back an OAuth 2.1-protected **unique HTTPS endpoint** you can paste into ChatGPT’s **Settings → Connectors** as a custom connector. From there, you toggle the tools you want and start using them in chat. ([Cloud MCP][7]) A few niceties we’ve prioritized for production teams: * **Fast paths to “hello, tool.”** Click‑to‑deploy flows (including custom deployments), plus GitHub sign‑in and sensible defaults so you’re not spelunking Kubernetes on day one. ([Cloud MCP][8]) * **Security‑minded by default.** We discourage risky env vars and encourage least‑privilege tokens; you control arguments, env, and (where applicable) private package access. (See the *Custom Deployment* guide for details and current availability notes.) ([Cloud MCP][7]) * **Try first, scale later.** Spin up time‑boxed **trial deployments** to validate behavior in ChatGPT before moving to always‑on instances. ([Cloud MCP][7]) **TL;DR:** ChatGPT’s MCP support makes the protocol a practical daily driver. If you want to move fast, deploy your server on **CloudMCP.run**, copy the endpoint into a **Custom Connector**, and give your team a safe, standardized way to turn conversations into **actions**. ([OpenAI Help Center][1]) *Further reading:* OpenAI’s Connector guide (plans, how‑to, troubleshooting), the MCP authorization + transports docs, and the Agents SDK’s hosted/approval patterns. ([OpenAI Help Center][1]) [1]: https://help.openai.com/en/articles/11487775-connectors-in-chatgpt "Connectors in ChatGPT | OpenAI Help Center" [2]: https://openai.github.io/openai-agents-js/guides/mcp/ "Model Context Protocol (MCP) | OpenAI Agents SDK" [3]: https://cookbook.openai.com/examples/mcp/mcp_tool_guide "Guide to Using the Responses API's MCP Tool" [4]: https://docs.anthropic.com/en/docs/mcp "Model Context Protocol (MCP) - Anthropic" [5]: https://modelcontextprotocol.io/specification/2025-03-26/basic/transports?utm_source=chatgpt.com "Transports" [6]: https://modelcontextprotocol.io/specification/draft/basic/authorization?utm_source=chatgpt.com "Authorization" [7]: https://cloudmcp.run/blog/deploy-any-mcp-server "Deploy Remote MCP Servers from NPM, PyPI, or GitHub with Custom Deployments" [8]: https://cloudmcp.run/blog/welcome "Introducing CloudMCP.run - Deploy MCP Servers Without the Headaches" # Using Claude Connectors with Cloud MCP Source: https://docs.cloudmcp.run/blog/claude-connectors-guide A fast, no-fluff walkthrough showing how to connect Cloud MCP to Claude, enable Connectors, and use them together in a single conversation. ## TL;DR You’ll (1) deploy or pick an MCP server on **Cloud MCP**, (2) add it to **Claude** as a Claude Connector, (3) toggle **Claude Connectors** tools, and (4) prompt Claude to use your Connectors in a chat. *** ## Prerequisites * A **Cloud MCP** account with at least one deployed MCP server (e.g., Playwright, Desktop Commander, or any server from the registry). * A **Claude** account with **MCP** support and **Connectors** available in your workspace. * You’re comfortable approving an OAuth flow when Claude connects to your Cloud MCP server. > Tip: Cloud MCP exposes **OAuth-protected Remote (HTTP) MCP** endpoints. Claude never sees your Cloud MCP credentials; it just calls the server’s tools over the OAuth session. *** *** # How to Use Claude Connectors with Cloud MCP (Video + Guide) [https://youtu.be/hlHnhAr0nFU](https://youtu.be/hlHnhAr0nFU) *** ## 1) Pick (or deploy) an MCP server on Cloud MCP 1. Open Cloud MCP → **Servers** and choose a server that fits your task (e.g., a search or code-aware tool). 2. If needed, provide env vars/secrets and click **Deploy**. Wait until the server is **Healthy**. 3. Go to the server details page and locate and click the **Copy URL** button. Cloud MCP dashboard showing deployed servers *** ## 2) Add the Cloud MCP Connector to Claude (Remote HTTP MCP) 1. In Claude, open **Settings → Connectors**. Claude Settings page 2. Choose **Add Custom Connector**. Claude Add connector button 3. Paste the Cloud MCP server URL (the OAuth-protected endpoint that Cloud MCP provides). 4. Approve the **Cloud MCP OAuth** screen when prompted. 5. After a successful handshake, you should see the tools listed in the chat window; expand it to confirm. Claude Connector tools > If tools don’t appear: re-open the connection panel, confirm URL in Cloud MCP, and retry the OAuth approval. *** ## 4) Use your Cloud MCP Claude Connector Tools! Claude chat calling MCP tools via Cloud MCP connector *** ## 6) Troubleshooting * **MCP tools don’t appear in Claude:** Reconnect the Remote (HTTP) server in Settings; confirm the Cloud MCP server is **Healthy** and the OAuth grant is still valid. * **Connector not available in chat:** Ensure it’s toggled on in **Settings → Connectors** and that you’ve authorized it. * **Ambiguous tool routing:** In your prompt, explicitly say *which* tool to use for *which* sub-task. Avoid enabling unnecessary connectors/tools for a session. *** ## 7) Privacy & access notes * Cloud MCP keeps your MCP server behind **OAuth**; Claude receives only tool responses. * Disable any connector you don’t need for a session. *** ## 8) Where to go next * Add more MCP servers to Cloud MCP (e.g., research, code intelligence, browsers). * Create **small, purpose-built** prompts that map cleanly to a tool or connector. * Save a “starter chat” template in your team wiki with the exact toggles and prompt you use for repeatable tasks. ### Need Help? If you run into any issues: * Reach out to [me](mailto:vikash@cloudmcp.run) * Check our [Blog Posts](https://cloudmcp.run/blog) * Join our [Discord community](https://discord.gg/cloudmcp) *** *Ready to deploy your Claude Connectors? [Sign Up for a plan! →](https://cloudmcp.run/pricing?utm_source=blog\&utm_medium=claude-connectors-guide)* # How to Deploy a Remote MCP Server (on cloudmcp.run) Source: https://docs.cloudmcp.run/blog/cloud-mcp-deployment-guide Learn how to deploy Model Context Protocol (MCP) servers on cloudmcp.run in just a few clicks. This step-by-step guide walks you through finding, saving, and deploying MCP servers. # How to Deploy an MCP Server on CloudMCP.run Deploying an MCP (Model Context Protocol) server on CloudMCP.run is designed to be quick and straightforward. In this guide, we'll walk you through the entire process from finding a server to having it deployed and running in production. ## Prerequisites Before you begin, make sure you have: * A cloudmcp.run account (sign up with GitHub at [cloudmcp.run](https://cloudmcp.run)) * Basic understanding of what MCP servers do * Any required API keys or credentials for the server you want to deploy ## Step 1: Find Your MCP Server Start by navigating to the "Find Servers" page from your dashboard. Here you can browse our registry of available MCP servers or import your own from a GitHub repository. Find Servers page showing search functionality and Import Server button You can: * **Search the registry**: Type keywords to find servers that match your needs (e.g., "desktop-commander", "filesystem", "database") * **Import your own**: Click the "Import Server" button to link your own GitHub repository * **Bookmark/Save Servers**: Click the bookmark icon on any server card to save it to your personal library for easy access later For this guide, we'll deploy the popular `@wonderwhy-er/desktop-commander` server, which gives Claude terminal control and file system access. Find Servers page showing search result and bookmark icon ## Step 2: Browse and Save Servers Once you've found servers you're interested in, they'll appear in your "Saved Servers" section. This is your personal library of MCP servers ready to deploy. Deploy Saved Servers page showing three saved MCP servers with deployment options From this view, you can: * See your deployed servers * See all your saved servers with their descriptions * Check the package name and version * View when each server was saved * Click "Deploy Server" to begin deployment Each server card shows: * **Package name**: The npm package or GitHub repository * **Version**: Current version or branch * **Description**: What the server does * **Save date**: When you added it to your library ## Step 3: Configure Your Deployment Click "Deploy Server" on your chosen server to open the deployment configuration modal. Deployment configuration modal showing fields for deployment name, command, arguments, and environment variables ### Configuration Options: #### Deployment Name Give your deployment a unique, descriptive name. This helps you identify it later, especially if you deploy the same server multiple times with different configurations. #### Command The command to run your server. Common options: * `npx` - For npm packages (most common) * `node` - For custom scripts * `python` - For Python-based servers #### Arguments The specific package or script to run. For npm packages, this is typically: * `-y @package-name` (the `-y` flag skips npm prompts) #### Environment Variables Add any required configuration: * API keys * Database connection strings * Custom settings * Authentication tokens > 🔒 **Security Tip**: Environment variables are encrypted and never exposed in logs or the UI after creation. ### Example Configuration For the desktop-commander server: * **Deployment Name**: `desktop-commander` * **Command**: `npx` * **Arguments**: `-y @wonderwhy-er/desktop-commander` * **Environment Variables**: (Add any required API keys or settings) Click "Deploy" when you're ready to launch your server. ## Step 4: Monitor Your Deployment After clicking deploy, you'll be redirected to your deployments page where you can monitor the status of your server. Active Deployments page showing a running desktop-commander server with its details and controls ### Deployment Details: Your deployed server card shows: * **Status indicator**: Green dot for active, yellow for deploying, red for stopped * **Deployment date**: When the server was deployed * **Description**: What the server does * **Package info**: The underlying package being run * **Server URL**: Your unique endpoint (e.g., `https://2976130-e28603...`) ### Available Actions: * **Copy URL**: Click the copy icon next to the server URL to copy it to your clipboard * **Install in VSCode**: 1-click install directly into VSCode with OAuth authentication * **Stop**: Shut down and delete the server ## Step 5: Connect Your MCP Client Now that your server is deployed, you can connect to it from any MCP-compatible client. ### For Configuration-file Based Clients: 1. Copy your server URL from the deployment card 2. In your MCP client configuration, add: ```json theme={null} { "mcpServers": { "desktop-commander": { "url": "https://your-server-url.cloudmcp.run" } } } ``` 3. Restart your client to connect to the server ### Testing Your Connection Once connected, you can test your server: * For desktop-commander: Try asking Claude to list files or run terminal commands * For database servers: Query your connected database * For API servers: Make requests to your configured endpoints ## Managing Your Deployments Click on your deployment card to view: * 1-click VSCode MCP installation. * Performance metrics\* (soon!) * Stop action ### Scaling and Performance CloudMCP.run automatically handles: * **Auto-scaling**: Servers scale based on demand * **Load balancing**: Requests are distributed efficiently * **Failover**: Automatic recovery from crashes * **Caching**: Improved response times for repeated requests ## Best Practices 1. **Use descriptive names**: Make it easy to identify deployments 2. **Stop unused servers**: Save resources by stopping inactive deployments ## Troubleshooting ### Server Won't Start * Check your environment variables are correctly formatted * Verify the package name and version * Review deployment logs for error messages ### Connection Issues * Ensure your server URL is correctly copied * Check that your client supports the MCP version * Verify network connectivity ### Performance Problems * Check server logs for errors * Consider upgrading your plan for more resources * Contact support if issues persist ## Advanced Features ### Multiple Deployments You can deploy the same server multiple times with different configurations: * Different environment variables * Separate instances for development/production * Isolated deployments for different projects ### Custom Servers Import your own MCP servers from GitHub: 1. Click "Import Server" on the Find Servers page 2. Enter your GitHub repository URL 3. Configure and deploy like any other server ## What's Next? Now that you've successfully deployed your first MCP server: * 🚀 **Deploy more servers**: Explore our registry for other useful integrations * 📚 **Read the docs**: Deep dive into advanced configuration options * 💬 **Join our Discord**: Connect with other developers using CloudMCP * 🛠️ **Build your own**: Create custom MCP servers for your specific needs ## Need Help? If you run into any issues: * Check our [documentation](https://docs.cloudmcp.run) * Join our [Discord community](https://discord.gg/cloudmcp) * Email support at [support@cloudmcp.run](mailto:support@cloudmcp.run) *** *Ready to deploy your next MCP server? [Head to your dashboard →](https://cloudmcp.run/dashboard)* # Introducing Cloud MCP Router: Progressive Tool Discovery for Real‑World AI Agents Source: https://docs.cloudmcp.run/blog/cloud-mcp-router Stop overloading your agents with hundreds of tools. Cloud MCP Router brings progressive discovery, auth, and collision‑safe proxying to the Model Context Protocol so you can scale to real, multi‑app workflows. > **TL;DR** — Agents don’t fail because they can’t call tools; they fail because we dump *all the tools* into the prompt at once. **Cloud MCP Router** adds a progressive, discovery‑driven layer in front of your MCP servers so the model sees *only what it needs, when it needs it*. Smaller prompts, fewer mis‑selections, and the ability to scale past arbitrary tool caps—without rewriting your existing MCP servers. *** ## The problem we’re solving Modern agents juggle calendars, email, docs, CRMs, repos, issues, and PRs. Hand the model 80–200 tools at once and you get: * **Context overload:** Tool schemas crowd out user content and inflate token cost. * **Decision paralysis:** Long, look‑alike tool lists cause mis‑selections and retries. * **Arbitrary caps:** Teams hide tools just to keep prompts short—shrinking what agents can actually do. This pattern is especially acute in **Model Context Protocol (MCP)** ecosystems designed for rich, tool‑heavy workflows. The result: your “power user” assistant never reaches its potential because the tool layer isn’t designed for discovery. *** ## Meet Cloud MCP Router **Cloud MCP Router** is a progressive, discovery‑driven layer that sits in front of your existing MCP servers (official, custom, or community) and turns any large toolset into a *query‑as‑you‑go* catalog. Instead of spraying every tool and schema into the base prompt, it exposes a small set of **router tools** that guide the agent through staged narrowing—only surfacing schemas at the moment of execution. ### What the model sees * **Start with discovery:** `discover_server_actions` returns just the *relevant* actions (by intent), not entire schemas. * **Drill in on demand:** `get_action_details` reveals parameters only for the chosen action. * **Execute confidently:** `execute_action` runs with the now‑known parameters (with elicitation automatically bridged). * **Stay unblocked:** `search_documentation` fetches the smallest useful doc snippets. *** ## How it works (under the hood) ### 1) Collision‑safe proxying of *any* MCP server Point the Router at remote MCP servers (stdio) and it will connect, list their tools/prompts/resources, and **proxy** them through a clean namespace. It sanitizes and uniquifies names, enforces length limits, and pre‑checks for collisions before exposing anything to the client—so your model never sees confusing duplicates. > **Why that matters:** Tools stay stable and human‑readable, even across many vendors and teams. No more “mystery collisions” that silently break calls. ### 2) **Router‑only mode** to shrink the prompt on demand Flip **router‑only mode** and the Router removes all proxied tools from the surface area, leaving only the small, discovery‑first router tools. When you’re ready, you can selectively re‑enable a subset of actions or whole servers—and still avoid overload. Toggle via the `Router-Mode` switch on your dashboard. ### 3) Progressive discovery & execution API (the “router tools”) * `discover_server_actions` — intent → relevant actions (fast, ranked). * `get_action_details` — reveal schema *only* for the chosen action. * `execute_action` — call the remote tool; **elicitation** is automatically bridged back to the upstream client session so the agent can ask follow‑ups mid‑execution without losing context. ### 4) Resources & prompts, too Beyond tools, the Router proxies **resources** (with stable `proxy://…` URIs) and **prompts**, keeping names safe and avoiding collisions across servers. It even installs a catch‑all resource template so ad‑hoc reads “just work.” ### 5) Auth that fits your stack The Router protects its MCP endpoint with **OAuth2** authentication against your Cloud MCP endpoint. It also publishes **well‑known protected resource metadata** so compliant clients know how to authorize. You get modern headers and correct `WWW-Authenticate` challenges out of the box. *** ## Why customers adopt Cloud MCP Router * **Smaller prompts, lower cost:** Only a tiny subset of metadata is surfaced at any moment. * **Fewer mistakes:** Staged, ranked choices beat a flat list of 100+ tools. * **Scale past arbitrary caps:** Because schemas are fetched lazily, catalogs can grow to *hundreds* of actions without overwhelming the model. * **Keep your stack:** No rewrites required—just add your existing MCP servers and go. * **Built‑in resilience:** Doc search and auth‑recovery tools unstick agents without inflating the base prompt. * **Operational sanity:** Health checks, safe namespacing, and collision detection remove brittle edges before they reach production. *** ## Example: What the agent’s loop looks like 1. **Discover:** “Open a PR that closes issue #123” → Router returns relevant actions like `repos.create_pull_request`, `issues.update`, ranked by intent. 2. **Detail:** Model asks details for `repos.create_pull_request`; Router returns just that action’s schema. 3. **Execute:** Model calls `execute_action` with the filled parameters; if extra info is needed mid‑call, elicitation is bridged back to the client session seamlessly. **Net effect:** The base prompt stays lean. The agent makes better choices. Your catalog can grow without fear. *** ## Security & enterprise readiness * **Session‑verified access tokens** (via Cloud MCP). * **Correct `WWW-Authenticate` challenges** and **.well‑known metadata** for resource authorization. *** ## Ready to route? Cloud MCP Router is available now. If you’re building assistants that need to span dozens of apps without cratering reliability or cost, this is the missing layer. * **Try it with your existing MCP servers**—no rewrites. * **Book a demo** to see progressive discovery reduce errors on your own workflows. * **Talk to us** about rollout, SSO, and enterprise controls. Let’s help your agents do more—with less. # Deploy Remote MCP Servers from NPM, PyPI, or GitHub with Custom Deployments Source: https://docs.cloudmcp.run/blog/deploy-any-mcp-server Learn how to deploy any MCP server from NPM, PyPI, or GitHub using CloudMCP's new custom deployment feature. Support for private packages, real-time validation, and multiple package managers. # Deploy Any MCP Server with CloudMCP's Custom Deployment Feature CloudMCP now lets you deploy **any** MCP (Model Context Protocol) server, not just those in our curated registry. Whether your server is published on NPM, PyPI, or hosted on GitHub, you can deploy it with just a few clicks using our new custom deployment feature. ## Prerequisites Before you begin, ensure you have: * A cloudmcp.run account (sign up with GitHub at [cloudmcp.run](https://cloudmcp.run)) * The package name or GitHub URL of the MCP server you want to deploy * Any required API keys or environment variables for your server * (Coming Soon!) Authentication tokens for private packages ## What's New? The custom deployment feature enables: * **Universal package support**: Deploy from NPM, PyPI, or GitHub repositories * **Private package deployment**: Use authentication tokens for private resources * **Real-time validation**: Instant package verification as you type * **Smart detection**: Automatic recognition of package vs repository inputs * **Flexible configuration**: Full control over arguments and environment variables ## Step 1: Access Custom Deployment Navigate to your CloudMCP dashboard and open the **Deployments** page. Scroll down to find the new "Custom Deployment" section. Custom Deployment section showing Deploy Custom Server button Click the **"Deploy Custom Server"** button to open the deployment configuration dialog. ## Step 2: Configure Your Package Manager The custom deployment dialog opens with a clean interface for configuring your server. Custom Deployment dialog showing package manager selection and input fields ### Select Your Package Manager Choose from four popular package managers based on your server's language: * **NPX** - For Node.js packages (most MCP servers) * **UVX** - For Python packages using UV * **PIPX** - For traditional Python packages * **BUNX** - For Bun runtime packages The package manager determines how CloudMCP will install and run your server. ## Step 3: Enter Your Package or Repository ### Smart Input Detection CloudMCP automatically detects what type of resource you're entering: Package input field showing smart detection with package icon * **Package name**: Shows a package icon (📦) * NPM: `@modelcontextprotocol/server-filesystem` * PyPI: `mcp-server-sqlite` * **GitHub repository**: Shows a GitHub icon (🐙) * `https://github.com/owner/repo` * `github.com/owner/repo` ### Real-time Validation As you type, CloudMCP validates your input in real-time: Real-time validation showing successful package verification The validation checks: * Package exists in the selected registry * Latest version available * Whether authentication is required * Package metadata and description > 💡 **Tip**: The validation happens automatically after you stop typing for 500ms, preventing unnecessary API calls while you type. ## Step 5: Add Configuration ### Deployment Name Give your deployment a descriptive name to identify it in your dashboard. Good naming examples: * `production-database-server` * `dev-filesystem-access` * `customer-api-integration` ### Command Arguments (Optional) Add any additional command-line arguments your server needs: Arguments field showing example arguments Common use cases: * Specify configuration files: `--config /path/to/config.json` * Set operation modes: `--mode production` * Enable features: `--enable-feature-x` ### Environment Variables Configure environment variables through the intuitive interface: Environment variables interface with add/remove buttons To add variables: 1. Click **"Add Variable"** 2. Enter the key (e.g., `API_KEY`) 3. Enter the value 4. Add more as needed 5. Remove unwanted variables with the trash icon > 🔒 **Security Tip**: CloudMCP blocks potentially dangerous environment variables like `LD_PRELOAD` and `NODE_OPTIONS` for security. ## Step 6: Deploy Your Server Once everything is configured, click **"Deploy Server"** to launch your deployment. CloudMCP will: 1. Create a dedicated instance for your server 2. Install the package from your selected registry 3. Apply all environment variables securely 4. Start the server with your specified arguments 5. Provide you with a unique endpoint URL ## Step 7: Monitor Your Deployment After deployment, you'll see your custom server in the Active Deployments section: Active deployment card showing custom badge and server details ### Custom Deployment Indicators Custom deployments are easy to identify: * **"Custom" badge**: Distinguishes from registry servers * **Package info**: Shows the exact package or repository deployed * **Status indicator**: Real-time deployment status * **Server URL**: Your unique endpoint for connecting ### Available Actions * **Copy URL**: Get your server endpoint * **Install in VSCode**: One-click VSCode integration * **Stop**: Shut down when no longer needed ## Trial vs Paid Deployments CloudMCP offers flexible deployment options: ### Trial Deployments * **Duration**: 48 hours * **Perfect for**: Testing and development * **Limit**: Based on your account type * **Automatic expiry**: Servers stop after 48 hours ### Paid Deployments * **Duration**: Unlimited * **Perfect for**: Production use * **Resources**: Dedicated instances * **Support**: Priority support included ## Best Practices ### 1. Validate Before Deploying Let the real-time validation complete before clicking deploy. This catches issues early and saves time. ### 2. Use Descriptive Names Help your future self by using clear, descriptive deployment names: * ❌ `server1` * ✅ `production-github-integration` ### 3. Secure Your Tokens * Never share authentication tokens * Rotate tokens regularly * Use minimal required permissions ### 4. Test with Trials First Use trial deployments to: * Test server functionality * Verify environment variables * Check performance requirements ## Troubleshooting ### Validation Fails **Package not found error:** * Verify the package name spelling * Check the package exists in the selected registry * For GitHub, ensure the URL format is correct **Version not available:** * Check if the version exists * Try using `latest` or no version * For GitHub, verify the branch name ### Deployment Failures **Environment variable errors:** * Check for typos in variable names * Verify required variables are set * Ensure values don't contain invalid characters **Resource limits:** * Check your deployment quota * [Upgrade](https://cloudmcp.run/pricing) plan if needed * Delete unused deployments ### Connection Problems **Can't connect to deployed server:** * Verify the server started successfully * [Redeploy](https://cloudmcp.run/dashboard/deployments) your server. * Ensure your client supports the server's MCP version of the package. * Send us a support ### Package Versions Specify exact versions for stability: ``` NPM: @package/name@1.2.3 PyPI: package-name==1.2.3 ``` ### Multiple Configurations Deploy the same server multiple times: * Different environment variables for dev/prod * Separate instances for different projects * Isolated deployments for testing ### Monitoring Deployments Track your custom deployments: * Check status indicators regularly * Monitor resource usage (coming soon) * Set up alerts for failures (coming soon) ## What's Next? Now that you've mastered custom deployments: * 🚀 **Deploy your servers**: Start with your own MCP servers [--> Dashboard](https://cloudmcp.run/dashboard) * 📦 **Try different registries**: Explore NPM, PyPI, and GitHub options ## Coming Soon We're constantly improving custom deployments: * **Deployment templates**: Save configurations for reuse * **Bulk deployments**: Deploy multiple servers at once * **Version management**: Easy updates and rollbacks * **Performance metrics**: Detailed resource monitoring ## Need Help? If you encounter any issues: * Check our [blog](https://cloudmcp.run/blog) for updates and tutorials * Join our [Discord community](https://discord.gg/cloudmcp) * Contact me with the [support](https://cloudmcp.run/support) form! *** *Ready to deploy your custom MCP server? [Start deploying →](https://cloudmcp.run/dashboard/deployments)* # MCP Registry Launch: What the Official MCP Server Directory Means for Cloud MCP Source: https://docs.cloudmcp.run/blog/mcp-registry-launch Learn what the new official MCP Registry is, why it matters, and how Cloud MCP is integrating it to deliver an always-updated 'Official Servers' catalog and enterprise sub-registry support. # MCP Registry Launch: the “single source of truth” moment for Model Context Protocol **Published:** September 2025 In the last few days, the Model Context Protocol (MCP) team unveiled the **official MCP Registry** in preview-a canonical, open catalog and API for discovering publicly available MCP servers. It standardizes how servers are published and found, and introduces a federated model so organizations can run **public** or **private sub‑registries** on top of a shared upstream dataset. In short: one place to publish, many places to consume. ([mcp blog][1]) Why the fuss? Because MCP adoption has been gated by *discovery*-too many scattered lists, too many bespoke installers. The new registry provides that missing backbone: a public endpoint (with OpenAPI docs) that client authors and marketplaces can ingest, filter, and extend. The preview launch is explicit that breaking changes are still possible, but the direction is clear: a community‑maintained, vendor‑neutral index for MCP servers. ([GitHub][2]) ## What’s new (and why it matters) * **Canonical dataset & API.** A read‑only API at `registry.modelcontextprotocol.io` exposes server listings (e.g., `GET /v0/servers`), making it trivial for clients and aggregators to keep their catalogs fresh. ([techcommunity.microsoft.com][3]) * **Federated sub‑registries.** The official registry is the upstream; downstream *public* marketplaces (for specific clients) and *private* enterprise registries can mirror and enrich entries while sharing schemas and tooling. ([mcp blog][1]) * **Standard metadata (`server.json`).** Servers publish a compact manifest that links to actual packages (npm, PyPI, Docker, etc.), so the registry acts as a *metaregistry*-pointing to code hosted elsewhere while unifying discovery. ([GitHub][2]) ## The conversation online (last 30 days) Coverage and commentary have been brisk. Visual Studio Magazine framed the timing alongside Microsoft’s new “Awesome Copilot” MCP server, noting how concrete server implementations and a shared registry “arrived within days of each other.” That pairing makes MCP more usable inside familiar developer tools while standardizing how integrations are found. ([Visual Studio Magazine][4]) On the community side, explainer posts and how‑tos popped up within hours-from a Microsoft Tech Community walkthrough of the API endpoints to hands‑on guides for adding servers-underscoring immediate interest from practitioners. ([techcommunity.microsoft.com][3]) Developers are also debating ergonomics and governance on social platforms. A Hacker News thread (2 days old) discusses preview‑only API access, asks about a UI roadmap, and argues for value‑add curation (auth, vetting, RBAC) on top of the upstream feed-precisely the kind of healthy pressure that drives ecosystem polish. ([Hacker News][5]) *** ## What the MCP Registry means for **Cloud MCP** Cloud MCP exists to make **remote MCP servers** dead simple: paste a URL, OAuth to connect, and give your AI real capabilities across **mobile, web, and desktop**-no local binaries, no terminal. We already support one‑click deployments and **custom deployments** from npm/PyPI/GitHub with real‑time validation. The official registry lets us supercharge that experience. ([Cloud MCP][6]) Here’s how we’re integrating it: 1. **An “Official Servers” lane in *Find Servers*.** We’ll mirror the upstream registry on a frequent cadence and surface an **Official** filter inside your Cloud MCP dashboard, so you can browse the freshest list of published servers without hunting across the web. Entries remain install‑ready-click *Deploy* to spin up a remote instance with your environment variables and OAuth. ([Cloud MCP][7]) 2. **Rich metadata from `server.json`.** We’ll ingest the registry’s standard metadata (name/namespace, packages, versions) to power **version pinning**, **changelogs**, and **install provenance** in Cloud MCP. You’ll see the source registry (npm/PyPI/Docker) and the exact package version you’re deploying. ([GitHub][2]) 3. **Health & verification signals.** The official registry supports community moderation and deny‑listing. We’ll surface those signals alongside Cloud MCP’s own checks to help you choose trustworthy servers for production. ([mcp blog][1]) 4. **Enterprise catalogs via sub‑registries.** For teams that curate internal tools, Cloud MCP will respect **private sub‑registries**: point Cloud MCP at your internal feed (mirrored from the official upstream), enforce org policy, and still benefit from the shared schema and ecosystem tooling. ([mcp blog][1]) **Bottom line for Cloud MCP users:** the official registry gives you a continuously updated, standardized source of MCP servers; Cloud MCP turns those listings into secure, remote deployments in seconds-**across every MCP‑capable client**. Discover centrally, deploy instantly, run anywhere. ([Cloud MCP][6]) *** ### Sources & further reading * **Official announcement:** “Introducing the MCP Registry” (preview, federated sub‑registries, OpenAPI). ([mcp blog][1]) * **Repo overview:** Registry README (preview status, maintainers, `server.json` model, live API docs). ([GitHub][2]) * **API how‑to:** Microsoft Tech Community (endpoints and curl usage). ([techcommunity.microsoft.com][3]) * **Ecosystem reaction:** Visual Studio Magazine (context and timing with Microsoft’s server). ([Visual Studio Magazine][4]) * **Community debate:** Hacker News thread on the registry launch (preview/API, curation, UI). ([Hacker News][5]) * **Cloud MCP background:** Deploy Remote MCP servers with OAuth; quick deploy and custom deployments from npm/PyPI/GitHub. ([Cloud MCP][6]) *If you’re ready to try it, head to your Cloud MCP dashboard, open **Find Servers**, and-soon-toggle **Official** to browse the upstream catalog, then **Deploy** to give your AI new superpowers in seconds.* ([Cloud MCP][7]) [1]: https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/ "Introducing the MCP Registry | mcp blog" [2]: https://github.com/modelcontextprotocol/registry "GitHub - modelcontextprotocol/registry: A community driven registry service for Model Context Protocol (MCP) servers." [3]: https://techcommunity.microsoft.com/discussions/appsonazure/how-to-use-the-newly-launched-mcp-registry/4452855 "How to use the newly launched MCP Registry | Microsoft Community Hub" [4]: https://visualstudiomagazine.com/articles/2025/09/09/microsofts-awesome-copilot-mcp-server-joined-by-mcp-registry.aspx "Microsoft's 'Awesome Copilot MCP Server' Joined by MCP Registry -- Visual Studio Magazine" [5]: https://news.ycombinator.com/item?id=45176580 "The MCP Registry | Hacker News" [6]: https://cloudmcp.run/ "Cloud MCP - Remote Model Context Protocol Servers" [7]: https://cloudmcp.run/blog/cloud-mcp-deployment-guide "How to Remotely Deploy an MCP Server (on cloudmcp.run)" # Why Remote MCP Servers Unlock a New Era for AI Agents Beyond Desktop Source: https://docs.cloudmcp.run/blog/remote-mcp-servers-mobile-ai-agents The Model Context Protocol is transformative, but its desktop-only limitation leaves billions of mobile and web users behind. Remote MCP deployment changes everything - here's why it matters and what it enables. # Why Remote MCP Servers Unlock a New Era for AI Agents Beyond Desktop The Model Context Protocol (MCP) has revolutionized how AI agents interact with tools and data. But there's a critical limitation that's holding back its full potential: **traditional MCP servers only run on desktop**. This means that the billions of users on mobile devices, web browsers, and other platforms are locked out of the AI agent revolution. They can chat with AI, but they can't give it real capabilities. **Remote MCP deployment changes everything.** ## The Desktop Bottleneck Traditional MCP servers use STDIO (standard input/output) for communication. This works great on a desktop where you have: * Full file system access * Ability to install native binaries * Unrestricted process execution * Generous CPU and memory resources * Persistent background processes But try running that on an iPhone, Android device, or in a web browser. You immediately hit walls: * **Mobile sandboxing** prevents file system access * **App store restrictions** block binary installations * **Limited resources** can't handle heavy computation * **No background processes** means no persistent services * **Security models** prevent system-level operations The result? Mobile and web users get a watered-down AI experience. Their AI assistants can talk, but they can't *do*. ## Enter Remote MCP Servers Remote MCP servers flip the script. Instead of running locally, they run in the cloud and communicate over HTTP with OAuth authentication. This simple architectural change unlocks profound capabilities. Suddenly, your mobile AI assistant can: * **Manage infrastructure** on AWS, Azure, or Google Cloud * **Query databases** like PostgreSQL, MongoDB, or BigQuery * **Execute code** in sandboxed Python or Node.js environments * **Automate browsers** with Puppeteer or Playwright * **Process documents** with OCR and AI extraction * **Control Docker containers** and Kubernetes clusters * **Access file systems** for reading and writing documents * **Schedule tasks** with cron-like automation None of this is possible with local MCP servers on mobile. All of it becomes trivial with remote deployment. ## Real-World Impact: Use Cases That Matter ### **Mobile DevOps on the Go** Imagine you're a DevOps engineer getting paged at 2 AM. Instead of rushing to your laptop, you grab your phone and tell your AI assistant: "Check the Kubernetes cluster health and rollback the last deployment if CPU usage is above 80%." With remote MCP servers for Kubernetes and cloud providers, your mobile AI becomes a full DevOps command center. ### **Field Data Collection and Processing** A field researcher collecting samples can use their phone to: * Upload photos to cloud storage * Run image analysis with specialized tools * Update databases with findings * Generate reports with complex formatting * All through natural language commands The heavy lifting happens on remote servers while the phone provides the interface. ### **Executive Decision Support Anywhere** A CEO traveling can ask their mobile AI: "Pull yesterday's sales data from BigQuery, compare it to last quarter's average, and create a presentation for the board meeting." Remote MCP servers for BigQuery, data visualization, and document generation make this possible without touching a laptop. ### **Creative Workflows Unleashed** Content creators can leverage remote MCP servers for: * **FFmpeg servers** for video processing and conversion * **ImageMagick servers** for batch image editing * **Pandoc servers** for document format conversion * **Git servers** for version control and collaboration These tools require binaries and processing power that mobile devices simply don't have. ## The Technical Advantages ### **1. Resource Liberation** Heavy computational tasks run on powerful cloud servers, not battery-constrained mobile devices. Your phone becomes a lightweight controller for heavyweight capabilities. ### **2. Universal Access** The same MCP servers work across all platforms - iOS, Android, web browsers, smart TVs, even voice assistants. Write once, deploy everywhere. ### **3. Team Collaboration** Remote servers can be shared across teams. Everyone accesses the same tools with the same configurations, ensuring consistency and enabling collaboration. ### **4. Security and Compliance** OAuth authentication, encrypted connections, and cloud-grade security protect sensitive operations. Audit logs track every action for compliance. ### **5. Always Up-to-Date** Remote servers can be updated instantly without requiring app store approvals or user updates. Bug fixes and new features deploy immediately to all users. ## Breaking Down Specific Server Categories ### **Development and Code Execution** * **Code sandboxes** (Python, Node.js, Ruby) for running scripts * **Database clients** for querying and managing data * **Git operations** for repository management * **Container orchestration** for Docker and Kubernetes *Why they need remote deployment:* Require runtimes, compilers, and system access unavailable on mobile. ### **Data Processing and Analytics** * **BigQuery, Snowflake, Databricks** for enterprise analytics * **Apache Spark** for distributed computing * **ETL pipelines** for data transformation * **Machine learning frameworks** for model training *Why they need remote deployment:* Massive computational requirements and specialized libraries. ### **Automation and Integration** * **Browser automation** with Puppeteer/Playwright * **API orchestration** for complex workflows * **Webhook handlers** for event-driven automation * **Scheduled tasks** for recurring operations *Why they need remote deployment:* Need persistent processes and full browser environments. ### **Media and Content** * **FFmpeg** for video/audio processing * **ImageMagick** for image manipulation * **Pandoc** for document conversion * **PDF generation** and manipulation *Why they need remote deployment:* Require native binaries and significant processing power. ## The Mobile-First AI Future We're entering an era where AI agents aren't confined to desktop applications. With remote MCP servers, every device becomes a portal to unlimited AI capabilities. Consider the implications: * **Systemprompt** and similar mobile apps can offer the same power as desktop AI tools * **Voice assistants** like Alexa or Google Assistant could integrate MCP capabilities * **Smartwatches** could control complex infrastructure with a tap * **AR glasses** could overlay AI-powered tools onto the physical world This isn't science fiction - it's happening now. Companies like Cloudflare are building infrastructure for remote MCP servers. Platforms like **CloudMCP.run** are making deployment as simple as clicking a button. ## Getting Started with Remote MCP The transition from desktop-only to remote MCP is straightforward: 1. **Choose your servers**: Identify which MCP servers would benefit your users 2. **Deploy remotely**: Use platforms like CloudMCP.run for instant deployment 3. **Configure authentication**: Set up OAuth for secure access 4. **Connect clients**: Mobile apps and web interfaces can now access your servers 5. **Monitor and iterate**: Track usage, gather feedback, and expand capabilities ## The Bottom Line Remote MCP servers aren't just a technical evolution - they're a paradigm shift. They transform AI agents from desktop-bound assistants into ubiquitous, powerful tools accessible from any device, anywhere. The companies and developers who recognize this shift early will have a massive advantage. They'll be able to offer AI experiences that their desktop-only competitors simply can't match. The future of AI isn't sitting at a desk. It's in your pocket, on your wrist, in your car, and everywhere else you go. Remote MCP servers are the bridge to that future. **Ready to deploy your first remote MCP server?** [Get started with CloudMCP.run →](https://cloudmcp.run) *** *CloudMCP.run makes it simple to deploy any MCP server remotely with OAuth security, instant scaling, and pay-per-use pricing. No infrastructure headaches, just pure innovation.* # Introducing CloudMCP.run - Deploy MCP Servers Without the Headaches Source: https://docs.cloudmcp.run/blog/welcome We're excited to introduce CloudMCP.run, a platform that makes deploying Model Context Protocol servers as easy as clicking a button. # Introducing CloudMCP.run - Deploy MCP Servers (Remotely) Without the Headaches If you've been working with AI agents and the Model Context Protocol (MCP), you know the drill. You've got a brilliant idea for an MCP server that could give AI models access to new capabilities - maybe it's a custom database connector, a specialized API integration, or a unique tool that could supercharge AI workflows. But then reality hits. Setting up the infrastructure. Managing deployments. Configuring security. Handling scaling. Monitoring performance. Before you know it, you're spending more time wrestling with DevOps than actually building your innovation. **That's why we built CloudMCP.run.** ## What is CloudMCP.run? CloudMCP.run is a platform that lets you deploy Model Context Protocol servers instantly. We handle all the infrastructure complexity so you can focus on what matters - building amazing AI tools and integrations. Think of it as Vercel or Netlify, but specifically designed for MCP servers. With just a few clicks, you can have a production-ready MCP server running in the cloud, complete with: * 🚀 **Instant deployment** - Launch pre-configured MCP servers in minutes * 📈 **Auto-scaling** - Your servers scale automatically based on demand * 🔒 **Built-in security** - Robust authentication and authorization out of the box * ⚡ **Optimized performance** - Low-latency responses for real-time AI applications * 🔧 **GitHub integration** - Sign up and manage everything with your GitHub account ## Why MCP Servers Need Better Infrastructure The Model Context Protocol is revolutionizing how AI models interact with external tools and data sources. By providing a standardized way for AI to access capabilities beyond their training data, MCP opens up incredible possibilities. But running MCP servers effectively requires: * **High availability** - AI agents need reliable access to tools * **Low latency** - Real-time applications can't wait for slow responses * **Security** - Protecting sensitive data and preventing unauthorized access * **Scalability** - Usage can spike unexpectedly as AI applications grow Managing all of this yourself is a massive undertaking that distracts from your core innovation. ## How CloudMCP.run Works We've made deployment dead simple: 1. **Choose your server** - Pick from our library of popular MCP servers or bring your own 2. **Configure** - Set up your environment variables and authentication 3. **Deploy** - Click deploy and your server is live in minutes 4. **Connect** - Use your server URL in any MCP-compatible AI application That's it. No Kubernetes configs. No Docker orchestration. No sleepless nights debugging infrastructure issues. ## What's Available Today We're launching with support for the most popular MCP server configurations, including: * Database connectors (PostgreSQL, MySQL, MongoDB) * API integrations (Slack, GitHub, custom REST APIs) * File system tools * Custom computation servers * And many more... Each server comes pre-configured with best practices for security and performance. Just add your credentials and deploy. ## Our Vision We believe the future of AI lies in its ability to interact with the world through tools and integrations. MCP is the protocol that makes this possible, but it shouldn't require a PhD in cloud architecture to deploy. Our mission is to democratize access to MCP infrastructure, allowing developers of all skill levels to contribute to the AI ecosystem. Whether you're a solo developer with a clever idea or a team building enterprise AI solutions, CloudMCP.run gives you the foundation to move fast and build confidently. ## Get Started Today Ready to deploy your first MCP server? Here's how to get started: 1. **Sign up** at [cloudmcp.run](https://cloudmcp.run) using your GitHub account 2. **Start your free trial** - No credit card required 3. **Deploy your first server** - Be up and running in under 5 minutes We're offering a generous free tier so you can experiment and build without worrying about costs. When you're ready to scale, our transparent pricing grows with your usage. ## What's Next This is just the beginning. We're working on exciting features including: * **Custom domains** for your MCP servers * **Advanced monitoring** and debugging tools * **Team collaboration** features * **Private server registry** for proprietary MCP implementations * **One-click templates** for common use cases ## Join Us The AI revolution needs better infrastructure. If you're tired of fighting with deployments when you should be building the future, give CloudMCP.run a try. Have questions? Feedback? Want to request a specific MCP server? We'd love to hear from you. Drop us a line at [hello@cloudmcp.run](mailto:hello@cloudmcp.run) or join our [Discord community](#). Let's build the future of AI tooling together - without the infrastructure headaches. *** *Ready to deploy your first MCP server? [Get started free at cloudmcp.run →](https://cloudmcp.run)* # Development Source: https://docs.cloudmcp.run/development Preview changes locally to update your docs **Prerequisites**: * Node.js version 19 or higher * A docs repository with a `docs.json` file Follow these steps to install and run Mintlify on your operating system. ```bash theme={null} npm i -g mint ``` Navigate to your docs directory where your `docs.json` file is located, and run the following command: ```bash theme={null} mint dev ``` A local preview of your documentation will be available at `http://localhost:3000`. ## Custom ports By default, Mintlify uses port 3000. You can customize the port Mintlify runs on by using the `--port` flag. For example, to run Mintlify on port 3333, use this command: ```bash theme={null} mint dev --port 3333 ``` If you attempt to run Mintlify on a port that's already in use, it will use the next available port: ```md theme={null} Port 3000 is already in use. Trying 3001 instead. ``` ## Mintlify versions Please note that each CLI release is associated with a specific version of Mintlify. If your local preview does not align with the production version, please update the CLI: ```bash theme={null} npm mint update ``` ## Validating links The CLI can assist with validating links in your documentation. To identify any broken links, use the following command: ```bash theme={null} mint broken-links ``` ## Deployment If the deployment is successful, you should see the following: Screenshot of a deployment confirmation message that says All checks have passed. ## Code formatting We suggest using extensions on your IDE to recognize and format MDX. If you're a VSCode user, consider the [MDX VSCode extension](https://marketplace.visualstudio.com/items?itemName=unifiedjs.vscode-mdx) for syntax highlighting, and [Prettier](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) for code formatting. ## Troubleshooting This may be due to an outdated version of node. Try the following: 1. Remove the currently-installed version of the CLI: `npm remove -g mint` 2. Upgrade to Node v19 or higher. 3. Reinstall the CLI: `npm i -g mint` Solution: Go to the root of your device and delete the `~/.mintlify` folder. Then run `mint dev` again. Curious about what changed in the latest CLI version? Check out the [CLI changelog](https://www.npmjs.com/package/mintlify?activeTab=versions). # Code blocks Source: https://docs.cloudmcp.run/essentials/code Display inline code and code blocks ## Inline code To denote a `word` or `phrase` as code, enclose it in backticks (\`). ``` To denote a `word` or `phrase` as code, enclose it in backticks (`). ``` ## Code blocks Use [fenced code blocks](https://www.markdownguide.org/extended-syntax/#fenced-code-blocks) by enclosing code in three backticks and follow the leading ticks with the programming language of your snippet to get syntax highlighting. Optionally, you can also write the name of your code after the programming language. ```java HelloWorld.java theme={null} class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } } ``` ````md theme={null} ```java HelloWorld.java class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } } ``` ```` # Images and embeds Source: https://docs.cloudmcp.run/essentials/images Add image, video, and other HTML elements ## Image ### Using Markdown The [markdown syntax](https://www.markdownguide.org/basic-syntax/#images) lets you add images using the following code ```md theme={null} ![title](/path/image.jpg) ``` Note that the image file size must be less than 5MB. Otherwise, we recommend hosting on a service like [Cloudinary](https://cloudinary.com/) or [S3](https://aws.amazon.com/s3/). You can then use that URL and embed. ### Using embeds To get more customizability with images, you can also use [embeds](/writing-content/embed) to add images ```html theme={null} ``` ## Embeds and HTML elements ``` # Markdown syntax Source: https://docs.cloudmcp.run/essentials/markdown Text, title, and styling in standard markdown ## Titles Best used for section headers. ```md theme={null} ## Titles ``` ### Subtitles Best used for subsection headers. ```md theme={null} ### Subtitles ``` Each **title** and **subtitle** creates an anchor and also shows up on the table of contents on the right. ## Text formatting We support most markdown formatting. Simply add `**`, `_`, or `~` around text to format it. | Style | How to write it | Result | | ------------- | ----------------- | ----------------- | | Bold | `**bold**` | **bold** | | Italic | `_italic_` | *italic* | | Strikethrough | `~strikethrough~` | ~~strikethrough~~ | You can combine these. For example, write `**_bold and italic_**` to get ***bold and italic*** text. You need to use HTML to write superscript and subscript text. That is, add `` or `` around your text. | Text Size | How to write it | Result | | ----------- | ------------------------ | ---------------------- | | Superscript | `superscript` | superscript | | Subscript | `subscript` | subscript | ## Linking to pages You can add a link by wrapping text in `[]()`. You would write `[link to google](https://google.com)` to [link to google](https://google.com). Links to pages in your docs need to be root-relative. Basically, you should include the entire folder path. For example, `[link to text](/writing-content/text)` links to the page "Text" in our components section. Relative links like `[link to text](../text)` will open slower because we cannot optimize them as easily. ## Blockquotes ### Singleline To create a blockquote, add a `>` in front of a paragraph. > Dorothy followed her through many of the beautiful rooms in her castle. ```md theme={null} > Dorothy followed her through many of the beautiful rooms in her castle. ``` ### Multiline > Dorothy followed her through many of the beautiful rooms in her castle. > > The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood. ```md theme={null} > Dorothy followed her through many of the beautiful rooms in her castle. > > The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood. ``` ### LaTeX Mintlify supports [LaTeX](https://www.latex-project.org) through the Latex component. 8 x (vk x H1 - H2) = (0,1) ```md theme={null} 8 x (vk x H1 - H2) = (0,1) ``` # Navigation Source: https://docs.cloudmcp.run/essentials/navigation The navigation field in docs.json defines the pages that go in the navigation menu The navigation menu is the list of links on every website. You will likely update `docs.json` every time you add a new page. Pages do not show up automatically. ## Navigation syntax Our navigation syntax is recursive which means you can make nested navigation groups. You don't need to include `.mdx` in page names. ```json Regular Navigation theme={null} "navigation": { "tabs": [ { "tab": "Docs", "groups": [ { "group": "Getting Started", "pages": ["quickstart"] } ] } ] } ``` ```json Nested Navigation theme={null} "navigation": { "tabs": [ { "tab": "Docs", "groups": [ { "group": "Getting Started", "pages": [ "quickstart", { "group": "Nested Reference Pages", "pages": ["nested-reference-page"] } ] } ] } ] } ``` ## Folders Simply put your MDX files in folders and update the paths in `docs.json`. For example, to have a page at `https://yoursite.com/your-folder/your-page` you would make a folder called `your-folder` containing an MDX file called `your-page.mdx`. You cannot use `api` for the name of a folder unless you nest it inside another folder. Mintlify uses Next.js which reserves the top-level `api` folder for internal server calls. A folder name such as `api-reference` would be accepted. ```json Navigation With Folder theme={null} "navigation": { "tabs": [ { "tab": "Docs", "groups": [ { "group": "Group Name", "pages": ["your-folder/your-page"] } ] } ] } ``` ## Hidden pages MDX files not included in `docs.json` will not show up in the sidebar but are accessible through the search bar and by linking directly to them. # Reusable snippets Source: https://docs.cloudmcp.run/essentials/reusable-snippets Reusable, custom snippets to keep content in sync One of the core principles of software development is DRY (Don't Repeat Yourself). This is a principle that applies to documentation as well. If you find yourself repeating the same content in multiple places, you should consider creating a custom snippet to keep your content in sync. ## Creating a custom snippet **Pre-condition**: You must create your snippet file in the `snippets` directory. Any page in the `snippets` directory will be treated as a snippet and will not be rendered into a standalone page. If you want to create a standalone page from the snippet, import the snippet into another file and call it as a component. ### Default export 1. Add content to your snippet file that you want to re-use across multiple locations. Optionally, you can add variables that can be filled in via props when you import the snippet. ```mdx snippets/my-snippet.mdx theme={null} Hello world! This is my content I want to reuse across pages. My keyword of the day is {word}. ``` The content that you want to reuse must be inside the `snippets` directory in order for the import to work. 2. Import the snippet into your destination file. ```mdx destination-file.mdx theme={null} --- title: My title description: My Description --- import MySnippet from '/snippets/path/to/my-snippet.mdx'; ## Header Lorem impsum dolor sit amet. ``` ### Reusable variables 1. Export a variable from your snippet file: ```mdx snippets/path/to/custom-variables.mdx theme={null} export const myName = 'my name'; export const myObject = { fruit: 'strawberries' }; ``` 2. Import the snippet from your destination file and use the variable: ```mdx destination-file.mdx theme={null} --- title: My title description: My Description --- import { myName, myObject } from '/snippets/path/to/custom-variables.mdx'; Hello, my name is {myName} and I like {myObject.fruit}. ``` ### Reusable components 1. Inside your snippet file, create a component that takes in props by exporting your component in the form of an arrow function. ```mdx snippets/custom-component.mdx theme={null} export const MyComponent = ({ title }) => (

{title}

... snippet content ...

); ``` MDX does not compile inside the body of an arrow function. Stick to HTML syntax when you can or use a default export if you need to use MDX. 2. Import the snippet into your destination file and pass in the props ```mdx destination-file.mdx theme={null} --- title: My title description: My Description --- import { MyComponent } from '/snippets/custom-component.mdx'; Lorem ipsum dolor sit amet. ``` # Global Settings Source: https://docs.cloudmcp.run/essentials/settings Mintlify gives you complete control over the look and feel of your documentation using the docs.json file Every Mintlify site needs a `docs.json` file with the core configuration settings. Learn more about the [properties](#properties) below. ## Properties Name of your project. Used for the global title. Example: `mintlify` An array of groups with all the pages within that group The name of the group. Example: `Settings` The relative paths to the markdown files that will serve as pages. Example: `["customization", "page"]` Path to logo image or object with path to "light" and "dark" mode logo images Path to the logo in light mode Path to the logo in dark mode Where clicking on the logo links you to Path to the favicon image Hex color codes for your global theme The primary color. Used for most often for highlighted content, section headers, accents, in light mode The primary color for dark mode. Used for most often for highlighted content, section headers, accents, in dark mode The primary color for important buttons The color of the background in both light and dark mode The hex color code of the background in light mode The hex color code of the background in dark mode Array of `name`s and `url`s of links you want to include in the topbar The name of the button. Example: `Contact us` The url once you click on the button. Example: `https://mintlify.com/docs` Link shows a button. GitHub shows the repo information at the url provided including the number of GitHub stars. If `link`: What the button links to. If `github`: Link to the repository to load GitHub information from. Text inside the button. Only required if `type` is a `link`. Array of version names. Only use this if you want to show different versions of docs with a dropdown in the navigation bar. An array of the anchors, includes the `icon`, `color`, and `url`. The [Font Awesome](https://fontawesome.com/search?q=heart) icon used to feature the anchor. Example: `comments` The name of the anchor label. Example: `Community` The start of the URL that marks what pages go in the anchor. Generally, this is the name of the folder you put your pages in. The hex color of the anchor icon background. Can also be a gradient if you pass an object with the properties `from` and `to` that are each a hex color. Used if you want to hide an anchor until the correct docs version is selected. Pass `true` if you want to hide the anchor until you directly link someone to docs inside it. One of: "brands", "duotone", "light", "sharp-solid", "solid", or "thin" Override the default configurations for the top-most anchor. The name of the top-most anchor Font Awesome icon. One of: "brands", "duotone", "light", "sharp-solid", "solid", or "thin" An array of navigational tabs. The name of the tab label. The start of the URL that marks what pages go in the tab. Generally, this is the name of the folder you put your pages in. Configuration for API settings. Learn more about API pages at [API Components](/api-playground/demo). The base url for all API endpoints. If `baseUrl` is an array, it will enable for multiple base url options that the user can toggle. The authentication strategy used for all API endpoints. The name of the authentication parameter used in the API playground. If method is `basic`, the format should be `[usernameName]:[passwordName]` The default value that's designed to be a prefix for the authentication input field. E.g. If an `inputPrefix` of `AuthKey` would inherit the default input result of the authentication field as `AuthKey`. Configurations for the API playground Whether the playground is showing, hidden, or only displaying the endpoint with no added user interactivity `simple` Learn more at the [playground guides](/api-playground/demo) Enabling this flag ensures that key ordering in OpenAPI pages matches the key ordering defined in the OpenAPI file. This behavior will soon be enabled by default, at which point this field will be deprecated. A string or an array of strings of URL(s) or relative path(s) pointing to your OpenAPI file. Examples: ```json Absolute theme={null} "openapi": "https://example.com/openapi.json" ``` ```json Relative theme={null} "openapi": "/openapi.json" ``` ```json Multiple theme={null} "openapi": ["https://example.com/openapi1.json", "/openapi2.json", "/openapi3.json"] ``` An object of social media accounts where the key:property pair represents the social media platform and the account url. Example: ```json theme={null} { "x": "https://x.com/mintlify", "website": "https://mintlify.com" } ``` One of the following values `website`, `facebook`, `x`, `discord`, `slack`, `github`, `linkedin`, `instagram`, `hacker-news` Example: `x` The URL to the social platform. Example: `https://x.com/mintlify` Configurations to enable feedback buttons Enables a button to allow users to suggest edits via pull requests Enables a button to allow users to raise an issue about the documentation Customize the dark mode toggle. Set if you always want to show light or dark mode for new users. When not set, we default to the same mode as the user's operating system. Set to true to hide the dark/light mode toggle. You can combine `isHidden` with `default` to force your docs to only use light or dark mode. For example: ```json Only Dark Mode theme={null} "modeToggle": { "default": "dark", "isHidden": true } ``` ```json Only Light Mode theme={null} "modeToggle": { "default": "light", "isHidden": true } ``` A background image to be displayed behind every page. See example with [Infisical](https://infisical.com/docs) and [FRPC](https://frpc.io). # Introduction Source: https://docs.cloudmcp.run/index Welcome to the new home for your documentation ## Setting up Get your documentation site up and running in minutes. Follow our three step quickstart guide. ## Make it yours Design a docs site that looks great and empowers your users. Edit your docs locally and preview them in real time. Customize the design and colors of your site to match your brand. Organize your docs to help users find what they need and succeed with your product. Auto-generate API documentation from OpenAPI specifications. ## Create beautiful pages Everything you need to create world-class documentation. Use MDX to style your docs pages. Add sample code to demonstrate how to use your product. Display images and other media. Write once and reuse across your docs. ## Need inspiration? Browse our showcase of exceptional documentation sites. # Quickstart Source: https://docs.cloudmcp.run/quickstart Start building awesome documentation in minutes ## Get started in three steps Get your documentation site running locally and make your first customization. ### Step 1: Set up your local environment During the onboarding process, you created a GitHub repository with your docs content if you didn't already have one. You can find a link to this repository in your [dashboard](https://dashboard.mintlify.com). To clone the repository locally so that you can make and preview changes to your docs, follow the [Cloning a repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) guide in the GitHub docs. 1. Install the Mintlify CLI: `npm i -g mint` 2. Navigate to your docs directory and run: `mint dev` 3. Open `http://localhost:3000` to see your docs live! Your preview updates automatically as you edit files. ### Step 2: Deploy your changes Install the Mintlify GitHub app from your [dashboard](https://dashboard.mintlify.com/settings/organization/github-app). Our GitHub app automatically deploys your changes to your docs site, so you don't need to manage deployments yourself. For a first change, let's update the name and colors of your docs site. 1. Open `docs.json` in your editor. 2. Change the `"name"` field to your project name. 3. Update the `"colors"` to match your brand. 4. Save and see your changes instantly at `http://localhost:3000`. Try changing the primary color to see an immediate difference! ### Step 3: Go live 1. Commit and push your changes. 2. Your docs will update and be live in moments! ## Next steps Now that you have your docs running, explore these key features: Learn MDX syntax and start writing your documentation. Make your docs match your brand perfectly. Include syntax-highlighted code blocks. Auto-generate API docs from OpenAPI specs. **Need help?** See our [full documentation](https://mintlify.com/docs) or join our [community](https://mintlify.com/community).