Scalix Cloud

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

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

Search for columns by name or type across all tables.

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

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

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

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

{
  "type": "object",
  "properties": {
    "sql": {
      "description": "SQL query to analyze and optimize",
      "type": "string"
    }
  },
  "required": [
    "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.

{
  "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"
  ]
}

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.

{
  "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"
  ]
}

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

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

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

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

Apply a database migration by version number.

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

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

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

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

{
  "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"
  ]
}

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

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

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.

{
  "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"
  ]
}

List all deployed serverless functions.

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

Deploy a Scalix Function — serverless, per-request billed, running in isolated microVMs — from a container image. Invoke it with scalix_fn_invoke once deployed.

{
  "type": "object",
  "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"
  ]
}

Invoke a deployed function with a JSON payload.

{
  "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"
  ]
}

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.

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

Set a key-value pair with optional TTL.

{
  "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"
  ]
}

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

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

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.

{
  "type": "object",
  "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/<vendor>/<model> 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"
  ]
}

List the AI models available to the project — virtual tiers and the pass-through catalog model IDs — for use in scalix_ai_infer.

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

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.

{
  "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"
  ]
}

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.

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

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

{
  "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"
  ]
}

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

{
  "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"
  ]
}

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.

{
  "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"
  ]
}

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.

{
  "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"
  ]
}

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

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

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.

{
  "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"
  ]
}

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

{
  "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"
  ]
}

Read a text file out of a persistent Linux machine.

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

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.

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

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

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

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

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

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.

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

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.

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

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.

{
  "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"
  ]
}

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

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

List all custom domains and their SSL/verification status.

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

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

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

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

{
  "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"
  ]
}

Get the status and logs of a build.

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

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.

{
  "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"
  ]
}

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.

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

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.

{
  "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"
    }
  }
}

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

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

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.

{
  "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"
  ]
}

List all deployed container services in the project.

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

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.

{
  "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"
  ]
}

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.

{
  "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"
  ]
}

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.

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