# How to Connect AceData Cloud MCP to Your AI Assistant

> Source: <https://dev.to/germey/how-to-connect-acedata-cloud-mcp-to-your-ai-assistant-2d4p>
> Published: 2026-08-05 01:08:29+00:00

The hard part of adopting an AI coding agent is rarely the first prompt; it is building a terminal setup you can reuse inside a real repository without mixing credentials, project rules, and task context.

This guide sets up Claude Code CLI with Ace Data Cloud, then uses it for focused terminal work: explaining code, reviewing a diff, and following repository instructions stored in `CLAUDE.md`

.

Claude Code can run interactively in a project directory, execute one task and exit, consume piped input, or continue an earlier conversation. The Ace Data Cloud configuration needs two values:

`ANTHROPIC_AUTH_TOKEN`

: your API token. Claude Code adds the `Bearer`

prefix when sending it.`ANTHROPIC_BASE_URL`

: `https://api.acedata.cloud`

.You can define them in your shell profile or isolate them in Claude Code's settings. I prefer the second option on shared development machines because the variables remain scoped to one tool.

On macOS, Linux, or WSL, use the native installer:

```
curl -fsSL https://claude.ai/install.sh | bash
```

Homebrew is also supported:

```
brew install claude-code
```

On Windows, use WinGet:

```
winget install Claude.ClaudeCode
```

Open a fresh terminal and verify the command:

```
claude --help
```

If you see `command not found`

, reopen the terminal and check `$PATH`

before reinstalling.

Copy your API token from the Ace Data Cloud console. Do not put it in source control, `CLAUDE.md`

, or a command that will remain in shell history.

For a persistent shell-level configuration, add this to `~/.zshrc`

, `~/.bashrc`

, or `~/.bash_profile`

:

```
export ANTHROPIC_AUTH_TOKEN="{token}"
export ANTHROPIC_BASE_URL="https://api.acedata.cloud"
```

Reload the relevant profile:

```
source ~/.zshrc  # use ~/.bashrc for Bash
```

To scope the variables to Claude Code, create or edit `~/.claude/settings.json`

instead:

```
{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "{token}",
    "ANTHROPIC_BASE_URL": "https://api.acedata.cloud"
  }
}
```

In both examples, replace `{token}`

locally. The useful boundary is simple: user-level settings hold credentials; repository files describe the project.

Now enter a repository and start an interactive session:

```
cd /path/to/your/project
claude
```

Begin with a modest request such as: `explain the request flow from the HTTP handler to the database`

. This checks the agent's understanding before you ask it to modify files.

Interactive mode is useful for exploration, but one-shot commands are easier to audit. Run a query and exit with `-p`

:

```
claude -p "explain this function"
```

Claude Code also accepts piped input. To review only the current diff:

```
git diff main | claude -p "review these changes"
```

Ask for concrete findings—correctness risks, missing tests, or unclear error handling—rather than a vague quality score. Then inspect the response yourself. The pipe narrows the supplied context, but it does not turn the model's judgment into a merge decision.

For ongoing work, `claude -c`

continues the latest conversation in the current directory, while `claude -r`

restores a previous one. In interactive mode, `/compact`

compresses context and `/clear`

starts over. These controls help when an old assumption begins influencing a new task.

Create `CLAUDE.md`

in the repository root to store instructions Claude Code should load at startup:

```
# Project
Django API with a Vue.js frontend.

## Working rules
- Use Python 3.12.
- Follow PEP 8.
- Add unit tests for API behavior changes.
- Do not edit generated migration files by hand.
```

Keep this file short and operational. It is not a place for secrets or a full architecture handbook. Commit it only when the instructions should apply to everyone working in the repository.

My preferred loop is: enter the repository, ask Claude Code to explain the relevant path, use one bounded prompt to make or review a change, run the project's tests, and inspect `git diff`

before committing. The agent accelerates the middle of the loop; it does not replace the boundaries around it.

The [Claude Code Terminal CLI integration guide](https://platform.acedata.cloud/documents/claude-code-terminal-integration) contains the complete command and environment-variable reference. The setup is intentionally small: two environment variables, one project-memory file, and terminal commands you can inspect as you go.