Developers · CLI

Your MCP instance, from the terminal.

amcp calls the same MCP tools your AI clients use, runs code-mode programs that chain dozens of calls in one step, and drives the full management API — by hand, in scripts, or from a connected agent.

Open source (AGPL-3.0) · works on Cloud and self-hosted · Node 22+

zsh — ~/work
$ npm i -g @anythingmcp/cli$ amcp login --browser --url https://cloud.anythingmcp.comLogged in to https://cloud.anythingmcp.com$ amcp tools ls --filter ordershopify_search_orders   read-only   Search orders…shopify_get_order       read-only   Get one order…$ amcp tools call shopify_search_orders \  --args '{"query":"fulfillment_status:unfulfilled"}' \  | jq -r '.orders.nodes[].name'#1038#1035#1031

Two jobs, one tool

The same binary speaks MCP and the management API, with the credential you grant it.

Call MCP tools

List a server's tools, read their schema and run them from your shell — Shopify, HubSpot, SAP, your SQL database — then pipe the JSON wherever you need it.

Manage the instance

Connectors, MCP servers, users, roles, SSO, memory, skills, audit and settings — every /api/* route, with a management-scoped key.

Code mode

One program, many tool calls.

With code mode on, a server offers code_execute: send a short JavaScript program and the sandbox runs it against your tools. This one pages through every paid Shopify order since October, keeps the five biggest customers and looks each one up in HubSpot — in a single call from your terminal.

top-customers.jsthe program
// Runs inside the AnythingMCP sandbox: read-only, your own permissions.const byEmail = new Map();let after = null, pages = 0;// 1. Page through every paid Shopify order since Octoberdo {  const r = await amcp.run("shopify_search_orders", {    query: "financial_status:paid created_at:>=2026-10-01",    first: 250, after,  });  for (const o of r.orders.nodes) {    if (!o.email) continue;    const c = byEmail.get(o.email)      ?? { name: o.customer?.displayName, orders: 0, revenue: 0 };    c.orders += 1;    c.revenue += Number(o.currentTotalPriceSet.shopMoney.amount);    byEmail.set(o.email, c);  }  const { hasNextPage, endCursor } = r.orders.pageInfo;  after = hasNextPage ? endCursor : null;  pages++;} while (after);// 2. Keep the five biggest customersconst top = [...byEmail]  .sort((a, b) => b[1].revenue - a[1].revenue)  .slice(0, 5);// 3. Join each one with its HubSpot contactconst result = [];for (const [email, c] of top) {  const h = await amcp.run("hubspot_search_objects", {    object_type: "contacts",    filter_groups: [{ filters: [      { propertyName: "email", operator: "EQ", value: email },    ] }],    properties: ["lifecyclestage"],    limit: 1,  });  const stage = h.results[0]?.properties.lifecyclestage ?? "not in CRM";  result.push({ email, ...c, revenue: c.revenue.toFixed(2), stage });}return { pagesScanned: pages, top: result };
zshrun it from the CLI
# once per server (admin): allow inline code$ amcp api PUT /api/mcp-servers/$SRV --yes \  --data '{"codeMode":"inline"}'# wrap the file as {"code": …} and run it$ jq -Rs '{code: .}' top-customers.js \  | amcp tools call code_execute --args -{  "pagesScanned": 3,  "top": [    {      "email": "[email protected]",      "name": "Kellerhaus GmbH",      "orders": 14,      "revenue": "4820.50",      "stage": "customer"    },    {      "email": "[email protected]",      "name": "Studio Lumen",      "orders": 9,      "revenue": "3110.00",      "stage": "opportunity"    },    {      "email": "[email protected]",      "name": "Martin Weber",      "orders": 6,      "revenue": "2475.90",      "stage": "not in CRM"    },    …  ]}

8

tool calls inside the sandbox

1

call from your terminal

5

customers back, not 750 orders

  • Read-only: the program can only call tools that don't change data, with your own permissions.
  • Isolated: no filesystem, network or environment access; up to 500 tool calls per run.
  • Audited: every inner call is logged like a direct one, with the run that made it.
  • Switched on per server (codeMode "inline") for roles with inline code, on Team and above.
How code mode works

Worth keeping? Propose it as a tool

code_propose_tool records the same program as a proposal. Once an admin approves it, every AI client on the server gets top_customers_with_crm_stage as a normal tool.

$ jq -Rs '{    name: "top_customers_with_crm_stage",    description: "Top 5 Shopify customers, with HubSpot stage",    rationale: "Sales asks for this every Monday",    code: .  }' top-customers.js | amcp tools call code_propose_tool --args -{"ok":true,"proposalId":"cmh4k2…","message":"Proposal recorded for admin review. It will not run or become a tool until an admin approves it."}

Recipes you can paste

Real commands, real flags, real endpoints. Swap in your own tools and IDs.

01

Call a tool with real arguments

Read the input schema with describe, then call. Text output is the tool's JSON; --json wraps it with the tool name for scripts.

# read the schema, then call with real arguments$ amcp tools describe shopify_search_orders$ amcp tools call shopify_search_orders \  --args '{"query":"financial_status:paid created_at:>=2026-11-01","first":2}'{  "orders": {    "pageInfo": { "hasNextPage": true, "endCursor": "eyJsYXN0X2lkIjo2…" },    "nodes": [      { "name": "#1043", "displayFulfillmentStatus": "UNFULFILLED",        "currentTotalPriceSet": {          "shopMoney": { "amount": "412.80", "currencyCode": "EUR" } },        "customer": { "displayName": "Kellerhaus GmbH" } },      …

02

Pipe it into your scripts

Tool output is plain JSON on stdout, so jq, cron and CI just work. Errors go to stderr with a distinct exit code.

# unfulfilled orders older than two days, as TSV$ amcp tools call shopify_search_orders \  --args '{"query":"fulfillment_status:unfulfilled created_at:<2026-11-03"}' \  | jq -r '.orders.nodes[] | [.name, .customer.displayName, .createdAt[:10]] | @tsv'#1038   Kellerhaus GmbH     2026-10-30#1035   Studio Lumen        2026-10-29#1031   Bäckerei Hofmann    2026-10-28# exit codes: 0 ok · 1 tool error · 2 usage · 3 auth · 4 connection

03

Stand up a workspace in one script

Install a catalogue connector with its token, create an MCP server for a team, attach the connector, turn on code mode and test the connection.

# bootstrap.sh — a HubSpot connector, a server for sales, code mode on$ CONN=$(jq -n --arg t "$HUBSPOT_TOKEN" '{credentials:{HUBSPOT_ACCESS_TOKEN:$t}}' \  | amcp api POST /api/adapters/hubspot/import --data - --yes | jq -r .connectorId)$ SRV=$(amcp api POST /api/mcp-servers --yes \  --data '{"name":"Sales","description":"CRM tools for the sales team"}' | jq -r .id)$ amcp api PUT /api/mcp-servers/$SRV/connectors --yes \  --data "{\"connectorIds\":[\"$CONN\"]}"$ amcp api PUT /api/mcp-servers/$SRV --yes --data '{"codeMode":"inline"}'$ amcp api POST /api/connectors/$CONN/test --yes{ "ok": true, "kind": "ok", "message": "Connection successful" }

04

See what your agents did

Every tool call is audited. Pull the failures, slow calls or one user's activity straight from the log.

# which calls failed today, and who made them?$ amcp api GET "/api/audit/invocations?status=ERROR&limit=3" \  | jq -r '.[] | [.createdAt[11:16], .tool.name, .user.email, .error[:40]] | @tsv'08:41   hubspot_search_objects   [email protected]         HTTP 429: retry after 1s07:02   shopify_get_order        [email protected]   Order not found06:55   zendesk_get_ticket       [email protected]       HTTP 404: RecordNotFound

05

Discover the whole API offline

The catalogue of management operations ships with the CLI and is regenerated from the backend in CI, so it always matches your instance.

# the whole management API ships with the CLI: no key, no network$ amcp api --list mcp-serversmcp-servers  GET    /api/mcp-servers  — List MCP servers for current organization  POST   /api/mcp-servers [body]  — Create a new MCP server  DELETE /api/mcp-servers/:id  — Delete MCP server  GET    /api/mcp-servers/:id  — Get MCP server detail  PUT    /api/mcp-servers/:id [body]  — Update MCP server  …$ amcp api --list | grep -c /api/   # 200+ operations

Built for agents, too

Give a coding agent amcp and a management key and it can onboard a workspace end to end — add a connector, create a server, assign roles, wire SSO — within the scope you grant it. Read-only keys can only read, every call is rate-limited and audited, and a write in a script needs an explicit --yes.

Secure by default

01

The API key is never accepted as a command argument and never printed in status output.

02

Keys are stored with file mode 0600; HTTPS is required except on loopback for local dev.

03

Redirects are refused, so a key can't follow a request to another origin.

04

A per-key rate limit refuses a runaway client instead of hammering your instance.

Get it

Install globally, then log in to your Cloud or self-hosted instance.

$npm i -g @anythingmcp/cli
$brew install helpcode-ai/tap/amcp# macOS, Linux

Install the CLI

Two minutes to your first call. No AnythingMCP yet? Start free on Cloud, or self-host it.