Scalix Cloud

Official53 toolsLive

by scalixworld

The agent-native cloud: database, functions, AI, storage, computers. 50 tools, one API key.

world.scalix/cloud MCP Server

The world.scalix/cloud server is an agent-native cloud that exposes functionality across database, functions, AI, storage, and computers. It provides 53 tools behind a single API key, grouped under the MCP ecosystem. Use it to integrate these capabilities into AI agents and developer workflows through one API entry.

🛠️ Key Features

53 tools under one API key
Database capabilities
Serverless functions
AI features
Storage
“Computers” integration

🚀 Use Cases

Agent-native access to database, functions, AI, and storage
MCP-based integrations for AI inference workflows
Developer tooling that targets Linux-based environments

⚡ Developer Benefits

Single API key for access
MCP tooling support (e.g., mcp, mcp-server)
Compatible with common agent coding toolchains (claude-code, claude-plugin, gemini-cli-extension)

⚠️ Limitations

Readme excerpt only provides installation/config metadata (53 tools and a single API key); specific tool behaviors are not included in the provided data.

Topics

mcpmcp-serverpostgresserverlessaiclaude-codeclaude-plugingemini-cli-extensionai-inferencedatabasekv-storelinux

Captured live from the server via tools/list.

scalix_db_relationships

Get the relationship map showing how tables are connected via foreign keys.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_db_search_columns

Search for columns by name or type across all tables.

Parameters1

query

string

required

Search term to match column names or types

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "description": "Search term to match column names or types",
      "type": "string"
    }
  },
  "required": [
    "query"
  ]
}

scalix_db_pii

List all columns classified as containing personally identifiable information (PII).

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_db_optimize

Analyze a SQL query and return optimization suggestions including index recommendations and query rewrites.

Parameters1

sql

string

required

SQL query to analyze and optimize

Raw schema

{
  "type": "object",
  "properties": {
    "sql": {
      "description": "SQL query to analyze and optimize",
      "type": "string"
    }
  },
  "required": [
    "sql"
  ]
}

scalix_db_text_to_sql

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.

Parameters1

question

string

required

The question to answer from the database, in plain language (e.g. 'how many orders shipped last week?')

Raw schema

{
  "type": "object",
  "properties": {
    "question": {
      "description": "The question to answer from the database, in plain language (e.g. 'how many orders shipped last week?')",
      "type": "string"
    }
  },
  "required": [
    "question"
  ]
}

scalix_db_query

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.

Parameters3

confirm_token	string	optional	Confirmation token from a prior CONFIRMATION_REQUIRED response; required to execute destructive SQL (single-use, short TTL)
params	array	optional	Bind parameters for the query
sql	string	required	SQL query to execute

Raw schema

{
  "type": "object",
  "properties": {
    "confirm_token": {
      "description": "Confirmation token from a prior CONFIRMATION_REQUIRED response; required to execute destructive SQL (single-use, short TTL)",
      "type": "string"
    },
    "params": {
      "description": "Bind parameters for the query",
      "items": {},
      "type": "array"
    },
    "sql": {
      "description": "SQL query to execute",
      "type": "string"
    }
  },
  "required": [
    "sql"
  ]
}

scalix_db_schema

Get the full database schema including all tables, columns, types, and relationships.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_db_table

Get detailed information about a specific database table including columns, indexes, and foreign keys.

Parameters1

table

string

required

Table name to inspect

Raw schema

{
  "type": "object",
  "properties": {
    "table": {
      "description": "Table name to inspect",
      "type": "string"
    }
  },
  "required": [
    "table"
  ]
}

scalix_db_migrate

Apply a database migration by version number.

Parameters2

tenant_id	string	required	Tenant ID
version	string	required	Migration version to apply

Raw schema

{
  "type": "object",
  "properties": {
    "tenant_id": {
      "description": "Tenant ID",
      "type": "string"
    },
    "version": {
      "description": "Migration version to apply",
      "type": "string"
    }
  },
  "required": [
    "tenant_id",
    "version"
  ]
}

