What actually happens when you try to fine-tune a model through Gemini's own API today? This post finds out for real, and the answer changes the whole approach: a real, local, from-scratch fine-tuning pipeline instead, with a genuine before-and-after comparison against a hosted model, and what it all means for how you'd architect this decision at an enterprise level.

What can a hosted LLM API actually tell you about what's happening inside the model, and what only looks like it can? This post builds a real support-ticket-triage system to find out, and turns the answer into a decision framework for anyone architecting production AI systems: what's really observable, what's not, and why it matters for governance, cost, and vendor risk.

What if every agent app didn't need its own one-off glue code to reach a tool? This post explores MCP, the Model Context Protocol, by building a real ops-knowledge server and reaching it two different ways from Gemini: a free experimental bridge that only reaches tools, and a hand-built one that reaches everything a server can offer. What you get for free, and what it costs to get full coverage, is the real story.

What if you could just tell the model the exact shape you need, and actually have it guaranteed instead of hoped for? This post explores exactly that: enforcing structured output for real, comparing every way Gemini offers to do it, against 5 cases designed to break the old "ask nicely and parse the JSON" approach this whole series has relied on. What actually changes when you stop asking and start enforcing? Come find out, real bugs and all.

Fifteen real prompting techniques, explained one at a time: what each one is, when to reach for it, and real code showing it working, from the basics through Anthropic's own guidance to a safely-bounded version of meta-prompting. Plus a heavily-caveated case study in measuring instead of assuming, and four real bugs found along the way.

Ever wondered if you could learn and test AI concepts without wrestling with backend plumbing, or had an idea to build but didn't know how to write it for a specific provider? Introducing Requisite AI, an open-source, provider-agnostic Python framework published on PyPI, packaging chat, tool calling, agents, twelve multi-agent orchestration strategies, memory, RAG, MCP, and rate limiting behind one small, consistent API. Install it, add a .env file, write a few lines, and you have a working agent, no SDK-specific plumbing required. #AI #Python #OpenSource #LLM #AIAgents #MachineLearning #RequisiteAI #GenerativeAI #DeveloperTools #ProviderAgnostic

MCP, A2A, ANP, AG-UI, UCP, ACP, AP2, x402, Visa TAP, Mastercard Verifiable Intent, Web Bot Auth. If you've been trying to keep up with AI agent protocols, the acronym list keeps growing and it can feel like chaos. In my latest post, I map all eleven protocols across five layers, with a diagram for each, and close with a multi-agent enterprise procurement scenario that shows how a single request climbs the entire stack in practice. Read the full breakdown...

YouTube video by SUG CHENNAI

Most agents react one step at a time. This post builds one that plans its full approach up front, executes it, and revises the plan when real evidence contradicts its hypothesis, compared across a raw Python implementation and a LangGraph loop-back edge, with real bugs found and fixed along the way.

Part 1 built orchestrators and workers. This post builds the two patterns that didn't fit that shape: agents arguing opposite sides of a question with a real reviewer weighing in, and orchestrators nested inside orchestrators. Real bugs found along the way, including one that looked like inherent model inconsistency and turned out to be an actual memory leak between sibling agents, fixed and verified with a real before/after.

I built a Claude Skill that converts plain text and ASCII diagrams into real images in just 10 mins! It intelligently decides whether to preserve the original text layout or generate a polished flowchart. Perfect for sharing terminal output, code snippets, and architecture sketches anywhere.

One agent doing everything is one prompt trying to be good at two different jobs at once. This post builds an actual multi-agent system, twice, once by hand in raw Python and once with LangGraph, coordinating a researcher with a writer and a router with three specialists. Real API calls, real bugs found and fixed, and an honest look at what a framework actually buys you versus what it costs.

YouTube video by SUG CHENNAI

