RAG Summarization Using LangChain, FAISS, and Hugging Face

from transformers import pipeline

from langchain_core.documents import Document
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser

from langchain_text_splitters import RecursiveCharacterTextSplitter

from langchain_community.vectorstores import FAISS

from langchain_huggingface import HuggingFaceEmbeddings, HuggingFacePipeline

# 1. Create a long article

article = """
Retrieval-Augmented Generation, commonly called RAG, is a technique
used to improve the responses generated by language models.

Traditional language models generate answers using information learned
during training. However, the information available during training may
be incomplete, outdated, or unrelated to a specific organization's data.

RAG addresses this limitation by retrieving relevant information from
an external knowledge source before generating a response.

A typical RAG system begins by collecting documents from sources such
as PDFs, websites, databases, documentation, or text files.

Large documents are usually divided into smaller pieces called chunks.
Chunking makes it easier to search for specific information and retrieve
only the most relevant parts of a document.

Each chunk is converted into an embedding. An embedding is a numerical
representation of the meaning of text.

The embeddings are stored inside a vector database or vector store.
FAISS is a popular library that can perform efficient similarity search
over vector embeddings.

When a user asks a question, the question is also converted into an
embedding. The system compares the query embedding with the embeddings
stored in the vector store.

The most similar chunks are retrieved and used as context for the
language model.

The language model receives the retrieved context together with the
user's question or instruction. It then generates a response based on
the provided information.

RAG can reduce hallucinations by grounding the model's response in
retrieved information. However, the quality of the final response still
depends heavily on the quality of document chunking, embeddings, and
retrieval.

Choosing an appropriate chunk size is important. Very large chunks may
contain unnecessary information, while very small chunks may lose
important context.

Chunk overlap can help preserve information that appears near the
boundary between two chunks.

RAG systems are commonly used for document question answering,
enterprise search, knowledge assistants, customer support, and
summarisation.
"""

# 2 convert the article into langchain doc

documents = [Document(page_content=article)]

# 3. create a text splitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)

# 4. split the article into smaller chunks

chunks = text_splitter.split_documents(documents)

# 5. display the chunks

for index, chunk in enumerate(chunks, start=1):
    print(f"\nChunk {index}:")
    print(chunk.page_content)

# 6. Load the embedding model

embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

# 7. Create the FAISS vector store

vector_store = FAISS.from_documents(chunks, embeddings)

# 8. create a retriever

retriever = vector_store.as_retriever(search_kwargs={"k": 4})

# 9. get a summarisation topic

query = input("\nEnter a topic to summarize: ")

# 10. retrieve relevant chunks

retrieved_chunks = retriever.invoke(query)

# 11. displaying retrieved chunks

print("\nRetrieved chunks: ")

for rank, chunk in enumerate(retrieved_chunks, start=1):
    print(f"\nRank {rank}:")
    print(chunk.page_content)

# 12. combine retrieved chunks into context

context = "\n\n".join(chunk.page_content for chunk in retrieved_chunks)

# 13. load a local hugging face lang model

hf_pipeline = pipeline(
    task="text-generation", model="distilgpt2", max_new_tokens=150, do_sample=False
)

# 14. convert the hugging face pipeline into a langchain llm

llm = HuggingFacePipeline(pipeline=hf_pipeline)

# 15. create the summarisation prompt

prompt = PromptTemplate.from_template("""
Summarise the provided context.

Focus specifically on the topic given below.

Use only information from the provided context.

Do not add information that is not present in the context.

Topic:
{query}

Context:
{context}

Summary:
""")

# 16. Create the output parser

output_parser = StrOutputParser()

# 17. Build the summarisation chain

chain = prompt | llm | output_parser

# 18. generate the summary

response = chain.invoke({"query": query, "context": context})

# 19. final summary

print("\nFinal Summary: ")
print(response)

Output

Final Summary: 

Summarise the provided context.

Focus specifically on the topic given below.

Use only information from the provided context.

Do not add information that is not present in the context.

Topic:
How does RAG work ?

Context:
RAG systems are commonly used for document question answering,
enterprise search, knowledge assistants, customer support, and
summarisation.

RAG addresses this limitation by retrieving relevant information from
an external knowledge source before generating a response.

A typical RAG system begins by collecting documents from sources such
as PDFs, websites, databases, documentation, or text files.

