Category
ai agents
22 articles across 7 sub-topics
LangChain Tools and Agents: The Classic Agent Loop
šÆ Quick TLDR: The Classic Agent Loop TLDR: LangChain's @tool decorator plus AgentExecutor give you a working tool-calling agent in about 30 lines of Python. The ReAct loop ā Thought ā Action ā Observation ā drives every reasoning step. For simple l...
LangChain 101: Chains, Prompts, and LLM Integration
TLDR: LangChain's LCEL pipe operator (|) wires prompts, models, and output parsers into composable chains ā swap OpenAI for Anthropic or Ollama by changing one line without touching the rest of your code. š One LLM API Today, Rewrite Tomorrow: The...
From LangChain to LangGraph: When Agents Need State Machines
TLDR: LangChain's AgentExecutor is a solid starting point ā but it has five hard limits (no branching, no pause/resume, no parallelism, no human-in-the-loop, no crash recovery). LangGraph replaces the implicit loop with an explicit graph, unlocking e...
LangGraph Tool Calling: ToolNode, Parallel Tools, and Custom Tools
TLDR: Wire @tool, ToolNode, and bind_tools into LangGraph for agents that call APIs at runtime. š The Stale Knowledge Problem: Why LLMs Need Runtime Tools Your agent confidently tells you the current stock price of NVIDIA. It's from its training d...
Streaming Agent Responses in LangGraph: Tokens, Events, and Real-Time UI Integration
TLDR: Stream agents token by token with astream_events; wire to FastAPI SSE for zero-spinner UX. š The 25-Second Spinner: Why Streaming Is a UX Requirement, Not a Nice-to-Have Your agent takes 25 seconds to respond. Users abandon after 8 seconds....
The ReAct Agent Pattern in LangGraph: Think, Act, Observe, Repeat
TLDR: ReAct = Think + Act + Observe, looped as a LangGraph graph ā prebuilt or custom. š The Single-Shot Failure: Why One LLM Call Isn't Enough for Complex Tasks Your agent is supposed to write a function, run the tests, fix the failures, and re...
Multi-Agent Systems in LangGraph: Supervisor Pattern, Handoffs, and Agent Networks
TLDR: Split work across specialist agents ā supervisor routing beats one overloaded generalist every time. š The Context Ceiling: Why One Agent Can't Do Everything Your research agent is writing a 20-page report. It has 15 tools. Its context windo...
LangGraph Memory and State Persistence: Checkpointers, Threads, and Cross-Session Memory
TLDR: Checkpointers + thread IDs give LangGraph agents persistent memory across turns and sessions. š The Amnesia Problem: Why Stateless Agents Frustrate Users Your customer support agent is on its third message with a user. The user says: "As I ...
Human-in-the-Loop Workflows with LangGraph: Interrupts, Approvals, and Async Execution
TLDR: Pause LangGraph agents mid-run with interrupt(), get human approval, resume with Command. š The Autonomous Agent Risk: When Acting Without Permission Goes Wrong Your autonomous coding agent refactored the authentication module while you were...
LangGraph 101: Building Your First Stateful Agent
TLDR: LangGraph adds state, branching, and loops to LLM chains ā build stateful agents with graphs, nodes, and typed state. š The Stateless Chain Problem: Why Your Agent Forgets Everything You built a LangChain chain that answers questions. Then y...
Skills vs LangChain, LangGraph, MCP, and Tools: A Practical Architecture Guide
TLDR: These are not competing ideas. They are layers. Tools do one action. MCP standardizes access to actions and resources. LangChain and LangGraph orchestrate calls. Skills package business outcomes with contracts, guardrails, and evaluation. Most ...
Multistep AI Agents: The Power of Planning
TLDR: A simple ReAct agent reacts one tool call at a time. A multistep agent plans a complete task decomposition upfront, then executes each step sequentially ā handling complex goals that require 5-10 interdependent actions without re-prompting the ...
'The Developer''s Guide: When to Use Code, ML, LLMs, or Agents'
TLDR: AI is a tool, not a religion. Use Code for deterministic logic (banking, math). Use Traditional ML for structured predictions (fraud, recommendations). Use LLMs for unstructured text (summarization, chat). Use Agents only when a task genuinely ...
AI Agents Explained: When LLMs Start Using Tools
TLDR: A standard LLM is a brain in a jar ā it can reason but cannot act. An AI Agent connects that brain to tools (web search, code execution, APIs). Instead of just answering a question, an agent executes a loop of Thought ā Action ā Observation unt...
Build vs Buy: Deploying Your Own LLM vs Using ChatGPT, Gemini, and Claude APIs
TLDR: Use the API until you hit $10K/month or a hard data privacy requirement. Then add a semantic cache. Then evaluate hybrid routing. Self-hosting full model serving is only cost-effective at > 50M tokens/day with a dedicated MLOps team. The build ...
Step-by-Step: How to Expose a Skill as an MCP Server
TLDR: Turn any Python function into a multi-client MCP server in 11 steps ā from annotation to Docker. š The Copy-Paste Problem: Why Skills Die at IDE Boundaries A developer pastes their summarize_pr_diff function into a Slack message because thei...
Deploying LangGraph Agents: LangServe, Docker, LangGraph Platform, and Production Observability
TLDR: Swap InMemorySaver ā PostgresSaver, add LangServe + Docker, trace with LangSmith. š The Demo-to-Production Gap: Why Notebook Agents Fail at Scale Your LangGraph agent works perfectly in the demo. You deploy it to a single FastAPI instance. ...
Headless Agents: Deploy Skills as MCP Servers ā Full Guide from Concept to Three Clients
TLDR: Build an MCP server once and call it from Cursor, Claude Desktop, and VS Code without rewrites ā this guide takes you from a single Python function to a containerized, authenticated, three-client deployment in 11 concrete steps. š The Trappe...
LLM Skills vs Tools: The Missing Layer in Agent Design
TLDR: A tool is a single callable capability (search, SQL, calculator). A skill is a reusable mini-workflow that coordinates multiple tool calls with policy, guardrails, retries, and output structure. If you model everything as "just tools," your age...
LLM Skill Registries, Routing Policies, and Evaluation for Production Agents
TLDR: If tools are primitives and skills are reusable routines, then the skill registry + router + evaluator is your production control plane. This layer decides which skill runs, under what constraints, and how you detect regressions before users do...
RAG vs Fine-Tuning: When to Use Each (and When to Combine Them)
TLDR: RAG gives LLMs access to current knowledge at inference time; fine-tuning changes how they reason and write. Use RAG when your data changes. Use fine-tuning when you need consistent style, tone, or domain reasoning. Use both for production assi...