Building with LangChain: Chains, RAG, and Agents

1. Getting Started: LangChain Chains

In LangChain, the most fundamental concept is the Chain. A chain is a sequence of calls, which can be to an LLM, a tool, or a data preprocessing step. Think of it as a Directed Acyclic Graph (DAG) of components.

Let's start by installing the necessary libraries and setting up your environment.

pip install langchain langchain-openai python-dotenv



# For RAG and Agents, we'll need a few more
pip install beautifulsoup4 pypdf chromadb faiss-cpu tiktoken

Remember to create a .env file and store your OPENAI_API_KEY in it, just as we've done in previous lessons.

Simple and Sequential Chains

The most basic chain, LLMChain, combines a prompt template and an LLM. More complex chains, like SequentialChain, allow you to pipe the output of one chain into the input of another. This lets you build multi-step logic.

To get a practical feel for this, let's watch a clear, code-along tutorial.

As you can see, chains provide a clear and structured way to define a sequence of operations. This is the foundation upon which more complex applications are built.

2. Building a RAG Pipeline with LangChain

Remember the RAG architecture from our last lesson? LangChain provides specialized components for every step of that process, dramatically reducing the amount of boilerplate code you need to write.

Let's see how to implement this entire pipeline, from loading a document to generating an answer.

The video effectively demonstrates the "retrieval" part of RAG. Now, how do we combine this with the "generation" part? LangChain makes this straightforward with a dedicated create_retrieval_chain.

Here is a consolidated code example showing the full pipeline, inspired by the LangChain documentation.

import os
from dotenv import load_dotenv

from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI




# Load environment variables
load_dotenv()




# 1. Load Documents
print("Loading documents...")
loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
docs = loader.load()




# 2. Split Documents
print("Splitting documents...")
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(docs)




# 3. Create Vector Store
print("Creating vector store...")



# Note: OpenAIEmbeddings will use the OPENAI_API_KEY from your .env file
vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())




# 4. Create Retriever
retriever = vectorstore.as_retriever()




# 5. Create the RAG Chain
print("Creating RAG chain...")
llm = ChatOpenAI(model="gpt-3.5-turbo")




# This prompt template is key. It instructs the LLM on how to use the retrieved context.
system_prompt = (
    "You are an assistant for question-answering tasks. "
    "Use the following pieces of retrieved context to answer "
    "the question. If you don't know the answer, say that you "
    "don't know. Use three sentences maximum and keep the "
    "answer concise."
    "\n\n"
    "{context}"
)

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        ("human", "{input}"),
    ]
)




# This chain takes a question and the retrieved documents and generates an answer.
question_answer_chain = create_stuff_documents_chain(llm, prompt)




# This is the final chain that orchestrates the whole process.
rag_chain = create_retrieval_chain(retriever, question_answer_chain)




# 6. Ask a question
print("Asking question...")
question = "what is langsmith?"
response = rag_chain.invoke({"input": question})

print("\n--- Response ---")
print(response["answer"])




# The response also includes the source documents used for the answer
# print("\n--- Context ---")
# for doc in response["context"]:
#     print(doc.page_content)
#     print("-" * 20)

This single script accomplishes everything we discussed: loading, splitting, embedding, storing, retrieving, and generating. It's a powerful demonstration of how LangChain streamlines RAG development.

3. Beyond Predefined Steps: LangChain Agents

Chains are powerful, but they follow a fixed path. What if you need the LLM to make decisions? For instance, to decide whether to search for information or to use a calculator to perform a mathematical operation. This is where Agents come in.

An Agent uses an LLM as a "reasoning engine" to decide which Tools to use and in what sequence to accomplish a goal.

Let's see a simple agent in action.

The key idea is that instead of you defining the exact workflow, you provide the agent with a set of capabilities (tools) and a goal (the user's query), and it figures out the steps itself.

You can even combine the concepts of RAG and Agents by creating a RAG Agent. In this setup, the retriever we built earlier becomes one of the tools available to the agent. The agent can then decide whether it needs to search your documents to answer a question or if it can answer from its own knowledge.

Conclusion

In this lesson, you've taken a major step from understanding AI concepts to applying them with a powerful framework. You now have the foundational skills to build a wide range of LLM-powered applications using LangChain.

Key Takeaways:

• LangChain Chains: You can orchestrate LLM workflows by creating LLMChains for single steps and SequentialChains to link multiple steps together.
• LangChain for RAG: LangChain provides a complete toolkit to build RAG pipelines efficiently, including document loaders, text splitters, vector store integrations, and retrieval chains.
• LangChain Agents: For more dynamic tasks, you can build agents that use an LLM as a reasoning engine to decide which tools (like search, a calculator, or even your RAG retriever) to use to solve a problem.

Preview of the Next Lesson:
The chains and agents we've built today are stateless—they treat every query as a new one. For building chatbots, this is a major limitation. In our next lesson, we will address this by learning how to implement conversation memory in chatbot applications, allowing your creations to remember past interactions and have more natural, context-aware conversations.