Forem: Apoorv Gupta

Laptop/PC Device Anomaly Analyzer: Self-Healing System Powered by Agentic Postgres

Apoorv Gupta — Mon, 10 Nov 2025 07:31:10 +0000

This is a submission for the Agentic Postgres Challenge with Tiger Data

What I Built

Laptop Anomaly Analyzer is an autonomous, AI-powered monitoring system built on Agentic Postgres + Tiger MCP + Gemini.

It continuously collects local system metrics (CPU, RAM, Disk, Network I/O), detects performance anomalies in real time, and automatically explains why they happened — all from within Postgres itself.

No external ML service, no Python inference engine — just Agentic Postgres acting as its own AI brain.

The project began as a simple TimescaleDB-based logger for my laptop performance, but evolved into an agentic database experiment where the DB doesn’t just store telemetry, it understands, reasons, and reacts.

Demo

🔗 GitHub Repository: github.com/StephCurry07/laptop-anomaly-analyzer

(Repo includes collector script, MCP config, and dashboard setup)

Outputs:

Dashboard Preview:

![Grafana Dashboard]

How I Used Agentic Postgres

This project combines several of Agentic Postgres’ most advanced features:

⚙️ Tiger MCP (Model Context Protocol)

Runs three autonomous database agents:
- anomaly_detector → runs every 10 minutes to detect CPU/RAM anomalies.
- root_cause_agent → triggers on new anomalies, uses vector search to find similar incidents.
- daily_summary → summarizes system performance once a day using Gemini reasoning.
All logic executes inside the database, orchestrated through MCP — no external scripts required.

💬 Tiger CLI

Provides a natural-language interface:

 "Summarize anomalies in the last 24 hours"
 "Find similar CPU spikes from past week"

Overall Experience

It was my first time using postgres for a project. Building with Agentic Postgres completely changed how I think about data systems. Instead of pushing data to an external model or pipeline, the database itself became the reasoning layer, thanks to MCP and TigerData.

Stack Used

Postgres + TimescaleDB
Tiger MCP
TigerData
Gemini CLI
Grafana (for visualization)
Python (for metric collection)

Beyond the Cache: AI-Driven Incident Management with Redis

Apoorv Gupta — Mon, 11 Aug 2025 06:58:01 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

What I Built

I built an AI-powered incident management platform that doesn’t just track incidents—it actively tries to fix them automatically in real-time.

Instead of being a passive dashboard, the system reacts instantly to new issues by triggering an autofix workflow backed by Redis Streams and JSON storage.

When an incident is detected, Redis:

Stores it as the primary database in JSON format.
Pushes it into a Redis Stream for processing.
Supports real-time WebSocket updates to all connected clients so the UI reflects changes instantly.

The system can:

Detect: New incidents are pushed into Redis JSON.
Fix: A service attempts context-specific fixes.
Update: The dashboard is refreshed via WebSocket with status changes.

This makes the platform not just a monitoring tool—but a self-healing system.

Demo

Github Link: https://github.com/StephCurry07/Redis-IncidentResponseDashboard

📹 Video Walkthrough: YouTube Link

Screenshots:

How I Used Redis 8

I used Redis 8 well beyond simple caching:

Primary Database (RedisJSON)
- Incidents are stored directly in RedisJSON with rich metadata (severity, status, description, tags).
- Updates are instant and atomic—ideal for high-frequency changes from multiple services.
Real-time Streams for Autofix Pipeline
- Every new incident is appended to a Redis Stream (incident_stream).
- A background AI service consumes from this stream to attempt automated fixes, logging results back to Redis.
Pub/Sub for UI Live Updates
- On every update (fix, status change), a message is published to incident_updates.
- The frontend listens over WebSockets for instant UI refreshes without polling.
Full-Text Search (RediSearch) (optional enhancement)
- Allows users to quickly filter incidents by description, tags, or owner with sub-millisecond search results.

Why It’s Beyond the Cache

Redis is the operational core of this system—without it, real-time reaction, distributed event processing, and instant updates wouldn’t be possible.

It’s:

A primary DB (RedisJSON)
A data pipeline (Streams)
A search engine (RediSearch)

... all in one.

Instead of just serving cached reads, Redis orchestrates the entire lifecycle from incident detection → AI fix → live UI updates.

Next Steps

Implement AI autofix logic to handle different infrastructure types.
Integrate with CI/CD pipelines for proactive rollback.
Add historical analytics using RedisTimeSeries.

Stock Search and Insights Using Algolia and n8n

Apoorv Gupta — Mon, 28 Jul 2025 01:08:01 +0000

This is a submission for the Algolia MCP Server Challenge

Stock Search & Insights Platform

What I Built

I built a Stock Search & Insights Platform powered by the Algolia MCP Server for blazing-fast symbol and company name lookups.

Algolia provides instant search across an index of stock names and symbols.
Bun serves as the lightweight backend to fetch data and interact with external APIs.
n8n acts as an orchestration backend, managing workflows for technical analysis, AI-driven insights, and data enrichment.
TwelveData APIs are used for fetching real-time prices, technical analysis, and SMA calculations.
Chart-IMG API generates advanced charts with Bollinger Bands, RSI, and Volume indicators.
GPT‑4o‑mini analyzes the data and produces quick, AI-driven insights for each stock.

The result: A single interface where users can search for a stock, instantly view real-time price data, AI-powered analysis, and technical charts — all in one place.

Demo

GitHub Repo: https://github.com/StephCurry07/Algolia-StockSearch
Video Walkthrough: https://youtu.be/BVtRHilMbRo

How I Utilized the Algolia MCP Server

Built an Algolia MCP Server to manage and query a custom stock index containing symbols, company names, and exchanges.
Exposed MCP-like endpoints (/mcp/searchStocks, /mcp/analyzeStock) that act as a single entry point for the frontend, abstracting away multiple API calls and complex workflows.
Integrated Algolia InstantSearch with my React frontend for fast, typo-tolerant, and responsive search.
Used the MCP server as a broker between Algolia, n8n workflows (for chart generation, technical analysis, and AI insights), and external APIs (TwelveData & Chart-IMG).
This architecture decouples the frontend from multiple data sources — the MCP server handles enrichment, error handling, and data aggregation before sending a unified response back to the UI.

Key Takeaways

Performance is key: Algolia MCP made stock searching instantaneous, which is crucial for a financial data app.
Workflow automation saves time: n8n helped me orchestrate data fetching (real-time quotes, SMA, technical indicators) and combine them into a single response for the frontend.
AI adds value: Using GPT‑4o‑mini, I transformed raw numbers into actionable insights for end-users.
Charting matters: Integrating Chart-IMG allowed me to display professional-grade charts with key indicators effortlessly.
Learned how to combine Algolia + MCP + Bun + n8n + React + AI into a cohesive product pipeline.