> ## Documentation Index
> Fetch the complete documentation index at: https://mezmo-9a59581a-promptless-aura-wait-for-tool.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# AURA Quickstart

> Install the aura binary locally, generate a config, connect an MCP server, and put your agent to work.

**Prerequisites:** macOS or Linux, and an LLM API key (OpenAI, Anthropic, Gemini, Bedrock, or OpenRouter), or a local [Ollama](https://ollama.com) instance.

## 1. Install AURA

```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/mezmo/aura/main/scripts/install.sh | bash
```

This gets you the `aura` CLI, which is all this quickstart needs. How it installs depends on your platform:

* **macOS with Homebrew.** The script installs the [`mezmo/tap` formula](https://github.com/mezmo/homebrew-tap), which puts `aura` in your Homebrew prefix, already on your `PATH`. The formula ships the `aura` binary alone.
* **Everything else.** The script downloads release binaries to `~/.local/bin/aura` and `~/.local/bin/aura-web-server`.

If `aura` isn't found after a direct download, add the install directory to your `PATH`:

```bash theme={null}
export PATH="$HOME/.local/bin:$PATH"
```

<Tip>The script takes no arguments. Environment variables control the release version, the install directory, and which binaries you get. See [`scripts/README.md`](https://github.com/mezmo/aura/blob/main/scripts/README.md) for the full list.</Tip>

## 2. Generate a config

```bash theme={null}
aura init
```

The wizard asks a few questions, then writes a ready-to-run `config.toml` in the current directory:

* **Provider.** It first checks your environment for a conventional API key (e.g. `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`) and suggests the matching provider as the default.
* **API key.** If that variable is already set, it asks whether to use it. Otherwise it prompts for the key with masked input.
* **Model.** It queries the provider's live model list and offers a short, curated shortlist. Pick by number, accept the default, or type any model id.
* **Output.** It writes `config.toml`, plus a `.env` only when you entered a key that wasn't already in your environment.

Your key never lands in `config.toml`. The generated file references it as `api_key = "{{ env.OPENAI_API_KEY }}"` instead. If a `.env` was written, add it to your `.gitignore`.

## 3. Start chatting

```bash theme={null}
aura
```

AURA launches as a local chat assistant, loading `./config.toml` and running the agents on your machine.

<Note>The generated config is an **SRE orchestrator**: a coordinator that routes each request to one of three specialist workers (`incident-responder`, `metrics-analyst`, and `log-analyst`), running them in parallel when the tasks are independent. You can add or remove workers, rewrite their prompts, and change any other option in `config.toml` later, using the [Configuration Reference](/aura/configuration-reference).</Note>

## 4. Connect your tools

Right now AURA's workers can reason about problems and analyze data you paste in, but they can't query anything yet.

At the AURA chat prompt, type:

```
/mcp add
```

This launches a guided wizard that adds an [MCP](https://modelcontextprotocol.io) server to your config, giving the workers tools they can call. Pick one from the built-in catalog:

| Server     | What your agents get                                  | You'll need                                                       |
| ---------- | ----------------------------------------------------- | ----------------------------------------------------------------- |
| Mezmo      | Log analysis, exports, and pipeline monitoring        | A Mezmo service API key (**Settings > API Keys**)                 |
| PagerDuty  | Incidents, on-call schedules, and escalation policies | A PagerDuty API token (**User Settings > API Access**)            |
| Datadog    | Metrics, monitors, dashboards, and APM traces         | A Datadog API key and application key (**Organization Settings**) |
| Kubernetes | Read-only cluster inspection through your kubeconfig  | Node.js (for `npx`) and a working kubeconfig context              |

Or choose **custom** to configure any other MCP server over `http_streamable`, `sse`, or `stdio`.

The wizard then:

1. Collects credentials with masked input, or reuses an environment variable you already have set.
2. Connects to the server and lists the tools it discovered, all in memory, before anything touches disk. A credential that doesn't work never reaches your config.
3. Previews the exact `[mcp.servers.<name>]` block and asks whether to write it. Pressing Enter accepts. If the connection check failed, the wizard says so and pressing Enter declines instead.
4. Writes the config, then asks which workers should see the new tools and records an `mcp_filter` for each. You might give the Kubernetes tools to `incident-responder` alone and leave `log-analyst` without them.

Secrets go to a `.env` beside your config; the TOML gets `{{ env.VAR }}` placeholders. AURA resolves them only to authenticate to the MCP server, so your credentials never enter a prompt or a tool definition and the model never sees them. Nothing is written until you confirm.

## 5. Restart and put it to work

MCP servers are loaded at startup, so restart AURA to activate the one you just added. Run `/quit`, then:

```bash theme={null}
aura
```

Try the starter prompt the wizard printed for your server. For PagerDuty:

> Who is on call right now, and are there any open incidents?

Run `/mcp` at any time to list the servers the active agent has configured.

## What's next

* **[Web Server Reference](/aura/web-server-reference)**: run AURA as a daemon that serves these same agents over an HTTP API, so alerts and other automated events can trigger agent runs.
* **[Example Configs](/aura/example-configs)**: minimal per-provider configs and complete agent compositions to start from.
* **[CLI Reference](/aura/cli-reference)**: every slash command, flag, and the full `/mcp add` walkthrough.
* **[Configuration Reference](/aura/configuration-reference)**: every option available in `config.toml`.
* **[Full-Stack Docker Quickstart](/aura/quickstart-docker)**: run AURA with a browser chat UI and a Phoenix trace viewer via `docker compose`.
* **[Orchestration Quickstart](/aura/quickstart-orchestration-math)**: a self-contained multi-agent example that demonstrates parallel task execution.
* **[Kubernetes SRE Quickstart](/aura/quickstart-k8s-sre)**: an AI-powered SRE agent on a KIND cluster with real Kubernetes and Prometheus MCP servers.

## Troubleshooting

### `aura: command not found`

The install directory isn't on your `PATH`. Run `export PATH="$HOME/.local/bin:$PATH"` and add it to your shell profile.

### `aura init` can't list models

`aura init` fetches the provider's model list to confirm your key works and to build the shortlist it offers you. If that request fails, because you're offline or the key was rejected, it warns and continues, allowing you to type the model id yourself. Pass `--offline` to skip the request entirely. AWS Bedrock has no model-list endpoint, so it's always skipped.

### Workers say they have no tools

No MCP servers are configured yet. Run `/mcp add`, then restart `aura`.

### `/mcp add` isn't available

The wizard edits the `config.toml` on your machine, so it's only available when AURA runs agents from that file. Connecting to an [AURA web server](/aura/web-server-reference) with `--api-url` disables the `/mcp add` command, since the config lives on the server instead.

### Newly added MCP server isn't showing up

There's no hot reload. Restart `aura` after `/mcp add` finishes.