Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

{
  "mcpServers": {
    "cloud": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${CLOUD_TOKEN}"
      }
    }
  }
}

claude mcp add --transport http cloud https://api.scalix.world/v1/mcp --header "Authorization: Bearer ${CLOUD_TOKEN}"

[mcp_servers.cloud]
url = "https://api.scalix.world/v1/mcp"
bearer_token_env_var = "CLOUD_TOKEN"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cloud": {
      "type": "remote",
      "url": "https://api.scalix.world/v1/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer {env:CLOUD_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "cloud": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${CLOUD_TOKEN}"
      }
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=cloud&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vYXBpLnNjYWxpeC53b3JsZC92MS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgJHtDTE9VRF9UT0tFTn0ifX0%3D"
}

{
  "servers": {
    "cloud": {
      "type": "http",
      "url": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${CLOUD_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "cloud": {
      "httpUrl": "https://api.scalix.world/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${CLOUD_TOKEN}"
      }
    }
  }
}

extensions:
  "cloud":
    enabled: true
    name: "cloud"
    type: streamable_http
    uri: "https://api.scalix.world/v1/mcp"
    headers:
      "Authorization": "Bearer ${CLOUD_TOKEN}"
    timeout: 300

Placeholders to fill from your own secret store: ${CLOUD_TOKEN}. The registry never accepts secret values.

Quality 86 / 100good

protocol75 · weight 25

warn
protocol.modernnewest supported version is 2025-06-18; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
n/a
protocol.statelessonly applies to 2026-07-28 servers
pass
protocol.transportstreamable HTTP
n/a
protocol.list_ttlonly applies to 2026-07-28 servers

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene100 · weight 30

pass
tools.descriptionsevery tool has a description
pass
tools.description_lengthdescriptions are concise
pass
tools.schemasevery tool has an object input schema
pass
tools.annotations53 of 53 tools declare readOnlyHint or destructiveHint
pass
tools.directory_hintsevery tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
pass
tools.token_costabout 6,952 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stability75 · weight 15

warn
stability.changes11 tool changes in 30 days
pass
stability.rug_pullno tool changed its meaning under the same name

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

53 tools, about 6,952 tokens to load them all · tool set b6a603925000 · tools last changed 2026-10-16 · checked 2026-10-20 09:31 UTC

Tool changes

2026-10-16scalix_computer_execchangedinput schema
2026-10-16scalix_db_querychangedinput schema
2026-10-15scalix_computer_execchangedinput schema
2026-10-15scalix_storage_delete_bucketadded
Permanently delete a storage bucket and every object in it. Irreversible.
2026-10-15scalix_storage_delete_objectadded
Permanently delete an object (key) from a storage bucket. Irreversible.
2026-10-15scalix_storage_create_bucketchangedinput schema
2026-10-15scalix_storage_downloadchangedinput schema
2026-10-15scalix_storage_uploadchangedinput schema
2026-10-15scalix_storage_listchangedinput schema
2026-10-13scalix_sandbox_runchangeddescription
before
Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr.
after · 56% of words in common
Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr, the probed interpreter version, and any files the code wrote (base64, under size/count caps).

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 96 / 100

provenance85

liveness100

freshness100

hygiene100

+repository +dns-namespace +website +reachable +uptime-100% +updated-8d-ago

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://api.scalix.world/v1/mcp` streamable-http	api_key `${CLOUD_TOKEN}`	yes	100%	814 ms	2025-06-18	2026-10-20

Tools (53)

`scalix_ai_infer`	Run AI inference on Scalix AI. Sends a prompt and returns the model's response in the OpenAI-compatible chat-completions format; tokens are billed to the project's credit pool. Discover available model IDs with scalix_ai_models.
`scalix_ai_models`read-only	List the AI models available to the project — virtual tiers and the pass-through catalog model IDs — for use in scalix_ai_infer.
`scalix_auth_configure`destructive	Configure end-user authentication for the project — require MFA, require email confirmation, and set the allowed auth providers. Needs an admin API key: organization admin scope is never delegated to a connected app, so this tool fails on an OAuth connection.
`scalix_build_create`	Create a new container image build from a Git repository or Dockerfile.
`scalix_build_status`read-only	Get the status and logs of a build.
`scalix_computer_create`	Get or create a persistent Linux machine by name. Idempotent — calling it again with the same name returns the existing machine rather than creating another, so it is safe to retry. Unlike a sandbox, the disk survives stop/start and is only erased by scalix_computer_delete.
`scalix_computer_delete`destructive	Permanently delete a persistent Linux machine AND its disk. This cannot be undone — use scalix_computer_stop if you may want the files back.
`scalix_computer_exec`destructive	Run a command inside a persistent Linux machine and wait for it to finish. Returns exit code, stdout and stderr. The machine must be running.
`scalix_computer_list`read-only	List your persistent Linux machines with their status, address and resource shape.
`scalix_computer_read_file`read-only	Read a text file out of a persistent Linux machine.
`scalix_computer_set_ssh_keys`destructive	Replace the ssh keys authorised for root on a persistent Linux machine. This is how you revoke: send the list without the key you want gone, and on a running machine it stops working immediately. Sending an empty list removes every key. Not a patch — whatever you send becomes the whole list, so read the current keys from scalix_computer_list first if you mean to add one.
`scalix_computer_start`	Start a stopped persistent Linux machine. Same disk, same address.
`scalix_computer_stop`	Stop a persistent Linux machine. The disk and the network address are kept, so starting it again returns the same files at the same address. Stop machines you are done with — a stopped machine costs only its disk.
`scalix_computer_write_file`destructive	Write a text file into a persistent Linux machine. Use this instead of shelling out with cat/echo — no quoting to get wrong.
`scalix_crew_board_post`	Post a note to the crew's notice board for other members and the human to see. The board is news, not knowledge: set ttl_seconds so routine updates expire on their own, pin only what every future task must see, and set owner_member_id to hand work off to a specific member. Notes cannot be edited from here — post a correction instead.
`scalix_crew_board_read`read-only	Read a crew's notice board: every pinned note plus the newest unpinned ones, current as of this call. The board is the crew's shared coordination state — read it before starting work so you act on the latest news, and post what teammates need to know with scalix_crew_board_post.
`scalix_crew_list`read-only	List your crews with their ids and names. A crew is a team of AI members that share a notice board; use the crew id with the board tools.
`scalix_cron_create`	Create a cron schedule to run a function or webhook on a timer.
`scalix_db_migrate`destructive	Apply a database migration by version number.
`scalix_db_optimize`read-only	Analyze a SQL query and return optimization suggestions including index recommendations and query rewrites.
`scalix_db_pii`read-only	List all columns classified as containing personally identifiable information (PII).
`scalix_db_query`destructive	Execute a SQL query against the project database. Returns columns, rows, row count, and cost breakdown. Destructive statements (DROP/TRUNCATE/bulk DELETE) require a two-step confirmation: the first call returns code CONFIRMATION_REQUIRED with a confirmation_token — re-call with that value in confirm_token to execute.
`scalix_db_relationships`read-only	Get the relationship map showing how tables are connected via foreign keys.
`scalix_db_schema`read-only	Get the full database schema including all tables, columns, types, and relationships.
`scalix_db_search_columns`read-only	Search for columns by name or type across all tables.
`scalix_db_table`read-only	Get detailed information about a specific database table including columns, indexes, and foreign keys.
`scalix_db_text_to_sql`read-only	Translate a plain-language question into a candidate SQL query using pattern-matching against the live schema (no AI model — simple questions only: counts, averages, filtered selects on a named table). Returns the SQL without executing it, with a confidence score; low confidence means the table was guessed. Review the statement and tables_used, then run it with scalix_db_query. For complex questions, read scalix_db_schema and write the SQL directly.
`scalix_domain_add`	Add a custom domain to the project. Returns DNS records to configure.
`scalix_domain_list`read-only	List all custom domains and their SSL/verification status.
`scalix_domain_verify`	Verify DNS configuration for a custom domain and provision SSL certificate.
`scalix_events_publish`	Publish an event to a topic. Provide an event_type (a short name for the kind of event, e.g. 'user.created') and the data payload.
`scalix_events_topics`read-only	List the event-bus topics in the project, with each topic's ID and name. Use this to find or verify a topic_id before publishing with scalix_events_publish; publishing to a non-existent topic fails.
`scalix_fn_deploy`	Deploy a Scalix Function — serverless, per-request billed, running in isolated microVMs — from a container image. Invoke it with scalix_fn_invoke once deployed.
`scalix_fn_invoke`destructive	Invoke a deployed function with a JSON payload.
`scalix_fn_list`read-only	List all deployed serverless functions.
`scalix_kv_get`read-only	Read a single value from the project's key-value store by exact key. Returns the stored value, or a not-found error if the key does not exist or its TTL has expired. Use scalix_kv_list to discover keys by prefix first.
`scalix_kv_list`read-only	List keys in the key-value store, optionally filtered by prefix.
`scalix_kv_set`destructive	Set a key-value pair with optional TTL.
`scalix_project_create`	Create a new project within an organization. Returns the project ID, name, and slug. Issue an API key for the new project separately. Needs an admin API key: organization admin scope is never delegated to a connected app, so this tool fails on an OAuth connection.
`scalix_project_list`read-only	List every project in an organization, with each project's ID, name, and slug. Use this to resolve a project ID before calling project-scoped tools. Needs an admin API key: organization admin scope is never delegated to a connected app, so this tool fails on an OAuth connection.
`scalix_run_delete`destructive	Permanently delete a Scalix Run service. This cannot be undone: it stops the running instances, releases the public HTTPS URL, erases any attached volumes and discards every revision, so scalix_run_rollback cannot bring it back afterwards. To stop paying for an idle service without losing it, set min_instances to 0 with scalix_run_scale instead.
`scalix_run_deploy`	Deploy a long-running container service on Scalix Run from a container image. Creates a new service, or a new revision of an existing service with the same name, with health checks, a public HTTPS URL, and autoscaling between min_instances and max_instances (min 0 = scale-to-zero when idle). Billed per vCPU-hour while instances run. Roll back a bad revision with scalix_run_rollback.
`scalix_run_list`read-only	List all deployed container services in the project.
`scalix_run_rollback`	Roll a Scalix Run service back to an earlier revision — omit 'revision' to return to the immediately previous one. Traffic switches to the target revision; the replaced revision is kept and can be redeployed later. Use scalix_run_list to see services and their current revisions.
`scalix_run_scale`	Change the autoscaling bounds of an existing Scalix Run service without redeploying it. Raising min_instances keeps instances warm (no cold starts, higher cost); min_instances 0 enables scale-to-zero when idle. Takes effect immediately. Find service IDs with scalix_run_list.
`scalix_sandbox_run`	Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr, the probed interpreter version, and any files the code wrote (base64, under size/count caps).
`scalix_status`read-only	Get the current health status of the Scalix Cloud platform including all service components.
`scalix_storage_create_bucket`	Create a new Scalix Storage bucket in the project (S3-compatible object storage). Bucket names must be unique within the project. Setting public=true makes every object in the bucket readable without authentication — leave it false (the default) and use presigned URLs for private sharing. Public buckets double as static websites: upload index.html and serve it from the project's store subdomain at https://{slug}.store.scalix.world/buckets/{bucket}/objects/ (directory requests serve index.html; a 404.html object is served as the error page).
`scalix_storage_delete_bucket`destructive	Permanently delete a storage bucket and every object in it. Irreversible.
`scalix_storage_delete_object`destructive	Permanently delete an object (key) from a storage bucket. Irreversible.
`scalix_storage_download`read-only	Download an object from storage. Returns the content as base64.
`scalix_storage_list`read-only	List storage buckets, or list objects in a specific bucket with optional prefix filter.
`scalix_storage_upload`destructive	Upload content to object storage. Provide the content as a base64-encoded string.

Schemas: list_tools.

Similar MCP servers

Official server.json

{
  "name": "world.scalix/cloud",
  "icons": [
    {
      "src": "https://scalix.world/scalix-logo.svg",
      "mimeType": "image/svg+xml"
    }
  ],
  "title": "Scalix Cloud",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://api.scalix.world/v1/mcp",
      "type": "streamable-http",
      "headers": [
        {
          "name": "Authorization",
          "isSecret": true,
          "isRequired": true,
          "description": "Bearer <your Scalix API key> - create one free at https://console.scalix.world"
        }
      ]
    }
  ],
  "version": "1.5.0",
  "repository": {
    "url": "https://github.com/scalixworld/scalix-cloud-mcp",
    "source": "github"
  },
  "websiteUrl": "https://scalix.world",
  "description": "The agent-native cloud: database, functions, AI, storage, computers. 51 tools, one API key."
}