LangChain

LangChain is an open-source framework for developing applications that use large language models (LLMs). It provides a unified set of abstractions (models, embeddings, vector stores, chains, agents, memory, callbacks) and over 250 integrations, enabling the rapid construction, debugging, and deployment of complex LLM systems, including chatbots, RAG search engines, and agentic solutions.

History

• October 2022 — First public release as an open-source project by creator Harrison Chase, then an employee at Robust Intelligence.
• April 2023 — LangChain Inc. is founded, securing over $20 million in funding in a $20–25 million round from Sequoia (a rapidly disclosed "pre-empt" investment) at a valuation of ~$200 million, following an earlier $10 million seed round from Benchmark.
• August 2023 — Release of LangChain Expression Language (LCEL), a declarative syntax for building chains.
• October 2023 — LangServe is announced, a library for deploying LCEL chains as production-ready APIs via FastAPI.
• 2024–2025 — The ecosystem is expanded with services like LangSmith (a platform for tracing, metrics, and A/B testing) and LangGraph (for orchestrating multi-agent workflows); the number of stars on GitHub exceeds 100,000.

LangChain Capabilities

• Reasoning Chains (Chains). LangChain allows for the creation of sequences of steps, where each step performs a specific task. These steps can include interacting with a model, processing its output, searching for additional information, and other operations. This approach enables the creation of complex workflows consisting of multiple stages.
• Agents. Agents in LangChain are programs that can dynamically choose actions depending on the situation. For example, an agent can decide which tool to use (e.g., web search, database query, computation) based on the current context and intermediate results.

• Tools. LangChain includes integrations with over 250 external tools and services. This allows models to work with various data sources, such as databases, APIs, and file management systems, as well as execute actions via the command line.

• Memory and Context (Memory). LangChain supports long-term memory, allowing models to "remember" information between interactions. This is particularly important for creating chatbots or applications that need to remember the context of user interactions and consider this history in subsequent responses.

• Retrieval-Augmented Generation (RAG). Within the RAG approach, LangChain utilizes not only text generation but also the retrieval of additional information from real-world sources (e.g., databases or websites). This enables models to provide more accurate and well-founded answers based on up-to-date data.
• Debugging and Observability (Callbacks & Tracing). To ensure transparency and control over the model's process, LangChain provides tracing and monitoring capabilities. This makes it possible to track what data the model is using, what intermediate steps it is performing, and to collect performance metrics to improve the system's quality.

• Platform Extensions. LangChain includes additional components like LangSmith and LangGraph, which provide capabilities for centralized monitoring, A/B testing, and managing multi-agent workflows. LangSmith helps analyze model performance and conduct testing, while LangGraph allows for managing complex, multi-step tasks and tracking their execution in real-time.

LangSmith

LangSmith [6] — is a cloud platform designed for tracking, analyzing, and optimizing applications that use large language models (LLMs), particularly those built with LangChain. LangSmith provides a range of capabilities for monitoring and improving the quality of LLM-powered applications, including performance tracking, testing, and evaluation.

• Tracing: Allows for tracking all model interactions, including inputs, outputs, and intermediate results.
• Metrics and Performance: Collects statistics on response time, token count, and other parameters to evaluate model performance.
• A/B Testing: Supports the comparison of different model versions or settings to select the most effective ones.
• Human-in-the-loop: Involves experts to evaluate and correct model results, improving its accuracy.
• Integrations with other frameworks: Provides support for integration with various platforms for monitoring and application analysis.

• Multi-task support: Allows for tracking and managing multiple tasks simultaneously within a single project.

LangGraph

LangGraph [7]— is a tool for orchestrating complex multi-step and multi-agent workflows, used within the LangChain ecosystem. LangGraph provides a platform for creating and managing complex logical chains and tasks that involve multiple agents or execution stages.

• Multi-step workflows: Builds complex task chains where each step depends on the previous ones.
• Cycles and branching: Supports returning to previous stages (backtracking) and making decisions based on different paths.
• Version control and "time travel": Provides control over changes in the workflow and the ability to revert to previous versions.
• Multi-agent systems: Allows for managing multiple agents working in parallel or sequentially to perform different tasks.
• Support for hybrid solutions: Integrates various data processing and inference methods within a single workflow.

• Flexible integration with external systems: Easily connects external services and systems, such as APIs and databases, into workflows.

LangChain Expression Language (LCEL)

LangChain Expression Language (LCEL) [8]— is a declarative DSL framework for composing Runnable objects (chains, agents, handlers). It is expressed using the | (pipe) operator, which allows describing what should happen rather than how to implement it step-by-step. The declarative style (what-to) describes the desired outcome, and the system itself decides how to achieve it. LCEL is an orchestration mechanism that allows LangChain to optimally execute chains at runtime.

• For simple chains (e.g., prompt → LLM → parser or simple extraction), LCEL is well-suited.
• However, if complex logic is required—such as branching, loops, multiple agents, and complex state management—LangGraph is recommended. Within the graph's nodes, LCEL can still be used.

• If only a single LLM call is needed, LCEL is unnecessary; a direct model call is sufficient.
• For a simple chain, LCEL is quite suitable and allows you to leverage its benefits.

• For complex chains, LangGraph is used, with the option to apply LCEL internally where appropriate.

Typical Use Cases

LangChain can be used to solve a wide range of tasks, such as:

• Chatbots: Creating intelligent assistants that can interact with users, answer questions, and work with external data sources.
• Autonomous agents: Developing systems that can perform specific tasks without human intervention, such as information gathering or report generation.
• Data search and analysis: Building systems for semantic search and document analysis, which can be useful for working with legal, financial, and other types of data.
• Business process automation: Creating solutions to automate data processing, report generation, and other routine tasks.

See also

• AI Agent
• Toolformer
• AutoGPT
• Vector database

Literature

• Yao, S. et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
• Hong, S. et al. (2023). MetaGPT: Meta Programming for a Multi-Agent Collaborative Framework. arXiv:2308.00352.
• Li, G. et al. (2023). CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society. arXiv:2303.17760.
• Wu, Q. et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. arXiv:2308.08155.
• Liu, X. et al. (2023). AgentBench: Evaluating LLMs as Agents. arXiv:2308.03688.
• Chen, W. et al. (2023). AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors. arXiv:2308.10848.
• Yao, S. et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601.
• Shinn, N. et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366.
• Wang, L. et al. (2025). A Survey on Large Language Model Based Autonomous Agents. arXiv:2308.11432.
• Guo, T. et al. (2024). Large Language Model Based Multi-Agents: A Survey of Progress and Challenges. arXiv:2402.01680.
• Li, X. (2025). LLMs Working in Harmony: A Survey on the Technological Aspects of Building Effective LLM-Based Multi-Agent Systems. arXiv:2504.01963.
• Duan, Z.; Wang, J. (2024). Exploration of LLM Multi-Agent Application Implementation Based on LangGraph + CrewAI. arXiv:2411.18241.
• Wang, J. & Duan, Z. (2024). Agent AI with LangGraph: A Modular Framework for Enhancing Machine Translation Using Large Language Models. arXiv:2412.03801.
• Camargo da Silva, T. (2025). Extracting Knowledge Graphs from User Stories using LangChain. arXiv:2506.11020.
• Wang, Z. et al. (2024). Poisoned LangChain: Jailbreak LLMs by LangChain. arXiv:2406.18122.