---

name: langchain description: | LangChain framework for LLM application development. Covers chains, agents, tools, RAG pipelines, vector stores, memory, and LangChain Expression Language (LCEL). Python and TypeScript/JavaScript.

USE WHEN: user mentions "langchain", "LLM chain", "AI agent", "LCEL", "retrieval chain", "LangChain tools", "LangSmith", "LangGraph"

DO NOT USE FOR: direct API calls without framework - use Claude/OpenAI SDK; vector database specifics - use vector-databases; RAG architecture patterns - use rag-patterns allowed-tools: Read, Grep, Glob, Write, Edit

LangChain

LCEL (LangChain Expression Language — recommended)

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

model = ChatAnthropic(model="claude-sonnet-4-20250514")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant specialized in {topic}."),
    ("human", "{question}"),
])

# Pipe syntax
chain = prompt | model | StrOutputParser()
result = chain.invoke({"topic": "Python", "question": "Explain decorators"})

# Streaming
async for chunk in chain.astream({"topic": "Python", "question": "Explain decorators"}):
    print(chunk, end="")

TypeScript

import { ChatAnthropic } from '@langchain/anthropic';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const model = new ChatAnthropic({ model: 'claude-sonnet-4-20250514' });
const prompt = ChatPromptTemplate.fromMessages([
  ['system', 'You are a helpful assistant specialized in {topic}.'],
  ['human', '{question}'],
]);

const chain = prompt.pipe(model).pipe(new StringOutputParser());
const result = await chain.invoke({ topic: 'TypeScript', question: 'Explain generics' });

RAG Chain

from langchain_community.vectorstores import Chroma
from langchain_anthropic import ChatAnthropic
from langchain_openai import OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

# Setup
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

prompt = ChatPromptTemplate.from_template("""
Answer based on the context. If unsure, say so.

Context: {context}
Question: {question}
""")

chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | ChatAnthropic(model="claude-sonnet-4-20250514")
    | StrOutputParser()
)

answer = chain.invoke("How does authentication work?")

Tools and Agents

from langchain_core.tools import tool
from langchain_anthropic import ChatAnthropic
from langgraph.prebuilt import create_react_agent

@tool
def search_database(query: str) -> str:
    """Search the product database by query."""
    results = db.search(query)
    return json.dumps(results)

@tool
def calculate_price(product_id: str, quantity: int) -> float:
    """Calculate total price for a product and quantity."""
    product = db.get_product(product_id)
    return product.price * quantity

model = ChatAnthropic(model="claude-sonnet-4-20250514")
agent = create_react_agent(model, [search_database, calculate_price])

result = agent.invoke({"messages": [("human", "Find laptop prices and calculate cost for 5 units")]})

Structured Output

from pydantic import BaseModel, Field

class ExtractedInfo(BaseModel):
    name: str = Field(description="Person's name")
    email: str = Field(description="Email address")
    sentiment: str = Field(description="positive, negative, or neutral")

structured_model = model.with_structured_output(ExtractedInfo)
result = structured_model.invoke("John (john@example.com) loves the product!")
# ExtractedInfo(name='John', email='john@example.com', sentiment='positive')

Document Loading and Splitting

from langchain_community.document_loaders import PyPDFLoader, WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Load
docs = PyPDFLoader("document.pdf").load()

# Split
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)

# Store in vectorstore
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./db")

Anti-Patterns

Anti-Pattern	Fix
Legacy LLMChain API	Use LCEL pipe syntax
No streaming for user-facing	Always stream with astream
Huge chunks in RAG	Use 500-1000 char chunks with 200 overlap
No retrieval evaluation	Track retrieval quality with LangSmith
Agent without tool descriptions	Write clear docstrings — LLM uses them
Embedding model mismatch	Same embedding model for indexing and querying

Production Checklist

• LCEL syntax (not legacy chains)
• Streaming enabled for user-facing responses
• LangSmith tracing for debugging/evaluation
• Structured output with Pydantic models
• Proper chunk size and overlap for RAG
• Error handling and fallbacks in chains
• Rate limiting on external tool calls