Skip to main content

​
General

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.
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.
Aurora supports:You only need one API key from any of these providers to get started.
Yes! Aurora is licensed under the Apache License 2.0. The source code is available on GitHub.

​
Installation and Setup

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)
Quick start:
# 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 in your browser.
  • 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.
Use the VERSION parameter:
make prod-prebuilt VERSION=v1.2.3
Available versions are listed at https://github.com/orgs/Arvo-AI/packages.
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.

​
Configuration

  • 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
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
  • 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.

​
Storage and Data

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.
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>.
  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
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.

​
Development

Development mode includes hot reload for both frontend and backend:
make dev
This builds and starts all containers with volume mounts for live code changes.
View all container logs:
make logs
View specific container logs:
docker logs -f aurora-server-1
docker logs -f aurora-frontend-1
docker logs -f aurora-celery_worker-1
For the API server:
make rebuild-server
For other containers, rebuild everything:
make down
make dev-build
make dev
We welcome contributions! Please:
  1. Read the Contributing Guide
  2. Read the Code of Conduct
  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 for more ways to get involved.

​
Architecture

  • 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
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)
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.

​
Troubleshooting

  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
You need to set the Vault root token in your .env file:
# 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
  • 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
See the Troubleshooting page for detailed solutions, or check Support for ways to get help from the community and maintainers.
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 file for full details.
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.
No, the Apache License 2.0 does not require you to contribute changes back. However, we encourage contributions to help improve Aurora for everyone!

Build docs developers (and LLMs) love

Get started for freeTalk to us