# LangChain: the provider is a string, the framework is one of three products

> LangChain is a MIT licensed Python framework that puts one interface in front of chat models, embeddings, vector stores and tools, and its quickstart is four lines long. The interesting decisions are all outside that snippet: which of the three products you actually need, which of the separately versioned distributions you pin, and what the repository does not show you about retrieval.

**langchain-ai/langchain** — LangChain gives agent builders a common layer for models, tools, retrieval, and multi-step execution.

- Repository: https://github.com/langchain-ai/langchain
- Website: https://docs.langchain.com/langchain/
- Stars: 147,049 · Forks: 24,608
- Language: Python
- License: MIT
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/langchain-ai-langchain

## uv add langchain, then a provider:model string does the wiring

The whole quickstart is an install line and a four line script.

```bash
uv add langchain
```

```python
from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-5.5")
result = model.invoke("Hello, world!")
```

Three things in those seven lines are the design. The install command is uv, and no pip alternative appears anywhere in this README, so a poetry or plain pip project has to translate it. init_chat_model takes a single string with a provider prefix and a model name, which is where the interoperability promise lives: changing provider is editing a string, not rewriting a client. And the example stops at assignment, never printing result, so the first thing to check on your own machine is where the returned message keeps its text. The coupling also sits in that same string: the provider prefix is the only place a vendor is named, and nothing in the example shows where the API key comes from.

## The framework, the orchestrator and the debugger are three products

Read the ecosystem section as a routing table, because the framework alone does not cover what most teams need next. Deep Agents is the higher-level package built on LangChain for agents with planning, subagents and file system use. LangGraph is the low-level orchestration framework, and the quickstart sends you there explicitly when you want more advanced customization or controllable agent workflows. LangSmith is agent evals, observability and debugging, with a separate LangSmith Deployment product for long-running stateful workflows. So "we use LangChain" can mean one MIT licensed package or three moving parts, and the difference decides how much of your system you can hold in version control. The honest framing is that the orchestration and the operational tooling are documented elsewhere; this repository's licence covers what is in this repository.

## The root directory is a wrapper, the package is under libs/

The top level is short and none of it is the library. It holds libs/, openwiki/, LICENSE, README.md, AGENTS.md, CITATION.cff, a .devcontainer/ directory, a .vscode/ directory, .mcp.json, .pre-commit-config.yaml, .markdownlint.json, .editorconfig and .gitignore. So the code behind the import you just wrote sits one level down, and the default branch is master rather than the main that most tooling assumes. The README describes none of these directories, including openwiki/, so if you want to know which packaging file belongs to the distribution you installed, you go and read it. The agent files are a smaller signal about how the project is worked on: .mcp.json and AGENTS.md at the root mean the repository ships its own configuration for tool-assisted development, which is a reasonable thing to copy and also one more thing to audit before you enable it.

## Three distributions version independently, two on the same afternoon

There is no single version number to put in a requirements file, because the releases are separate distributions with separate version lines. The recent set is langchain==1.4.3 on 2026-09-28, langchain-core==1.6.6 on 2026-09-29 and langchain-anthropic==1.7.5 on 2026-09-29. Two observations follow. The release names are recorded as pip requirement strings with the double equals, which is a naming choice that makes an installed version easy to identify in a lockfile and a poor choice for a tag you have to type. And the three numbers are not aligned: on 2026-09-29 a fresh resolve could give you langchain 1.4.3 with langchain-core 1.6.6 and a partner package at 1.7.5, with no single release telling you the combination was tested. The project is active, with the last push on 2026-09-25, so pin the two you import directly rather than trusting the newest.

## The abstraction ladder is the product, and no number in it is a measurement

The reasons section sells six properties, and they are all about development process rather than output quality: a standard interface for models, embeddings and vector stores, real-time data augmentation from a large integration library, model interoperability so you can swap models in and out, rapid prototyping through a modular component architecture, production features delivered through LangSmith, and flexibility across abstraction layers from high-level chains for quick starts down to low-level components. Read carefully, nothing in that list claims a chain is more accurate or a tool call is more reliable than doing it directly. The ladder is also the cost. Two teams on the same library can pick different rungs, and the model interoperability promise means your prompts and tool schemas meet every provider's quirks anyway. A framework that measures itself in iteration speed should be judged on that, and the project publishes no benchmark here to help you.

