Blogs

A deep dive into the Transformer architecture introduced in the landmark 2017 paper — what it is, how it works, why it replaced RNNs, and why every modern AI model from GPT to Gemini traces its roots here.

Breaking down the difference between training, fine-tuning, and inference—why they're not the same thing, what actually happens in each stage, and why understanding this makes LLM systems way less confusing.

Why tokenization is the most underrated part of LLMs—how tokens aren't words, why they affect cost and performance, and why bad tokenization breaks everything downstream.

A complete breakdown of encoder-decoder architectures—how they compress sequences into context vectors, generate outputs step-by-step, why teacher forcing matters, and the four key limitations that led to attention mechanisms.

Building a fine-tuned AI to translate legal jargon into plain English—from FLAN-T5 failures to Gemma-2B success using QLoRA on a free GPU, and the engineering lessons learned along the way.

How I exposed my portfolio blog system as an MCP server so Claude could operate it with natural language — and the 5 small but painful bugs that stood in the way.

An honest, unstructured brain dump about embeddings, vector databases, and re-ranking—from confusion about what the numbers mean to understanding coordinates, similarity search, and retrieval optimization.

Breaking down quantization from scary optimization technique to simple concept—how reducing bit precision makes models smaller and faster, and why calibration matters more than the math.

A practical inference benchmark comparing DistilBERT performance on CPU vs GPU—measuring latency, throughput, and memory across different batch sizes to understand what actually happens in production.

Learning machine learning alone in a Tier-3 city without mentors, bootcamps, or a tech ecosystem—why constraints became advantages and how building in public taught me more than any course.

A personal reflection on breaking free from perfectionism—why I stopped over-engineering side projects and started shipping imperfect code that actually reaches users.

Breaking down Vision Language Models into their core components—vision encoders, text encoders, fusion mechanisms—and the two main paradigms: contrastive learning (CLIP-style) and generative models.

Building a semantic blog recommendation system from scratch using embeddings, vector databases, and pre-computed results—why tags aren't enough and how I integrated ML into my Next.js portfolio.

Breaking down Logistic Regression from first principles—why it exists to express confidence in binary outcomes, how sigmoid transforms linear scores into probabilities, and a minimal from-scratch implementation.

Understanding AI, Machine Learning, and Deep Learning as a hierarchy rather than competing terms—from the broad AI umbrella to data-driven ML to neural-network-based deep learning.

A beginner-friendly breakdown of RAG's five core steps: from document preprocessing and chunking to embeddings, vector databases, and how LLMs use retrieved context to generate accurate answers.

Breaking down MCP (Model Context Protocol) through a simple analogy: tools are functions, MCP servers are toolboxes, and LLMs can invoke them through natural language without any UI interaction.

How I built a simple blog system into my portfolio using a custom API, MongoDB, and markdown—so I can write and publish from anywhere.

My honest beginner experience with n8n, why my first simple workflow took 12+ hours, and what I learned about automation, triggers, and platform limitations.