> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/Arvo-AI/aurora/llms.txt
> Use this file to discover all available pages before exploring further.

# Frequently Asked Questions

> Common questions about Aurora

## General

<Accordion title="What is Aurora?">
  Aurora is an automated root cause analysis investigation tool that uses AI agents to help Site Reliability Engineers (SREs) resolve incidents quickly and efficiently. It provides a natural-language interface for investigating infrastructure issues.
</Accordion>

<Accordion title="Do I need cloud provider accounts to use Aurora?">
  No! Aurora works without any cloud provider accounts. The only external requirement is an LLM API key (from OpenRouter, OpenAI, or Anthropic). Cloud connectors for GCP, AWS, and Azure are optional and can be enabled later if needed.
</Accordion>

<Accordion title="What LLM providers does Aurora support?">
  Aurora supports:

  * OpenRouter ([https://openrouter.ai/keys](https://openrouter.ai/keys))
  * OpenAI ([https://platform.openai.com/api-keys](https://platform.openai.com/api-keys))
  * Anthropic ([https://console.anthropic.com/settings/keys](https://console.anthropic.com/settings/keys))

  You only need one API key from any of these providers to get started.
</Accordion>

<Accordion title="Is Aurora open source?">
  Yes! Aurora is licensed under the Apache License 2.0. The source code is available on [GitHub](https://github.com/Arvo-AI/aurora).
</Accordion>

## Installation and Setup

<Accordion title="What are the system requirements?">
  To run Aurora, you need:

  * Docker and Docker Compose >= 28.x
  * Node.js >= 18.x (for frontend development)
  * Python >= 3.11 (for backend development)
  * Make (for using Makefile commands)
  * An LLM API key (OpenRouter, OpenAI, or Anthropic)
</Accordion>

<Accordion title="How do I get started with Aurora?">
  Quick start:

  ```bash theme={null}
  # 1. Clone the repository
  git clone https://github.com/arvo-ai/aurora.git
  cd aurora

  # 2. Initialize configuration
  make init

  # 3. Add your LLM API key to .env
  nano .env  # Add OPENROUTER_API_KEY=sk-or-v1-...

  # 4. Start Aurora
  make prod-prebuilt

  # 5. Get Vault root token and add to .env
  docker logs vault-init 2>&1 | grep "Root Token:"
  nano .env  # Add VAULT_TOKEN=hvs.xxxx

  # 6. Restart Aurora
  make down
  make prod-prebuilt
  ```

  Open [http://localhost:3000](http://localhost:3000) in your browser.
</Accordion>

<Accordion title="What's the difference between prod-prebuilt and prod-local?">
  * `make prod-prebuilt`: Pulls pre-built Docker images from GitHub Container Registry (GHCR). Faster, recommended for most users.
  * `make prod-local`: Builds Docker images locally from source. Useful for testing feature branches or custom builds.

  Both run Aurora in production mode. For development with hot reload, use `make dev`.
</Accordion>

<Accordion title="How do I pin a specific Aurora version?">
  Use the VERSION parameter:

  ```bash theme={null}
  make prod-prebuilt VERSION=v1.2.3
  ```

  Available versions are listed at [https://github.com/orgs/Arvo-AI/packages](https://github.com/orgs/Arvo-AI/packages).
</Accordion>

<Accordion title="What is the Vault root token and why do I need it?">
  Aurora uses HashiCorp Vault to securely store secrets like API keys and cloud credentials. The Vault root token authenticates Aurora services to access these secrets.

  The token is automatically generated on first startup and displayed in the `vault-init` container logs. You must add it to your `.env` file as `VAULT_TOKEN` for Aurora to function properly.
</Accordion>

## Configuration

<Accordion title="Where is Aurora configuration stored?">
  * Environment variables: `.env` file in the project root
  * Secrets: HashiCorp Vault (persisted in Docker volumes)
  * Database: PostgreSQL (aurora\_db)
  * GCP service accounts: `server/connectors/gcp_connector/*.json`
</Accordion>

<Accordion title="How do I enable cloud connectors?">
  Cloud connectors are optional. To enable them:

  1. Check `.env.example` for required environment variables
  2. For GCP: Place service account JSON in `server/connectors/gcp_connector/*.json`
  3. For AWS: Set `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` in `.env`
  4. For Azure: Set Azure-specific credentials in `.env`
  5. Restart Aurora: `make down && make dev`
</Accordion>

<Accordion title="What ports does Aurora use?">
  * **3000**: Frontend (Next.js)
  * **5080**: API server (Flask)
  * **5006**: Chatbot WebSocket
  * **5432**: PostgreSQL
  * **6379**: Redis
  * **8080**: Weaviate (vector database)
  * **8200**: Vault (secrets management)
  * **8333**: SeaweedFS S3 API
  * **8888**: SeaweedFS file browser
  * **9333**: SeaweedFS cluster status

  Ensure these ports are available before starting Aurora.
</Accordion>

## Storage and Data

<Accordion title="What is SeaweedFS?">
  SeaweedFS is an S3-compatible object storage system that Aurora uses by default for storing files. It's open source (Apache 2.0) and runs locally in your Aurora stack.

  You can also configure Aurora to use other S3-compatible services like AWS S3, Cloudflare R2, MinIO, or Backblaze B2.
</Accordion>

<Accordion title="Where is my data stored?">
  Aurora uses Docker volumes for persistent storage:

  * **postgres-data**: Database data
  * **vault-data**: Vault secrets
  * **vault-init**: Vault initialization keys
  * **weaviate-data**: Vector database
  * **seaweedfs-data**: Object storage

  These volumes persist even when containers are stopped. To completely remove data, use `docker volume rm <volume-name>`.
</Accordion>

<Accordion title="How do I backup my Aurora data?">
  1. **Database**: Use PostgreSQL backup tools (pg\_dump)
  2. **Vault secrets**: Export from Vault CLI or API
  3. **Object storage**: Backup SeaweedFS data volume or use S3 sync tools
  4. **Docker volumes**: Use `docker run --rm -v <volume>:/data -v $(pwd):/backup ubuntu tar czf /backup/backup.tar.gz /data`
</Accordion>

<Accordion title="Is Vault data encrypted?">
  Yes. Vault encrypts all secrets at rest and in transit. The encryption keys are managed by Vault and stored in the `vault-init` volume. Keep this volume secure and backed up.
</Accordion>

## Development

<Accordion title="How do I run Aurora in development mode?">
  Development mode includes hot reload for both frontend and backend:

  ```bash theme={null}
  make dev
  ```

  This builds and starts all containers with volume mounts for live code changes.
</Accordion>

<Accordion title="How do I view logs?">
  View all container logs:

  ```bash theme={null}
  make logs
  ```

  View specific container logs:

  ```bash theme={null}
  docker logs -f aurora-server-1
  docker logs -f aurora-frontend-1
  docker logs -f aurora-celery_worker-1
  ```
</Accordion>

<Accordion title="How do I rebuild a specific container?">
  For the API server:

  ```bash theme={null}
  make rebuild-server
  ```

  For other containers, rebuild everything:

  ```bash theme={null}
  make down
  make dev-build
  make dev
  ```
</Accordion>

<Accordion title="How do I contribute to Aurora?">
  We welcome contributions! Please:

  1. Read the [Contributing Guide](https://github.com/Arvo-AI/aurora/blob/main/CONTRIBUTING.md)
  2. Read the [Code of Conduct](https://github.com/Arvo-AI/aurora/blob/main/CODE_OF_CONDUCT.md)
  3. Fork the repository
  4. Create a feature branch (e.g., `feature/your-feature-name`)
  5. Make your changes
  6. Submit a Pull Request

  See [Support](/help/support) for more ways to get involved.
</Accordion>

## Architecture

<Accordion title="What technologies does Aurora use?">
  * **Frontend**: Next.js 15, TypeScript, Tailwind CSS, shadcn/ui
  * **Backend**: Python, Flask, Celery, LangGraph
  * **Database**: PostgreSQL, Weaviate (vector DB)
  * **Queue**: Redis
  * **Secrets**: HashiCorp Vault
  * **Storage**: SeaweedFS (S3-compatible)
  * **Deployment**: Docker Compose, Kubernetes
</Accordion>

<Accordion title="What is the Docker Compose stack?">
  The Aurora stack includes:

  * **aurora-server**: Flask REST API (:5080)
  * **celery\_worker**: Background task processing
  * **chatbot**: WebSocket server (:5006)
  * **frontend**: Next.js UI (:3000)
  * **postgres**: Primary database (:5432)
  * **weaviate**: Vector database (:8080)
  * **redis**: Task queue (:6379)
  * **vault**: Secrets management (:8200)
  * **seaweedfs**: Object storage (:8333)
</Accordion>

<Accordion title="How does Aurora use AI agents?">
  Aurora uses LangGraph to orchestrate AI agents for incident investigation. Agents can:

  * Analyze logs and metrics
  * Query cloud provider APIs
  * Perform root cause analysis
  * Generate remediation recommendations
  * Learn from past incidents

  The agent workflow is defined in the backend and uses your configured LLM provider.
</Accordion>

## Troubleshooting

<Accordion title="Aurora won't start - what should I check?">
  1. Verify Docker Compose version >= 28.x: `docker compose version`
  2. Check for port conflicts on 3000, 5080, 5006, 5432, 6379, 8080, 8200, 8333
  3. Ensure `.env` file exists and contains required variables
  4. Check container logs: `make logs`
  5. Try rebuilding: `make down && make dev-build && make dev`
</Accordion>

<Accordion title="I see Vault authentication errors">
  You need to set the Vault root token in your `.env` file:

  ```bash theme={null}
  # Get the token from vault-init logs
  docker logs vault-init 2>&1 | grep "Root Token:"

  # Add to .env
  VAULT_TOKEN=hvs.xxxxxxxxxxxxxxxxxxxxxxxxxxxx

  # Restart Aurora
  make down && make dev
  ```
</Accordion>

<Accordion title="Changes to my code aren't showing up">
  * **Frontend**: Changes should hot-reload automatically in dev mode. Try refreshing the browser.
  * **Backend**: Rebuild the server: `make rebuild-server`
  * If issues persist: `make down && make dev`
</Accordion>

<Accordion title="Where can I get more help?">
  See the [Troubleshooting](/help/troubleshooting) page for detailed solutions, or check [Support](/help/support) for ways to get help from the community and maintainers.
</Accordion>

## License and Legal

<Accordion title="What license is Aurora under?">
  Aurora is licensed under the Apache License 2.0. This is a permissive open source license that allows you to use, modify, and distribute Aurora freely, including for commercial purposes.

  See the [LICENSE](https://github.com/Arvo-AI/aurora/blob/main/LICENSE) file for full details.
</Accordion>

<Accordion title="Can I use Aurora commercially?">
  Yes! The Apache License 2.0 allows commercial use. You can deploy Aurora in your organization, modify it for your needs, and even offer it as a service.
</Accordion>

<Accordion title="Do I need to contribute my changes back?">
  No, the Apache License 2.0 does not require you to contribute changes back. However, we encourage contributions to help improve Aurora for everyone!
</Accordion>