An agent that forgets everything the moment a session ends isn't really an agent, it's a chatbot with amnesia. This post builds real memory: a short-term buffer that summarizes instead of truncates, long-term facts that persist and get retrieved by relevance, a structured user profile, episodic session logs, agent-generated reflections, and the unglamorous but necessary work of pruning and consolidating a memory store so it doesn't grow forever. Verified against a real run, including catching and fixing a case where merging conflicting facts got the chronology backwards, a reminder that a memory system doesn't just need to remember things, it needs to remember them in the right order.

Passing your eval harness and your guardrail suite doesn't mean the system stays that way. This post adds tracing and drift detection to the same RAG pipeline: every request logged as structured spans under one trace_id, and retrieval quality checked against a saved baseline instead of trusted from a single launch-day run. The real trace data makes an argument words alone couldn't: the deterministic output scanner cost 0.0ms on average, while the LLM-based input classifier averaged over 4 seconds, on every request, safe or not. That's the actual price of judgment-based checks in the request path, made visible instead of theoretical.

Passing eval metrics doesn't mean your RAG system is safe to ship. This post builds a bypass-rate test suite for guardrails: an LLM classifier that blocks prompt injection, off-topic requests, and destructive-action asks before they ever reach retrieval, plus a deterministic scanner that catches credential leaks in the final answer. The real lesson isn't a clean bypass rate, it's that bypass rate alone is a trap: a guardrail that blocks everything also scores 0% bypassed while being completely useless. False positive rate is the number that keeps it honest.

Picking a chunking strategy, adding hybrid search, and layering in a reranker all feel like improvements. But "feels better" isn't a metric. This post builds a real evaluation harness, hand-labeled test queries, Hit Rate, Precision, Recall, and MRR for retrieval, plus LLM-judged faithfulness and relevancy for generation, and runs it across three retriever configs so you can see, in numbers, what each layer actually bought you.

Picking the right vector database gets you fast search. It doesn't get you good retrieval. This post builds hybrid search, query rewriting, a real cross-encoder reranker, and parent-child retrieval on top of the vector database guide, the pieces that actually decide whether retrieval finds the right answer.

Ever wondered which vector database to actually use for RAG, and what's happening when you "save" and "search" embeddings? This post breaks down Chroma, FAISS, Pinecone, and Qdrant with working code, covers the search algorithms powering them (HNSW, IVF, PQ, and more), and shows how to plug any of them straight into the multi-turn agent from the last post.

Discover how to supercharge agentic AI with Retrieval-Augmented Generation (RAG), enabling intelligent multi-turn agents that solve complex problems grounded in your documentation. This comprehensive guide includes architecture patterns, step-by-step implementation, and production deployment configs for Docker & Kubernetes.

YouTube video by SUG CHENNAI

Take your AI agents to the next level: Master agentic loops to solve complex multi-step problems that single-turn agents can't handle.

Have you been trying to create AI agents but don't know where to start? This blog explains how to create basic AI Agents where you can get started.

You type a prompt, the AI generates a hundred lines of code, you tweak, it rewrites, and somewhere along the way you realize you are not really in control of what is being built. That is Vibe Coding. And while it is fun, it has a ceiling. Spec Driven Development is the structured alternative that gives you the best of AI-assisted development without losing control of your architecture. In this post, we explore what SDD is, how it compares to vibe coding, and walk through a real-world multi-agent AI project to see it in action.

Starting your AI journey in software development? The terminology alone can be overwhelming. This blog breaks down the four core concepts you need to understand before writing a single line of AI-powered code.

YouTube video by SUG CHENNAI

YouTube video by SUG CHENNAI

YouTube video by SUG CHENNAI

YouTube video by SUG CHENNAI

Want to connect to local SQL server when developing using dockers? Here's a graceful way to do it which maps to your SQL server automatically.

YouTube video by SUG CHENNAI

🔍 Sitecore Tip: Easily list all renderings in your solution by type (View, Controller, XSL, etc.) using this PowerShell script! Perfect for audits, cleanups, or migrations. 💡 #Sitecore #PowerShell #DevTips

This is the second part of a series that dives deep into the CSS shape() command, continuing with a more detailed look at the arc command.