Skip to main content

Example where LangChain uses Transformer Library to answer questions from custom knowledge bases?

 Here's an example where LangChain uses the Hugging Face Transformers library to answer questions from a custom knowledge base using Retrieval-Augmented Generation (RAG).


🔑 What Will This Example Do?

  1. Load custom documents into a knowledge base.
  2. Split documents into smaller text chunks.
  3. Embed text chunks using a Sentence Transformer model from Hugging Face.
  4. Store embeddings in a local FAISS vector database.
  5. Retrieve relevant chunks using similarity search.
  6. Use a Transformer LLM to generate answers based on the retrieved context.

Prerequisites

Install required libraries:

pip install langchain transformers sentence-transformers faiss-cpu pypdf

Code Example

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.llms import HuggingFacePipeline
from langchain.chains import RetrievalQA
from transformers import pipeline

# 1. Load Custom Knowledge Base (PDF)
pdf_loader = PyPDFLoader("knowledge_base.pdf")  # Replace with your PDF file path
documents = pdf_loader.load()

# 2. Split Text into Chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(documents)

# 3. Embed Chunks using Hugging Face Sentence Transformer
embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
db = FAISS.from_documents(chunks, embedding_model)

# 4. Setup Hugging Face LLM Pipeline
qa_model = pipeline("text-generation", model="google/flan-t5-small")
llm = HuggingFacePipeline(pipeline=qa_model)

# 5. Create Retrieval-based QA Chain
retriever = db.as_retriever()
qa_chain = RetrievalQA.from_chain_type(llm, retriever=retriever, chain_type="stuff")

# 6. Ask Questions
query = "What is the main conclusion of the document?"
answer = qa_chain.run(query)

print(f"Q: {query}")
print(f"A: {answer}")

🔑 How It Works

  1. The PDF is converted into text.
  2. The text is split into overlapping chunks to improve retrieval.
  3. Each chunk is embedded into vector space using Hugging Face Sentence Transformers.
  4. FAISS stores these embeddings for similarity search.
  5. When a query is made, the most relevant chunks are retrieved.
  6. The LLM (FLAN-T5 in this case) generates an answer using the retrieved chunks as context.

📌 Optional Improvements

  • Use larger models like flan-t5-xl or gpt2 for better answers.
  • Enable streaming generation with Hugging Face pipelines.
  • Replace FAISS with ChromaDB or Qdrant for advanced filtering.

When to Use This Setup?

Use Case Recommendation
Local Inference ✅ Full Local Pipeline
Custom Knowledge Base ✅ Best for small to medium-sized docs
Privacy ✅ No cloud APIs
Fine-Tuning 🔥 Easy model customization


Comments

Popular posts from this blog

Simple Linear Regression - and Related Regression Loss Functions

Today's Topics: a. Regression Algorithms  b. Outliers - Explained in Simple Terms c. Common Regression Metrics Explained d. Overfitting and Underfitting e. How are Linear and Non Linear Regression Algorithms used in Neural Networks [Future study topics] Regression Algorithms Regression algorithms are a category of machine learning methods used to predict a continuous numerical value. Linear regression is a simple, powerful, and interpretable algorithm for this type of problem. Quick Example: These are the scores of students vs. the hours they spent studying. Looking at this dataset of student scores and their corresponding study hours, can we determine what score someone might achieve after studying for a random number of hours? Example: From the graph, we can estimate that 4 hours of daily study would result in a score near 80. It is a simple example, but for more complex tasks the underlying concept will be similar. If you understand this graph, you will understand this blog. Sim...

What problems can AI Neural Networks solve

How does AI Neural Networks solve Problems? What problems can AI Neural Networks solve? Based on effectiveness and common usage, here's the ranking from best to least suitable for neural networks (Classification Problems, Regression Problems and Optimization Problems.) But first some Math, background and related topics as how the Neural Network Learn by training (Supervised Learning and Unsupervised Learning.)  Background Note - Mathematical Precision vs. Practical AI Solutions. Math can solve all these problems with very accurate results. While Math can theoretically solve classification, regression, and optimization problems with perfect accuracy, such calculations often require impractical amounts of time—hours, days, or even years for complex real-world scenarios. In practice, we rarely need absolute precision; instead, we need actionable results quickly enough to make timely decisions. Neural networks excel at this trade-off, providing "good enough" solutions in seco...

Activation Functions in Neural Networks

  A Guide to Activation Functions in Neural Networks 🧠 Question: Without activation function can a neural network with many layers be non-linear? Answer: Provided at the end of this document. Activation functions are a crucial component of neural networks. Their primary purpose is to introduce non-linearity , which allows the network to learn the complex, winding patterns found in real-world data. Without them, a neural network, no matter how deep, would just be a simple linear model. In the diagram below the f is the activation function that receives input and send output to next layers. Commonly used activation functions. 1. Sigmoid Function 2. Tanh (Hyperbolic Tangent) 3. ReLU (Rectified Linear Unit - Like an Electronic Diode) 4. Leaky ReLU & PReLU 5. ELU (Exponential Linear Unit) 6. Softmax 7. GELU, Swish, and SiLU 1. Sigmoid Function                       The classic "S-curve," Sigmoid squashes any input value t...