scalix_storage_list

List storage buckets, or list objects in a specific bucket with optional prefix filter.

Parameters2

bucket	string	optional	Bucket name. If omitted, lists all buckets.
prefix	string	optional	Filter objects by key prefix

Raw schema

{
  "type": "object",
  "properties": {
    "bucket": {
      "description": "Bucket name. If omitted, lists all buckets.",
      "type": "string"
    },
    "prefix": {
      "description": "Filter objects by key prefix",
      "type": "string"
    }
  }
}

scalix_storage_upload

Upload content to object storage. Provide the content as a base64-encoded string.

Parameters4

bucket	string	required	Target bucket name
content	string	required	Base64-encoded file content
content_type	string	optional	MIME type
key	string	required	Object key (path)

Raw schema

{
  "type": "object",
  "properties": {
    "bucket": {
      "description": "Target bucket name",
      "type": "string"
    },
    "content": {
      "description": "Base64-encoded file content",
      "type": "string"
    },
    "content_type": {
      "default": "application/octet-stream",
      "description": "MIME type",
      "type": "string"
    },
    "key": {
      "description": "Object key (path)",
      "type": "string"
    }
  },
  "required": [
    "bucket",
    "key",
    "content"
  ]
}

scalix_storage_download

Download an object from storage. Returns the content as base64.

Parameters2

bucket	string	required	Bucket name
key	string	required	Object key (path)

Raw schema

{
  "type": "object",
  "properties": {
    "bucket": {
      "description": "Bucket name",
      "type": "string"
    },
    "key": {
      "description": "Object key (path)",
      "type": "string"
    }
  },
  "required": [
    "bucket",
    "key"
  ]
}

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.

Parameters2

name	string	required	Bucket name, unique within the project
public	boolean	optional	true = all objects publicly readable without auth; false (default) = private, share via presigned URLs

Raw schema

{
  "type": "object",
  "properties": {
    "name": {
      "description": "Bucket name, unique within the project",
      "type": "string"
    },
    "public": {
      "default": false,
      "description": "true = all objects publicly readable without auth; false (default) = private, share via presigned URLs",
      "type": "boolean"
    }
  },
  "required": [
    "name"
  ]
}

scalix_fn_list

List all deployed serverless functions.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

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.

Parameters3

image	string	required	Container image reference
name	string	required	Function name
runtime	string	optional	Runtime (e.g., nodejs20, python3.12)

Raw schema

{
  "type": "object",
  "properties": {
    "image": {
      "description": "Container image reference",
      "type": "string"
    },
    "name": {
      "description": "Function name",
      "type": "string"
    },
    "runtime": {
      "description": "Runtime (e.g., nodejs20, python3.12)",
      "type": "string"
    }
  },
  "required": [
    "name",
    "image"
  ]
}

scalix_fn_invoke

Invoke a deployed function with a JSON payload.

Parameters2

data	object	optional	JSON payload to pass to the function
function_id	string	required	Function ID to invoke

Raw schema

{
  "type": "object",
  "properties": {
    "data": {
      "description": "JSON payload to pass to the function",
      "type": "object"
    },
    "function_id": {
      "description": "Function ID to invoke",
      "type": "string"
    }
  },
  "required": [
    "function_id"
  ]
}

scalix_kv_get

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.

Parameters1

key

string

required

Exact key to look up (case-sensitive)

Raw schema

{
  "type": "object",
  "properties": {
    "key": {
      "description": "Exact key to look up (case-sensitive)",
      "type": "string"
    }
  },
  "required": [
    "key"
  ]
}

scalix_kv_set

Set a key-value pair with optional TTL.

Parameters3

key	string	required	Key to set
ttl	integer	optional	Time-to-live in seconds (0 = no expiry)
value	string	required	Value to store

Raw schema

