{
  "data": {
    "tool": {
      "category": "data",
      "endpoint": "https://api.scalix.world/v1/mcp",
      "jsonUrl": "https://www.anchorterminal.com/api/v1/tools/scalix-cloud.json",
      "kind": "mcp",
      "listed": "indexed",
      "liveUrl": "https://www.anchorterminal.com/api/v1/live/scalix-cloud.json",
      "markdownUrl": "https://www.anchorterminal.com/tools/scalix-cloud.md",
      "mcpTools": {
        "check": {
          "checker": "anchor-check/1.0",
          "totalTokens": 7119,
          "counts": {
            "error": 0,
            "note": 1,
            "warn": 9
          },
          "findings": [
            {
              "rule": "TC12",
              "severity": "warn",
              "tool": "scalix_db_query",
              "message": "no type for params[]",
              "fix": "Give every parameter a type (or an enum)."
            },
            {
              "rule": "TC13",
              "severity": "warn",
              "tool": "scalix_computer_exec",
              "message": "env (object with no properties)",
              "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
            },
            {
              "rule": "TC13",
              "severity": "warn",
              "tool": "scalix_cron_create",
              "message": "config (object with no properties)",
              "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
            },
            {
              "rule": "TC13",
              "severity": "warn",
              "tool": "scalix_events_publish",
              "message": "data (object with no properties)",
              "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
            },
            {
              "rule": "TC13",
              "severity": "warn",
              "tool": "scalix_fn_invoke",
              "message": "data (object with no properties)",
              "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
            },
            {
              "rule": "TC13",
              "severity": "warn",
              "tool": "scalix_run_deploy",
              "message": "env (object with no properties)",
              "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
            },
            {
              "rule": "TC13",
              "severity": "warn",
              "tool": "scalix_sandbox_run",
              "message": "files (object with no properties)",
              "fix": "Declare the properties (or additionalProperties with a schema) and the array's items."
            },
            {
              "rule": "TC14",
              "severity": "warn",
              "tool": "scalix_fn_deploy",
              "message": "allowed values are in the description, not an enum: runtime",
              "fix": "Move them into enum."
            },
            {
              "rule": "TC23",
              "severity": "warn",
              "message": "51 tools",
              "fix": "Offer a smaller default toolset and let clients opt into the rest."
            },
            {
              "rule": "TC24",
              "severity": "note",
              "message": "51 of 51 tools have no outputSchema",
              "fix": "Declare outputSchema for tools that return structured data, and return structuredContent that matches it."
            }
          ]
        },
        "checkedAt": "2026-10-04T22:26:03Z",
        "count": 51,
        "schemaTokens": 7119,
        "status": "ok",
        "tools": [
          {
            "name": "scalix_db_relationships",
            "description": "Get the relationship map showing how tables are connected via foreign keys.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_db_search_columns",
            "description": "Search for columns by name or type across all tables.",
            "inputSchema": {
              "properties": {
                "query": {
                  "description": "Search term to match column names or types",
                  "type": "string"
                }
              },
              "required": [
                "query"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_db_pii",
            "description": "List all columns classified as containing personally identifiable information (PII).",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_db_optimize",
            "description": "Analyze a SQL query and return optimization suggestions including index recommendations and query rewrites.",
            "inputSchema": {
              "properties": {
                "sql": {
                  "description": "SQL query to analyze and optimize",
                  "type": "string"
                }
              },
              "required": [
                "sql"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_db_text_to_sql",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_db_query",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_db_schema",
            "description": "Get the full database schema including all tables, columns, types, and relationships.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_db_table",
            "description": "Get detailed information about a specific database table including columns, indexes, and foreign keys.",
            "inputSchema": {
              "properties": {
                "table": {
                  "description": "Table name to inspect",
                  "type": "string"
                }
              },
              "required": [
                "table"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_db_migrate",
            "description": "Apply a database migration by version number.",
            "inputSchema": {
              "properties": {
                "tenant_id": {
                  "description": "Tenant ID",
                  "type": "string"
                },
                "version": {
                  "description": "Migration version to apply",
                  "type": "string"
                }
              },
              "required": [
                "tenant_id",
                "version"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_storage_list",
            "description": "List storage buckets, or list objects in a specific bucket with optional prefix filter.",
            "inputSchema": {
              "properties": {
                "bucket": {
                  "description": "Bucket name. If omitted, lists all buckets.",
                  "type": "string"
                },
                "prefix": {
                  "description": "Filter objects by key prefix",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_storage_upload",
            "description": "Upload content to object storage. Provide the content as a base64-encoded string.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_storage_download",
            "description": "Download an object from storage. Returns the content as base64.",
            "inputSchema": {
              "properties": {
                "bucket": {
                  "description": "Bucket name",
                  "type": "string"
                },
                "key": {
                  "description": "Object key (path)",
                  "type": "string"
                }
              },
              "required": [
                "bucket",
                "key"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_storage_create_bucket",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_fn_list",
            "description": "List all deployed serverless functions.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_fn_deploy",
            "description": "Deploy a Scalix Function — serverless, per-request billed, running in isolated microVMs — from a container image. Invoke it with scalix_fn_invoke once deployed.",
            "inputSchema": {
              "properties": {
                "image": {
                  "description": "Container image reference",
                  "type": "string"
                },
                "name": {
                  "description": "Function name",
                  "type": "string"
                },
                "runtime": {
                  "description": "Runtime — `node` or `python` (exactly what the functions orchestrator accepts)",
                  "type": "string"
                }
              },
              "required": [
                "name",
                "image"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_fn_invoke",
            "description": "Invoke a deployed function with a JSON payload.",
            "inputSchema": {
              "properties": {
                "data": {
                  "description": "JSON payload to pass to the function",
                  "type": "object"
                },
                "function_id": {
                  "description": "Function ID to invoke",
                  "type": "string"
                }
              },
              "required": [
                "function_id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_kv_get",
            "description": "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.",
            "inputSchema": {
              "properties": {
                "key": {
                  "description": "Exact key to look up (case-sensitive)",
                  "type": "string"
                }
              },
              "required": [
                "key"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_kv_set",
            "description": "Set a key-value pair with optional TTL.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_kv_list",
            "description": "List keys in the key-value store, optionally filtered by prefix.",
            "inputSchema": {
              "properties": {
                "prefix": {
                  "description": "Filter keys by prefix",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_ai_infer",
            "description": "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.",
            "inputSchema": {
              "properties": {
                "max_tokens": {
                  "default": 1024,
                  "description": "Maximum tokens to generate",
                  "type": "integer"
                },
                "model": {
                  "description": "Model ID (from scalix_ai_models — a scalix-auto/* tier or a scalix-gw/\u003cvendor\u003e/\u003cmodel\u003e catalog id)",
                  "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_ai_models",
            "description": "List the AI models available to the project — virtual tiers and the pass-through catalog model IDs — for use in scalix_ai_infer.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_events_publish",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_events_topics",
            "description": "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.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_cron_create",
            "description": "Create a cron schedule to run a function or webhook on a timer.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_sandbox_run",
            "description": "Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr.",
            "inputSchema": {
              "properties": {
                "code": {
                  "description": "Source code to execute",
                  "type": "string"
                },
                "files": {
                  "description": "Additional files (filename -\u003e 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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_computer_create",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_computer_set_ssh_keys",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_computer_list",
            "description": "List your persistent Linux machines with their status, address and resource shape.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_computer_exec",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_computer_write_file",
            "description": "Write a text file into a persistent Linux machine. Use this instead of shelling out with cat/echo — no quoting to get wrong.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_computer_read_file",
            "description": "Read a text file out of a persistent Linux machine.",
            "inputSchema": {
              "properties": {
                "id": {
                  "description": "Machine id",
                  "type": "string"
                },
                "path": {
                  "description": "Absolute path inside the machine",
                  "type": "string"
                }
              },
              "required": [
                "id",
                "path"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_computer_stop",
            "description": "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.",
            "inputSchema": {
              "properties": {
                "id": {
                  "description": "Machine id",
                  "type": "string"
                }
              },
              "required": [
                "id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_computer_start",
            "description": "Start a stopped persistent Linux machine. Same disk, same address.",
            "inputSchema": {
              "properties": {
                "id": {
                  "description": "Machine id",
                  "type": "string"
                }
              },
              "required": [
                "id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_computer_delete",
            "description": "Permanently delete a persistent Linux machine AND its disk. This cannot be undone — use scalix_computer_stop if you may want the files back.",
            "inputSchema": {
              "properties": {
                "id": {
                  "description": "Machine id",
                  "type": "string"
                }
              },
              "required": [
                "id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_crew_list",
            "description": "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.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_crew_board_read",
            "description": "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.",
            "inputSchema": {
              "properties": {
                "crew_id": {
                  "description": "Crew id from scalix_crew_list",
                  "type": "string"
                }
              },
              "required": [
                "crew_id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_crew_board_post",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_domain_add",
            "description": "Add a custom domain to the project. Returns DNS records to configure.",
            "inputSchema": {
              "properties": {
                "domain": {
                  "description": "Domain name to add (e.g., api.example.com)",
                  "type": "string"
                }
              },
              "required": [
                "domain"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_domain_list",
            "description": "List all custom domains and their SSL/verification status.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_domain_verify",
            "description": "Verify DNS configuration for a custom domain and provision SSL certificate.",
            "inputSchema": {
              "properties": {
                "domain": {
                  "description": "Domain to verify",
                  "type": "string"
                }
              },
              "required": [
                "domain"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_build_create",
            "description": "Create a new container image build from a Git repository or Dockerfile.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_build_status",
            "description": "Get the status and logs of a build.",
            "inputSchema": {
              "properties": {
                "build_id": {
                  "description": "Build ID to check",
                  "type": "string"
                }
              },
              "required": [
                "build_id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_project_create",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_project_list",
            "description": "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.",
            "inputSchema": {
              "properties": {
                "org_id": {
                  "description": "Organization ID whose projects to list",
                  "type": "string"
                }
              },
              "required": [
                "org_id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_auth_configure",
            "description": "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.",
            "inputSchema": {
              "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"
                }
              },
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_status",
            "description": "Get the current health status of the Scalix Cloud platform including all service components.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_run_deploy",
            "description": "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.",
            "inputSchema": {
              "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 \u0026 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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_run_list",
            "description": "List all deployed container services in the project.",
            "inputSchema": {
              "properties": {},
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "scalix_run_scale",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_run_rollback",
            "description": "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.",
            "inputSchema": {
              "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"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": false,
              "idempotentHint": false,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          },
          {
            "name": "scalix_run_delete",
            "description": "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.",
            "inputSchema": {
              "properties": {
                "id": {
                  "description": "Service ID (from scalix_run_list)",
                  "type": "string"
                }
              },
              "required": [
                "id"
              ],
              "type": "object"
            },
            "annotations": {
              "destructiveHint": true,
              "idempotentHint": true,
              "openWorldHint": true,
              "readOnlyHint": false
            }
          }
        ]
      },
      "name": "Scalix Cloud",
      "note": "Indexed from the official MCP registry: facts and our own checks, not reviewed, so no score, grade or rank.",
      "packages": null,
      "pageJsonUrl": "https://www.anchorterminal.com/tools/scalix-cloud.json",
      "popularity": {
        "githubStars": 2
      },
      "registryName": "world.scalix/cloud",
      "remotes": [
        {
          "type": "streamable-http",
          "url": "https://api.scalix.world/v1/mcp"
        }
      ],
      "repository": "https://github.com/scalixworld/scalix-cloud-mcp",
      "reviewed": false,
      "slug": "scalix-cloud",
      "source": "the official MCP registry",
      "sourceUrl": "https://registry.modelcontextprotocol.io/v0.1/servers?search=world.scalix/cloud",
      "summary": "The agent-native cloud: database, functions, AI, storage, computers. 50 tools, one API key.",
      "updatedAt": "2026-08-12T05:05:03Z",
      "url": "https://www.anchorterminal.com/tools/scalix-cloud",
      "vendor": "scalix.world",
      "vendorUrl": "https://scalix.world",
      "version": "1.4.1",
      "websiteUrl": "https://scalix.world",
      "where": "hosted",
      "why": [
        "vendor"
      ]
    }
  },
  "kind": "anchor.page",
  "links": {
    "api": "https://www.anchorterminal.com/api/v1/index.json",
    "html": "https://www.anchorterminal.com/tools/scalix-cloud",
    "json": "https://www.anchorterminal.com/tools/scalix-cloud.json",
    "llms": "https://www.anchorterminal.com/llms.txt",
    "markdown": "https://www.anchorterminal.com/tools/scalix-cloud.md",
    "slim": "https://www.anchorterminal.com/tools/scalix-cloud.min.md"
  },
  "markdown": "# Scalix Cloud\n\n\u003e Indexed, not reviewed: facts from the official MCP registry and our own checks. No score, grade or rank, and not in the rankings until the panel reviews it. How the index works: https://www.anchorterminal.com/indexed/\n\n- Kind: MCP server, by scalix.world (https://scalix.world)\n- Category: Databases \u0026 files (https://www.anchorterminal.com/categories/data.md)\n- Listed because: It's published in the registry under scalix.world, a namespace the registry only gives to whoever proves they control that domain.\n- What the official MCP registry says: The agent-native cloud: database, functions, AI, storage, computers. 50 tools, one API key.\n\n## Facts\n\n- MCP registry: `world.scalix/cloud` 1.4.1\n- Endpoint: https://api.scalix.world/v1/mcp (streamable HTTP)\n- Source: https://github.com/scalixworld/scalix-cloud-mcp\n- Website: https://scalix.world\n- GitHub stars: 2\n- Registry entry updated: 2026-08-12\n\n## Tools\n\n- Tools it lists (51, about 7,119 tokens of context, `tools/list` without credentials over MCP 2025-06-18, checked 2026-10-04 22:26 UTC):\n  - `scalix_db_relationships` (read-only): Get the relationship map showing how tables are connected via foreign keys.\n  - `scalix_db_search_columns` (read-only): Search for columns by name or type across all tables.\n  - `scalix_db_pii` (read-only): List all columns classified as containing personally identifiable information (PII).\n  - `scalix_db_optimize` (read-only): Analyze a SQL query and return optimization suggestions including index recommendations and query rewrites.\n  - `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,…\n  - `scalix_db_query` (writes): Execute a SQL query against the project database. Returns columns, rows, row count, and cost breakdown. Destructive statements (DROP/TRUNCATE/bulk DELETE)…\n  - `scalix_db_schema` (read-only): Get the full database schema including all tables, columns, types, and relationships.\n  - `scalix_db_table` (read-only): Get detailed information about a specific database table including columns, indexes, and foreign keys.\n  - `scalix_db_migrate` (writes): Apply a database migration by version number.\n  - `scalix_storage_list` (read-only): List storage buckets, or list objects in a specific bucket with optional prefix filter.\n  - `scalix_storage_upload` (writes): Upload content to object storage. Provide the content as a base64-encoded string.\n  - `scalix_storage_download` (read-only): Download an object from storage. Returns the content as base64.\n  - `scalix_storage_create_bucket` (writes): 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…\n  - `scalix_fn_list` (read-only): List all deployed serverless functions.\n  - `scalix_fn_deploy` (writes): Deploy a Scalix Function — serverless, per-request billed, running in isolated microVMs — from a container image. Invoke it with scalix_fn_invoke once deployed.\n  - `scalix_fn_invoke` (writes): Invoke a deployed function with a JSON payload.\n  - `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…\n  - `scalix_kv_set` (writes): Set a key-value pair with optional TTL.\n  - `scalix_kv_list` (read-only): List keys in the key-value store, optionally filtered by prefix.\n  - `scalix_ai_infer` (writes): 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…\n  - `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.\n  - `scalix_events_publish` (writes): 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.\n  - `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;…\n  - `scalix_cron_create` (writes): Create a cron schedule to run a function or webhook on a timer.\n  - `scalix_sandbox_run` (writes): Execute code in an isolated sandbox. Supports Python, JavaScript, TypeScript, and Bash. Returns stdout/stderr.\n  - `scalix_computer_create` (writes): 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,…\n  - `scalix_computer_set_ssh_keys` (writes): 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…\n  - `scalix_computer_list` (read-only): List your persistent Linux machines with their status, address and resource shape.\n  - `scalix_computer_exec` (writes): 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.\n  - `scalix_computer_write_file` (writes): Write a text file into a persistent Linux machine. Use this instead of shelling out with cat/echo — no quoting to get wrong.\n  - `scalix_computer_read_file` (read-only): Read a text file out of a persistent Linux machine.\n  - `scalix_computer_stop` (writes): 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…\n  - `scalix_computer_start` (writes): Start a stopped persistent Linux machine. Same disk, same address.\n  - `scalix_computer_delete` (writes): Permanently delete a persistent Linux machine AND its disk. This cannot be undone — use scalix_computer_stop if you may want the files back.\n  - `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.\n  - `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…\n  - `scalix_crew_board_post` (writes): 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…\n  - `scalix_domain_add` (writes): Add a custom domain to the project. Returns DNS records to configure.\n  - `scalix_domain_list` (read-only): List all custom domains and their SSL/verification status.\n  - `scalix_domain_verify` (writes): Verify DNS configuration for a custom domain and provision SSL certificate.\n  - `scalix_build_create` (writes): Create a new container image build from a Git repository or Dockerfile.\n  - `scalix_build_status` (read-only): Get the status and logs of a build.\n  - `scalix_project_create` (writes): 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:…\n  - `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…\n  - `scalix_auth_configure` (writes): Configure end-user authentication for the project — require MFA, require email confirmation, and set the allowed auth providers. Needs an admin API key:…\n  - `scalix_status` (read-only): Get the current health status of the Scalix Cloud platform including all service components.\n  - `scalix_run_deploy` (writes): 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…\n  - `scalix_run_list` (read-only): List all deployed container services in the project.\n  - `scalix_run_scale` (writes): Change the autoscaling bounds of an existing Scalix Run service without redeploying it. Raising min_instances keeps instances warm (no cold starts, higher…\n  - `scalix_run_rollback` (writes): 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…\n  - `scalix_run_delete` (writes): 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…\n- How its tools read to an agent (0 errors, 9 warnings, 1 note, about 7,119 tokens; rules at https://www.anchorterminal.com/check.md; not part of the score):\n  - warn TC12 scalix_db_query: no type for params[]\n  - warn TC13 scalix_computer_exec: env (object with no properties)\n  - warn TC13 scalix_cron_create: config (object with no properties)\n  - warn TC13 scalix_events_publish: data (object with no properties)\n  - warn TC13 scalix_fn_invoke: data (object with no properties)\n  - warn TC13 scalix_run_deploy: env (object with no properties)\n  - warn TC13 scalix_sandbox_run: files (object with no properties)\n  - warn TC14 scalix_fn_deploy: allowed values are in the description, not an enum: runtime\n  - warn TC23 server: 51 tools\n  - note TC24 server: 51 of 51 tools have no outputSchema\n\n- JSON: https://www.anchorterminal.com/api/v1/tools/scalix-cloud.json\n- Being indexed says nothing about quality, and nobody can pay for it. Ask for a review: https://www.anchorterminal.com/builders/#claiming\n",
  "meta": {
    "attribution": "Anchor Terminal (https://www.anchorterminal.com)",
    "docs": "https://www.anchorterminal.com/docs/",
    "generatedAt": "2026-10-05",
    "license": "CC-BY-4.0",
    "method": "https://www.anchorterminal.com/benchmark/",
    "methodology": "0.3",
    "openapi": "https://www.anchorterminal.com/openapi.json",
    "preview": false,
    "run": "2026-10-01",
    "runLabel": "October 2026 research run"
  },
  "page": {
    "breadcrumbs": [
      {
        "name": "Home",
        "url": "https://www.anchorterminal.com/"
      },
      {
        "name": "Terminal",
        "url": "https://www.anchorterminal.com/tools/"
      },
      {
        "name": "Indexed",
        "url": "https://www.anchorterminal.com/indexed/"
      },
      {
        "name": "Scalix Cloud",
        "url": ""
      }
    ],
    "description": "Scalix Cloud, an MCP server by scalix.world, listed from the official MCP registry. Indexed, not reviewed: facts and our own checks, no score or ranking. The agent-native cloud: database, functions, AI, storage, computers. 50 tools, one API key.",
    "facts": [
      "not reviewed",
      "not ranked",
      "facts only"
    ],
    "h1": "Scalix Cloud",
    "image": "https://www.anchorterminal.com/assets/og/indexed.png",
    "path": "/tools/scalix-cloud",
    "published": "",
    "section": "indexed",
    "title": "Scalix Cloud: MCP server, indexed from the official MCP registry",
    "toc": null,
    "updated": "2026-10-05",
    "url": "https://www.anchorterminal.com/tools/scalix-cloud"
  },
  "tokens": {
    "markdown": 2600,
    "slim": 2530
  },
  "version": 1
}