## Retrieval is a component, and the repository ships no RAG recipe

Retrieval is where most people arrive, and it is where this repository is thinnest. Vector stores, retrievers and embeddings appear as component types in the reasons list, and the integrations entry covers chat and embedding models plus tools and toolkits, which tells you the parts exist. What the repository does not contain is a worked retrieval pipeline: no chunking strategy, no embedding model named, no similarity threshold, no example that loads a document and asks a question about it. The only runnable example is a single model invoke, and everything else is a link to docs.langchain.com or to the API reference at reference.langchain.com/python. That is a real cost for the most common use case, because a framework that offers nine vector stores but no opinion on how to prepare your documents leaves the part that determines answer quality entirely to you.

## LangChain.js shares the name, not the interface

Two doors lead out of this repository, and only one of them fits a JavaScript team. The quickstart points to LangChain.js as the equivalent JS and TS library, which means two implementations share a name, a product line and a documentation site while presenting different APIs. The documentation layout reflects that split, with separate oss/python paths for the conceptual guides and a separate ecosystem overview page explaining how LangChain, LangGraph and Deep Agents fit together, and a Python-specific reference site. Support follows the same shape: a community forum for technical questions, an academy with free courses made by the team, a contributing guide and a code of conduct. If your stack is TypeScript, the four line quickstart above is the wrong starting point, and the repository you want is the other one.

## Conclusion

Use LangChain when you want one interface across several model providers and you accept the abstraction it puts between you and the model API, and pair it with LangGraph the moment a workflow needs control over its own steps. Do not adopt it for retrieval alone, since the repository ships no retrieval example, and do not adopt it expecting the debugging story to be in the framework, because the README points that at LangSmith. Before the first commit, pin langchain and langchain-core separately, because they version independently, and check whether the provider prefix in your model string is one your key actually covers.

## FAQ

### What is LangChain vs OpenAI?

OpenAI is one of the model providers LangChain talks to, and the quickstart shows it as a prefix inside a single string, init_chat_model("openai:gpt-5.5"), with integrations covering chat and embedding models more broadly. LangChain is the framework layer in front of those providers, offering a standard interface for models, embeddings, vector stores and tools rather than a model of its own.

### Is LangChain a RAG?

No, it is a framework, and retrieval is one of the component types it provides: the reasons section names embeddings, vector stores and retrievers among the things it standardises. Nothing in this repository presents retrieval augmented generation as a feature LangChain implements for you, and no retrieval example appears in the README.

### how to install langchain

The quickstart uses uv, with the single command `uv add langchain`. No pip, poetry or conda alternative appears in this README, and the package code itself lives under the libs/ directory of the repository rather than at its root.

### how to use langchain in python

Import init_chat_model from langchain.chat_models, pass a provider and model as one string such as "openai:gpt-5.5", then call invoke() on the result. The example in the README assigns the return value to a variable called result and does not print it, so check the returned message for its text before building on it.

### how to use langchain and langgraph

LangChain is the framework that chains interoperable components together, and LangGraph is the lower level orchestration framework the quickstart recommends when you want more advanced customization or controllable agent workflows. LangSmith, a third product, covers evals, observability and debugging for the resulting application.

### how to use langchain for rag

This repository names the parts rather than showing the recipe: embeddings, vector stores and retrievers are listed as standardised component types, and the integrations entry covers chat and embedding models plus tools and toolkits. For an actual pipeline, including chunking and an embedding model, the README sends you to docs.langchain.com and to the API reference instead of giving a runnable example.

## Sources

- [Official documentation](https://docs.langchain.com/langchain/)
- [Official README](https://github.com/langchain-ai/langchain#readme)
- [Project repository](https://github.com/langchain-ai/langchain)
- [Release notes](https://github.com/langchain-ai/langchain/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/langchain-ai-langchain