{
  "type": "object",
  "properties": {
    "key": {
      "description": "Key to set",
      "type": "string"
    },
    "ttl": {
      "description": "Time-to-live in seconds (0 = no expiry)",
      "type": "integer"
    },
    "value": {
      "description": "Value to store",
      "type": "string"
    }
  },
  "required": [
    "key",
    "value"
  ]
}

scalix_kv_list

List keys in the key-value store, optionally filtered by prefix.

Parameters1

prefix

string

optional

Filter keys by prefix

Raw schema

{
  "type": "object",
  "properties": {
    "prefix": {
      "description": "Filter keys by prefix",
      "type": "string"
    }
  }
}

scalix_ai_infer

Run AI inference on Scalix AI — the Scalix Lumio model family. 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.

Parameters5

max_tokens	integer	optional	Maximum tokens to generate
model	string	optional	Model ID (from scalix_ai_models, e.g. a Scalix Lumio variant)
prompt	string	required	User prompt / message
system	string	optional	System message
temperature	number	optional	Sampling temperature (0-2)

Raw schema

{
  "type": "object",
  "properties": {
    "max_tokens": {
      "default": 1024,
      "description": "Maximum tokens to generate",
      "type": "integer"
    },
    "model": {
      "description": "Model ID (from scalix_ai_models, e.g. a Scalix Lumio variant)",
      "type": "string"
    },
    "prompt": {
      "description": "User prompt / message",
      "type": "string"
    },
    "system": {
      "description": "System message",
      "type": "string"
    },
    "temperature": {
      "default": 0.7,
      "description": "Sampling temperature (0-2)",
      "type": "number"
    }
  },
  "required": [
    "prompt"
  ]
}

scalix_ai_models

List the AI models available to the project — the Scalix Lumio family and any models enabled for the org — with their IDs for use in scalix_ai_infer.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

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.

Parameters3

data	object	required	Event payload (JSON)
event_type	string	required	Event type/name, e.g. 'user.created'
topic_id	string	required	Topic ID to publish to

Raw schema

{
  "type": "object",
  "properties": {
    "data": {
      "description": "Event payload (JSON)",
      "type": "object"
    },
    "event_type": {
      "description": "Event type/name, e.g. 'user.created'",
      "type": "string"
    },
    "topic_id": {
      "description": "Topic ID to publish to",
      "type": "string"
    }
  },
  "required": [
    "topic_id",
    "event_type",
    "data"
  ]
}

scalix_events_topics

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.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_cron_create

Create a cron schedule to run a function or webhook on a timer.

Parameters4

action_type	string	required	Type of action to trigger
config	object	optional	Action configuration (function_id or webhook URL)
expression	string	required	Cron expression (e.g., '/5 * * *')
name	string	required	Schedule name

Raw schema

{
  "type": "object",
  "properties": {
    "action_type": {
      "description": "Type of action to trigger",
      "enum": [
        "function",
        "webhook"
      ],
      "type": "string"
    },
    "config": {
      "description": "Action configuration (function_id or webhook URL)",
      "type": "object"
    },
    "expression": {
      "description": "Cron expression (e.g., '*/5 * * * *')",
      "type": "string"
    },
    "name": {
      "description": "Schedule name",
      "type": "string"
    }
  },
  "required": [
    "name",
    "expression",
    "action_type"
  ]
}

scalix_sandbox_run

Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr.

Parameters5

code	string	required	Source code to execute
files	object	optional	Additional files (filename -> content)
language	string	required	Programming language
packages	array	optional	Packages to install (pip/npm)
timeout_seconds	integer	optional	Max execution time in seconds (default: 30)

Raw schema

