LangChain vs LlamaIndex 2026: Which AI Framework Should You Use?

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import tool
from langchain import hub

# Define custom tools
@tool
def search_docs(query: str) -> str:
    """Search internal documentation for relevant information."""
    # your search logic here
    return "Search results for: " + query

@tool
def run_python(code: str) -> str:
    """Execute Python code and return the output."""
    import subprocess
    result = subprocess.run(['python', '-c', code], capture_output=True, text=True)
    return result.stdout or result.stderr

# Create ReAct agent
llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = hub.pull("hwchase17/openai-tools-agent")
tools = [search_docs, run_python]

agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = agent_executor.invoke({
    "input": "Search for our refund policy and summarize it in 3 bullet points"
})

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.node_parser import SentenceSplitter
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# Configuration
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-large")
Settings.node_parser = SentenceSplitter(chunk_size=1024, chunk_overlap=200)

# Load and index (3 lines vs LangChain's 15+)
documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine(similarity_top_k=5)

# Query
response = query_engine.query("What is the refund policy?")
print(response.response)
print("\nSource nodes:")
for node in response.source_nodes:
    print(f"  Score: {node.score:.3f} | {node.metadata}")

from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool

# Build multiple specialized indexes
policy_engine = VectorStoreIndex.from_documents(policy_docs).as_query_engine()
product_engine = VectorStoreIndex.from_documents(product_docs).as_query_engine()

tools = [
    QueryEngineTool.from_defaults(policy_engine, name="policy", description="Company policies"),
    QueryEngineTool.from_defaults(product_engine, name="product", description="Product catalog"),
]

# Automatically breaks complex questions into sub-questions
sq_engine = SubQuestionQueryEngine.from_defaults(query_engine_tools=tools)
response = sq_engine.query(
    "What products are eligible for the 30-day return policy?"
)

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA

loader = PyPDFLoader("doc.pdf")
docs = RecursiveCharacterTextSplitter(chunk_size=1000).split_documents(loader.load())
db = Chroma.from_documents(docs, OpenAIEmbeddings())
qa = RetrievalQA.from_chain_type(ChatOpenAI(), retriever=db.as_retriever())
print(qa.invoke({"query": "What is the summary?"})["result"])

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
docs = SimpleDirectoryReader(input_files=["doc.pdf"]).load_data()
index = VectorStoreIndex.from_documents(docs)
print(index.as_query_engine().query("What is the summary?"))

# Use LlamaIndex for retrieval, wrap as LangChain tool
from llama_index.core import VectorStoreIndex
from langchain.tools import Tool

index = VectorStoreIndex.from_documents(docs)
query_engine = index.as_query_engine()

llama_tool = Tool(
    name="DocumentSearch",
    func=lambda q: str(query_engine.query(q)),
    description="Search company documents for information"
)
# Now use this tool in any LangChain agent