Deploy and manage web applications, APIs, and static sites directly from an MCP server. Ample Computer supports managed PostgreSQL, MySQL, Redis, and MongoDB databases, object storage, isolated builds, live HTTPS URLs, server provisioning, command execution, and build/runtime log monitoring.
Try asking
Encrypted at rest, isolated from the model
Resolved from an AES-256-GCM vault at the moment of the call and attached to the request — the model never sees the secrets.
Delete an app and its releases; preserve shared servers and declared resources Apps are addressed by deployment ID, not name: a name can be shared, an ID cannot. Find it with `ample app list`.
Read an app's deployment status
List deployed apps, including static sites without a server
Rename an app: --title is what the person sees, --link gives it <link>.ample.run (its last few links keep working)
Create an object-storage bucket (returns S3 credentials)
Show the bucket's S3 credentials and endpoint
Delete a bucket and all objects in it
Get bucket details (including live usage and over_quota)
List buckets
Serve the bucket's objects publicly (the response has public_url)
Write one object: text, base64 data or a public https URL Ample downloads. For a file you or the person has, call ample_upload_create with bucket and path
Create a managed database. Bind it to an app with `ample deploy --database DATABASE_URL=<name>`, which injects its connection string. An app that needs a database and binds none gets one of its own automatically, so create one only to share it between apps or set it up first
Delete a managed database and its data. Refused while a deployment binds it
Get database details
List managed databases
Deploy a local app/workspace and wait until it is live This command blocks until the release is live or fails, then exits: 0 = live, 1 = failed, 2 = needs input (a preflight question to answer). Ample remembers your last deploy (content-addressed), so re-running with no source or config changes is a no-op that reports the app as already live instead of rebuilding. Only re-run `ample deploy` after a real change or to retry a failure — do not poll it for status. With `--format json` the result always carries top-level `status` ("live"), `unchanged` (bool), `deployment_id`, and `server_id` fields.
Disable new sends and immediately revoke the app's email credential
Enable email and return its status. No email is sent. If can_send is false, tell the person next_action before building. Deploy --force afterward to inject credentials
Inspect one email's status and delivery events; bodies are available only for tests
Capture rendered HTML/text and get a private 15-minute desktop/mobile preview link. Sends nothing. Links may contain login codes: do not share publicly
Send a real email only when the person requests it; use preview or --test otherwise. Templates are rendered in the app. Accepted is not proof of inbox placement
Whether the app can send now (can_send, blocked_by, next_action), credential binding and the monthly allowance
Wait up to 45 seconds for the result of a call that answered status running; answers running again while it works. Never replays it.
Run a command or an HTTP request on one of your services on a schedule The job runs inside the service's server with its environment, directory and database, whether or not the app has traffic. Give one schedule (--schedule cron with --timezone, or --every) and one target (--command, or --request for a web service; the request carries an Ample-Job-Token header equal to the app's AMPLE_JOB_TOKEN). Re-running with the same arguments changes nothing; different arguments update the job. Test it right away with `ample job run <name> --wait`.
Show a job: schedule, next run, limits and its last few runs
List scheduled jobs and when each runs next
Run a job now With --wait it is synchronous: it returns when the run finishes, exits 0 if it succeeded and 1 if it failed (the result has the output and, on failure, who should act and how).
Show a job's recent runs, newest first
Tail build/runtime logs for a deployment
Read an existing operation without starting another deployment
Analyze the repo and plan its infrastructure before deploying Detects every deployable service (monorepos included), proposes the topology (servers, databases, volumes, links), and lists open questions with options and safe defaults. Exits 0 when the plan is ready, 2 when blocking questions remain — resolve them with `--answer <path>=<value>` (or edit ample.toml) and re-run. `--write` pins the plan to a checked-in ample.toml that deploys then consume; detection still fills anything the manifest leaves unpinned.
Create a new server
Destroy a server
Execute a command on a server
Keep a running server from being treated as idle for a while, e.g. during a series of commands Without --for or --release it shows what holds the server. Code inside the server can hold it too: `ample-awake -- <command>`. Holds are capped by the plan; held time is billed like any running time.
Stop a service and remove it (its directory on the server is kept)
Restart a service, for example after updating its files
Run a command from a directory on an existing server as a supervised service Re-running with the same arguments is a no-op; after changing files in the directory, use `ample service restart`.
Show whether a service is running and how often it restarted
Link taking one file (or, with --archive, a project folder's tar.gz) into a workspace or bucket. Give the person page_url to drop it there, or PUT to upload_url (curl -T). Valid an hour
An upload's arrival and deploy
Create an account-owned source workspace (expires after seven inactive days). With --from-app it holds that live app's current source, and deploying it updates that app
Import a public HTTPS Git repository into an empty workspace
Replace workspace source with a bounded tar.gz archive (preserve ample.toml and .ample when editing)
Write a workspace file from text, base64 data, or a public https URL Ample downloads (an image, a file the person shared); --deploy then deploys the workspace
Put one file into a live app (app: its name, URL or deployment id; it redeploys with the file), a workspace (workspace_id), or a bucket (bucket). file is the file the person attached, or {"download_url": "<public https URL>", "file_id": "url"} for a file on the web. path is where it goes, for example public/hero.png (defaults to the file's name). When the person has a file you cannot pass, use ample_upload_create instead.
Show the person their Ample apps, one app (deployment_id), an ample_deploy's progress (execution_id) or, after a plan limit, the upgrade. Read-only: never deploys.
Panel only: reread the apps, the selected app and a followed deploy.
Panel only: the signed-in account.
Panel only: a link that adds an email to a temporary account.
Panel only: recent build or runtime logs of an app.
Panel only: requests to an app over the last 24 hours.
Pick your app for a step-by-step guide. Most sign in with OAuth, so there is no API key to copy.
Discovery, routing, credentials, tool scoping and execution logs all happen at the gateway→connections stay ACTIVE with no work from you
Ample Computer MCP runs through a gateway that holds the credentials, scopes the access and records every call.
Ask what happened in Slack yesterday and get a consolidated, channel by channel recap with links back to the threads.
Ask whether your database is healthy and your agent checks connectivity, inspects the schema, and flags drift in a handful of calls.
Managed auth, hosted MCP servers, and every Ample Computer MCP tool your agent needs.
Free to start.
Add as preferred source on Google