{
  "type": "object",
  "properties": {
    "code": {
      "description": "Source code to execute",
      "type": "string"
    },
    "files": {
      "description": "Additional files (filename -> content)",
      "type": "object"
    },
    "language": {
      "description": "Programming language",
      "enum": [
        "python",
        "javascript",
        "typescript",
        "bash"
      ],
      "type": "string"
    },
    "packages": {
      "description": "Packages to install (pip/npm)",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "timeout_seconds": {
      "description": "Max execution time in seconds (default: 30)",
      "type": "integer"
    }
  },
  "required": [
    "language",
    "code"
  ]
}

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.

Parameters5

disk_gb	integer	optional	Root disk in GB, 5-200 (default 10). Fixed at create — disks do not grow. Ignored if the machine already exists.
memory_mb	integer	optional	Memory in MB, 512-32768 (default 1024). Ignored if the machine already exists.
name	string	required	Machine name: lowercase letters, digits and hyphens, max 63 characters. Unique to you.
ssh_keys	array	optional	OpenSSH public keys to authorise for root, max 32, e.g. ["ssh-ed25519 AAAAC3Nz… you@laptop"]. Only needed if a human will ssh in — exec, write_file and read_file all work without one. Send the public half only; a private key is rejected. Ignored if the machine already exists — use scalix_computer_set_ssh_keys to change them. Supplying this needs the sandbox:execute scope on top of sandbox:create, because a key is a root shell; omit it and sandbox:create alone is enough.
vcpus	integer	optional	vCPUs, 1-16 (default 1). Ignored if the machine already exists.

Raw schema

{
  "type": "object",
  "properties": {
    "disk_gb": {
      "description": "Root disk in GB, 5-200 (default 10). Fixed at create — disks do not grow. Ignored if the machine already exists.",
      "type": "integer"
    },
    "memory_mb": {
      "description": "Memory in MB, 512-32768 (default 1024). Ignored if the machine already exists.",
      "type": "integer"
    },
    "name": {
      "description": "Machine name: lowercase letters, digits and hyphens, max 63 characters. Unique to you.",
      "type": "string"
    },
    "ssh_keys": {
      "description": "OpenSSH public keys to authorise for root, max 32, e.g. [\"ssh-ed25519 AAAAC3Nz… you@laptop\"]. Only needed if a human will ssh in — exec, write_file and read_file all work without one. Send the public half only; a private key is rejected. Ignored if the machine already exists — use scalix_computer_set_ssh_keys to change them. Supplying this needs the sandbox:execute scope on top of sandbox:create, because a key is a root shell; omit it and sandbox:create alone is enough.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "vcpus": {
      "description": "vCPUs, 1-16 (default 1). Ignored if the machine already exists.",
      "type": "integer"
    }
  },
  "required": [
    "name"
  ]
}

scalix_computer_set_ssh_keys

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.

Parameters2

id	string	required	Machine id
ssh_keys	array	required	The complete list of OpenSSH public keys, max 32. Empty array removes all of them.

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Machine id",
      "type": "string"
    },
    "ssh_keys": {
      "description": "The complete list of OpenSSH public keys, max 32. Empty array removes all of them.",
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "required": [
    "id",
    "ssh_keys"
  ]
}

scalix_computer_list

List your persistent Linux machines with their status, address and resource shape.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_computer_exec

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.

Parameters6

args	array	optional	Arguments, e.g. ["-lc", "npm test"]
command	string	required	Program to run, e.g. bash
cwd	string	optional	Working directory inside the machine
env	object	optional	Environment variables for this command only
id	string	required	Machine id from scalix_computer_create or scalix_computer_list
timeout_ms	integer	optional	Give up after this many milliseconds, 1000-600000 (default 120000)

Raw schema