Retrieval-Augmented Generation, commonly called RAG, is a technique
used to improve the responses generated by language models.

RAG can reduce hallucinations by grounding the model's response in
retrieved information. However, the quality of the final response still
depends heavily on the quality of document chunking, embeddings, and
retrieval.

Summary:
RAG may help improve the response rate
for the RAG system, providing a better overall response rate.
RAG should provide more detail on the performance of the RAG process as well as the types of information that can be retrieved from
the web.
All RAG systems are often used for document question answering,
enterprise search, knowledge assistants, customer support, and
summarisation.
Summary:
RAG can reduce hallucinations by grounding the model's response in
retrieved information. However, the quality of the final response stilldepends heavily on the quality of document chunking, embeddings, andretrieval.
RAG should provide more detail on the performance of the RAG process as well

Import 1: `pipeline`

from transformers import pipeline

This imports the pipeline function from the Hugging Face Transformers library. A pipeline provides an easy way to use a pre-trained model. In your code, it is used for:

pipeline(
    task="text-generation",
    model="distilgpt2"
)

Flow:

distilgpt2 model
      ↓
Hugging Face pipeline
      ↓
Generate text

Import 2: `Document`

from langchain_core.documents import Document

Document is a LangChain object used to store text and metadata. Example:

Document(
    page_content="RAG is used to retrieve relevant information."
)

Your article is converted into a Document object so that LangChain components can process it.

Import 3: `PromptTemplate`

from langchain_core.prompts import PromptTemplate

PromptTemplate is used to create reusable prompts with variables. For example:

prompt = PromptTemplate.from_template("""
Question: {query}

Context: {context}

Answer:
""")

The placeholders:

{query}
{context}

are replaced with actual values later. Example:

{query}
↓
"Explain RAG"

{context}
↓
Retrieved document chunks

Import 4: `StrOutputParser`

from langchain_core.output_parsers import StrOutputParser

The language model returns an output that needs to be processed. StrOutputParser() converts the model’s response into a normal Python string. Example:

output_parser = StrOutputParser()

Flow:

LLM Output
    ↓
StrOutputParser
    ↓
Python String

Import 5: `RecursiveCharacterTextSplitter`

from langchain_text_splitters import RecursiveCharacterTextSplitter

This is used to divide a large document into smaller pieces called chunks. RAG systems usually do not store one large document as a single piece. Instead:

Large Document
       ↓
Text Splitter
       ↓
Chunk 1
Chunk 2
Chunk 3
Chunk 4

RecursiveCharacterTextSplitter tries to split text intelligently using separators such as:

Paragraph
Sentence
Word
Character

This helps preserve meaningful text structure.

Import 6: `FAISS`

from langchain_community.vectorstores import FAISS

FAISS is used as a vector store. After converting text into embeddings, FAISS stores those embeddings and performs similarity searches. Example:

Chunk 1 → [0.12, 0.45, ...]
Chunk 2 → [0.87, 0.21, ...]
Chunk 3 → [0.34, 0.92, ...]

When the user asks a question:

"What is chunking?"

The question is also converted into an embedding. FAISS finds the chunks with the most similar meaning. Flow:

User Query
    ↓
Embedding
    ↓
FAISS Similarity Search
    ↓
Most Relevant Chunks

Import 7: `HuggingFaceEmbeddings` and `HuggingFacePipeline`

from langchain_huggingface import (
    HuggingFaceEmbeddings,
    HuggingFacePipeline
)

These classes connect Hugging Face models with LangChain.

`HuggingFaceEmbeddings`

HuggingFaceEmbeddings

Used to convert text into embeddings.

`HuggingFacePipeline`

HuggingFacePipeline

Used to convert a Hugging Face text-generation pipeline into a LangChain-compatible LLM.

Step 1: Create a long article

article = """
...
"""

This is your knowledge source. The article contains information about:

RAG
Chunking
Embeddings
FAISS
Retrieval
Language models
Hallucinations

In a real RAG application, this information could come from:

PDF files
Websites
Databases
Documentation
Text files
Company documents

Here, you are manually storing the content in a Python string.

Step 2: Convert the article into a LangChain Document

documents = [Document(page_content=article)]

LangChain works with Document objects. Your article:

RAG is a technique...

is converted into:

Document(
    page_content=article
)

The square brackets:

[ ... ]

