ARIA (Autonomous Reliability Intelligence Agent) is an AI-powered SRE (Site Reliability Engineering) assistant for a 10-microservice e-commerce platform. When a service fails, engineers typically spend hours manually digging through logs, incident tickets, and runbooks to find the root cause. ARIA automates that entire process — you ask a question like "Why did payment-service fail yesterday?" and four specialized AI agents retrieve evidence, analyze the root cause, suggest remediations, and write an executive summary. 100% free, runs entirely on your local machine.
┌─────────────────────────────────────────────────────┐
│ STREAMLIT UI │
└─────────────────┬───────────────────────────────────┘
│ HTTP
┌─────────────────▼───────────────────────────────────┐
│ FASTAPI │
└─────────────────┬───────────────────────────────────┘
│
┌─────────────────▼────────────────────────────────────┐
│ COORDINATOR AGENT │
│ ┌─────────────┐ ┌─────────┐ ┌─────────────────┐ │
│ │ Retrieval │→ │ RCA │→ │ Remediation │ │
│ │ Agent │ │ Agent │ │ Agent │ │
│ │ FAISS+DuckDB│ │ Ollama │ │ Ollama │ │
│ └─────────────┘ └─────────┘ └────────┬────────┘ │
│ │ │
│ ┌───────────────▼────────┐ │
│ │ Executive Agent │ │
│ │ Ollama LLM │ │
│ └───────────────┬────────┘ │
└──────────────────────────────────────────┼───────────┘
│
Incident Report
DATA PIPELINE (Databricks)
Raw Files → Bronze (Delta) → Silver (Cleaned) → Gold (Aggregated)
| Layer | Tools |
|---|---|
| Data Engineering | Databricks Free Edition, Delta Lake, Unity Catalog, PySpark |
| Data Generation | Python, Faker |
| Vector Search | FAISS, sentence-transformers (all-MiniLM-L6-v2) |
| LLM | Ollama, llama3.2 (local, free) |
| Local Query Engine | DuckDB |
| API | FastAPI, Uvicorn |
| UI | Streamlit |
| Monitoring | Prometheus (prometheus-client) |
| Evaluation | Custom benchmark framework |
aria-ai/
├── data_gen/ # Synthetic data generators (6 datasets)
├── data/raw/ # Generated raw files (JSONL, Parquet, JSON)
├── agents/ # 4 AI agents + coordinator
│ ├── base_agent.py
│ ├── retrieval_agent.py
│ ├── rca_agent.py
│ ├── remediation_agent.py
│ ├── executive_agent.py
│ └── coordinator.py
├── rag/ # RAG pipeline: chunking, embedding, FAISS
├── api/ # FastAPI REST endpoints
├── ui/ # Streamlit dashboard
├── monitoring/ # Prometheus metrics
├── pipelines/ # Pipeline runner script
├── evaluation/ # Benchmark dataset + evaluator
├── terraform/ # Infrastructure as Code
├── k8s/ # Kubernetes manifests
├── .github/workflows/ # GitHub Actions CI/CD
├── docs/ # Architecture docs + screenshots
└── requirements.txt
aria_ai (catalog)
├── raw/
│ └── files (Volume — raw uploaded files)
├── bronze/
│ ├── logs (100,000 rows)
│ ├── incidents (20,000 rows)
│ ├── alerts (10,000 rows)
│ ├── runbooks (500 rows)
│ ├── metrics (259,210 rows)
│ └── rca_reports (11 rows)
├── silver/
│ └── * (6 cleaned Delta tables)
└── gold/
├── service_health_summary
├── incident_trends
├── alert_summary
└── rca_knowledge_base
Run notebooks in this order in your Databricks workspace:
01_bronze_ingest02_silver_transform03_gold_aggregate
1. Clone and install:
git clone https://github.com/YOUR_USERNAME/aria-sre.git
cd aria-sre
python -m venv venv
venv\Scripts\activate # Windows
pip install -r requirements.txt2. Generate synthetic data:
python -m pipelines.run_pipeline3. Pull Ollama model:
ollama pull llama3.24. Build RAG index:
python -m rag.build_index5. Start FastAPI backend (Terminal 1):
uvicorn api.main:app --reload --port 80006. Start Streamlit UI (Terminal 2):
streamlit run ui/app.py7. Open http://localhost:8501, select a service, ask a question.
| Dataset | Format | Records |
|---|---|---|
| Application logs | JSONL | 100,000 |
| Incident tickets | JSONL | 20,000 |
| Monitoring alerts | JSONL | 10,000 |
| Runbooks | JSON | 500 |
| Time-series metrics | Parquet | 259,210 |
| RCA post-mortems | JSON | 11 |
| Total | 389,721 |
| Method | Endpoint | Description |
|---|---|---|
| GET | /health |
API status check |
| GET | /services |
List all monitored services |
| POST | /query |
Run full ARIA pipeline |
| GET | /incident/{id} |
Fetch specific incident |
| GET | /incidents/{service} |
List incidents for a service |
| GET | /metrics |
Prometheus metrics scrape |
Benchmarked on 5 real incident scenarios:
| Metric | Score |
|---|---|
| Pipeline Success Rate | 100% |
| Avg Keyword Match Score | 52% |
| Retrieval Hit Rate | 20% |
| Avg Query Latency | ~178 seconds |
What these mean:
- 100% success = the agent pipeline never crashed across all test cases
- 52% keyword match = ARIA identified the correct root cause concepts roughly half the time using a local CPU-only LLM with no fine-tuning
- 20% retrieval = only 1 of 5 services had sufficient runbook coverage in the vector index — main improvement area
- ~178s latency = expected for llama3.2 running on CPU, no GPU
- Retrieval coverage — only payment-service has dense runbook
coverage in FAISS. Other services need more runbook templates added
to
generate_runbooks.py - LLM speed — ~3 minutes per query on CPU. GPU or a faster model (e.g. Qwen 0.5B) would significantly reduce latency
- No fine-tuning — llama3.2 is a general model, not trained on SRE data. Fine-tuning on incident/runbook data would improve keyword match scores significantly
- Static data — pipeline runs on batch-generated data, not real-time streaming logs
- Designed and implemented a medallion architecture (Bronze/Silver/Gold) using real Databricks Free Edition with Delta Lake, Unity Catalog, and PySpark transformations
- Built a complete RAG pipeline from scratch — document chunking, vector embeddings, FAISS index, hybrid retrieval with metadata filters
- Implemented a multi-agent system with 4 specialized agents (Retrieval, RCA, Remediation, Executive) orchestrated by a coordinator
- Built a production-style REST API with FastAPI and a dashboard UI with Streamlit
- Added Prometheus observability — tracking LLM latency, agent execution counts, retrieval metrics per query
- Designed and ran an evaluation framework measuring retrieval quality, RCA accuracy, and pipeline reliability with a benchmark dataset
On the Streamlit dashboard, select which microservice you want to investigate (e.g. payment-service) and type a natural language question like "Why did payment-service fail with gateway timeouts?"
ARIA's coordinator triggers 4 specialized agents in sequence:
- Retrieval Agent — searches 1,758 document chunks in FAISS and queries 389,721 records via DuckDB to gather evidence
- RCA Agent — analyzes retrieved incidents, alerts, and runbooks using Ollama LLM to identify the most probable root cause
- Remediation Agent — uses runbook knowledge to suggest immediate actions, short-term fixes, and long-term prevention
- Executive Agent — writes a clean management summary with business impact and next steps
The final report is organized into three tabs:
- Executive Summary — non-technical, for management
- Technical RCA — root cause with confidence score and reasoning
- Remediation Plan — specific kubectl commands and config fixes
The knowledge ARIA reasons over comes from a real medallion architecture built in Databricks Free Edition:
- Bronze — 389,721 raw records ingested as Delta tables
- Silver — cleaned, deduplicated, enriched with derived columns
- Gold — pre-aggregated service health scores and incident trends
Sai Deva Harsha — B.Tech Computer Science 2025
Certifications: NVIDIA NCA-GENL, NVIDIA NCP-AAI
Currently pursuing: Databricks Data Engineer Associate, Azure AI-103