{
  "type": "object",
  "properties": {
    "args": {
      "description": "Arguments, e.g. [\"-lc\", \"npm test\"]",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "command": {
      "description": "Program to run, e.g. bash",
      "type": "string"
    },
    "cwd": {
      "description": "Working directory inside the machine",
      "type": "string"
    },
    "env": {
      "description": "Environment variables for this command only",
      "type": "object"
    },
    "id": {
      "description": "Machine id from scalix_computer_create or scalix_computer_list",
      "type": "string"
    },
    "timeout_ms": {
      "description": "Give up after this many milliseconds, 1000-600000 (default 120000)",
      "type": "integer"
    }
  },
  "required": [
    "id",
    "command"
  ]
}

scalix_computer_write_file

Write a text file into a persistent Linux machine. Use this instead of shelling out with cat/echo — no quoting to get wrong.

Parameters4

content	string	required	File contents as text
id	string	required	Machine id
mode	integer	optional	Unix mode in decimal, e.g. 493 for 0755. Omit unless the file must be executable.
path	string	required	Absolute path inside the machine, e.g. /root/app/main.py

Raw schema

{
  "type": "object",
  "properties": {
    "content": {
      "description": "File contents as text",
      "type": "string"
    },
    "id": {
      "description": "Machine id",
      "type": "string"
    },
    "mode": {
      "description": "Unix mode in decimal, e.g. 493 for 0755. Omit unless the file must be executable.",
      "type": "integer"
    },
    "path": {
      "description": "Absolute path inside the machine, e.g. /root/app/main.py",
      "type": "string"
    }
  },
  "required": [
    "id",
    "path",
    "content"
  ]
}

scalix_computer_read_file

Read a text file out of a persistent Linux machine.

Parameters2

id	string	required	Machine id
path	string	required	Absolute path inside the machine

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Machine id",
      "type": "string"
    },
    "path": {
      "description": "Absolute path inside the machine",
      "type": "string"
    }
  },
  "required": [
    "id",
    "path"
  ]
}

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.

Parameters1

string

required

Machine id

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Machine id",
      "type": "string"
    }
  },
  "required": [
    "id"
  ]
}

scalix_computer_start

Start a stopped persistent Linux machine. Same disk, same address.

Parameters1

string

required

Machine id

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Machine id",
      "type": "string"
    }
  },
  "required": [
    "id"
  ]
}

scalix_computer_delete

Permanently delete a persistent Linux machine AND its disk. This cannot be undone — use scalix_computer_stop if you may want the files back.

Parameters1

string

required

Machine id

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Machine id",
      "type": "string"
    }
  },
  "required": [
    "id"
  ]
}

scalix_crew_list

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.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_crew_board_read

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.

Parameters1

crew_id

string

required

Crew id from scalix_crew_list

Raw schema

{
  "type": "object",
  "properties": {
    "crew_id": {
      "description": "Crew id from scalix_crew_list",
      "type": "string"
    }
  },
  "required": [
    "crew_id"
  ]
}

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.

Parameters6

author_member_id	string	optional	Your member id, so the note is attributed. Omit when posting as the human.
body	string	required	The note, max 8000 chars. Write for a teammate who was not watching your work.
crew_id	string	required	Crew id from scalix_crew_list
owner_member_id	string	optional	Hand off: the member id now responsible for this item.
pinned	boolean	optional	Keep this in front of everyone indefinitely. Default false; most notes should expire instead.
ttl_seconds	integer	optional	Seconds until the note expires, 60 to 7776000 (90 days). Omit for no expiry — usually only right for pins.

Raw schema

{
  "type": "object",
  "properties": {
    "author_member_id": {
      "description": "Your member id, so the note is attributed. Omit when posting as the human.",
      "type": "string"
    },
    "body": {
      "description": "The note, max 8000 chars. Write for a teammate who was not watching your work.",
      "type": "string"
    },
    "crew_id": {
      "description": "Crew id from scalix_crew_list",
      "type": "string"
    },
    "owner_member_id": {
      "description": "Hand off: the member id now responsible for this item.",
      "type": "string"
    },
    "pinned": {
      "description": "Keep this in front of everyone indefinitely. Default false; most notes should expire instead.",
      "type": "boolean"
    },
    "ttl_seconds": {
      "description": "Seconds until the note expires, 60 to 7776000 (90 days). Omit for no expiry — usually only right for pins.",
      "type": "integer"
    }
  },
  "required": [
    "crew_id",
    "body"
  ]
}

scalix_domain_add

Add a custom domain to the project. Returns DNS records to configure.

Parameters1

domain

string

required

Domain name to add (e.g., api.example.com)

Raw schema

