# Scalix Cloud MCP server

> Operate Scalix Cloud databases, functions, storage, containers, AI inference and Linux machines from your assistant.

- Listing: https://mcp.tc/i/scalix-cloud
- Connect: use the server's own URL `https://api.scalix.world/v1/mcp` (with your API key); clients connect to it directly. The listing link is a page, not an MCP endpoint.
- Type: remote (Streamable HTTP)
- Auth: API key
- Category: [Cloud & DevOps](https://mcp.tc/c/cloud-devops)
- Vendor: Scalix
- Homepage: <https://scalix.world>
- Repository: <https://github.com/scalixworld/scalix-cloud-mcp>

## About

Connects to Scalix Cloud, a hosted platform for databases, serverless functions, container services, object storage, key-value data, AI inference and persistent Linux machines. You can inspect schemas, run SQL, deploy functions and containers, manage domains and builds, run code in a sandbox, and publish events.

It runs as a hosted Streamable HTTP endpoint at https://api.scalix.world/v1/mcp, with no local install. Requests need a Scalix API key sent as a Bearer token in the Authorization header. Some project and auth tools need an admin API key. Destructive SQL requires a two-step confirmation.

## What it can do

- Inspect database schema, relationships and PII columns, and run SQL queries
- Deploy and invoke serverless functions and container services
- Scale, roll back or delete Scalix Run services
- Create and use persistent Linux machines, run commands and edit files
- Upload, download and list object storage and key-value data
- Run AI inference and code in an isolated sandbox
- Add custom domains and start container image builds

## Tools (51)

- `scalix_db_relationships`: Show how tables are connected via foreign keys. (read-only)
- `scalix_db_search_columns`: Search columns by name or type across all tables. (read-only)
- `scalix_db_pii`: List columns classified as containing PII. (read-only)
- `scalix_db_optimize`: Analyze a SQL query and suggest indexes and rewrites. (read-only)
- `scalix_db_text_to_sql`: Turn a simple question into a candidate SQL query without running it. (read-only)
- `scalix_db_query`: Execute SQL against the project database; destructive statements need confirmation. (can modify or delete data)
- `scalix_db_schema`: Get the full schema with tables, columns, types and relationships. (read-only)
- `scalix_db_table`: Get columns, indexes and foreign keys of one table. (read-only)
- `scalix_db_migrate`: Apply a database migration by version number. (can modify or delete data)
- `scalix_storage_list`: List buckets or objects in a bucket, with optional prefix. (read-only)
- `scalix_storage_upload`: Upload base64 content to object storage. (can modify or delete data)
- `scalix_storage_download`: Download an object as base64. (read-only)
- `scalix_storage_create_bucket`: Create an S3-compatible storage bucket, private by default.
- `scalix_fn_list`: List deployed serverless functions. (read-only)
- `scalix_fn_deploy`: Deploy a serverless function from a container image.
- `scalix_fn_invoke`: Invoke a deployed function with a JSON payload. (can modify or delete data)
- `scalix_kv_get`: Read a value from the key-value store by exact key. (read-only)
- `scalix_kv_set`: Set a key-value pair with optional TTL. (can modify or delete data)
- `scalix_kv_list`: List keys, optionally filtered by prefix. (read-only)
- `scalix_ai_infer`: Run AI inference with a prompt and model, billed to project credits.
- `scalix_ai_models`: List AI models available for inference. (read-only)
- `scalix_events_publish`: Publish an event with a type and data to a topic.
- `scalix_events_topics`: List event-bus topics with IDs and names. (read-only)
- `scalix_cron_create`: Create a cron schedule that runs a function or webhook.
- `scalix_sandbox_run`: Run Python, JavaScript, TypeScript or Bash in an isolated sandbox.
- `scalix_computer_create`: Get or create a persistent Linux machine by name.
- `scalix_computer_set_ssh_keys`: Replace the SSH keys authorised for root on a machine. (can modify or delete data)
- `scalix_computer_list`: List persistent Linux machines with status and resources. (read-only)
- `scalix_computer_exec`: Run a command inside a running machine and return output. (can modify or delete data)
- `scalix_computer_write_file`: Write a text file into a machine. (can modify or delete data)
- `scalix_computer_read_file`: Read a text file from a machine. (read-only)
- `scalix_computer_stop`: Stop a machine while keeping its disk and address.
- `scalix_computer_start`: Start a stopped machine.
- `scalix_computer_delete`: Permanently delete a machine and its disk. (can modify or delete data)
- `scalix_crew_list`: List your crews with their ids and names. (read-only)
- `scalix_crew_board_read`: Read a crew's notice board: every pinned note plus the newest unpinned ones, current as of this call. (read-only)
- `scalix_crew_board_post`: Post a note to the crew's notice board for other members and the human to see.
- `scalix_domain_add`: Add a custom domain to the project.
- `scalix_domain_list`: List all custom domains and their SSL/verification status. (read-only)
- `scalix_domain_verify`: Verify DNS configuration for a custom domain and provision SSL certificate.
- `scalix_build_create`: Create a new container image build from a Git repository or Dockerfile.
- `scalix_build_status`: Get the status and logs of a build. (read-only)
- `scalix_project_create`: Create a new project within an organization.
- `scalix_project_list`: List every project in an organization, with each project's ID, name, and slug. (read-only)
- `scalix_auth_configure`: Configure end-user authentication for the project — require MFA, require email confirmation, and set the allowed auth providers. (can modify or delete data)
- `scalix_status`: Get the current health status of the Scalix Cloud platform including all service components. (read-only)
- `scalix_run_deploy`: Deploy a container service with autoscaling and a public HTTPS URL.
- `scalix_run_list`: List all deployed container services in the project. (read-only)
- `scalix_run_scale`: Change min and max instances of a service.
- `scalix_run_rollback`: Roll a service back to an earlier revision.
- `scalix_run_delete`: Permanently delete a container service. (can modify or delete data)

## Example prompts

- "Show me the database schema and which columns contain PII"
- "Deploy this container image as a Scalix Run service with scale-to-zero"
- "Create a Linux machine called dev-box and run apt update on it"
- "Roll back my api service to the previous revision"

## Install

### Claude Code

1. Run this in a terminal, in your project folder:

```bash
claude mcp add --transport http scalix-cloud https://api.scalix.world/v1/mcp --header "Authorization: Bearer <YOUR_API_KEY>"
```

2. Replace the placeholder with your key before you run it, then check it with `/mcp` inside Claude Code.

Add `--scope user` to make it available in every project, not just this one.

### Claude Desktop

1. Use the `mcp-remote` bridge, which keeps the key on this computer (a connector added on claude.ai with the key under **Request headers** also shows up here). Open **Settings → Developer → Edit Config** and add:

`claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "scalix-cloud": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.scalix.world/v1/mcp",
        "--header",
        "Authorization: Bearer <YOUR_API_KEY>"
      ]
    }
  }
}
```

2. Replace the placeholder with your key and restart Claude Desktop.

The bridge needs Node.js on your computer.

### claude.ai

1. Open the connector form on claude.ai. This button fills in the name and URL for you:

[Add to claude.ai](<https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Scalix%20Cloud&connectorUrl=https%3A%2F%2Fapi.scalix.world%2Fv1%2Fmcp>) (opens connector settings)

2. Check that the URL reads `https://api.scalix.world/v1/mcp`. Under **Request headers**, add `Authorization: Bearer <YOUR_API_KEY>` with your key from Scalix, then click **Add**.

3. Turn it on in a chat from the tools menu.

Free plans allow one custom connector. On Team and Enterprise plans an owner adds it under **Organization settings → Connectors**.

### Cursor

[Add to Cursor](<https://cursor.com/install-mcp?name=scalix-cloud&config=eyJ1cmwiOiJodHRwczovL2FwaS5zY2FsaXgud29ybGQvdjEvbWNwIiwiaGVhZGVycyI6eyJBdXRob3JpemF0aW9uIjoiQmVhcmVyIDxZT1VSX0FQSV9LRVk%2BIn19>) (opens Cursor)

Or add it by hand to `~/.cursor/mcp.json` (all projects) or `.cursor/mcp.json` (this project):

`mcp.json`:

```json
{
  "mcpServers": {
    "scalix-cloud": {
      "url": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

### VS Code

Add it to `.vscode/mcp.json`. VS Code asks for the key the first time and stores it securely:

`.vscode/mcp.json`:

```json
{
  "servers": {
    "scalix-cloud": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${input:api-key}"
      }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "api-key",
      "description": "API key",
      "password": true
    }
  ]
}
```

### Devin Desktop

1. Add it to `~/.config/devin/mcp_config.json` (macOS and Linux) or `%APPDATA%\devin\mcp_config.json` (Windows):

`mcp_config.json`:

```json
{
  "mcpServers": {
    "scalix-cloud": {
      "serverUrl": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

2. Refresh the MCP server list in Cascade.

Devin Desktop is the new name for Windsurf. It reads `serverUrl` (or `url`) for remote servers.

### Codex

```bash
codex mcp add scalix-cloud --url https://api.scalix.world/v1/mcp --bearer-token-env-var SCALIX_CLOUD_API_KEY
```

Or edit `~/.codex/config.toml` directly:

`config.toml`:

```toml
[mcp_servers.scalix-cloud]
url = "https://api.scalix.world/v1/mcp"
bearer_token_env_var = "SCALIX_CLOUD_API_KEY"
```

Set `SCALIX_CLOUD_API_KEY` to your key in the shell that runs Codex.

### Gemini CLI

```bash
gemini mcp add --transport http --header "Authorization: Bearer <YOUR_API_KEY>" scalix-cloud https://api.scalix.world/v1/mcp
```

This adds it to the current project. Add `-s user` to use it everywhere.

### Any client

Most clients accept this shape. Some name the URL field differently: `serverUrl` in Devin Desktop, `httpUrl` in Gemini CLI’s settings file.

```json
{
  "mcpServers": {
    "scalix-cloud": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

Zed puts servers under `context_servers` in its settings. Cline needs `"type": "streamableHttp"`, or it assumes SSE.

Client only starts local servers? Bridge it with `npx -y mcp-remote https://api.scalix.world/v1/mcp`.

## Recent changes

- 2026-10-07 19:37 UTC: 1 tool changed. Source: automatic check. Changed: scalix\_storage\_create\_bucket.
- 2026-10-06 21:22 UTC: Tracking started: 51 tools read. Source: automatic check.

More on the History tab, with descriptions before and after for the newest entries: https://mcp.tc/i/scalix-cloud#history (Atom feed: https://mcp.tc/i/scalix-cloud/history.xml). It records what mcp.tc's anonymous checks saw, every 3 hours where the tool list can be read without sign-in; it is not a security review.

## Details

- Server version: 1.5.0
- MCP protocol version: 2025-06-18
- Last checked: 2026-10-07 (reachable)
- Listed: 2026-10-05
- Updated: 2026-10-07

---
Source: https://mcp.tc/i/scalix-cloud (mcp.tc is an independent directory, not affiliated with this server's publisher). Corrections: https://mcp.tc/report
