Machine Learning Engineer

09/16/2026

👋 Hello builders,

I got tired of watching "AI stock analyst" demos fall apart on the first weird prompt, so I built one.

Meet the Stock Research Agent API, a multi-agent stock research system for NSE (Indian) equities, built with CrewAI + Groq + FastAPI, now with a Streamlit dashboard on top.

Ask it a plain-English question. Get back a structured, validated response every time. never a stack trace, never a made-up answer.

Here's what's under the hood 👇

🗣️ Understands natural language - "should I buy TCS?", "compare Infosys and Wipro", "give me some momentum stocks." A dedicated intent classifier figures out exactly what you're asking for before anything else runs.

🔎 Screening mode - no specific stock in mind? Ask for "oversold banking stocks" or "top gainers today." It scans a candidate universe, scores it with pure deterministic math (zero LLM guesswork in the ranking), and runs full analysis only on the top matches.

🧑‍💼 Three specialist agents, one sequential pipeline - a Market Data Analyst pulls live price and technical indicators, a News Sentiment Analyst reads recent headlines, and a Recommendation Strategist synthesizes both into a single BUY, SELL, or HOLD call with a target price and stop-loss.

📊 100% free data - price, volume, RSI, moving averages, MACD, and news headlines, all from Yahoo Finance. No paid market data API required.

🤷 Honest when it doesn't know something - ask it about the weather and it tells you straight: "I don't have that, I'm only trained on stock market data." That path has zero tools exposed to it, so it's structurally incapable of faking real-time data it doesn't have.

🧱 Schema-validated end to end - every agent output and API response is a validated data model. No fragile string-parsing, no silent failures.

🩹 Graceful degradation - one bad ticker or one flaky data call only degrades that part of the answer, never the whole request.

⚡ Runs entirely on Groq's free tier - fast open-weight models, zero inference cost to run.

Streamlit dashboard, REST API which can then be integrated with any frontend client- type a query, get a styled results table, sentiment breakdowns, and one-click CSV export.

This has been an exercise in making agentic AI systems actually dependable, not just impressive in a demo.

👇 GitHub repo link is in the comment - feedback, concerns, and PRs all very welcome!

09/08/2026

I built a cost-optimized LLM model router — and open-sourced it 🚀

If you're working with LLMs in production, you've probably run into this problem: every query costs the same to send to your most expensive model as it does to your cheapest one, unless something is actually making that decision for you.

"What's the capital of France?" doesn't need the same model as "design a database schema for a multi-tenant billing system." But most apps route every request to a single model regardless of how simple or complex it is — which means you're either overpaying constantly, or under-provisioning on the queries that actually need a stronger model.

So I built llm-cost-router: a system that classifies each incoming query by complexity, routes it to the cheapest model that can actually handle it, tracks exactly what it cost, and degrades gracefully when something goes wrong.

Here's what's inside:

🎯 Dual-mode complexity classification
A fast regex/keyword heuristic handles the common case instantly. For trickier cases, an LLM-based classifier kicks in — constrained to a strict JSON schema so the output is always reliable and typed, not something I have to parse out of free text.

💰 Real per-request cost tracking
Every request logs its exact dollar cost, computed from actual token usage — not estimates.

🛡️ Budget-aware routing
Users approaching their spend limit get automatically downgraded to cheaper tiers instead of just erroring out.

🔌 Circuit breaker for model health
If a model starts failing, the router stops sending it traffic and retries after a cooldown — instead of repeatedly hammering something that's down.

📊 Live observability
A fully provisioned Prometheus + Grafana stack (spun up with one docker-compose command) gives real-time dashboards: cost by tier, request distribution, latency percentiles, token throughput, and spend per user. Screenshots below 👇

🧪 Tested and evaluated, not just built
A labeled eval set and pytest suite validate the classifier's accuracy, so changes get caught before they ship — the same discipline you'd want in any production system.

The stack: FastAPI, Groq (for free-tier testing with gpt-oss models), Prometheus, Grafana, and Docker Compose.

Why I built this: a lot of "AI engineer" tutorials stop at "call an API and get a response." The actual engineering — cost control, reliability, observability, graceful degradation — is what separates a demo from something you could actually run in production. This project was my way of building that muscle hands-on, end to end.