{
  "type": "object",
  "properties": {
    "domain": {
      "description": "Domain name to add (e.g., api.example.com)",
      "type": "string"
    }
  },
  "required": [
    "domain"
  ]
}

scalix_domain_list

List all custom domains and their SSL/verification status.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_domain_verify

Verify DNS configuration for a custom domain and provision SSL certificate.

Parameters1

domain

string

required

Domain to verify

Raw schema

{
  "type": "object",
  "properties": {
    "domain": {
      "description": "Domain to verify",
      "type": "string"
    }
  },
  "required": [
    "domain"
  ]
}

scalix_build_create

Create a new container image build from a Git repository or Dockerfile.

Parameters4

branch	string	optional	Git branch
dockerfile	string	optional	Path to Dockerfile in repo
git_url	string	required	Git repository URL
name	string	required	Build name

Raw schema

{
  "type": "object",
  "properties": {
    "branch": {
      "default": "main",
      "description": "Git branch",
      "type": "string"
    },
    "dockerfile": {
      "default": "Dockerfile",
      "description": "Path to Dockerfile in repo",
      "type": "string"
    },
    "git_url": {
      "description": "Git repository URL",
      "type": "string"
    },
    "name": {
      "description": "Build name",
      "type": "string"
    }
  },
  "required": [
    "name",
    "git_url"
  ]
}

scalix_build_status

Get the status and logs of a build.

Parameters1

build_id

string

required

Build ID to check

Raw schema

{
  "type": "object",
  "properties": {
    "build_id": {
      "description": "Build ID to check",
      "type": "string"
    }
  },
  "required": [
    "build_id"
  ]
}

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.

Parameters3

name	string	required	Project display name
org_id	string	required	Organization ID
slug	string	required	URL-safe project slug

Raw schema

{
  "type": "object",
  "properties": {
    "name": {
      "description": "Project display name",
      "type": "string"
    },
    "org_id": {
      "description": "Organization ID",
      "type": "string"
    },
    "slug": {
      "description": "URL-safe project slug",
      "type": "string"
    }
  },
  "required": [
    "org_id",
    "name",
    "slug"
  ]
}

scalix_project_list

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.

Parameters1

org_id

string

required

Organization ID whose projects to list

Raw schema

{
  "type": "object",
  "properties": {
    "org_id": {
      "description": "Organization ID whose projects to list",
      "type": "string"
    }
  },
  "required": [
    "org_id"
  ]
}

scalix_auth_configure

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.

Parameters3

allowed_providers	array	optional	Allowed auth providers (e.g., ["email", "google", "github"])
mfa_enabled	boolean	optional	Require multi-factor authentication
require_email_confirmation	boolean	optional	Require users to confirm their email before a session is issued

Raw schema

