# anythink-cloud/anythink-cli [Health: Active]

**Category:** ☁️ Cloud Platforms  
**Repository:** https://github.com/anythink-cloud/anythink-cli  
**GitHub Stars:** 6  
**npm Downloads (last month):** 249  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/anythink-cloud-anythink-cli

## Description
Build and run a complete backend from your agent on the Anythink platform: relational data with row-/field-level security, full-text + semantic + geo search, RBAC + BYOK, a workflow/automation engine, a growth & retention engine (email, actionable push, promotions, per-user referral codes + rewards, points/credits), payments + marketplace billing, and a growing catalog of integrations (Claude, OpenAI, Slack, Google, GitHub…) — driven through one CLI-backed MCP tool. Install with npx -y @anythink-cloud/mcp.

## Tools
Capabilities this server exposes over MCP:

- **config_use** — Switch the active project profile that the 'cli' tool's commands operate against. Use this to move between already-connected projects without re-authenticating. The profile must already exist (created by 'projects_use' or 'login_direct'); run 'config_show' to see available profile names. Returns confirmation, or an error if the profile does not exist.
- **projects_delete** — Permanently delete a project and tear down its backend instance, including its database and stored data. This is destructive and irreversible — always confirm with the user first, and prefer matching by a specific id over a short prefix to avoid removing the wrong project. Requires an active billing account (set one with 'accounts_use'). Returns the deleted project's name and id on success.
- **login_direct** — Store credentials directly for a project (bypasses billing login). Use this when you already have an org ID and API key or JWT token.
- **projects_use** — Connect to a project and save it as the active profile so the 'cli' tool's data, entities, users, and other commands target it. Resolves the project, then either stores the API key you pass or exchanges a transfer token for project-scoped credentials automatically. Requires an active billing account (set one with 'accounts_use'); the project must be Active (see 'projects_list'). Returns the saved profile name, org id, API URL, and auth method.
- **logout** — Remove the saved credentials for a project profile from local CLI config. Use this to disconnect from a project or clear a stale token; it deletes only the stored profile locally and does not revoke the token server-side or affect the project. Omit the profile to remove the currently active one. Run 'config_show' to see profile names.
- **signup** — Register a brand-new Anythink platform account with email and password. Use this only when the user has no account yet; if they already have one, use 'login' instead. This creates the top-level user identity — it does not create a billing account or project (do that with 'accounts_create' and 'projects_create' after logging in). On success the user may need to click an email confirmation link before 'login' works; tell them to confirm, then call 'login'.
- **accounts_create** — Create a new billing account (organization) to hold projects and payment details. Requires a prior platform login (use the 'login' tool first). The new account is automatically set as the active account, so subsequent 'projects_create' / 'projects_list' calls target it without further setup. Returns the new account's id and name. Most users need only one account — call 'accounts_list' first to check whether a suitable one already exists.
- **config_remove** — Delete a saved project profile from the local CLI configuration. Removes only the locally stored credentials and settings — it does not delete the project or revoke tokens server-side (to remove the project itself, use 'projects_delete'). Run 'config_show' to see profile names. Returns confirmation, or a not-found message.
- **projects_list** — List the projects (provisioned backend instances) in a billing account. Requires platform login and an active billing account (set one with 'accounts_use'). Returns each project's id, name, description, region, org id, status (Initializing/Provisioning/Active/Suspended/Terminated/Error), API URL, and creation date. Use this to find a project's id before connecting with 'projects_use' or removing it with 'projects_delete'.
- **login** — Log in to the Anythink platform with email and password. Returns a session token used for account and project management. For Google sign-in, use the 'login_google' tool.
- **accounts_use** — Set the active billing account that project commands operate on. Call this after 'login' when you belong to more than one account, before using 'projects_list', 'projects_create', or 'projects_use'. Accepts a full account UUID or a unique prefix; run 'accounts_list' to see valid ids. Returns the resolved account name and id, or an error if no account matches.
- **login_google** — Sign in to the Anythink platform with Google. Opens the user's browser to Google's consent screen and waits for them to approve, then stores the session token. The browser step must be completed by the user; everything before and after is tool-driven. This does NOT pick a billing account or project — after it returns, call 'accounts_list' then 'accounts_use', and 'projects_list' then 'projects_use'. Needs a local browser, so it only works over stdio (not the hosted HTTP server).
- **cli** — Run any Anythink CLI command and return its output. Use this for commands not covered by dedicated tools (entities, fields, data, workflows, roles, menus, secrets, users, files, pay, oauth, migrate, fetch, api, docs, etc.). Pass the command exactly as you would after 'anythink', e.g. 'entities list' or 'data list posts'. Menu commands: 'menus list' shows dashboard menus with tree structure; 'menus add-item <menu_id> <entity> --icon <Icon> --parent <parent_id>' adds an entity to a dashboard menu. For destructive commands add '--yes' to skip confirmation prompts. Add '--json' where supported for machine-readable output.
- **accounts_list** — List the billing accounts (organizations) the logged-in user belongs to. Requires a prior platform login (use the 'login' tool first). Returns each account's id, organization name, billing email, currency, and status (Active/Suspended/Canceled), and flags which one is currently active. A billing account holds your projects and payment details — pick one with 'accounts_use' before creating or listing projects.
- **projects_create** — Provision a new project — a dedicated, isolated Anythink backend instance with its own database, API, auth, and storage. Requires platform login and an active billing account (set one with 'accounts_use'). Provisioning runs asynchronously: the project starts in a Provisioning state, so poll 'projects_list' until it is Active. Returns the new project's id, name, org id, and API URL. Connect to it with 'projects_use'.
- **config_show** — Show the local CLI configuration: all saved project profiles and platform logins, and which of each is active. For every profile it returns the name, org id, auth method (api-key or token), alias, and platform; for every platform it returns the URLs, billing account, and login status. Use this to discover profile names for 'config_use', 'config_remove', or 'logout', and to check which project the 'cli' tool currently targets. Reads local config only — makes no network calls.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "anythink-cli": {
    "command": "npx",
    "args": ["-y","@anythink-cloud/mcp"]
  }
}
```

## Documentation

## What anythink-cloud/anythink-cli MCP server does

The anythink-cloud/anythink-cli MCP server gives an agent access to Anythink's headless backend platform through MCP. It covers platform administration as well as application-backend operations. An agent can create or list billing accounts, provision projects, connect a project to a saved local profile, and inspect or remove stored configuration.

Once a project is active, the server can operate on backend resources such as entities, fields, records, workflows, users, files, roles, menus, secrets, API keys, migrations, plans, and payments through the general `cli` tool. The available dedicated tools also cover platform login, Google sign-in, project selection, account selection, logout, and destructive project deletion.

## How it works

The anythink-cloud/anythink-cli MCP server combines focused MCP tools with a catch-all `cli` tool. Dedicated tools handle common account, project, authentication, and profile actions. The `cli` tool accepts an Anythink CLI command such as `entities list` or `data list posts` and returns its output, with `--json` available where the underlying command supports machine-readable output.

A typical setup starts with platform authentication, followed by selecting or creating a billing account and project. `projects_use` connects a project and stores project-scoped credentials; subsequent CLI operations use the active project profile. `config_use` switches between profiles that already exist, while `config_show` reports saved profiles and active platform settings without making network calls.

## Setup and configuration

The anythink-cloud/anythink-cli MCP server can be launched with `npx -y @anythink-cloud/mcp`. The repository also documents Homebrew installation, downloadable release binaries, a .NET global tool, and building from source. Homebrew installs both the `anythink` CLI and the `anythink-mcp` server.

Local credentials and project profiles are stored in `~/.anythink/config.json`. Use `login` for email and password authentication, or `login_google` for Google sign-in. Google sign-in opens a browser and works only over stdio. If credentials are already available, `login_direct` accepts an organization ID with an API key or JWT token.

After authentication, use `accounts_list` and `accounts_use` to select a billing account. Use `projects_list` to find a project, or `accounts_create` and `projects_create` to create the required resources. Newly created projects provision asynchronously and should be checked with `projects_list` until they become Active.

## Tools and capabilities

- Authenticate with email and password, Google, or direct project credentials.
- List and select billing accounts and provision isolated projects.
- Connect, switch, inspect, or remove local project profiles.
- Run Anythink CLI commands for entities, fields, data, search, workflows, users, files, roles, menus, integrations, payments, OAuth, migrations, and related operations.
- Create, inspect, update, and delete backend entities and their data through CLI commands.
- Permanently delete projects, including their database and stored data, when an active billing account is available.

## Limitations and notes

The `cli` tool can execute destructive commands, so commands that delete entities, data, or projects require care. Project deletion is irreversible, and the dedicated deletion tool recommends confirming the target with the user and preferring a full project ID over a short prefix.

Project and account management depends on the relevant authentication and billing state. A project must be Active before it can be connected with `projects_use`, and project creation requires an active billing account. `config_remove` and `logout` only remove local credentials or profiles; they do not delete projects or revoke server-side tokens.

Google authentication requires a local browser and is not available through the hosted HTTP server. The provided material does not specify compatibility with individual MCP desktop clients, pricing, or service plan requirements.

_Full upstream README: https://allmcps.com/mcp/anythink-cloud-anythink-cli/readme_