🕵️ AI-Powered Predictive Root-Cause Analytics Portal

An enterprise-grade AI-driven observability platform that transforms raw transactional logs into actionable intelligence using Large Language Models, in-memory SQL analytics, and automated root-cause diagnostics.

Designed for high-frequency financial systems, this platform automatically understands unknown log schemas, generates optimized SQL queries using Google Gemini, performs ultra-fast analytics with SQLite, and produces executive-ready incident reports—all without manual preprocessing.

✨ Overview

Traditional monitoring systems require predefined schemas, custom ETL pipelines, and significant engineering effort before meaningful analytics can be performed.

This platform eliminates those limitations by leveraging LLM-powered schema understanding, allowing users to upload any transactional CSV log while the AI dynamically determines how to query the data.

The result is an intelligent observability pipeline capable of:

Understanding unknown datasets
Generating SQL automatically
Detecting latency bottlenecks
Computing operational KPIs
Producing AI-generated executive diagnostics

🚀 Core Features

🤖 AI-Powered Dynamic SQL Generation

Upload any transactional CSV file
Google Gemini 3.5 Flash analyzes column names
Automatically generates optimized SQLite queries
No manual column mapping
No hardcoded schemas

⚡ High-Speed In-Memory Analytics

Instead of writing to disk, the application creates a temporary SQLite database inside RAM.

Benefits include:

Extremely fast query execution
Zero disk I/O overhead
Real-time KPI computation
Lightweight deployment

📊 Executive KPI Dashboard

Automatically computes operational metrics including:

Average Processing Latency
Peak Latency
Success Rate
Failed Transactions
Total Transactions
Processing Volume

All metrics are generated instantly after upload.

🚨 Intelligent Incident Desk

The platform automatically identifies the Top 25 worst-performing transactions ranked by latency.

Each incident includes information such as:

Transaction ID
Asset Class
Channel
Region
Transaction Value
Status
Processing Time

This allows engineers to prioritize the most critical bottlenecks immediately.

🧠 AI Root-Cause Diagnostics

Instead of simply displaying slow transactions, the platform sends incident metadata back to Gemini.

Gemini performs pattern recognition across multiple variables and generates an executive report containing:

Bottleneck correlations
Probable infrastructure failures
Engineering recommendations
System optimization suggestions

Example:

🧠 Executive Root Cause Report

• 82% of latency spikes originate from Debit transactions
  processed through ATM channels.

• Root Cause:
  Database connection pool contention during synchronous
  ledger validation.

• Recommendation:
  Introduce asynchronous processing using Kafka and
  optimize indexing on balance lookup tables.

🔄 Complete Intelligent Pipeline

                Upload CSV
                     │
                     ▼
         Pandas DataFrame Processing
                     │
                     ▼
      Google Gemini Schema Analysis
                     │
                     ▼
      AI-Generated SQLite Query
                     │
                     ▼
      In-Memory SQLite Analytics
                     │
          ┌──────────┴───────────┐
          ▼                      ▼
    KPI Computation       Incident Ranking
          │                      │
          └──────────┬───────────┘
                     ▼
      Gemini Root-Cause Diagnostics
                     │
                     ▼
      Executive Incident Report

🛠 Tech Stack

Category	Technology
Frontend	Streamlit
Programming Language	Python 3.9+
AI Engine	Google Gemini API
LLM Model	Gemini 3.5 Flash
Database	SQLite (`:memory:`)
Data Processing	Pandas
Numerical Computing	NumPy
Regex Parsing	Python Regex
Environment Management	python-dotenv

📂 Project Structure

latency-analytics-portal/
│
├── app.py
│     Main Streamlit dashboard
│
├── generate_csv.py
│     Generates synthetic financial telemetry logs
│
├── requirements.txt
│     Project dependencies
│
├── .env
│     Gemini API credentials
│
├── sample_logs.csv
│     Example transaction dataset
│
└── README.md

⚙️ Installation

1. Clone Repository

git clone https://github.com/SabhyataVerma/latency-analytics-portal.git

cd latency-analytics-portal

2. Create Virtual Environment

macOS / Linux

python3 -m venv .venv

source .venv/bin/activate

Windows

python -m venv .venv

.venv\Scripts\activate

3. Install Dependencies

pip install -r requirements.txt

4. Configure Environment Variables

Create a .env file:

GEMINI_API_KEY=YOUR_API_KEY

5. Generate Sample Dataset

python3 generate_csv.py

6. Launch Application

streamlit run app.py

🧠 Application Workflow

                Transaction CSV
                      │
                      ▼
         Upload through Streamlit UI
                      │
                      ▼
           Pandas DataFrame Creation
                      │
                      ▼
      Google Gemini Column Inspection
                      │
                      ▼
      AI-Generated SQL Query Creation
                      │
                      ▼
      In-Memory SQLite Query Execution
                      │
         ┌────────────┴────────────┐
         ▼                         ▼
   KPI Aggregation         Incident Detection
         │                         │
         └────────────┬────────────┘
                      ▼
       Gemini Executive Diagnostics
                      │
                      ▼
        Root Cause Investigation Report

📊 Example Dashboard

Executive KPI Cards

Total Transactions
Average Latency
Peak Latency
Success Rate
Failure Percentage

Incident Desk

Transaction	Channel	Asset	Region	Latency
TXN-10091	ATM	Debit	Tokyo	915 ms
TXN-81232	POS	Credit	London	842 ms
TXN-72611	Mobile	Debit	Singapore	801 ms

AI Executive Report

🧠 Predictive Root Cause Analysis

• 84% of severe latency incidents originate from Debit
  transactions processed through ATM channels.

• Database thread contention during synchronous
  ledger updates is the primary contributor.

• Introduce asynchronous processing with Apache Kafka,
  optimize database indexes,
  and increase connection-pool capacity.

🎯 Why This Project?

Eliminates Manual ETL

No predefined schemas.

The AI understands uploaded datasets automatically.

Accelerates Root Cause Analysis

Reduces investigation time from hours to seconds through automated diagnostics.

AI + SQL Hybrid Architecture

Combines the reliability of relational databases with the reasoning capabilities of Large Language Models.

Enterprise Ready

Designed with concepts commonly used in:

Application Performance Monitoring (APM)
Financial Technology
Infrastructure Observability
Incident Management
Intelligent Automation

📈 Future Enhancements

Interactive Plotly dashboards
Live streaming analytics using Apache Kafka
Multi-file comparative analysis
PDF and Markdown export
OAuth 2.0 Authentication
Cloud deployment on AWS
Historical trend forecasting
AI anomaly alert notifications

📜 License

This project is licensed under the MIT License.

👩‍💻 Author

Sabhyata Verma

Pre-final Year B.Tech Student
Electronics and Computer Engineering (ECM)
Vellore Institute of Technology (VIT), Chennai

GitHub

https://github.com/SabhyataVerma

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
.devcontainer		.devcontainer
.gitignore		.gitignore
README.md		README.md
app.py		app.py
generate_csv.py		generate_csv.py
requirements.txt		requirements.txt

Folders and files

Latest commit

History

Repository files navigation