create a list. So the structure is:

documents
    │
    └── Document
          │
          └── article text

This is useful because real applications may contain multiple documents. Example:

documents = [
    Document(page_content="Document 1"),
    Document(page_content="Document 2"),
    Document(page_content="Document 3")
]

Step 3: Create a text splitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=300,
    chunk_overlap=50
)

This creates an object responsible for splitting the document.

`chunk_size=300`

Each chunk contains approximately 300 characters. Conceptually:

Original Article
────────────────────────────

Chunk 1
[ 300 characters ]

Chunk 2
[ 300 characters ]

Chunk 3
[ 300 characters ]

`chunk_overlap=50`

The last part of one chunk is repeated in the next chunk. Example:

Chunk 1:

RAG retrieves relevant information from external sources
before generating a response.
                              ↓ overlap

Chunk 2:

from external sources before generating a response.
The retrieved information is then...

The overlap helps prevent important context from being lost at chunk boundaries.

Step 4: Split the article into chunks

chunks = text_splitter.split_documents(documents)

This takes the LangChain document:

Large Document

and converts it into:

Large Document
       ↓
RecursiveCharacterTextSplitter
       ↓
Chunk 1
Chunk 2
Chunk 3
Chunk 4
...

Each chunk is also a Document object. For example:

Document(
    page_content="RAG is a technique used to..."
)

Step 5: Display the chunks

for index, chunk in enumerate(chunks, start=1):
    print(f"\nChunk {index}:")
    print(chunk.page_content)

This loop displays every chunk.

`enumerate(chunks, start=1)`

enumerate() provides two values:

index
chunk

Example:

index = 1
chunk = first document chunk

index = 2
chunk = second document chunk

Using:

start=1

starts numbering from 1 instead of 0. Output:

Chunk 1:
RAG is a technique...

Chunk 2:
Large documents are divided...

Chunk 3:
Embeddings are numerical...

`chunk.page_content`

Each chunk is a LangChain Document. The actual text is stored inside:

chunk.page_content

Step 6: Load the embedding model

embeddings = HuggingFaceEmbeddings(
    model_name="all-MiniLM-L6-v2"
)

This loads the embedding model:

all-MiniLM-L6-v2

The embedding model converts text into a numerical representation. Example:

"RAG retrieves information"

becomes conceptually:

[0.12, -0.45, 0.87, 0.21, ...]

This numerical representation is called an embedding. Similar meanings produce embeddings that are closer together. Example:

"What is RAG?"
"Explain Retrieval-Augmented Generation"

These sentences have similar meanings, so their embeddings should be relatively close.

Step 7: Create the FAISS vector store

vector_store = FAISS.from_documents(
    chunks,
    embeddings
)

This step does two main things.

1. Convert chunks into embeddings

Chunk 1
    ↓
Embedding Model
    ↓
Vector 1

Chunk 2
    ↓
Embedding Model
    ↓
Vector 2

2. Store the embeddings in FAISS

FAISS Vector Store

Chunk 1 → Vector
Chunk 2 → Vector
Chunk 3 → Vector
Chunk 4 → Vector

FAISS can now efficiently search for similar vectors.

Step 8: Create a retriever

retriever = vector_store.as_retriever(
    search_kwargs={"k": 4}
)

The retriever provides a simple interface for searching the vector store. The value:

"k": 4

means:

Retrieve the top 4 most relevant chunks.

Flow:

User Query
    ↓
Retriever
    ↓
FAISS Search
    ↓
Top 4 Relevant Chunks

Step 9: Get a summarization topic

query = input(
    "\nEnter a topic to summarize: "
)

This asks the user to enter a topic. Example:

Enter a topic to summarize: chunking

Then:

query

contains:

"chunking"

This query will be used to find relevant chunks.

Step 10: Retrieve relevant chunks

retrieved_chunks = retriever.invoke(query)

The retriever receives the user’s query. Example:

chunking

The process is:

User Query
    ↓
Convert Query to Embedding
    ↓
Search FAISS
    ↓
Compare with Document Embeddings
    ↓
Return Top 4 Similar Chunks

The result is stored in:

retrieved_chunks

For example:

Retrieved Chunk 1:
Large documents are divided into smaller pieces called chunks.

Retrieved Chunk 2:
Choosing an appropriate chunk size is important.