{
  "type": "object",
  "properties": {
    "allowed_providers": {
      "description": "Allowed auth providers (e.g., [\"email\", \"google\", \"github\"])",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "mfa_enabled": {
      "description": "Require multi-factor authentication",
      "type": "boolean"
    },
    "require_email_confirmation": {
      "description": "Require users to confirm their email before a session is issued",
      "type": "boolean"
    }
  }
}

scalix_status

Get the current health status of the Scalix Cloud platform including all service components.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

scalix_usage

Get current usage metrics and costs for a project.

Parameters1

project_id

string

required

Project ID to check usage for

Raw schema

{
  "type": "object",
  "properties": {
    "project_id": {
      "description": "Project ID to check usage for",
      "type": "string"
    }
  },
  "required": [
    "project_id"
  ]
}

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.

Parameters6

env	object	optional	Environment variables as key-value pairs
image	string	required	Container image from the Scalix registry ({registry}/{project_id}/{repo}:{tag}). External registries (Docker Hub, etc.) are NOT supported — build & push first with scalix_build_create.
max_instances	integer	optional	Maximum instances
min_instances	integer	optional	Minimum instances (0 = scale to zero)
name	string	required	Service name
port	integer	optional	Port the container listens on

Raw schema

{
  "type": "object",
  "properties": {
    "env": {
      "description": "Environment variables as key-value pairs",
      "type": "object"
    },
    "image": {
      "description": "Container image from the Scalix registry ({registry}/{project_id}/{repo}:{tag}). External registries (Docker Hub, etc.) are NOT supported — build & push first with scalix_build_create.",
      "type": "string"
    },
    "max_instances": {
      "default": 10,
      "description": "Maximum instances",
      "type": "integer"
    },
    "min_instances": {
      "default": 0,
      "description": "Minimum instances (0 = scale to zero)",
      "type": "integer"
    },
    "name": {
      "description": "Service name",
      "type": "string"
    },
    "port": {
      "default": 8080,
      "description": "Port the container listens on",
      "type": "integer"
    }
  },
  "required": [
    "name",
    "image"
  ]
}

scalix_run_list

List all deployed container services in the project.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

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.

Parameters3

id	string	required	Service ID (from scalix_run_list)
max_instances	integer	optional	New maximum instance count the service may scale up to
min_instances	integer	optional	New minimum instance count (0 = scale-to-zero when idle)

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Service ID (from scalix_run_list)",
      "type": "string"
    },
    "max_instances": {
      "description": "New maximum instance count the service may scale up to",
      "type": "integer"
    },
    "min_instances": {
      "description": "New minimum instance count (0 = scale-to-zero when idle)",
      "type": "integer"
    }
  },
  "required": [
    "id"
  ]
}

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.

Parameters2

id	string	required	Service ID (from scalix_run_list)
revision	integer	optional	Revision number to roll back to; omit for the immediately previous revision

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Service ID (from scalix_run_list)",
      "type": "string"
    },
    "revision": {
      "description": "Revision number to roll back to; omit for the immediately previous revision",
      "type": "integer"
    }
  },
  "required": [
    "id"
  ]
}

scalix_run_delete

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.

Parameters1

string

required

Service ID (from scalix_run_list)

Raw schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Service ID (from scalix_run_list)",
      "type": "string"
    }
  },
  "required": [
    "id"
  ]
}

scalix_search

Search the Scalix original-source index — a curated set of original publishers (newsrooms, wires, regulators), not the open web. Returns originals only by default (syndicated copies collapsed to the source that published first), with provenance: source, published date, region, and canonical flag.

Parameters5

language	string	optional	Filter by language code, e.g. 'en'
limit	integer	optional	Max results (1-100)
original_only	boolean	optional	Return only canonical originals (default true); set false to see all syndicated copies
q	string	required	Search query
region	string	optional	Filter by region, e.g. 'in', 'eu', 'us', 'global'

Raw schema

{
  "type": "object",
  "properties": {
    "language": {
      "description": "Filter by language code, e.g. 'en'",
      "type": "string"
    },
    "limit": {
      "default": 20,
      "description": "Max results (1-100)",
      "type": "integer"
    },
    "original_only": {
      "default": true,
      "description": "Return only canonical originals (default true); set false to see all syndicated copies",
      "type": "boolean"
    },
    "q": {
      "description": "Search query",
      "type": "string"
    },
    "region": {
      "description": "Filter by region, e.g. 'in', 'eu', 'us', 'global'",
      "type": "string"
    }
  },
  "required": [
    "q"
  ]
}

README.md4 KBView on GitHub

Scalix World — MCP Server

The official Model Context Protocol server for Scalix World, the AI-native neocloud. One hosted MCP server lets an agent operate the entire platform — no local install. Database, compute, functions, storage, auth, AI, DNS and billing: 53 tools across 17 domains, one API key.

Claude Code plugin (recommended)

Install the full package — 53 tools, 4 skills and a /scalix:setup command:

bash

claude plugin marketplace add scalixworld/scalix-cloud-mcp
claude plugin install scalix@scalix

Then run /scalix:setup inside Claude Code to connect and verify.

Antigravity (Google)

Install as a plugin (recommended — one command):

bash

git clone https://github.com/scalixworld/scalix-cloud-mcp ~/.gemini/config/plugins/scalix

