LangChain - Python Library for Building AI Apps

LangChain is a Python library created by Harrison Chase in October 2022 that makes it easier to work with large language models. Instead of learning OpenAI's API, then Anthropic's API, then Google's API, LangChain gives you one interface that works with all of them.

The main problem it solves is this: you can call OpenAI and get a response, but what about when you need that response to search your database, remember previous conversations, or format data for your frontend? That's where LangChain comes in.

Companies like LinkedIn and Uber use it in production, though be warned - the 0.1 to 0.2 migration was brutal for most teams. Version 0.3 (released September 2024) dropped Python 3.8 support and switched to Pydantic 2, which completely fucked things up if you weren't ready.

And then just in August 2025, they changed peer dependencies again. Because apparently breaking changes every few months is a feature, not a bug.

Recently, they raised $100 million at a $1.1 billion valuation, which explains why they're pushing LangSmith so hard. Got to justify that valuation somehow. They also launched Open SWE in August 2025 - an async coding agent that's supposedly better than the existing AI coding tools.

What LangChain Actually Does

Instead of writing boilerplate code to:

• Switch between different AI providers
• Parse LLM responses into structured data
• Remember conversation history through memory components
• Search through your documents with vector stores
• Chain multiple AI calls together using LCEL

LangChain gives you pre-built components for all of this. The tradeoff is complexity - LangChain can be overwhelming if you're just trying to build a simple chatbot. Trust me, I've seen teams spend 3 weeks trying to get a basic Q&A bot working when a simple OpenAI API call would've done the job.

The Three Core Parts

Providers: One interface for OpenAI, Anthropic, Google, Azure OpenAI, Cohere, Hugging Face, and dozens of other LLM providers. When OpenAI raises their prices (which they do regularly), you can switch to Claude without rewriting your app. In theory. In practice, each provider has subtle differences that'll bite you in production.

Chains: Building blocks you can connect together using LangChain Expression Language. Want to search documents, then summarize them, then ask follow-up questions? LangChain has components for each step. The problem is debugging these chains when they break - and they will break in weird, hard-to-diagnose ways.

Tools: Let your LLM call functions, search the web, query databases, perform calculations, or run Python code. The LLM decides when to use each tool based on the conversation. Which sounds awesome until your agent gets stuck in an infinite loop calling the same tool over and over, racking up thousands in API bills.

LangChain works great for complex use cases but can be overkill for simple ones. If you just need basic chat functionality, the OpenAI SDK might be simpler. With OpenAI's function calling improvements and structured outputs, a lot of developers are questioning whether they need the extra complexity.

LangChain's package structure can be confusing at first. Here's what you need to know to avoid dependency hell.

Package Hell and How to Navigate It

langchain-core is the foundation everything else builds on. You'll install this automatically with other packages, but sometimes you'll see version conflicts between different langchain packages. When that happens, check your requirements.txt - you probably have conflicting version pins. I've spent entire afternoons debugging ImportError: cannot import name 'BaseModel' only to realize I had langchain-core 0.2.5 and langchain 0.3.1.

langchain-openai, langchain-anthropic, langchain-google-genai, etc. are separate packages for each provider. This means you only install what you need, but it also means when you want to switch from OpenAI to Claude, you need to install a new package and update all your imports. The upside is your Docker images stay smaller, which matters when you're deploying to AWS Lambda or similar.

langchain-community is where all the experimental stuff lives. Lots of integrations, but the quality varies wildly. Some work great, others will break in production. The community package has over 400 integrations, which sounds awesome until you realize half of them haven't been updated in months and break with recent dependencies.

langchain is the main package with chains, agents, and the higher-level stuff. This is usually what you want to start with, though be warned - it pulls in a lot of dependencies.

Pro tip: Always pin your versions. LangChain moves fast and breaking changes happen. I learned this the hard way when 0.2 came out and broke our production deployment at 2am on a Friday.

Version 0.3 (September 2024) dropped Python 3.8 support and switched to Pydantic 2. If you see errors like ImportError: cannot import name 'BaseModel' from 'pydantic.v1', you're hitting the Pydantic v1 to v2 migration issues. This broke so many production deployments that there are entire GitHub discussions dedicated to migration pain.

And then in August 2025, they changed the JavaScript package structure to use peer dependencies instead of direct dependencies. Because apparently the Python migration wasn't chaotic enough.

The Core Components You'll Actually Use

Chat Models are your interface to different AI providers. Same API whether you're using GPT-4, Claude, or some local model. The catch? Each provider has slightly different capabilities, so you can't always just swap them out seamlessly.

Prompt Templates let you build dynamic prompts with variables. Useful, but don't go overboard - sometimes a simple f-string is clearer than a LangChain template.

Vector Stores connect to databases like Pinecone or Chroma for semantic search. This is where things get expensive fast if you're not careful with your embedding calls.

Tools let your LLM call functions. Cool concept, but debugging tool calls can be a nightmare. When your LLM decides to call the wrong tool with the wrong parameters, good luck figuring out why.

LangGraph: The New Hotness

LangGraph is LangChain's answer to complex workflows. It's basically a state machine for AI agents. More powerful than basic chains, but the learning curve is steep.

If you're building anything more complex than "user asks question, AI responds," you'll probably end up using LangGraph. Just prepare to spend time debugging why your agent got stuck in an infinite loop.

Installation Reality Check

Don't just pip install langchain - you'll end up with a bunch of stuff you don't need. Install only what you actually use:

## For OpenAI only (most common starting point)
pip install langchain-core langchain-openai

## Add community integrations later if needed
pip install langchain-community

Pro tip: Pin your versions in requirements.txt. LangChain moves fast and breaking changes happen. I learned this when version 0.2 broke our production deployment at 2am.

OPENAI_API_KEY=your-key-here

Set up your API key as an environment variable. Don't hardcode it - you'll commit it to Git eventually.

Your First Working Example

Here's a basic example that actually works:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("human", "{question}")
])

chain = prompt | llm

result = chain.invoke({"question": "Explain Python list comprehensions"})
print(result.content)

The `|` operator chains components together. Looks weird at first but you get used to it.

RAG: The Actually Useful Pattern

Everyone wants to build ChatGPT for their documents. Here's the basic setup:

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter

## This will cost you embedding tokens
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
docs = splitter.split_documents(your_docs)

embeddings = OpenAIEmbeddings()  # $$$ 
vectorstore = Chroma.from_documents(docs, embeddings)

retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

Warning: Embedding costs add up fast. Test with small datasets first.

What Actually Matters

Start with simple chains. Don't jump into LangGraph agents on day one - you'll spend weeks debugging infinite loops.

Use streaming if you're building a UI. Nobody wants to wait 30 seconds for a response with no feedback.

Set up proper error handling early. When your chain breaks (and it will), you want meaningful error messages, not "KeyError: 'input'".

Monitor your costs from day one. Use the token tracking features or you'll get a $500 OpenAI bill as a surprise.