Chinmai S Dbackend + systems + ai

chinmai s d / backend + systems + ai

I build systems that collect, observe, and reason over data.

~/focus

I am Chinmai, a final-year Information Science student at DSCE. I work in Python on log-intelligence, observability, and distributed data collection, and I build the AI developer tooling that runs on top, from a custom wire protocol up to a Next.js dashboard.

Bengaluru, India

Review My Build Signal LinkedIn GitHub

about

The way I like to build

I keep coming back to one idea: a system should make its own behavior easy to inspect, whether that is a log pipeline or a language model.

I am a final-year Information Science student at Dayananda Sagar College of Engineering, and most of my work sits between backend systems and the AI tooling that runs on them. I have built a terminal log-intelligence tool (LogScope), RAG evaluation and observability tooling (TraceroAI), grounded hiring evaluation infrastructure (SignalStack), and an IEEE-published astronaut health monitoring system.

What feels most like me: taking a system from a custom wire protocol up to a dashboard, with a clear data contract, explicit failure states, and enough observability that someone can actually reason about what it does.

01 / Start from the user decisionI first ask what decision the system should make easier, faster, or safer.

02 / Define the data contractThen I lock down inputs, outputs, failure states, and what the UI should reveal.

03 / Ground the model in evidenceFor LLM systems, I prefer retrieved sources, citations, confidence, and review paths.

04 / Make latency and trust visibleI treat speed, observability, and uncertainty as product features, not backend details.

05 / Measure, review, and improveThe last step is closing the loop with metrics, feedback, and cleaner next iterations.

skills

The stack I actually use

Filtered from my resume and repos, this leans on backend, systems, and observability work, with the AI/ML tooling I ship on top.

What matters most Bounded backpressure, observable pipelines, measurable APIs, and grounded AI behavior.

Backend & Systems

PythonFastAPIasyncio / concurrencyREST APIsBackground workersQueue processingTCP / networkingDistributed systemsCI/CD

Observability & Monitoring

PrometheusLog clustering (Drain)Anomaly detectionFull-text search (FTS5)Inverted indexingLatency / cost / token trackingAI observability

GenAI & Agents

RAGLangChainLangGraphLlamaIndexLLM-as-JudgeStructured outputsPrompt engineeringOpenAI & Gemini APIs

Data & Storage

PostgreSQLSQLite / FTS5RedisChromaDBVector searchMongoDBInfluxDBDocker

ML

PyTorchTensorFlow / Kerasscikit-learnXGBoostProphetHugging Face TransformersFeature engineeringTime-series analysis

Frontend

JavaScriptTypeScriptReactNext.jsReact Native / ExpoTailwind CSSProduct dashboards

projects

Four builds that explain me

LogScope is the current build, and these are the proof-of-work systems around it: each one is a backend or systems problem with the AI tooling that earned its place.

LogScope

Current build: a terminal-native log-intelligence tool on a single asyncio event loop. File tailers and network agents feed one bounded queue, drained inline through parse, index, cluster, anomaly, and sinks, so that queue is the single backpressure point.

100+ tests across parser, query, clustering, net1 loop single backpressure point

PythonasyncioSQLite / FTS5Custom TCPDrainDocker

View GitHub

metrics and signals

LogScope

100+tests across parser, query, clustering, net

1 loopsingle backpressure point

Drainhand-written log clustering

At-least-onceidempotent TCP delivery

Open repository

TraceroAI

RAG evaluation and observability platform: a Python SDK feeding a FastAPI backend and a Next.js dashboard. It classifies each failed answer by stage, retrieval, context, or generation, instead of flagging generic hallucinations.

6 failure diagnosis categories2-tier embedding + LLM-as-Judge eval

Python SDKFastAPILangGraphRedisNext.jsPyPI

Live build

metrics and signals

TraceroAI

6failure diagnosis categories

2-tierembedding + LLM-as-Judge eval

PyPIpublished open-source SDK

Livetraceroai.tech

Open TraceroAI

SignalStack

A grounded AI evaluation platform that assesses candidates using evidence from GitHub repositories and coding profiles, validating every generated assessment against retrieved code snippets and structured outputs.

~5x fewer LLM API calls60% lower token cost

FastAPIPostgreSQLRedisOpenAIReactPrometheus

View GitHub

metrics and signals

SignalStack

~5xfewer LLM API calls

60%lower token cost

26backend test files

Prometheuslatency and cost metrics

Open repository

Astronaut Space Health

My IEEE-published health AI work as a real-time ML inference pipeline over streaming telemetry, classifying health risk across three severity levels against a sub-50 ms latency target.

93.1% XGBoost classification accuracy<50ms inference latency target

FastAPIXGBoostIsolationForestProphetTimeGAN

View GitHub

metrics and signals

Astronaut Space Health

93.1%XGBoost classification accuracy

<50msinference latency target

25%better alert reliability

IEEEICTBIG 2025 publication

Open repository

portfolio lab

Challenge my build log

A focused interface for asking about Chinmai's projects, metrics, skills, and engineering decisions.

AI engineering game

Reliability Quest

0 / 100 XP

0 XP

Click each quest to unlock how I think about reliable systems. Every step maps to a real build.

LogScopeBound the queue

Drain every source through one bounded queue so the system has a single, explicit backpressure point instead of unbounded buffers.

chinmai-build-log

Ask me about LogScope, TraceroAI, SignalStack, Astronaut Space Health, or Chinmai's backend, systems, and AI stack.

command layer

Type to navigate

Click anywhere outside the input, type a destination, and the portfolio routes there instantly.

