LangChain — Step by Step

LangChain is a framework for building applications with Large Language Models (LLMs). It helps connect LLMs to data sources (files, DBs, APIs), tools (search, math, code execution), memory systems (conversation history), and orchestration primitives like chains and agents.

Install the core framework and optional vector stores/embeddings

pip install langchain
pip install langchain-openai
pip install openai        # or another LLM provider
pip install faiss-cpu     # for vector search (optional)
pip install chromadb      # for embeddings storage

A minimal example using the ChatOpenAI wrapper

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4", temperature=0.7)

response = llm.invoke("Explain LangChain in 2 sentences")
print(response.content)

Structure prompts for re-use and clarity.

from langchain.prompts import PromptTemplate

template = """You are a helpful tutor. 
Explain {topic} in simple terms for a beginner."""
prompt = PromptTemplate.from_template(template)

print(prompt.format(topic="quantum computing"))

Chains connect prompts, parsers and LLMs into workflows.

from langchain.chains import LLMChain
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model="gpt-4", temperature=0)
prompt = PromptTemplate.from_template("Translate this text to French: {text}")

chain = LLMChain(llm=llm, prompt=prompt)

print(chain.run("Hello, how are you?"))

Persist conversation history so the assistant remembers context.

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4")
memory = ConversationBufferMemory()

conversation = ConversationChain(llm=llm, memory=memory)

print(conversation.run("Hello, I am Surendran."))
print(conversation.run("What is my name?"))

Load files, split text, embed and run Retrieval-Augmented Generation.

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

# Load a PDF
loader = PyPDFLoader("sample.pdf")
docs = loader.load()

# Split into chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

# Create embeddings + vector DB
embeddings = OpenAIEmbeddings()
db = FAISS.from_documents(chunks, embeddings)

# Build retriever
retriever = db.as_retriever()

# Retrieval QA Chain
llm = ChatOpenAI(model="gpt-4")
qa = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)

print(qa.run("What is the main topic of the PDF?"))

Agents can choose tools (calculators, search, execution) dynamically.

from langchain.agents import initialize_agent, load_tools
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4")
tools = load_tools(["llm-math"], llm=llm)

agent = initialize_agent(tools, llm, agent="zero-shot-react-description")

print(agent.run("What is 25 * 19?"))

RAG (Retrieval-Augmented Generation) pipeline:

1. Load data (PDF, DB, API)
2. Split + embed documents
3. Store in vector DB (FAISS, Chroma, Pinecone)
4. Build retriever
5. Query with LLM

This flow is the backbone for building knowledge-grounded assistants.

Where to go after this tutorial:

• Learn LangChain Expression Language (LCEL)
• Explore LangGraph for advanced agent workflows
• Build a small Streamlit/Gradio front-end for a chatbot
• Try other vector stores: Pinecone, Weaviate, Milvus