Basic RAG chain with LCEL in LangChain

Introduction

A Basic RAG chain with LCEL helps you find answers by combining your documents with smart AI. It uses retrieval to get info and then generates a clear answer.

You want to answer questions using your own documents or data.

You need quick, relevant answers from a large text collection.

You want to combine search and AI writing for better results.

You want to build a simple chatbot that knows your documents.

You want to learn how retrieval and generation work together.

Syntax

LangChain

from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.document_loaders import TextLoader
from langchain.indexes import VectorstoreIndexCreator

# Load documents
loader = TextLoader('mydocs.txt')
docs = loader.load()

# Create vector index
index = VectorstoreIndexCreator().from_documents(docs)

# Create RAG chain
qa = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    chain_type="stuff",
    retriever=index.vectorstore.as_retriever()
)

# Ask a question
answer = qa.run("What is LangChain?")

The RAG chain uses a retriever to find relevant documents.

LCEL means LangChain Expression Language, which helps build chains simply.

Examples

This example sets temperature to 0 for consistent answers.

LangChain

qa = RetrievalQA.from_chain_type(
    llm=OpenAI(temperature=0),
    chain_type="stuff",
    retriever=index.vectorstore.as_retriever()
)
answer = qa.run("Explain RAG in simple words.")

Using 'map_reduce' chain type to summarize multiple documents.

LangChain

qa = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    chain_type="map_reduce",
    retriever=index.vectorstore.as_retriever()
)
answer = qa.run("Summarize the documents.")

Sample Program

This program loads a text file, creates a vector index, builds a RAG chain, and answers a question about the document.

LangChain

from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.document_loaders import TextLoader
from langchain.indexes import VectorstoreIndexCreator

# Load a simple text document
loader = TextLoader('example.txt')
docs = loader.load()

# Create vector index from documents
index = VectorstoreIndexCreator().from_documents(docs)

# Build RAG chain with OpenAI LLM
qa = RetrievalQA.from_chain_type(
    llm=OpenAI(temperature=0),
    chain_type="stuff",
    retriever=index.vectorstore.as_retriever()
)

# Ask a question
question = "What is the main topic of the document?"
answer = qa.run(question)
print(f"Question: {question}")
print(f"Answer: {answer}")

Important Notes

Make sure you have your OpenAI API key set in your environment variables.

Use small documents first to see how retrieval works.

LCEL lets you write chains in a simple way without complex code.

Summary

RAG chains combine search and AI to answer questions from documents.

LCEL helps build these chains easily with less code.

Try loading your own documents and ask questions to learn how it works.

Practice

1. What is the main purpose of a RAG chain in Langchain?

easy

A. To combine document search with AI to answer questions

B. To train a new AI model from scratch

C. To visualize data in charts

D. To clean and preprocess raw data

Solution

1. Step 1: Understand RAG chain function

   A RAG (Retrieval-Augmented Generation) chain uses search to find relevant documents and AI to generate answers.

2. Step 2: Match purpose with options

   Only To combine document search with AI to answer questions describes combining search and AI to answer questions, which is the core of RAG chains.

3. Final Answer:

   To combine document search with AI to answer questions -> Option A

4. Quick Check:

   RAG chain = combine search + AI [OK]

Hint: RAG means search plus AI for answers [OK]

Common Mistakes:

• Thinking RAG trains new models
• Confusing RAG with data visualization
• Assuming RAG only cleans data

2. Which of the following is the correct way to create a RAG chain using LCEL in Langchain?

easy

A. rag_chain = LCEL.RAGChain.build(docs, llm)

B. rag_chain = LCEL.RAGChain.from_documents(docs, llm)

C. rag_chain = RAGChain(docs, llm).build()

D. rag_chain = LCEL.createRAG(docs, llm)

Solution

1. Step 1: Recall LCEL syntax for RAG chain

   LCEL provides a method called from_documents to create a RAG chain from documents and an LLM.

2. Step 2: Compare options with correct syntax

   Only rag_chain = LCEL.RAGChain.from_documents(docs, llm) uses LCEL.RAGChain.from_documents(docs, llm), which is the correct method.

3. Final Answer:

   rag_chain = LCEL.RAGChain.from_documents(docs, llm) -> Option B

4. Quick Check:

   LCEL.RAGChain.from_documents = correct syntax [OK]

Hint: Use from_documents method to create RAG chain [OK]

Common Mistakes:

• Using non-existent createRAG method
• Calling build() on RAGChain instance
• Mixing method names or class names

3. Given the code snippet:

docs = ["Doc1 content", "Doc2 content"]
llm = SomeLLM()
rag_chain = LCEL.RAGChain.from_documents(docs, llm)
answer = rag_chain.run("What is in Doc1?")
print(answer)

What is the expected output?

medium

A. An error because docs should be a string, not a list

B. A list of documents including Doc1 and Doc2

C. An answer generated by the LLM based on Doc1 content

D. The string 'What is in Doc1?' printed as is

Solution

1. Step 1: Understand RAG chain run method

   Running rag_chain.run(question) uses the LLM to answer based on retrieved documents.

2. Step 2: Analyze input and output

   Docs are provided as a list, which is valid. The output is an AI-generated answer about Doc1 content.

3. Final Answer:

   An answer generated by the LLM based on Doc1 content -> Option C

4. Quick Check:

   rag_chain.run(question) = AI answer [OK]

Hint: RAG chain answers questions using docs + LLM [OK]

Common Mistakes:

• Expecting raw docs list as output
• Thinking docs must be a single string
• Assuming run just echoes input question

4. You wrote this code:

rag_chain = LCEL.RAGChain.from_documents("doc.txt", llm)
answer = rag_chain.run("Explain the content.")

But it raises an error. What is the likely problem?

medium

A. The llm variable is not defined

B. LCEL.RAGChain does not have from_documents method

C. The run method requires two arguments

D. The documents argument should be a list, not a filename string

Solution

1. Step 1: Check documents argument type

   from_documents expects a list of document strings, not a filename string.

2. Step 2: Identify error cause

   Passing "doc.txt" as a string causes an error because it is not a list of documents.

3. Final Answer:

   The documents argument should be a list, not a filename string -> Option D

4. Quick Check:

   Documents must be list, not filename string [OK]

Hint: Pass list of docs, not filename string [OK]

Common Mistakes:

• Passing filename instead of document list
• Assuming run needs two arguments
• Thinking from_documents method is missing

5. You want to build a RAG chain that answers questions from multiple document types (PDF, text, and web pages) using LCEL. Which approach correctly prepares the documents before creating the RAG chain?

hard

A. Load and convert each document type to text, combine into a list, then pass to LCEL.RAGChain.from_documents

B. Pass file paths directly to LCEL.RAGChain.from_documents without loading

C. Use only one document type to avoid errors

D. Create separate RAG chains for each document type and run them independently

Solution

1. Step 1: Understand document preparation for RAG

   RAG chains require documents as text strings, so all document types must be converted to text first.

2. Step 2: Combine and pass documents correctly

   After conversion, combine all texts into a list and pass to LCEL.RAGChain.from_documents for a single chain.

3. Final Answer:

   Load and convert each document type to text, combine into a list, then pass to LCEL.RAGChain.from_documents -> Option A

4. Quick Check:

   Convert all docs to text list before RAG chain [OK]

Hint: Convert all docs to text list before RAG chain [OK]

Common Mistakes:

• Passing file paths instead of text
• Using only one document type unnecessarily
• Creating multiple chains instead of one combined