LangChain overview

LangChain is an open-source framework that gives every chat model one interface, wraps the tools a model can call, and runs the agent loop that ties them together.

Last updated: 27 Sep, 2026 · LangChain 1.4

What changed in LangChain v1

The crash course opens on the LangChain documentation, which now has three parts: LangChain, LangGraph and Deep Agents. The v1 release changed a lot in the LangChain part: the syntax for creating agents, how models from different providers are connected, how a tool is called and how structured output comes back. The course covers the changes in this order:

• Agents are built with one function, create_agent.
• Models from OpenAI, Gemini, Groq and many more load through one call, init_chat_model.
• Tools are ordinary Python functions with a docstring.
• Structured output comes back as a Pydantic model, a TypedDict or a dataclass.
• Messages share one set of types across every provider: system, human, AI and tool.
• Short-term memory and streaming are part of the agent itself.
• Middleware hooks into the agent's loop, built-in or custom, and guardrails check what goes in and out.

The project is set up with uv, a Python package and project manager written in Rust that is much faster than pip. Any editor works: VS Code, Cursor, or Google Antigravity, the one the video uses.

Models, tools, agents and middleware

LangChain gives every chat model provider one interface, so the same code runs against Groq, Gemini or OpenAI after a one-word change. Tools are Python functions a model can ask to run. create_agent puts the two together in a loop: the model asks for a tool, the tool runs, the model reads the result, until it answers. Middleware adds behaviour around that loop, such as retries, limits, human approval and guardrails. In v1 the older chains and agent executor moved out to a separate package, langchain-classic.

LangChain agents run on LangGraph, the lower-level framework from the same company, which gives them memory and the ability to pause for a human. Everything below stays at the create_agent level and never builds a graph by hand; the LangGraph course covers that layer. Harrison Chase started LangChain in October 2022; it is MIT-licensed, and this course uses 1.4.2.

The create_agent: the agent loop lesson draws that loop.

The support desk starts as a conversation stored in a Python list. By the end it looks up orders, remembers the customer, stops before a refund until a person approves it, hides card numbers and cannot loop forever. A second project answers from the shop's policy documents, says so when they do not cover the question, and comes with tests.

Everything in both projects is something you build on its own first, in the lesson the drawing names. The course map below shows the order they arrive in.

A chat model you write yourself

Early on you write a small chat model of your own. It shows how a chat model works under the hood, and the framework treats it exactly as it treats a hosted one. The course itself runs on a real hosted model through Groq's free tier; a few lessons that need an exact, scripted outcome, such as a deliberate bad value, use a small stand-in built the same way, and each of those lessons says so at the top.

Where you use LangChain

• Support and assistant bots that call your own functions to look things up and act.
• Answering from your own documents, with the model saying so when they do not cover the question.
• Any app that must swap one model provider for another without rewriting the code around it.

Prerequisites

• Python 3.12 or later. LangChain itself runs on 3.10, but the retrieval lessons use numpy 2.5.3, which needs 3.12.
• Comfort with functions, classes and dictionaries.

Related

• Next: Installation and setup
• Reference: LangChain documentation