Then open the plugin's mcp_config.json and replace YOUR_SCALIX_API_KEY with a key from scalix.world (Console → API Keys). Antigravity auto-discovers plugins in ~/.gemini/config/plugins/ (global) or .agents/plugins/ (per-workspace).

Or add the server directly: paste the mcpServers block from mcp_config.json into ~/.gemini/config/mcp_config.json (Antigravity 2.0 / IDE) — or in Antigravity CLI type /mcp for the interactive manager. Note Antigravity uses serverUrl (not url).

Gemini CLI

bash

gemini extensions install https://github.com/scalixworld/scalix-cloud-mcp

Set SCALIX_API_KEY in your environment; the extension config and GEMINI.md context load automatically.

Connect

code

https://api.scalix.world/v1/mcp

Authenticate with a Scalix World API key (Authorization: Bearer <key>), scopable to specific services, projects, and actions. Listed in the official MCP registry as world.scalix/cloud.

Example (Claude Code):

bash

claude mcp add --transport http scalix https://api.scalix.world/v1/mcp \
  --header "Authorization: Bearer $SCALIX_API_KEY"

What an agent can do with it

Databases — provision Postgres-compatible databases with scale-to-zero; create copy-on-write branches to test migrations, then promote or drop them
Compute — deploy container services and serverless functions in isolated microVMs
Storage, Auth, DNS, Email — manage the production primitives around the app
AI inference — run AI workloads with routing, metering, and spend controls
Observability & billing — read logs and metrics, check usage and remaining credits; the agent can make cost-aware decisions with the same key it deploys with

Consequential actions (deletes, production changes, spend past budget caps) pause for human approval — guardrails are a platform feature, not a wrapper script.

Docs

MCP guide: https://docs.scalix.world/mcp
API reference: https://docs.scalix.world/api-reference/mcp
Start free (no card): https://scalix.world

About

Scalix World is a fully managed cloud platform engineered as one system — database, AI, compute, storage, auth, billing — operable by humans through a console and by agents through this MCP server, on sovereign European infrastructure. Built by Scalix.

Install

Tools (53)

scalix_db_relationshipsscalix_db_search_columnsscalix_db_piiscalix_db_optimizescalix_db_text_to_sqlscalix_db_queryscalix_db_schemascalix_db_table

Remote endpoint

Streamable HTTP

Hosted server - connect over the network, no local install.

url

https://api.scalix.world/v1/mcp

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "cloud": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.scalix.world/v1/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.

world.scalix/cloud MCP Server

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

scalix_db_relationships

scalix_db_search_columns

scalix_db_pii

scalix_db_optimize

scalix_db_text_to_sql

scalix_db_query

scalix_db_schema

scalix_db_table

scalix_db_migrate

scalix_storage_list

scalix_storage_upload

scalix_storage_download

scalix_storage_create_bucket

scalix_fn_list

scalix_fn_deploy

scalix_fn_invoke

scalix_kv_get

scalix_kv_set

scalix_kv_list

scalix_ai_infer

scalix_ai_models

scalix_events_publish

scalix_events_topics

scalix_cron_create

scalix_sandbox_run

scalix_computer_create

scalix_computer_set_ssh_keys

scalix_computer_list

scalix_computer_exec

scalix_computer_write_file

scalix_computer_read_file

scalix_computer_stop

scalix_computer_start

scalix_computer_delete

scalix_crew_list

scalix_crew_board_read

scalix_crew_board_post

scalix_domain_add

scalix_domain_list

scalix_domain_verify

scalix_build_create

scalix_build_status

scalix_project_create

scalix_project_list

scalix_auth_configure

scalix_status

scalix_usage

scalix_run_deploy

scalix_run_list

scalix_run_scale

scalix_run_rollback

scalix_run_delete

scalix_search

Scalix World — MCP Server

Claude Code plugin (recommended)

Antigravity (Google)

Gemini CLI

Connect

What an agent can do with it

Docs

About

Install

Remote endpoint

Related servers