It's fully open source. Repo link in the comments 👇 — feedback, issues, and PRs are all welcome, especially if you'd approach the routing or classification differently.

08/12/2026

I built a RAG chatbot that lets you chat with your own PDFs 📄💬

Hey everyone! Wanted to share something I've been building: a Contexo: document Q&A chatbot using Retrieval-Augmented Generation (RAG). You upload a PDF, and instead of scrolling through 40 pages looking for one paragraph, you just ask it questions in plain English — and every answer comes back grounded in the actual document, with page references so you can go verify it yourself.

HOW IT WORKS

Upload a PDF — it gets parsed page-by-page, split into overlapping chunks, and embedded into vectors.
Ask a question in a normal chat interface.
The app retrieves the most relevant chunks from that specific document and feeds them to an LLM as context, so it answers from your content instead of guessing from general training knowledge.

STACK

Next.js 15 (App Router) + TypeScript
Clerk for auth
Neon (serverless Postgres) + pgvector for embeddings storage
Drizzle ORM
Hugging Face Inference API for embeddings
Groq (Llama 3.1) for fast generation, via the Vercel AI SDK
shadcn/ui + Tailwind for the UI

A FEW THINGS I'M PROUD OF

Hybrid search — combining vector similarity with Postgres full-text search (fused with Reciprocal Rank Fusion), since pure embeddings are surprisingly bad at exact matches like figures, names, or acronyms.
Page-level citations — I had to write a custom PDF page extractor (pdf-parse flattens everything into one string by default) so every chunk keeps track of which page it came from, all the way to the answer.
Real multi-tenant isolation — every row, down to individual document chunks, is scoped by user ID, not just checked at the route level. Learned the hard way how easy it is to accidentally leak data across users in a RAG pipeline if you're not careful about where you filter.
Drag-and-drop upload, a proper document dashboard with bulk select + delete, and a chat UI with suggested prompts for empty states.

STILL ITERATING ON — AND COULD USE A HAND WITH

Retrieval quality tuning (chunk size/overlap, embedding model choice)
Background job for cleaning up soft-deleted documents instead of a synchronous cascade delete
Word document support (currently PDF-only)

If any of that sounds interesting, I'd genuinely welcome collaborators — whether that's a PR, an issue with ideas, or just a second pair of eyes on the retrieval logic. Beginner-friendly issues are marked as such in the repo.

🔗 Live demo: https://contexto-taupe.vercel.app/
💻 GitHub: https://github.com/rooneyrulz/rag-chatbot

Would love feedback, and if you find it useful, a ⭐ on the repo genuinely helps it get seen by more people (and by future-me, as motivation to keep polishing it). Sharing with anyone else who might want to build on this is welcome too. Thanks for reading!

12/02/2025

🚀 AI-Powered Job Finder API (Open Source!)

Hey everyone! 👋

I'm excited to share an intelligent job search API that uses AI agents to find and recommend the best jobs for you.

What it does:

✨ Searches LinkedIn & Glassdoor simultaneously
🤖 Uses AI (LangGraph + Groq LLM) to analyze and score jobs
🎯 Returns top 10 personalized recommendations with match scores
⚡ Built with FastAPI for blazing-fast performance

Tech Stack:

FastAPI—Modern async Python API
LangGraph—Agentic workflow orchestration
Groq LLM—Free, fast AI analysis (Llama)
BrightData—Real-time web scraping
Pydantic - Type-safe schemas

Why it's cool:
Instead of scrolling through hundreds of job posts, just send one API request and get AI-curated matches with explanations of why each job fits your criteria. The AI agent handles everything: scraping, analyzing, scoring, and ranking.

🔗 GitHub Repo: https://github.com/rooneyrulz/agentic-job-finder

Follow Machine Learning Engineer for more interesting ❤️

AI-powered job search API using FastAPI, LangGraph agents & Groq LLM. Scrapes LinkedIn/Glassdoor jobs via BrightData and returns intelligent, ranked recommendations with match scoring. - rooney...

11/18/2025

🚀 Want to become a real AI Engineer?

Start by mastering these 7 RAG (Retrieval-Augmented Generation) fundamentals.

