Dev Note

LangChain Tutorial: Complete Beginner’s Guide to Building LLM Applications
LangChain has become the go-to framework for building applications powered by Large Language Models (LLMs). In this comprehensive tutorial, you’ll learn everything from basic concepts to advanced techniques for creating sophisticated AI applications.
What is LangChain?
LangChain is a framework designed to simplify the development of applications using LLMs. It provides:
Unified Interface: Work with multiple LLM providers using the same code
Chains: Connect multiple components together
Agents: Create autonomous AI systems that can use tools
Memory: Maintain conversation context
Retrieval: Integrate external knowledge bases
Installation and Setup
Install LangChain
pip install langchain langchain-openai langchain-community
pip install chromadb faiss-cpu  # For vector stores
pip install python-dotenv
Environment Setup
# .env file
OPENAI_API_KEY=your-openai-key
ANTHROPIC_API_KEY=your-anthropic-key
from dotenv import load_dotenv
load_dotenv()
Core Concepts
1. Language Models
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
# OpenAI
llm_openai = ChatOpenAI(
    model="gpt-4-turbo-preview",
    temperature=0.7
)
# Anthropic
llm_claude = ChatAnthropic(
    model="claude-3-5-sonnet-20241022",
    temperature=0.7
)
# Simple invocation
response = llm_openai.invoke("What is LangChain?")
print(response.content)
2. Prompt Templates
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
# Simple template
simple_template = ChatPromptTemplate.from_template(
    "You are an expert in {topic}. Answer: {question}"
)
# Chat template with system message
chat_template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant specialized in {specialty}."),
    ("human", "{user_input}")
])
# With message history
template_with_history = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
3. Output Parsers
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from langchain_core.pydantic_v1 import BaseModel, Field
# String parser
str_parser = StrOutputParser()
# JSON parser with schema
class MovieReview(BaseModel):
    title: str = Field(description="Movie title")
    rating: int = Field(description="Rating from 1-10")
    summary: str = Field(description="Brief summary")
json_parser = JsonOutputParser(pydantic_object=MovieReview)
Building Chains
Simple Chain (LCEL)
LangChain Expression Language (LCEL) makes chain building intuitive:
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
# Create components
prompt = ChatPromptTemplate.from_template(
    "Tell me a short joke about {topic}"
)
llm = ChatOpenAI(model="gpt-4")
parser = StrOutputParser()
# Build chain using pipe operator
chain = prompt | llm | parser
# Invoke
result = chain.invoke({"topic": "programming"})
print(result)
Chain with Multiple Steps
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
llm = ChatOpenAI()
# Step 1: Generate outline
outline_prompt = ChatPromptTemplate.from_template(
    "Create an outline for a blog post about {topic}"
)
# Step 2: Write content based on outline
content_prompt = ChatPromptTemplate.from_template(
    "Write a blog post based on this outline:\n{outline}"
)
# Combined chain
chain = (
    {"topic": RunnablePassthrough()}
    | outline_prompt
    | llm
    | StrOutputParser()
    | {"outline": RunnablePassthrough()}
    | content_prompt
    | llm
    | StrOutputParser()
)
result = chain.invoke("AI in healthcare")
Parallel Chains
from langchain_core.runnables import RunnableParallel
# Create parallel analysis
analysis_chain = RunnableParallel(
    summary=summary_chain,
    sentiment=sentiment_chain,
    keywords=keyword_chain
)
result = analysis_chain.invoke({"text": "Your input text here"})
# result = {"summary": "...", "sentiment": "...", "keywords": [...]}
Working with Documents
Document Loaders
from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    WebBaseLoader,
    DirectoryLoader
)
# Load text file
text_loader = TextLoader("document.txt")
docs = text_loader.load()
# Load PDF
pdf_loader = PyPDFLoader("document.pdf")
pdf_docs = pdf_loader.load()
# Load from web
web_loader = WebBaseLoader("https://example.com/article")
web_docs = web_loader.load()
# Load directory of files
dir_loader = DirectoryLoader("./documents", glob="**/*.txt")
all_docs = dir_loader.load()
Text Splitters
from langchain.text_splitter import (
    RecursiveCharacterTextSplitter,
    CharacterTextSplitter
)
# Recursive splitter (recommended)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
)
chunks = splitter.split_documents(docs)
Vector Stores and Retrieval
Creating a Vector Store
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma, FAISS
# Initialize embeddings
embeddings = OpenAIEmbeddings()
# Create Chroma vector store
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)
# Or use FAISS
faiss_store = FAISS.from_documents(chunks, embeddings)
Retrieval
# Create retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 4}
)
# Search
relevant_docs = retriever.get_relevant_documents("What is machine learning?")
RAG (Retrieval Augmented Generation)
Basic RAG Chain
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
# Setup
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents, embeddings)
retriever = vectorstore.as_retriever()
llm = ChatOpenAI()
# RAG prompt
template = """Answer the question based only on the following context:
{context}
Question: {question}
Answer:"""
prompt = ChatPromptTemplate.from_template(template)
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)
# RAG chain
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)
# Use it
answer = rag_chain.invoke("What is the main topic?")
Memory and Conversation
Conversation Buffer Memory
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=ChatOpenAI(),
    memory=memory,
    verbose=True
)
# Chat
response1 = conversation.predict(input="Hi, my name is John")
response2 = conversation.predict(input="What's my name?")  # Remembers "John"
Memory with LCEL
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
# Setup
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
chain = prompt | llm | StrOutputParser()
# Message history store
store = {}
def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]
# Chain with history
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)
# Use with session
config = {"configurable": {"session_id": "user123"}}
response = chain_with_history.invoke({"input": "Hi!"}, config=config)
Agents and Tools
Creating Tools
from langchain.tools import tool
from langchain_community.tools import DuckDuckGoSearchRun
# Custom tool
@tool
def calculate(expression: str) -> str:
    """Calculate a mathematical expression."""
    try:
        return str(eval(expression))
    except:
        return "Error: Invalid expression"