Retrieved Chunk 3:
Chunk overlap helps preserve information.

Retrieved Chunk 4:
...

Step 11: Display retrieved chunks

print("\nRetrieved chunks: ")

This prints a heading. Then:

for rank, chunk in enumerate(
    retrieved_chunks,
    start=1
):
    print(f"\nRank {rank}:")
    print(chunk.page_content)

This displays the retrieved chunks. Example:

Rank 1:
Large documents are divided into smaller pieces called chunks.

Rank 2:
Chunk overlap can help preserve information.

Rank 3:
Choosing an appropriate chunk size is important.

The rank represents the position in the retrieved results.

Step 12: Combine retrieved chunks into context

context = "\n\n".join(
    chunk.page_content
    for chunk in retrieved_chunks
)

The retrieved chunks are currently separate documents. Example:

Chunk 1

Chunk 2

Chunk 3

Chunk 4

The .join() operation combines them into one string.

Chunk 1

Chunk 2

Chunk 3

Chunk 4

The \n\n adds two line breaks between chunks. The final combined result is stored in:

context

This context will be sent to the language model.

Step 13: Load a local Hugging Face language model

hf_pipeline = pipeline(
    task="text-generation",
    model="distilgpt2",
    max_new_tokens=150,
    do_sample=False
)

This creates a Hugging Face text-generation pipeline.

`task="text-generation"`

Tells the pipeline that the model should generate text.

`model="distilgpt2"`

Loads the DistilGPT-2 model.

`max_new_tokens=150`

Limits the generated response to approximately 150 new tokens.

`do_sample=False`

Disables random sampling. This makes generation more deterministic. Flow:

Prompt
   ↓
DistilGPT-2
   ↓
Generated Text

Step 14: Convert the Hugging Face pipeline into a LangChain LLM

llm = HuggingFacePipeline(
    pipeline=hf_pipeline
)

The Hugging Face pipeline alone is not directly part of the LangChain chain structure. So this wraps it inside:

HuggingFacePipeline

Now it can be connected using LangChain’s pipe operator:

prompt | llm | output_parser

Step 15: Create the summarization prompt

prompt = PromptTemplate.from_template("""
Summarise the provided context.

Focus specifically on the topic given below.

Use only information from the provided context.

Do not add information that is not present in the context.

Topic:

{query}

Context:

{context}

Summary:

""")

This creates a reusable prompt template. It contains two variables:

{query}
{context}

Later, this:

{
    "query": query,
    "context": context
}

replaces the placeholders. For example:

Topic:

chunking

Context:

Large documents are divided into smaller pieces called chunks.

Choosing an appropriate chunk size is important.

Chunk overlap can preserve information.

Summary:

This complete prompt is then sent to the language model.

Step 16: Create the output parser

output_parser = StrOutputParser()

This creates an output parser. Its purpose is to convert the model output into a clean string. Flow:

LLM Response
      ↓
StrOutputParser
      ↓
Python String

The result can then be printed easily.

Step 17: Build the summarization chain

chain = prompt | llm | output_parser

This is called an LCEL chain, where the pipe operator | connects components together. The complete flow is:

Input
  ↓
PromptTemplate
  ↓
Hugging Face LLM
  ↓
StrOutputParser
  ↓
Final Response

Or:

query + context
        ↓
Prompt
        ↓
distilgpt2
        ↓
Output Parser
        ↓
Summary

Step 18: Generate the summary

response = chain.invoke(
    {
        "query": query,
        "context": context
    }
)

The chain receives two inputs.

"query": query

Example:

chunking

And:

"context": context

Example:

Large documents are divided into smaller pieces called chunks.

Choosing an appropriate chunk size is important.

Chunk overlap helps preserve context.

The values replace:

{query}
{context}

inside the prompt. The complete process is:

User enters topic
        ↓
Retriever finds relevant chunks
        ↓
Chunks are combined into context
        ↓
Query + Context enter PromptTemplate
        ↓
Prompt sent to DistilGPT-2
        ↓
Model generates summary
        ↓
StrOutputParser processes output
        ↓
Response stored in `response`

Step 19: Display the final summary

print("\nFinal Summary: ")

print(response)

This displays the generated output. Example:

Final Summary:

Chunking is the process of dividing large documents into
smaller pieces. It improves retrieval efficiency and allows
the system to find relevant information. Choosing an appropriate
chunk size and overlap helps preserve context.

