This article explains why LLMs need memory, compares BufferMemory and ConversationSummaryBufferMemory, demonstrates how to build memory‑aware chains with LangChain Expression Language (LCEL), and shows practical examples including translation, RAG, and callbacks for monitoring chain execution.
This article explains how LangChain agents use a ReAct (Reasoning‑Acting) loop to decide when and which tools to invoke, shows built‑in and custom tools via the @tool decorator, compares ReAct with GPT‑4 native tool calling, and demonstrates a research‑assistant workflow that cuts report drafting time from hours to minutes.
This tutorial walks through the complete RAG pipeline—indexing documents into a vector store, retrieving relevant chunks with similarity, Top‑K, and MMR methods, and generating answers using LCEL chains, culminating in a multi‑turn internal knowledge‑base chatbot that cuts query latency below 100 ms.
Because LLMs have limited context windows, the article shows how to feed a 50‑page PDF to an AI by loading the document, splitting it into manageable chunks, converting each chunk into embeddings, storing them in a vector database, and then retrieving the most relevant passages for answering questions.
This article compares raw API calls with LangChain's abstractions, explains when to use ChatModel versus LLM interfaces, demonstrates model selection across providers, shows how to build prompt templates and output parsers, and provides a complete Python example with error‑handling best practices.
This article provides a step‑by‑step guide to using Agent Skills in LangChain DeepAgents, covering the Skills directory structure, the four engineering steps (discovery, system‑prompt injection, progressive loading, execution), and two practical examples—a simple skill lookup and a complex docx‑processing skill—complete with code snippets and troubleshooting tips.
This article breaks down why RAG pipelines often underperform and shows how proper chunking, overlap settings, hybrid vector‑plus‑BM25 retrieval, and a Rerank step can dramatically improve recall and precision, with concrete code examples and tuning tips.
This article systematically explains LangChain’s four fundamental design patterns—Command, Chain of Responsibility, Decorator, and Pipeline—showing their definitions, core implementations, and practical code examples to help developers understand and extend the framework.
The article analyzes Agent memory design by comparing human short‑term and long‑term memory, explains context‑window management strategies, outlines persistent storage options such as vector databases, relational stores, knowledge graphs and fine‑tuning, and presents a three‑layer architecture with write, retrieval and forgetting mechanisms.
This article walks through deploying Milvus with Docker Compose, creating a persistent collection, tuning HNSW indexes, integrating LangChain.js for semantic retrieval, and covering performance tips and common pitfalls to run a production‑grade vector database.
This article analyzes why Retrieval‑Augmented Generation often underperforms, then walks through concrete engineering steps—optimal chunking, overlap settings, hybrid vector + BM25 retrieval, RRF fusion, and reranking—while providing code snippets, parameter tables, and a full pipeline diagram to turn a usable RAG system into a high‑quality one.
This article introduces LangChain’s four core components—Model, Prompt, Chain, and Agent—explains their purposes, shows how to install and configure the library, demonstrates building pipelines with LCEL, and provides code examples for agents, parallel execution, and environment setup.
This article provides a detailed technical analysis of DeerFlow 2.0’s 14‑layer middleware stack, explaining how it extends LangChain’s runnable middleware with an onion‑style responsibility‑chain, compares the design to MyBatis interceptors, and breaks down each middleware’s purpose, implementation details, execution order, and engineering benefits for AI agent frameworks.
The article systematically dissects how Harness’s enterprise‑grade Super Agent architecture leverages LangChain’s component library and LangGraph’s execution engine, detailing dependency relationships, source‑level integration, and a real‑world multimodal customer‑service agent case.
This article explains how embeddings turn text into high‑dimensional vectors, compares commercial and open‑source embedding models, details cosine, Euclidean and inner‑product similarity metrics, reviews common index structures such as Flat, IVF, HNSW and PQ, and shows how to choose and use a vector database with LangChain.js while avoiding typical pitfalls.
This tutorial walks through creating a LangChain‑based AI agent by covering model integration, tool definition with @tool, short‑ and long‑term memory handling via checkpointers and vector stores, and assembling everything with create_agent, middleware, and code examples for a functional travel assistant.
This tutorial explains why document loading and splitting are critical for RAG pipelines, introduces LangChain's Document format, demonstrates loaders for various file types, details the RecursiveCharacterTextSplitter and alternative splitters, and provides practical tips on parameter tuning, metadata preservation, Chinese text handling, and common pitfalls.
This tutorial walks you through installing the uv package manager, configuring OpenAI credentials, running a basic OpenAI SDK example, exploring detailed API request and response fields, and building both blocking and streaming LangChain agents with custom tools and multimodal image inputs.
The article analyzes the shift from proprietary Claude Managed Agents to open‑source frameworks like LangChain Deep Agents Deploy, detailing harness engineering, deployment steps, memory management, and the benefits of an open ecosystem for building production‑ready AI agents.
This article explains why AI can only act on information that appears in its context window, outlines the twin problems of missing data and overload, and presents a practical methodology—including AGENTS.md maps and LangChain's LocalContextMiddleware implementation—to engineer concise, searchable context for reliable agent behavior.
This tutorial walks through the MCP architecture, shows how to install @langchain/mcp-adapters, connect real Amap and Playwright MCP servers to a LangGraph ReAct agent, combine multiple servers, choose between stdio and HTTP transports, and avoid common production pitfalls.
The article explains that Agent Harnesses are essential for managing AI memory and context, argues that closed‑source harnesses give vendors control over user data, outlines three risk levels of memory lock‑in, and advocates open, user‑controlled harnesses such as OpenClaw and Deep Agents.
This article provides a practical selection guide for developers building AI agents in 2026, dissecting the design, core components, strengths, and limitations of four major frameworks—LangChain, LlamaIndex, LangGraph, and AutoGen—while offering use‑case recommendations, code examples, and a decision‑tree to help choose the most suitable tool.
This article walks through a complete, production‑ready Retrieval‑Augmented Generation pipeline that lets AI answer a company’s private documents, covering chunking strategies, embedding model choices, vector‑database selection, retrieval methods, full LangChain chain assembly, and common pitfalls to avoid.
Harness Agent is an AI engineering framework that combines a large language model with a runtime control system—called the Harness—to provide task planning, sandboxed execution, tool integration, memory management, safety guardrails, and observability, turning raw model capabilities into reliable, production‑grade agents.
The article explains how Agent Harnesses tightly bind an LLM agent's memory, why using closed‑source Harnesses hands control of that memory to third‑party APIs, and argues that open‑source Harnesses are essential for retaining data ownership and avoiding lock‑in.
This article explains how AI agents often stall, repeat mistakes, or diverge on complex tasks, argues that the missing piece is a well‑designed harness, and demonstrates with real‑world case studies from OpenAI, LangChain, and Anthropic how a six‑component harness can boost performance by over 13 percentage points and enable million‑line code generation.
This article explains how LLMs use Function Calling to output structured JSON for tool execution, walks through the full multi‑turn tool call loop, shows how LangChain standardizes disparate vendor APIs with BaseTool and bind_tools, and shares practical pitfalls, best‑practice guidelines, and security considerations for building robust agents.
The article breaks down how to build a three‑layer memory architecture for AI agents—short‑term context windows with sliding‑window summarization, long‑term semantic retrieval via vector databases with selective storage and time decay, and a knowledge‑graph layer for relational reasoning—plus implementation tips and common pitfalls.
This tutorial walks through LCEL’s pipe operator and its underlying RunnableSequence, then demonstrates sequential, parallel, and lambda‑based chains, shows how to preserve context with RunnablePassthrough/Assign, compares invoke/stream/batch execution modes, and provides a complete production‑grade RAG chain with common pitfalls and a self‑check checklist.
The article walks through a medical triage AI Agent built with LangChain, LangGraph, and LangSmith, showing how the framework supplies core model and tool interfaces, how graph‑based orchestration manages complex branching, loops and human‑in‑the‑loop steps, and how tracing and evaluation prove reliability for product managers.
This article explains the ReAct pattern—interleaving reasoning and acting for LLM agents—by defining its core loop, comparing it with plain tool‑calling, providing a step‑by‑step hand‑written implementation in JavaScript, showing the LangChain.js wrapper, streaming output, and detailing five common pitfalls and a pre‑deployment checklist.
The article explains LCEL’s core design and the Runnable interface, showing how they unify prompts, models, and parsers into a single composable chain with built‑in streaming, batch, async support, parallel execution, type inference, and automatic tracing, illustrated with TypeScript examples.
After two weeks of failed RAG queries caused by fragmented tables, multi‑column layouts, and poor OCR, the author switched from open‑source PDF parsers to the commercial TextIn xParse engine, boosting retrieval accuracy from under 30% to over 95% and sharing practical integration tips.
The article explains why LLMs often produce malformed JSON, categorizes three common failure types, and walks through modern solutions—including withStructuredOutput + Zod, JsonOutputParser, and OutputFixingParser—plus a decision tree to choose the right approach for production use.
The article analyzes why LLMs often return unstructured text, compares LangChain's OutputParser and withStructuredOutput approaches, evaluates their stability, token usage, and model compatibility, and provides a decision guide and best‑practice recommendations for production‑grade structured output in 2025.
This article presents ten concrete techniques—including in‑memory and Redis caching, semantic caching, parallel execution, batch processing, prompt compression, model routing, streaming output, and connection‑pool reuse—to dramatically reduce latency and token costs in production LangChain applications.
This article explains how to make LangChain applications robust by using built‑in retry mechanisms, model fallbacks, tool exception handling, input validation, output‑fixing parsers, and callback monitoring, each illustrated with concrete code examples and practical recommendations.
This article explains DeepAgents SubAgent mechanisms, showing how context isolation and task division improve complex agent workflows, details two creation methods (dictionary‑based and compiled), demonstrates a search‑and‑report demo, and outlines suitable and unsuitable scenarios with practical code examples.
This tutorial walks through designing and implementing a dual‑stack memory architecture for AI agents—combining episodic vector‑based situational memory with graph‑based semantic memory—using LangChain, FAISS, and Neo4j, and demonstrates a complete end‑to‑end workflow with code examples.
Deep Agents, an open‑source framework built on LangChain and LangGraph, provides a ready‑to‑use agent harness with planning, file‑system tools, sandboxed shell access, sub‑agents, automatic context management, and built‑in observability for Python and TypeScript developers seeking a flexible replacement for Claude Code.
The article demonstrates how a monolithic LLM struggles with multi‑dimensional market analysis and shows, through step‑by‑step code, how assembling specialized AI agents for news, technical and financial analysis yields clearer structure, deeper insight, and higher evaluation scores.
This article explains the planning architecture for AI agents, contrasts it with the ReAct approach, provides step‑by‑step Python code using LangChain and LangGraph, evaluates both methods on task completion and process efficiency, and discusses when each architecture is most suitable.
This step‑by‑step tutorial shows how to create a functional AI development‑assistant agent using Spring Boot, LangChain4j, and LangGraph, covering environment setup, tool, state, and workflow definitions, API exposure, testing, Docker packaging, and optional enhancements.
This article introduces the background and key advantages of the DeepAgents framework, explains its four core capabilities—task planning, context management, sub‑agent generation, and long‑term memory—and provides a step‑by‑step code example that builds a complex AI agent with just a few lines of Python.
This guide presents an end‑to‑end solution for creating a test‑focused AI agent that indexes project code and defect data, integrates a large language model via LangChain, generates compliant Pytest cases, parses Allure reports, and offers deployment tips for seamless PyCharm integration.
This article explains why large language models alone can hallucinate, introduces the tool‑using agent architecture, and provides a step‑by‑step Python tutorial using LangChain, LangGraph, and Tavily to create, run, and evaluate a real‑time web‑search capable AI assistant.
This article analyzes the sources of LLM output uncertainty, explores hardware and architectural constraints, demonstrates how to build robust AI agents with prompt engineering, tool orchestration, and memory management, and compares traditional micro‑service design with modern LLM‑centric workflows.
The article analyzes how most RAG pipelines blindly feed retrieved documents to LLMs, introduces CRAG's lightweight evaluator with confidence thresholds, describes its sentence‑level decomposition, filtering, and dual‑knowledge routing, and provides a full implementation walkthrough with a real insurance query example.
This article explores the Learn Claude Code website, breaking down the universal agent loop into twelve incremental versions, demonstrating language‑agnostic implementations in Python and Java, and detailing progressive capabilities—from basic tool integration to memory compression, concurrency, and multi‑agent collaboration.
The article explains that the term “Agent development” hides a fundamental split between Agent Frameworks, which give developers building blocks to assemble their own agents, and Agent Harnesses, which provide ready‑to‑run agents, and shows how this distinction affects decisions, maintenance, and troubleshooting.
The article explains Agent Engineering—a systematic approach that turns nondeterministic large‑language‑model agents into reliable production‑grade applications through an iterative build‑test‑deploy‑observe‑improve loop, combining product, engineering, and data‑science thinking to address unpredictability and achieve continuous growth.
This article explains the role of memory modules in Retrieval‑Augmented Generation systems, compares short‑term and long‑term memory techniques, outlines storage and retrieval methods, discusses management strategies like forgetting and deduplication, and compares LangChain and LlamaIndex implementations for practical deployment.
This article explains why AI agents need a memory‑management solution, introduces LangChain DeepAgents' FileSystem middleware, details its four backend options for short‑term, long‑term, disk‑based, and hybrid storage, and provides step‑by‑step Python examples for installing, configuring, and using the middleware in real‑world scenarios.
This tutorial walks beginners through Python fundamentals, LangChain installation, core components like prompt templates, chains, and retrieval, and culminates in a complete intelligent customer‑service chatbot, showing step‑by‑step code and practical tips for building AI applications.
The article explains how Agent Frameworks and Agent Harness occupy different points on an opinionated spectrum, detailing their abstractions, built‑in components, trade‑offs, and when to choose each, with examples like OpenClaw, LangChain, and Deep Agents.
The author demonstrates a practical RAG workflow that tames large‑model hallucinations by cleaning and chunking company documents, storing them in a vector database, and using LangChain or LlamaIndex with OpenAI embeddings and GPT‑4, while highlighting common pitfalls and tuning tips.
This article walks through LangChain DeepAgents' Tool Selector and Todo List middleware, detailing why they are needed, how they streamline tool usage and task planning, and provides step‑by‑step Python examples that demonstrate improved performance on complex multi‑tool tasks.
This guide walks you through installing Ollama, downloading the qwen3:4b model, and using Python’s async client to perform streaming chat requests, then shows how to integrate the same model with LangChain, including setup, initialization, and both regular and streaming output examples.
This article shows QA engineers how to build a Python semantic validator using Claude AI and LangChain, demonstrating rule‑based checks, a concrete e‑commerce example, performance tricks, and cost estimates to catch logical inconsistencies that traditional schema validators miss.
This article explains how LangChain DeepAgents' Summarization middleware automatically compresses conversation history to overcome large‑model context window limits, detailing its core mechanism, applicable scenarios, configuration parameters (trigger, keep, model, summary_prompt), and step‑by‑step Python examples that illustrate its integration and internal message flow.
This article introduces LangChain's DeepAgents framework, explains its design goals, compares it with LangChain and LangGraph, and provides a step‑by‑step code walkthrough that demonstrates task planning, sub‑agent delegation, tool usage, and result generation for building complex AI agents with just a few lines of code.
This guide outlines the key competencies for generative AI professionals and curates a focused reading list—covering NLP fundamentals, software engineering, LLM libraries, vector databases, and multimodal AI—to help readers build practical expertise and deploy impactful AI solutions.
This tutorial walks through adding Retrieval‑Augmented Generation (RAG) and persistent long‑term memory to a LangGraph AI agent, covering concepts, step‑by‑step code for document loading, vector store creation, prompt engineering, memory management, and best‑practice pitfalls.
The article demonstrates how sharding a knowledge base and using decentralized retrieval can improve both latency (28% faster) and answer precision for AI agents, contrasting a monolithic RAG setup with a dual‑shard implementation that isolates engineering and marketing domains.
This article explains design patterns that boost the reliability of modern agentic AI systems, focusing on a parallel hybrid search fusion that runs vector and keyword retrievals concurrently, merges their results, and demonstrates through code and benchmarks that the combined approach yields more accurate and complete answers than either method alone.
This article demonstrates how parallel hybrid search—combining vector and keyword retrieval—enhances the reliability of agentic AI systems by delivering complete, high‑fidelity context compared with using either method alone.
This article presents a high‑reliability design pattern for agentic AI—parallel query expansion—detailing its Pydantic model, LangGraph workflow, concurrent execution with ThreadPoolExecutor, and a comparative experiment that shows improved recall and answer quality over a simple RAG pipeline.
This article explains how sharding a knowledge base and using decentralized retrieval can boost the reliability, precision, and latency of AI agents, providing code examples, a LangGraph workflow, and a performance comparison that shows a 28% speed gain over a monolithic setup.
The article presents a high‑reliability design pattern for AI agents that uses parallel query expansion to generate diverse search queries, executes them concurrently with ThreadPoolExecutor, and demonstrates through a side‑by‑side RAG comparison that this approach markedly improves recall and answer quality.
This article explains Retrieval‑Augmented Generation (RAG), detailing its offline knowledge‑base construction and online retrieval‑enhanced generation workflow, comparing it with traditional and fine‑tuned models, and providing step‑by‑step LangChain implementations, advanced techniques, and practical use‑case demos.
This article introduces the decentralized blackboard collaboration pattern for building reliable agentic AI systems, explains its shared data space and specialist agents, demonstrates a customer‑support ticket workflow with analyzer, retriever, and draftsman agents, and highlights benefits such as error reduction, deeper specialization, and auditability.
This article introduces the Agent Assembly Line pattern—a three‑stage, parallel pipeline built with Pydantic models and ThreadPoolExecutor—to boost the throughput of AI agent systems, provides full implementation code, and demonstrates a 206% performance gain over a sequential approach.
This article walks through a reliability‑focused design pattern for agentic AI—competitive agent ensembles—by initializing diverse LLMs, defining structured Pydantic models, creating parallel competitor nodes, evaluating their outputs with a judge node, and demonstrating a 63% speedup and higher quality results.
This article explains AI agents as autonomous systems that perceive environments, set goals, and act, contrasting them with traditional AI, detailing their core definition, architecture, key components, practical applications, implementation steps, classification, technology stack, case studies, emerging trends, challenges, and future directions.
The article analyzes why AI agents need isolated sandboxes, outlines two architectural patterns—running the agent inside a sandbox or using the sandbox as an external tool—compares their advantages and challenges, and provides concrete implementation examples and community insights.
The article presents a step‑by‑step design and implementation of a Claude‑style Skills mechanism for LangChain agents, using a double‑layer tool architecture, state‑driven dynamic filtering, and middleware interception to load only relevant tools, dramatically reducing token consumption and improving decision quality and response speed.
LangChain's Deep Agents framework provides a batteries-included architecture for building complex LLM agents with built-in planning, filesystem access, shell execution, sub-agent delegation, smart default prompts, and context management, enabling long-running, multi-step tasks like coding and research.
This article explains the predictive‑execution design pattern for agentic AI, showing how to launch tool calls speculatively in parallel with LLM reasoning, provides a full Python implementation using LangChain, and demonstrates a 28% latency reduction compared with a sequential workflow.
This article explains why large‑language‑model hallucinations are risky, introduces Retrieval‑Augmented Generation (RAG) as a remedy, and walks through nine Python‑based RAG architectures—standard, conversational, corrective, adaptive, fusion, HyDE, self‑RAG, agentic, and graph RAG—detailing their workflows, code examples, strengths, weaknesses, and a decision‑making map for selecting the right design.
This article provides an in‑depth comparison of nine mainstream AI agent development frameworks—Pydantic AI, SmolAgents, DeepAgents, LlamaIndex, CAMEL, AutoGen, CrewAI, LangGraph, and OpenAI Agents SDK—detailing their design principles, strengths, weaknesses, typical scenarios, and guidance for selecting or mixing them in production.
This guide walks through the MemOS open‑source memory framework, showing how to create a graph‑based memory ChatBot, add and retrieve memories incrementally, enable asynchronous memory reorganization, and seamlessly integrate the system into LangChain 1.x agents using middleware.
This guide explains how Apache AGE extends PostgreSQL with OpenCypher‑compatible graph capabilities, covering architecture, installation, storage schema, Cypher‑SQL integration, common graph operations, and a LangChain example that turns natural‑language questions into executable graph queries.
The article explains why traditional chat‑based AI tools are limited to advice, introduces next‑generation LLM‑native applications that can understand, plan, and act, and provides a step‑by‑step guide on designing AI workflows, autonomous agents, hybrid architectures, and the Model Context Protocol (MCP) using LangChain.
This article explains how to bring Anthropic's Skills concept into the open‑source LangChain DeepAgents framework by detailing the discovery, system‑prompt injection, progressive loading, and execution phases, and provides a complete code‑driven example using a web‑research Skill.
This article walks through creating a Retrieval‑Augmented Generation (RAG) powered Q&A service in Java using Spring AI, covering the rationale for choosing Spring AI over LangChain, required environment, Maven setup, configuration, document ingestion, Advisor‑based query handling, testing, and practical limitations of RAG implementations.
LangChain 1.0 replaces fragmented agent code with a production‑ready framework that unifies model outputs, simplifies tool integration, introduces content_blocks for consistent response handling, and adds a middleware system for privacy, summarization, and human‑in‑the‑loop safety, dramatically improving developer efficiency and reliability.
This tutorial walks through the complete development of an automatic email‑processing agent using LangGraph 1.0, covering scenario analysis, state design, node implementation, graph assembly, and testing with both high‑priority bug reports and routine greeting emails, while demonstrating state management, conditional routing, and human‑in‑the‑loop controls.
This article introduces Retrieval-Augmented Generation (RAG), covering its origins, core components (retriever and generator), advantages like reduced hallucination and knowledge updatability, architectural challenges such as chunk sizing and vector search algorithms, and provides a step-by-step LangChain implementation using FAISS, SentenceTransformer, and DeepSeek.
This article introduces LangGraph 1.0 as a programming‑language‑style framework for AI agents, explains its core abstractions—State, Node, Edge, Reducer, and Human‑in‑the‑Loop—shows how to define state and node functions, builds simple and parallel graphs with static, conditional, and MapReduce edges, and demonstrates conflict‑resolution using built‑in and custom reducers.
This article details how we built an AI‑tool ecosystem by evolving a basic online JS cloud‑function platform into a unified, reusable capability layer that integrates with Flowise, LangChain StructuredTool, and the Model Context Protocol (MCP) to provide secure, cross‑platform tool calls for agents.
This article walks through a three‑step Vibe‑Coding workflow—structured prompt creation, prompt optimization with DeepSeek, and precise bug‑fix guidance—to automatically generate, refine, and extend a React + TypeScript front‑end for a multimodal RAG system using Trae Solo, covering architecture, streaming chat, and PDF citation features.
This article explains how AI agents transform traditional data governance by introducing a four‑layer perception‑decision‑execution‑learning architecture, detailing the required technologies, tool integrations, code examples, deployment steps, team roles, security safeguards, and practical rollout strategies for enterprises seeking automated, intelligent data management.
This article demonstrates how to use ByteDance's Trae Solo to automatically generate a FastAPI service that wraps a LangChain/LangGraph weather‑assistant agent, enabling seamless OpenAI‑style access from the Chatbox client, with step‑by‑step code, testing, and deployment details.
This article walks through building a LangChain‑based multimodal RAG system that parses PDFs (both native and scanned), splits them into semantic chunks, stores embeddings in a vector database, and generates answers with precise source citations, complete with code samples and API integration.
After spending $47,000 running four LangChain agents in production, we reveal the hidden costs of A2A communication and Anthropic’s MCP, expose seven common deployment pitfalls, and argue that dedicated AI infrastructure is essential for scalable multi‑agent systems.
This tutorial extends a LangChain 1.0 multimodal RAG project by adding end‑to‑end image analysis and audio transcription features using Qwen3‑Omni, detailing data structures, utility classes, API changes, and Postman testing procedures.
This tutorial walks through the fundamentals of large language models, prompt engineering, and word embeddings, then shows how to set up a LangChain‑based LLM stack in Java using LangChain4j, covering core modules, memory, retrieval, chains, agents, and complete code examples.
DeepAgents, the new open‑source agent framework from LangChain, extends LangChain and LangGraph with built‑in task planning, virtual file systems, long‑term memory and sub‑agent support, and this article walks through its architecture, core capabilities, detailed code examples, and future roadmap.