logscopetraceroaigithublinkedinemailprojectscasesassistantcontact

case studies

What each build taught me

These are the stories I would use in an interview: the problem, the engineering choice, the result, and what I learned.

LogScope

Backpressure as a first-class design

problem

Log tools fall over under bursty volume when tailing, parsing, indexing, and queries all fight for the same resources with no single point of control.

solution

Run everything on one asyncio event loop: file tailers and network agents feed one bounded queue, drained inline through parse, index, cluster, anomaly, and sinks, so that queue is the single backpressure point.

result

Rotation- and truncation-aware tailing, a hand-written Drain clustering layer, FTS5 full-text search, a custom length-prefixed TCP protocol with at-least-once idempotent delivery, and 100+ tests.

lesson

Reliable systems come from one clear control point and explicit failure behavior, not from adding more threads.

TraceroAI

Diagnose RAG failures, not just flag them

problem

RAG apps fail silently, and 'hallucination' is too coarse to act on when developers cannot see retrieval, context assembly, or generation behavior.

solution

Build a Python SDK to FastAPI to Next.js pipeline with a two-tier engine: synchronous embedding-relevance scoring, then an asynchronous LLM-as-Judge groundedness check, collapsing every trace into one of six diagnosis categories.

result

A published PyPI SDK with tracing APIs, experiment workflows, and a LangGraph agent that drafts fixes for failing traces, with token and cost accounting done server-side.

lesson

Reliable RAG needs instrumentation and evaluation surfaces, plus a vocabulary for failure, as much as better prompts.

SignalStack

Evidence-first AI evaluation

problem

Hiring systems over-trust keywords, resumes, and ungrounded AI summaries instead of proof-of-work.

solution

Parse repositories, select source evidence, validate generated assessments against retrieved code, and batch evaluation at the outcome level to cut redundant LLM calls.

result

About 5x fewer LLM API calls and 60% lower token cost, validated across 26 backend test files, with Prometheus-compatible latency and cost-per-candidate metrics.

lesson

A reliable AI evaluator needs retrieval, deterministic checks, scoring design, and cost discipline, not only an LLM prompt.

Astronaut Space Health

Real-time ML needs clear contracts

problem

Streaming health predictions are fragile when feature order, time windows, model artifacts, and warm-up behavior are not explicit.

solution

Engineer 68 features over streaming telemetry, train XGBoost on 49K+ records plus 49K+ TimeGAN-augmented sequences, and combine IsolationForest and Prophet for anomaly detection and forecasting.

result

93.1% classification accuracy against a sub-50 ms latency target, a 25% improvement in alert reliability, and a paper published at IEEE ICTBIG 2025.

lesson

The model is only useful when the data cadence, inference path, and alert semantics are engineered together.

failure wall

Things I had to learn by building

I want this portfolio to show judgment, not perfection. These are the lessons that changed how I build the next version.

distributed systems

An unbounded queue is a crash waiting to happen

LogScope taught me to make the bounded queue the single backpressure point. The moment ingestion can outrun draining with nowhere to push back, the whole system gets fragile.

grounding

Do not let fluent output outrun evidence

If evidence is thin, the system should lower confidence and name the failure stage instead of sounding more polished. That idea drives TraceroAI's six diagnosis categories.

ml systems

Model demos need warm-up and failure states

The astronaut platform taught me that a model is not always ready just because an endpoint exists. Readiness, warm-up, and missing data need explicit states.

github live stats

Public build signal

Fetched from @chinmai-sd-123. Status: fallback.

18public repositories

3repos updated in 180 days

12recent public push events

recentlatest public repo update

currently building

Work in motion

Right now I am focused on LogScope: a single-event-loop log-intelligence tool with bounded backpressure, Drain clustering, and distributed collection over a custom TCP protocol.

LogScope

My current work-in-motion: a terminal-native log-intelligence tool on a single asyncio event loop, with rotation-aware tailing, Drain clustering, FTS5 search, and distributed agent-to-server collection over a custom TCP protocol.

PythonasyncioSQLite / FTS5Custom TCPDrainDocker

Live build

current build

TraceroAI

A live RAG evaluation and observability platform: Python SDK, FastAPI backend, and Next.js dashboard that diagnose failing traces by stage and draft fixes with a LangGraph agent.

Next.jsFastAPILangGraphRedisEvalsPyPI

Live build

live build

AI Coach

A secondary build I keep hardening beyond MVP: personalized habit and goal coaching with memory, intent routing, prompt-injection checks, and response caching.

FastAPIExpoGeminiJWTSQLAlchemyCaching

secondary

writing

Ideas I keep circling

These are the topics I naturally come back to while building: evidence, latency, model contracts, and human review.

systems

Backpressure and the single event loop

Why LogScope drains tailers and agents through one bounded queue, and what that buys you over a thread-per-source design.

Discuss this

LLMOps

Diagnosing RAG failures by stage

TraceroAI's core idea: classify each failed answer as retrieval, context, or generation instead of one vague hallucination label.

Discuss this

ML systems

Health telemetry as an ML product

What real-time prediction systems need beyond a trained model: cadence, features, artifacts, APIs, and alert reliability.

Discuss this

contact

Let us talk about useful AI

The best way to evaluate me is simple: read the repos, inspect the systems, then ask me how I would make the next version stronger.

Best way to reach me

I am most interested in AI systems where reliability, evaluation, and user trust matter. Send me the problem, the constraints, and what a good answer should prove.

Email Chinmai LinkedIn GitHub

Bengaluru, India