Complete RAG Flow

Your entire application works like this:

                 ARTICLE
                    │
                    ▼
           LangChain Document
                    │
                    ▼
             Text Splitter
                    │
                    ▼
       ┌────────────────────┐
       │       CHUNKS       │
       └────────────────────┘
                    │
                    ▼
            Embedding Model
       all-MiniLM-L6-v2
                    │
                    ▼
              FAISS Store
                    │
                    │
User enters topic ──┘
        │
        ▼
   Query Embedding
        │
        ▼
 Similarity Search
        │
        ▼
Top 4 Relevant Chunks
        │
        ▼
 Combine into Context
        │
        ▼
     PromptTemplate
        │
        ▼
      DistilGPT-2
        │
        ▼
    StrOutputParser
        │
        ▼
    Final Summary

This program demonstrates the core RAG pipeline:

Documents
    ↓
Chunking
    ↓
Embeddings
    ↓
Vector Store
    ↓
Retriever
    ↓
Relevant Context
    ↓
LLM
    ↓
Generated Response

One important note: retrieval part is a proper basic RAG workflow, but distilgpt2 is not specifically trained for instruction-following or summarization. The code can run, but the final summary may sometimes repeat the prompt or produce poor-quality output.

​RAG Summarization Using LangChain, FAISS, and Hugging Face

​Output

​Import 1: pipeline

​Import 2: Document

​Import 3: PromptTemplate

​Import 4: StrOutputParser

​Import 5: RecursiveCharacterTextSplitter

​Import 6: FAISS

​Import 7: HuggingFaceEmbeddings and HuggingFacePipeline

​HuggingFaceEmbeddings

​HuggingFacePipeline

​Step 1: Create a long article

​Step 2: Convert the article into a LangChain Document

​Step 3: Create a text splitter

​chunk_size=300

​chunk_overlap=50

​Step 4: Split the article into chunks

​Step 5: Display the chunks

​enumerate(chunks, start=1)

​chunk.page_content

​Step 6: Load the embedding model

​Step 7: Create the FAISS vector store

​1. Convert chunks into embeddings

​2. Store the embeddings in FAISS

​Step 8: Create a retriever

​Step 9: Get a summarization topic

​Step 10: Retrieve relevant chunks

​Step 11: Display retrieved chunks

​Step 12: Combine retrieved chunks into context

​Step 13: Load a local Hugging Face language model

​task="text-generation"

​model="distilgpt2"

​max_new_tokens=150

​do_sample=False

​Step 14: Convert the Hugging Face pipeline into a LangChain LLM

​Step 15: Create the summarization prompt

​Step 16: Create the output parser

​Step 17: Build the summarization chain

​Step 18: Generate the summary

​Step 19: Display the final summary

​Complete RAG Flow

RAG Summarization Using LangChain, FAISS, and Hugging Face

Output

Import 1: `pipeline`

Import 2: `Document`

Import 3: `PromptTemplate`

Import 4: `StrOutputParser`

Import 5: `RecursiveCharacterTextSplitter`

Import 6: `FAISS`

Import 7: `HuggingFaceEmbeddings` and `HuggingFacePipeline`

`HuggingFaceEmbeddings`

`HuggingFacePipeline`

Step 1: Create a long article

Step 2: Convert the article into a LangChain Document

Step 3: Create a text splitter

`chunk_size=300`

`chunk_overlap=50`

Step 4: Split the article into chunks

Step 5: Display the chunks

`enumerate(chunks, start=1)`

`chunk.page_content`

Step 6: Load the embedding model

Step 7: Create the FAISS vector store

1. Convert chunks into embeddings

2. Store the embeddings in FAISS

Step 8: Create a retriever

Step 9: Get a summarization topic

Step 10: Retrieve relevant chunks

Step 11: Display retrieved chunks

Step 12: Combine retrieved chunks into context

Step 13: Load a local Hugging Face language model

`task="text-generation"`

`model="distilgpt2"`

`max_new_tokens=150`

`do_sample=False`

Step 14: Convert the Hugging Face pipeline into a LangChain LLM

Step 15: Create the summarization prompt

Step 16: Create the output parser

Step 17: Build the summarization chain

Step 18: Generate the summary

Step 19: Display the final summary

Complete RAG Flow