Project index

Getting an AI to answer a question is the easy part. I wanted to see what happens when it has to plan, find the right sources, and check its work. This is my attempt to make that journey a little less mysterious.

NeMo Guardrails filters inputs. Portkey handles retries, caching, and model fallbacks. Logfire and LangSmith trace the path from question to answer.

1. Plan
2. Retrieve
3. Rerank
4. Respond

Evaluation setup: 15 golden Q&A pairs, 6 RAGAS metrics, and adversarial noise tests. Project-reported; production validation pending.

• Python
• LangGraph
• Qdrant
• RAGAS
• Portkey

A document upload is only the start of the story. LexGuard is about everything that happens after: getting the file through a queue, making it searchable, and picking up the pieces when a worker stops halfway.

RabbitMQ queues ingestion, a transactional outbox coordinates delivery, and pgvector indexes the documents. Prometheus and Grafana expose service health.

1. Ingest
2. Queue
3. Index
4. Retrieve

Project-reported: an eight-service Docker stack and 0.48s p99 in a concurrent benchmark; not a production SLA.

• Java
• Spring Boot
• RabbitMQ
• pgvector

Natural-language database queries are useful. Accidental writes are less fun. This agent checks queries, asks for confirmation before writes, and keeps a record of what happened.

Reads are allowlisted, writes require confirmation tokens, and DDL is blocked. Schema caching keeps repeated queries efficient.

1. Generate
2. Validate
3. Execute
4. Audit

Project-reported: 29 tests covering query safety and an audit log.

• FastAPI
• LangChain
• SQLAlchemy

I wanted a way to turn a mountain of docs into something I could work through. VaultLearn crawls the pages, organizes a study plan, and keeps questions scoped to what I’m learning.

LangGraph coordinates crawling and learning workflows. Generated notes remain compatible with Obsidian.

1. Crawl
2. Organize
3. Retrieve
4. Learn

Project-reported ingestion: 152 pages, six modules, and 3,493 chunks.

• LangGraph
• FastAPI
• ChromaDB

Probably not. This project explores routing by complexity, reusing similar answers, and falling back when a model takes too long. The savings below came from a synthetic benchmark, so there’s more to test.

FAISS and Redis support semantic caching, with timeouts, fallback models, and benchmark telemetry.

1. Classify
2. Cache
3. Route
4. Fallback

93.19% cost reduction in a controlled synthetic benchmark; production validation pending.

• Python
• FastAPI
• FAISS
• Redis

Financial filings aren’t light reading. I built a retrieval API that pulls relevant passages from 10-K documents and keeps citations close to the answer.

Docling parses filings; hybrid retrieval finds relevant passages and RAGAS evaluates the answers.

1. Parse
2. Index
3. Retrieve
4. Cite

Project-reported: 0.82 faithfulness over an index of 453+ chunks.

• FastAPI
• Docling
• ChromaDB
• RAGAS

An agent can sound sure of itself and still take the wrong turn. I built TraceLab to follow those turns: inspect the trace, find the failure, and compare a proposed fix with the original run.

A Python tracing SDK connects a branching support agent to evidence-linked evaluations. Workflows cover refunds, shipping, cancellations, retries, and human handoffs.

1. Trace
2. Inspect
3. Evaluate
4. Compare

19 evaluation scenarios. Scripted fixtures improve from 9/19 to 19/19 passing cases; real-model improvement and production validation pending.

• Python
• FastAPI
• PostgreSQL
• React
• TypeScript

Training the classifier was one part. Turning it into something you could actually call was the other. This project connects XGBoost training and validation to a small FastAPI service.

XGBoost training uses stratified cross-validation and feature analysis. FastAPI and Docker package the serving layer.

1. Train
2. Validate
3. Package
4. Serve

Project-reported F1: 0.859; not independently verified.

• Python
• XGBoost
• FastAPI
• Docker

A shared to-do list sounds simple, until you add permissions, caching, background jobs, and people editing at the same time. TaskFlow let me put those moving parts together.

JWT refresh tokens and roles control access. Redis caches data, RabbitMQ handles asynchronous messages, and WebSockets deliver live updates.

1. Authorize
2. Update
3. Publish
4. Sync

Focus: access control, caching, background messages, and keeping clients in sync.

• Java
• Spring Boot
• PostgreSQL
• Redis
• RabbitMQ
• WebSockets

Behind a checkout button are permissions, stored data, and payments that need to fit together. ShopSpree was my way of working through that backend.

Spring Security and JWT protect the API. PostgreSQL on Amazon RDS stores data and Stripe handles payments.

1. Authenticate
2. Browse
3. Checkout
4. Pay

Focus: authentication, data persistence, and payment integration.

• Spring Boot
• PostgreSQL
• Stripe