Blog¶

Agentic Retrieval: The Complete Guide from Document Ingestion to Compiled Knowledge

Naive RAG fails roughly 40% of the time at retrieval. Not because the LLM is bad — because what you hand it is bad. Wrong chunks, missing context, no awareness of what it doesn't know. Agentic retrieval fixes the retrieval layer, not the generation layer.

This guide covers the entire pipeline: from ingesting a raw PDF to deploying an agent that queries vector stores, SQL databases, knowledge graphs, and pre-computed summaries — and knows which one to use for each question.

AI Agent Application Demo: Putting a Brain Inside Your App

Source code: github.com/pkhamdee/coffee-agent

For decades we've built applications the same way: write a function, call the next function, handle each case with an if statement. The logic is explicit, deterministic, and completely predictable — a flowchart carved into code.

That model has a hard ceiling. When a user says something ambiguous, changes their mind mid-conversation, or combines requests in ways you didn't anticipate, the rigid-logic app breaks down. You write more and more special-case handling until the code becomes unmaintainable.

AI agents flip this model. You give your application a reasoning engine — a brain — and let it figure out what to do. This post walks through a real, runnable example: Coffee Agent, a coffee shop ordering chatbot built with NestJS, React, LangGraph, and a local LLM on Ollama.

Agentic AI Architectures: Patterns, Frameworks, and MCP for Enterprise Systems

Most AI tutorials show you how to call an API and get a response. That's not an agent. An agent is a system that perceives, plans, acts, and adapts — autonomously — using tools, memory, and other agents to complete tasks that no single LLM call could handle.

In 2026, agentic AI is the dominant paradigm for building AI into enterprise software. Not chatbots. Not search bars with AI behind them. Full autonomous systems that can research a topic, write code, test it, file a ticket, notify a Slack channel, and self-correct when something goes wrong — without a human in the loop for every step.

This is the definitive guide. We cover every design pattern, every major framework, the Model Context Protocol that is quietly unifying the entire ecosystem, and how to wire all of it into production enterprise systems.

Hybrid RAG in Production: A Full n8n + Airflow Implementation

You've got the concepts — chunking, hybrid search, reranking, GraphRAG. This is the wiring diagram. A complete hybrid RAG system you can import and run: ingestion on Apache Airflow, the query pipeline on n8n, retrieval fused across dense, BM25, GraphRAG, and live web.

This is the companion build to Agentic Retrieval: The Complete Guide. Every technique there, ported into nodes and DAG tasks you can click, run, and adapt — with a local-first swap for every cloud component.

Building a Production RAG App: The Decisions, the Traps, and the Fixes

I built a full-stack RAG application — streaming chat, document ingestion, hybrid search, sub-agents, admin-managed model config — and most of the hard parts had nothing to do with calling an LLM. The LLM call is 20 lines. The other 95% is retrieval quality, ingestion correctness, and not blocking your event loop.

This walks through the real decisions and the traps I hit: where naive RAG breaks, and the exact fix that shipped. Every number here is from the running code, not a whitepaper.

All the code is open source: github.com/pkhamdee/rag. Every snippet below links to the file it came from, so you can read the full implementation in context.

Credit: the template's structure and workflow originate from the Claude Code Agentic RAG Masterclass

Build a Second Brain with Claude Code and Obsidian

Most note-taking apps are graveyards. You clip an article, it sits in a folder, you never read it again. The knowledge doesn't connect to anything. It doesn't compound. After three years you have 4,000 notes and can't find anything.

This guide builds something different: a self-maintaining knowledge base where Claude Code acts as your librarian. You dump raw material in. Claude reads it, writes structured wiki articles, cross-links related concepts, and files everything. You ask questions. The answers become new notes. The library grows smarter every time you use it.

The architecture is based on Andrej Karpathy's LLM Wiki pattern: a persistent, compounding knowledge base where an LLM does the bookkeeping you'd never do yourself.

Git Workflow for Release Management: Branches vs Tags

Most teams invent their Git strategy as they go. One developer starts tagging releases. Another uses branches. A third creates a hotfix branch and never deletes it. By the time you need to patch a six-month-old release, nobody remembers what release-final-v2 means or where hotfixes actually landed.

A clear branching strategy prevents this. This post covers a battle-tested Git workflow built around two parallel approaches — version control with branches and version control with tags — and tells you exactly when to use each.

Agent-Driven Software Factory: Replace Vibe Coding With a 12-Agent Pipeline

Vibe coding is not a software development process.

Fire a prompt, accept the result, ship it. Fast in the same way skipping tests is fast — until something breaks and you can't explain why. The output is plausible-looking code with no validated problem, no verified requirements, no threat model, no acceptance tests, no deployment strategy. One feature. Eleven things that were supposed to happen but didn't.

The Software Factory Agent replaces that with a 12-agent pipeline. One developer runs the chain. Specialized agents handle market research, product scoping, UX design, security, implementation, testing, validation, and deployment — each in its own clean context window with only the tools it needs.

Two modes. Discovery mode (12 agents) validates the market, defines the product, and designs the UX before any engineering starts. Feature mode (9 agents) skips straight to implementation for incremental work on an existing product.

CKA Mock Exam — Complete Questions & Solutions

Exam Rules Reminder

• Use sudo to edit files in /etc/kubernetes/manifests/
• Use sudo for kubelet restart and system-level debugging
• Use documentation links provided in each question
• SSH into the correct node as specified in the question
• Always verify the correct namespace before applying changes

The Karpathy Skill: Four Rules That Make You a Better AI-Era Engineer

Most developers use AI coding assistants wrong.

They fire off a vague prompt, accept the first 200-line response, and then spend the next hour debugging why the "helpful" code broke three other things. The tool is fast — the outcome is slow.

Andrej Karpathy — the Stanford AI researcher who co-founded OpenAI, led Tesla's Autopilot team, and built NanoGPT from scratch — distilled decades of engineering intuition into four rules that are now circulating as a CLAUDE.md template for AI coding assistants. These rules are not about AI. They are about how senior engineers think — and they happen to be exactly what you need to get great results from any AI coding tool in 2026.

This post unpacks every rule with the why, concrete examples, and practical habits you can start using today.