Skip to main content
Hello and welcome back. Before we dive deeper into LangChain’s core concepts, this lesson provides a high-level map of the LangChain ecosystem — practical tips and pointers to help you navigate its libraries and integrations. At a glance, LangChain is organized across multiple libraries and a growing ecosystem. To reason about it as a developer, it helps to separate the stack into three layers you’ll encounter repeatedly:
  1. LangChain Core
    • LangChain Core is the runtime and the set of base abstractions. It provides the execution environment for chains, agents, tools, and other high-level constructs.
    • Core defines interfaces and base classes that concrete implementations must follow.
    • One of the most powerful features in Core is LCEL (LangChain Expression Language), which you’ll study later in the course. LCEL expresses runtime behavior and wiring between components.
The image is a diagram titled "Understanding LangChain Libraries," featuring LangChain Core at the center connected to "LangChain Expression Language (LCEL)," "Interfaces," and "Base Abstractions."
  1. LangChain Community (third-party integrations)
    • The community packages provide concrete implementations that satisfy Core’s abstractions: LLM provider adapters, vector database connectors, document loaders, retrievers, and many tools.
    • Use these community integrations to connect to providers such as OpenAI, Anthropic, Cohere, Amazon Bedrock, Azure OpenAI, and Google Vertex AI. These packages implement the interfaces and base classes defined in LangChain Core.
The image shows a diagram of various LLM providers connected to LangChain Core, including Anthropic, Cohere, Amazon Bedrock, Azure OpenAI, and Google Vertex AI.
  1. LangChain (the primary library implementation)
    • The main LangChain library builds on Core by providing ready-to-use implementations of many abstractions: chains, agents, retrieval strategies, and other high-level building blocks used to assemble an application’s cognitive architecture.
    • In practice, you’ll use the primary LangChain package for application-level components and community packages to plug in provider-specific implementations (LLMs, vector DBs, loaders, etc.).
In short: LangChain Core defines the runtime and abstract building blocks (including LCEL). Community packages implement those abstractions for specific providers and tools. The primary LangChain library offers concrete, opinionated implementations so you can compose chains, agents, and retrieval workflows without reimplementing core logic. Callouts and quick guidance
When architecting a LangChain application, think in layers: design your logic against Core abstractions (chains, retrievers, tools), then swap community integrations (LLMs, vector DBs, loaders) to suit your provider, budget, and latency requirements. This yields portable, testable code.
Summary table — Layers at a glance When to use each layer
  • Use Core when defining architecture and writing code against abstract interfaces so components can be swapped easily.
  • Use Community packages to integrate the specific LLMs, vector stores, or data loaders you need.
  • Use the primary LangChain library for fast iteration and production-ready building blocks (chains, tools, agents) that wire Core abstractions together.
This structure becomes clearer once you study LCEL, runtime behavior, and concrete usage examples. For further reading and provider documentation, see the links below. Links and references

Watch Video