OpenWikilangchain-ai/langchain

Overview

Purpose and Scope

LangChain presents itself as the agent engineering platform: a framework for building agents and other applications powered by large language models. The top-level README frames the project around interoperable components, third-party integrations, and abstractions that help teams keep application decisions flexible while model providers and infrastructure evolve. For a new reader, the most important orientation is that LangChain is not just a single helper library. It is a Python ecosystem centered on agent development, model access, integration packages, observability, deployment paths, and lower-level primitives that can be reused across many application shapes.

Sources: README.md, libs/langchain_v1/README.md

The repository is organized as a monorepo under the libs directory. That layout matters because the public package named langchain is only one part of the codebase. The monorepo README identifies core primitives, the current main LangChain package, the classic package, partner integrations, standardized integration tests, and text splitter utilities as separate package areas. This structure lets maintainers version and document foundational interfaces independently from higher-level agent conveniences and provider-specific implementations. When you are looking for behavior, start by deciding whether you need the main agent-facing package, a base abstraction, a maintained partner integration, or legacy functionality.

Sources: libs/README.md

Relevant Source Files

  • README.md — Provides the repository-level product positioning, quickstart command, minimal model invocation example, ecosystem links, and the main reasons to use LangChain.
  • libs/README.md — Explains the monorepo package layout, including core primitives, the main langchain package, classic functionality, partner integrations, standardized tests, and text splitters.
  • libs/langchain_v1/README.md — Documents the current langchain package, its installation command, recommended use cases, relationship to LangGraph, and documentation entry points.
  • libs/core/README.md — Documents langchain-core as the base abstraction package that powers the ecosystem and explains its modularity, stability, and provider-interface role.

Package Map

The current langchain package, described in the langchain_v1 package README, is the recommended starting point for quickly building agents and autonomous applications. It is positioned as the easiest way to connect to model providers such as OpenAI, Anthropic, Google, and others while relying on a pre-built agent architecture. The same README also explains the boundary with LangGraph: use LangChain for fast agent development and use LangGraph when a workload needs lower-level orchestration, deterministic and agentic workflow mixing, heavy customization, or carefully controlled latency. LangChain agents are built on LangGraph, but basic LangChain users do not need to learn LangGraph first.

Sources: libs/langchain_v1/README.md

LangChain Core is the foundation package. Its README describes it as the home of the base abstractions that power the ecosystem, designed to be modular, simple, and independent of any one model provider. This package is important for integration authors because a provider can implement the required interfaces and then work with the rest of the LangChain ecosystem. For application authors, Core explains why the higher-level packages feel consistent across models, embeddings, vector stores, messages, tools, and other components: the surface area is organized around shared contracts rather than one vendor’s API shape.

Sources: libs/core/README.md

The monorepo also keeps a package area for langchain-classic, but the overview should treat it as a compatibility and legacy location rather than the default entry point. The monorepo README names langchain as the current package and lists langchain-classic separately. The classic README describes legacy chains, community re-exports, the indexing API, deprecated functionality, and related compatibility surfaces, while recommending that most users choose the main langchain package. This distinction helps readers avoid starting new projects on older abstractions while still finding maintained paths for migration, indexing, and existing applications that depend on historical APIs.

Sources: libs/README.md

Core Primitives and Ecosystem Fit

At the application level, LangChain’s core primitives are the composable building blocks used to assemble model-powered behavior. The top-level README calls out standard interfaces for models, embeddings, vector stores, and more, plus integrations for model providers, tools, vector stores, retrievers, and external systems. The main package README adds agents and pre-built agent architecture to that picture. In practice, this means a developer can begin with a chat model, add tools or retrieval, and later move toward richer orchestration without rewriting every provider call. The abstraction layer is meant to preserve choice while the surrounding application matures.

Sources: README.md, libs/langchain_v1/README.md, libs/core/README.md

The broader LangChain ecosystem extends beyond the Python packages in this repository. The top-level README points readers toward Deep Agents for higher-level agent capabilities such as planning, subagents, and file system usage; LangGraph for controllable agent workflows; integrations for models and tools; LangSmith for evaluation, observability, and debugging; and LangSmith deployment for long-running, stateful workflows. Official LangSmith docs describe deployed agents in terms of assistants for configuration, threads for state, and runs for workloads, with additional runtime capabilities such as streaming, human review, cron jobs, MCP connectivity, and access control. Those platform concepts are not replacements for the package map; they are the operational layer a project can grow into.

Sources: README.md

First Working Path

The shortest repository-backed path is to install the main package and initialize a chat model. The top-level README and the langchain_v1 README both show the same quick install command for the current package. The root quickstart then imports init_chat_model from langchain.chat_models, creates a model with a provider-qualified identifier, and invokes it with a simple prompt. That example is intentionally small: it proves the package is installed, the model integration can be resolved, and the standard model interface returns a result. From there, a developer can add agent behavior, tools, retrieval, streaming, or deployment concerns depending on the application.

Sources: README.md, libs/langchain_v1/README.md

uv add langchain
from langchain.chat_models import init_chat_model
 
model = init_chat_model("openai:gpt-5.5")
result = model.invoke("Hello, world!")

Use a narrower package when your task is narrower. If you are implementing provider packages or shared abstractions, install langchain-core and work against the base interfaces. If you are maintaining code that depends on older chains or classic indexing behavior, inspect langchain-classic through the monorepo package map rather than assuming the main package contains every historical surface. If you need provider-specific integrations, the libs README explains that only a subset of partner packages live in this monorepo and that many integrations have moved to provider-owned or separate repositories for versioning, dependency management, collaboration, and testing.

Sources: libs/README.md, libs/core/README.md

Documentation Entry Points and Next Steps

For documentation, use the package README files as routing pages rather than exhaustive manuals. The current langchain package README sends readers to the Python API reference for full API details and to the LangChain Docs for conceptual guides, tutorials, and examples. The core package README does the same for langchain-core. The root README also points to LangSmith for developing, debugging, and deploying agents and LLM applications, while the monorepo README directs contributors to the contributing guide before submitting pull requests. This separation is intentional: the repository tells you what is packaged here, while the documentation site teaches usage patterns and production workflows.

Sources: README.md, libs/README.md, libs/langchain_v1/README.md, libs/core/README.md

Recommended next steps depend on what you are trying to build. Start with the Quickstart page if you want a first runnable model call or a simple agent. Read Component Architecture and LangChain Core Reference when you need to understand the shared interfaces that make provider swapping possible. Move to Language Models, Tools, Runnables and LCEL, and Agents pages when assembling applications. Use Providers Overview and Partner Integration Packages when choosing integrations. If you are preparing to operate agents in production, continue into LangSmith, deployment, streaming, human-in-the-loop, schedules, authentication, and observability topics.

Sources: README.md, libs/README.md

Ask a question...