LangChain: LLM Application Framework Guide 2026

LCEL: LangChain Expression Language

Build composable chains with the pipe operator. Every component is a Runnable with invoke/stream/batch support.

pip install langchain langchain-openai langchain-community

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

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

# LCEL chain — pipe operator composes Runnables
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful developer assistant. Be concise."),
    ("human", "{question}")
])

chain = prompt | llm | StrOutputParser()

# Invoke synchronously
result = chain.invoke({"question": "What is HNSW indexing?"})
print(result)

# Stream tokens in real-time
for chunk in chain.stream({"question": "Explain RAG in 3 steps"}):
    print(chunk, end="", flush=True)

# Batch multiple inputs efficiently
results = chain.batch([
    {"question": "What is pgvector?"},
    {"question": "What is Qdrant?"},
    {"question": "What is LangSmith?"},
])

# Async support (in async context)
# result = await chain.ainvoke({"question": "..."})

Building a RAG Pipeline with LCEL

Load documents, split, embed, store in a vector DB, then wire up a retrieval-augmented generation chain.

from langchain_community.document_loaders import WebBaseLoader, DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate

# 1. Load documents
loader = DirectoryLoader("./docs", glob="**/*.md")
docs = loader.load()

# 2. Split into chunks
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ".", " "]
)
chunks = splitter.split_documents(docs)

# 3. Embed and store in vector database
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma")
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 4. RAG prompt template
rag_prompt = ChatPromptTemplate.from_messages([
    ("system", """Answer the question using only the following context.
If the answer is not in the context, say "I don't know."

Context:
{context}"""),
    ("human", "{question}")
])

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# 5. LCEL RAG chain
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

answer = rag_chain.invoke("What is the main architecture of Milvus?")
print(answer)

LangChain Agents with Tool Use

Create an agent that dynamically decides which tools to call to answer a user's question.

from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
import httpx

@tool
def web_search(query: str) -> str:
    """Search the web for current information about a topic."""
    # Placeholder — integrate Tavily or SerpAPI in production
    return f"Search results for: {query}"

@tool
def calculator(expression: str) -> str:
    """Evaluate a mathematical expression. Input: valid Python math expression."""
    try:
        return str(eval(expression, {"__builtins__": {}}))
    except Exception as e:
        return f"Error: {e}"

tools = [web_search, calculator]

agent_prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Use tools when needed."),
    ("human", "{input}"),
    MessagesPlaceholder("agent_scratchpad")
])

agent = create_tool_calling_agent(llm, tools, agent_prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "What is 256 * 1536 and why does that number matter for embeddings?"})
print(result["output"])

# Enable LangSmith tracing (set env vars)
import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "YOUR_LANGSMITH_KEY"

LangChain vs LlamaIndex vs Haystack vs Semantic Kernel