Build AI Apps with LangChain and Python — 2026 Guide

pip install langchain langchain-openai langchain-community chromadb pypdf

import os
os.environ["OPENAI_API_KEY"] = "your-key-here"

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
 
llm = ChatOpenAI(model="gpt-4o", temperature=0)
 
messages = [
    SystemMessage(content="You are a helpful Python tutor."),
    HumanMessage(content="Explain Python decorators in one paragraph."),
]
 
response = llm.invoke(messages)
print(response.content)

from langchain_core.prompts import ChatPromptTemplate
 
template = ChatPromptTemplate.from_messages([
    ("system", "You are an expert in {domain}. Answer concisely."),
    ("human", "{question}"),
])
 
prompt = template.invoke({
    "domain": "Python performance optimization",
    "question": "When should I use multiprocessing vs asyncio?",
})
 
llm = ChatOpenAI(model="gpt-4o")
response = llm.invoke(prompt)
print(response.content)

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
 
llm = ChatOpenAI(model="gpt-4o")
 
prompt = ChatPromptTemplate.from_template(
    "Summarize this text in 3 bullet points:\n\n{text}"
)
 
chain = prompt | llm | StrOutputParser()
 
result = chain.invoke({
    "text": """
    Python is a high-level, general-purpose programming language. Its design philosophy
    emphasizes code readability with the use of significant indentation. Python is
    dynamically typed and garbage-collected. It supports multiple programming paradigms.
    """
})
print(result)

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_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
 
# Load and split documents
loader = PyPDFLoader("document.pdf")
docs = loader.load()
 
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)
 
# Create vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
 
# Build RAG chain
template = """Answer the question based only on the context below.
If you cannot answer, say "I don't know".
 
Context: {context}
 
Question: {question}"""
 
prompt = ChatPromptTemplate.from_template(template)
llm = ChatOpenAI(model="gpt-4o")
 
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)
 
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)
 
answer = rag_chain.invoke("What is the main topic of this document?")
print(answer)

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage
 
llm = ChatOpenAI(model="gpt-4o")
 
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}"),
])
 
chain = prompt | llm
 
history = []
 
def chat(user_message: str) -> str:
    response = chain.invoke({"input": user_message, "history": history})
    history.append(HumanMessage(content=user_message))
    history.append(AIMessage(content=response.content))
    return response.content
 
print(chat("My name is Alice."))
print(chat("What is my name?"))  # Should remember "Alice"

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 
@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    # Replace with real weather API call
    return f"It is sunny and 22°C in {city}."
 
@tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression safely."""
    try:
        result = eval(expression, {"__builtins__": {}})
        return str(result)
    except Exception as e:
        return f"Error: {e}"
 
tools = [get_weather, calculate]
llm = ChatOpenAI(model="gpt-4o")
 
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with access to tools."),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])
 
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
result = executor.invoke({"input": "What is the weather in Tokyo and what is 15 * 24?"})
print(result["output"])