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
