# How to Set Up Claude Code CLI with Ace Data Cloud (Beginner's Guide)

If you like working from the terminal, Claude Code becomes much more useful when it is configured once and then available inside every project; this guide walks through a simple setup using Ace Data Cloud as the API base URL.

![Claude Code CLI with Ace Data Cloud](https://platform2.cdn.acedata.cloud/gpt-image/e89657b9-de71-485c-a74f-e344206b37a3_0.png)

## What we are setting up

Claude Code is an agentic coding tool that you can run with the `claude` command from a normal terminal. The useful part is not just “chatting with a model.” It is that the tool can sit inside a real project directory, read context, help explain code, review diffs, write tests, and turn a short instruction into a concrete development task.

In this setup, Ace Data Cloud is used as the API base URL for Claude Code. The two key environment variables from the integration guide are:

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

`ANTHROPIC_AUTH_TOKEN` is the token you copy from the Ace Data Cloud console. `ANTHROPIC_BASE_URL` points Claude Code to `https://api.acedata.cloud`. The guide also notes that the token value is sent with a `Bearer` prefix automatically, so you do not need to add that prefix yourself in the variable.

This is the kind of setup I like as a builder: small surface area, easy to reason about, and no special editor workflow required. If your terminal works, your coding assistant works.

## Install Claude Code

The source guide lists three installation paths. The native installer is the recommended route and works across macOS, Linux, and WSL:

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

On Windows PowerShell, the equivalent command is:

```powershell
irm https://claude.ai/install.ps1 | iex
```

And on Windows CMD:

```cmd
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
```

There are also package-manager options if you prefer them:

```bash
brew install claude-code
```

or, on Windows:

```cmd
winget install Claude.ClaudeCode
```

After installation, open a new terminal. If `claude` is not found, the usual first checks are to restart the terminal, inspect your `PATH`, or rerun the installer.

## Configure the API variables

The most straightforward configuration is to add the Ace Data Cloud variables to your shell profile. For zsh users, that usually means `~/.zshrc`; for bash users, it may be `~/.bashrc` or `~/.bash_profile`.

```bash
# Ace Data Cloud - Claude Code Proxy Configuration
export ANTHROPIC_AUTH_TOKEN="{token}"
export ANTHROPIC_BASE_URL="https://api.acedata.cloud"
```

Then reload your shell configuration:

```bash
source ~/.zshrc  # or source ~/.bashrc
```

If you prefer to keep these variables scoped only to Claude Code, the guide also supports putting them into `~/.claude/settings.json`:

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

I usually choose the `settings.json` approach when I do not want global environment variables leaking into unrelated scripts. For a dedicated dev machine, the shell profile method is simpler.

## Start inside a real project

Once the variables are set, move into a project directory and start Claude Code:

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

That opens interactive mode. From there, you can ask project-level questions or assign practical tasks, for example:

```text
what does this project do?
```

```text
there's a bug where users can submit empty forms - fix it
```

```text
write unit tests for the calculator functions
```

Claude Code also supports one-off commands directly from the shell:

```bash
claude "fix build error"
claude -p "explain this function"
claude -c
claude -r
claude commit
```

Those commands are useful when you want a quick answer or action without staying in an interactive session. `claude -c` continues the most recent conversation in the current directory, while `claude -r` restores a previous conversation.

Inside interactive mode, a few built-in commands are worth remembering:

- `/help` shows help information.
- `/clear` clears conversation history.
- `/config` opens the settings panel.
- `/model` switches model.
- `/mcp` manages MCP services.
- `/compact` compresses context.
- `/memory` manages memory.
- `/login` switches account.

That `/mcp` command is especially useful if you are building more automated workflows around local tools, repos, or internal systems.

## Use it in scripts and reviews

The terminal version is not limited to interactive chat. It can read piped input, which makes it fit naturally into existing developer habits.

For example, you can review a branch diff:

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

Or ask it to watch log output and respond to anomalies:

```bash
tail -f app.log | claude -p "notify me if an anomaly is detected"
```

For teams, I would start with the review workflow. It is narrow enough to be safe, but still saves real time: you can ask for risky changes, missing tests, confusing naming, or migration concerns before opening a pull request.

## Add project memory with CLAUDE.md

A small `CLAUDE.md` file in the project root can make responses much more consistent. Claude Code loads this file at startup, so it is a good place for project-specific expectations:

```markdown
# Project Description
This is a full-stack project using Django + Vue.js.

## Coding Standards
- Use Python 3.12
- Follow PEP 8 coding style
- All APIs need to have unit tests
```

This does not need to be long. In practice, a short file with stack details, test commands, naming rules, and “things not to change casually” is enough to prevent many avoidable back-and-forth turns.

## Troubleshooting checklist

If Claude Code does not connect after setup, check the basics first:

1. Confirm your environment variables are set correctly.
2. Restart the terminal so the shell profile is reloaded.
3. If needed, create or verify `~/.claude/config.json` with `{"primaryApiKey": "self"}`.
4. Confirm your Ace Data Cloud token is valid in the console.

The main idea is simple: keep Claude Code close to where development already happens, and keep the configuration explicit. That gives you a practical terminal assistant for explaining code, reviewing diffs, writing tests, and handling small refactors without turning your workflow into a new platform to manage.

If you want the original reference while setting it up, the full Ace Data Cloud document is here: [Claude Code Terminal CLI Integration Guide](https://platform.acedata.cloud/documents/claude-code-terminal-integration).