RAG is one of the most practical skills in modern AI engineering. It gives LLMs access to fresh, private and factual information—things they were never trained on.

Let’s break it down. 👇

1️⃣ Why RAG matters

LLMs are powerful, but they come with limitations:

Knowledge cutoff → They stop learning after training
No private data → They can't see your internal docs
Hallucinations → They confidently make things up

RAG solves these issues by grounding every answer in retrieved, verified context.
When your company updates a policy, you just update the data—not the model.

2️⃣ The RAG Pattern (Simple but powerful)

RAG follows a clean loop:

1. Retrieve relevant context from your knowledge base
2. Augment the prompt with that context
3. Generate an answer grounded in real data

This pattern works across apps, bots, copilots, and enterprise systems.

3️⃣ Clean data = Better RAG

If your documents are messy, unstructured, or full of noise — even the best embeddings will return garbage.

📌Clean, well-formatted data is the easiest multiplier of RAG accuracy.
Poor data → poor retrieval → poor answers.

4️⃣ Retrieval quality is everything

RAG doesn’t fail at generation — it fails at retrieval.

Too few documents → missing context
Too many → noise
Wrong documents → confident nonsense

Always debug retrieval first.
If retrieval is bad, generation will *always* be bad.

5️⃣ Retrieval methods (RAG ≠ vector DB)

A big misconception: RAG is not about vector databases.
It’s a pattern. Retrieval can be as simple as loading text files.

Use the simplest approach that works:

🔎 Keyword search → exact matches
🧠 Semantic search (embeddings) → meaning-based retrieval
🔀 Hybrid search → keyword + semantic
🤖 Agentic search → LLM decides what to retrieve

6️⃣ Embeddings: The backbone of semantic search

Embeddings turn text into vectors like:
"How do I reset my password?" → [0.23, -0.45, 0.67, ...]

Sentences with similar meaning cluster together:

“I forgot my password”
“Need help resetting my password”

That’s how semantic search retrieves accurate context even when wording differs.

7️⃣ Chunking: What the model actually sees

Chunking splits documents into smaller pieces for retrieval.

Too small → missing context
Too large → irrelevant noise

📌 Best practice:
Split by logical sections, with 50–100 token overlap to avoid context loss.

Chunking directly shapes what the model sees—so it shapes your final output.

🎯 Final thought

RAG isn’t a product or a framework—it's a design pattern.
A pattern for giving LLMs the right context at the right time so they produce accurate, reliable answers.

If you want to build AI systems that work in the real world, start by mastering RAG.

learn AI the smart way ⭐
Follow Machine Learning Engineer for AI tips ❤️👍

12/27/2023

🚀 Exciting Machine Learning Project Update! 🚀

🔍 Project Overview: Heart Disease Binary Classifier

We are thrilled to share the latest updates on my machine learning project! 🤖📊 This project focuses on developing a binary classifier for predicting heart disease, leveraging Python and Scikit-learn for a comprehensive ML journey.

🌐 Key Features:

1. Data Preprocessing and Cleaning: Ensuring data integrity and enhancing predictive capabilities.

2. Exploratory Data Analysis (EDA): Gaining valuable insights through analysis and visualization.

3. Binary Classification Model: Implementing Logistic Regression, K-Nearest Neighbors and Support Vector Machine for comparative evaluation.

4. Hyperparameter Tuning: Fine-tuning the model for enhanced predictive accuracy.

5. Cross-Validation and Grid Search: Ensuring robustness across different subsets of the dataset.

💻 Technologies Used:

Python
Scikit-learn

📚 Note:

This project is designed for experimentation and learning purposes, not for production use. Feel free to explore the codebase, experiment with parameters, and contribute to ongoing development.

🤝 Your Input Matters:

We invite you to check out the GitHub repository, read about the project, and share your thoughts. Your contributions and feedback are highly welcomed! Let's learn and collaborate together. 🌟

Link to GitHub Repository 👉 https://github.com/rooneyrulz/heart-disease-binary-classifier

Happy Coding! 🚀

12/14/2023

11/23/2023

Handling Imbalanced Data.

05/28/2023

Data Mining ⛏️