--- 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) ```python 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 ```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 ```python 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 ```python 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 ```python 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 ```python 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