# Built-in tools
search = DuckDuckGoSearchRun()
Creating an Agent
from langchain.agents import create_openai_functions_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
# Tools
tools = [calculate, search]
# Prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with access to tools."),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
# Create agent
llm = ChatOpenAI(model="gpt-4")
agent = create_openai_functions_agent(llm, tools, prompt)
# Create executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Run
result = agent_executor.invoke({
    "input": "What is 25 * 48, and who invented calculus?"
})
Advanced Patterns
Self-Query Retriever
from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain.chains.query_constructor.base import AttributeInfo
metadata_field_info = [
    AttributeInfo(
        name="category",
        description="The category of the document",
        type="string"
    ),
    AttributeInfo(
        name="date",
        description="The publication date",
        type="string"
    )
]
self_query_retriever = SelfQueryRetriever.from_llm(
    llm=ChatOpenAI(),
    vectorstore=vectorstore,
    document_contents="Technical documentation",
    metadata_field_info=metadata_field_info
)
# Natural language query with filtering
docs = self_query_retriever.get_relevant_documents(
    "Show me Python tutorials from 2024"
)
Conversation Retrieval Chain
from langchain.chains import ConversationalRetrievalChain
qa_chain = ConversationalRetrievalChain.from_llm(
    llm=ChatOpenAI(),
    retriever=vectorstore.as_retriever(),
    memory=ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True
    )
)
# Chat with documents
result = qa_chain({"question": "What does this document say about X?"})
Best Practices
1. Error Handling
from langchain_core.runnables import RunnableLambda
def safe_invoke(chain, input_data):
    try:
        return chain.invoke(input_data)
    except Exception as e:
        return f"Error: {str(e)}"
# Or with fallbacks
chain_with_fallback = main_chain.with_fallbacks([backup_chain])
2. Caching
from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache
set_llm_cache(InMemoryCache())
3. Streaming
for chunk in chain.stream({"input": "Tell me a story"}):
    print(chunk, end="", flush=True)
Complete Example: Q&A Bot
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
# Load and process documents
loader = PyPDFLoader("knowledge_base.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": 3})
# Create chain
template = """You are an expert assistant. Answer based on this context:
{context}
Question: {question}
Provide a detailed, helpful answer:"""
prompt = ChatPromptTemplate.from_template(template)
llm = ChatOpenAI(model="gpt-4", temperature=0)
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()
)
# Use
answer = rag_chain.invoke("How do I configure the system?")
print(answer)
Conclusion
LangChain provides powerful abstractions for building LLM applications. Key takeaways:
Use LCEL for clean, composable chains
Implement RAG for knowledge-augmented responses
Leverage agents for autonomous task completion
Always handle errors and implement caching
Start building your AI applications today!
*LangChain version: 0.1.x
      Last updated: January 2025*

LangChain Tutorial: Complete Beginner's Guide to Building LLM Applications

댓글