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.
Hermes is Nous Research's command-line agent. MCP servers are declared in its YAML config and reloaded without a restart.
This guide connects Ample Computer MCP to Hermes through MewCP, so Hermes can use Ample Computer MCP's 52 tools, like ample_app_delete, ample_app_get and ample_app_list, without your Ample Computer MCP credentials ever reaching the app.
Ample Computer MCP signs in through managed OAuth. MewCP stores the token encrypted, refreshes it before it expires and injects it only at call time. Your agent never holds it, so it can never leak it.
More apps
Manage repositories, pull requests, issues, branches and development workflows on GitHub. Automate software delivery and collaborate across engineering projects.
Connect to external APIs, webhooks and internet services through standard HTTP requests. Build integrations with virtually any platform that exposes a web-based interface.
Give AI coding agents access to a curated library of real-world website designs, screenshots, design systems, and reusable UI components. Search visual references, find similar designs, analyze layouts, extract colors and typography, compare websites, and retrieve copy-ready JSX components for building better interfaces
An AI assistant can generate QR codes, update existing ones, retrieve analytics, or manage campaigns without switching apps. A QR-focused MCP server makes these actions available through one interface.
Other clients
Ample Computer MCP works the same way in every client below. Pick yours for its own guide.
Free to start.
Scope access to the exact Ample Computer MCP tools and accounts you allow, work and personal side by side. Anything outside that scope is refused at call time, even when the model asks for it.
Each call is logged: what ran, on which account, and whether it worked. Failures come back structured, so the agent knows whether to retry instead of guessing.
Every app sits behind one secure MCP URL, and there is no server for you to deploy or keep running. Add an integration in the dashboard and it is live on the next call, with no config to change and no new credentials to wire up. Tools load only when a task needs them, so your agent stays fast and focused however many apps you connect.
Edit config.yaml in your Hermes config directory (~/.hermes).
Put this under the top-level "mcp_servers:" key.
Run /reload-mcp in Hermes, or start a fresh session. Sign in when the browser window opens.
Start a new chat and ask: "List the tools you can use from MewCP." You should see your connected apps.
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.