How to Create Chatbot For Website with LangChain and Groq

1pip install pymupdf langchain langchain-core langchain-community langchain-text-splitters langchain-google-genai langchain-groq python-dotenv faiss-cpu fastapi uvicorn streamlit httpx
Copy

1chatbot-project/
2├── app/
3│   ├── faiss_index/             # FAISS vector index files
4│   ├── vectorstore_loader.py    # Script to load vector store
5│   ├── chatbot_api.py           # FastAPI backend
6│   ├── chatbot_ui.py            # Streamlit frontend (optional)
7├── data/
8│   └── website_content.pdf      # Cleaned website content
9├── .env                         # API keys
10├── website_content.html         # Raw HTML content
11├── requirements.txt             # All dependencies
12├── vectorstore_builder.py       # Script to build FAISS vector store
Copy

1GOOGLE_API_KEY=your_google_api_key
2GROQ_API_KEY=your_groq_api_key
Copy

1curl <https://www.website.com/> > website_content.html
Copy

1import fitz  # PyMuPDF
2from langchain_core.documents import Document
3import os
4
5def load_pdf_bytes(pdf_path: str) -> list[Document]:
6    with open(pdf_path, "rb") as f:
7        content = f.read()
8
9    pdf_doc = fitz.open(stream=content, filetype="pdf")
10    docs = []
11
12    for i in range(pdf_doc.page_count):
13        text = pdf_doc[i].get_text()
14        if text.strip():
15            docs.append(Document(
16                page_content=text,
17                metadata={"source": os.path.basename(pdf_path), "page": i + 1}
18            ))
19
20    pdf_doc.close()
21    return docs
Copy

1from langchain_text_splitters import RecursiveCharacterTextSplitter
2
3splitter = RecursiveCharacterTextSplitter(
4    chunk_size=1000,  # Maximum number of characters per chunk
5    chunk_overlap=200  # Number of overlapping characters between chunks
6)
7
8chunks = splitter.split_documents(all_docs)
Copy

1from langchain_google_genai import GoogleGenerativeAIEmbeddings
2from dotenv import load_dotenv
3import os
4
5load_dotenv()
6
7embeddings = GoogleGenerativeAIEmbeddings(
8    model="models/embedding-001",
9    google_api_key=os.getenv("GOOGLE_API_KEY")
Copy

1from langchain_community.vectorstores import FAISS
2import os
3
4vectorstore = FAISS.from_documents(chunks, embeddings)
5
6index_path = "app/faiss_index"
7os.makedirs(os.path.dirname(index_path), exist_ok=True) 
8vectorstore.save_local(index_path)  # Save the vector store locally
9
10print(f"Vectorstore saved to '{index_path}/'")
Copy

1def process_folder(folder_path: str, index_path="app/faiss_index"):
2    """Automate the process of parsing PDFs, splitting, embedding, and saving the vector store."""
3    all_docs = []
4    for filename in os.listdir(folder_path):
5        if filename.lower().endswith(".pdf"):  # Process only PDF files
6            full_path = os.path.join(folder_path, filename)
7            docs = load_pdf_bytes(full_path)
8            all_docs.extend(docs)
9
10    if not all_docs:
11        raise ValueError(f"No PDF files found in '{folder_path}' or all PDFs are empty.")
12
13    chunks = splitter.split_documents(all_docs)  # Split documents into chunks
14    embeddings = generate_embeddings()  # Generate embeddings
15    vectorstore = build_and_save_vectorstore(chunks, embeddings, index_path)  # Build and save the vectorstore
16    return vectorstore
17
18## Main execution
19if __name__ == "__main__":
20    vectorstore = process_folder("data")  # Run the process for the PDFs in the "data" folder
Copy

1from langchain_community.vectorstores import FAISS
2from langchain_google_genai import GoogleGenerativeAIEmbeddings
3from dotenv import load_dotenv
4import os
5
6load_dotenv()
7
8embeddings = GoogleGenerativeAIEmbeddings(
9    model="models/embedding-001",
10    google_api_key=os.getenv("GOOGLE_API_KEY")
11)
12
13def load_vectorstore(path="app/faiss_index"):
14    return FAISS.load_local(path, embeddings, allow_dangerous_deserialization=True)
Copy

1from langchain.chains import RetrievalQA
2from langchain_groq import ChatGroq
3import os
4
5def get_qa_chain(vectorstore):
6    llm = ChatGroq(
7        groq_api_key=os.getenv("GROQ_API_KEY"),
8        model_name="llama-3.1-8b-instant"
9    )
10
11    retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 3})
12
13    qa_chain = RetrievalQA.from_chain_type(
14        llm=llm,
15        retriever=retriever,
16    )
17
18    return qa_chain
Copy

1from fastapi import FastAPI
2from pydantic import BaseModel
3from langchain.chains import RetrievalQA
4from langchain_groq import ChatGroq
5from dotenv import load_dotenv
6from app.vectorstore_loader import load_vectorstore
7import os
8
9load_dotenv()
10
11app = FastAPI()
12
13def get_qa_chain(vectorstore):
14    llm = ChatGroq(
15        groq_api_key=os.getenv("GROQ_API_KEY"),
16        model_name="llama-3.1-8b-instant"
17    )
18
19    retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 3})
20
21    qa_chain = RetrievalQA.from_chain_type(
22        llm=llm,
23        retriever=retriever,
24    )
25
26    return qa_chain
27
28vectorstore = load_vectorstore()
29qa_chain = get_qa_chain(vectorstore)
30
31class Query(BaseModel):
32    question: str
33
34@app.post("/chat")
35async def chat(query: Query):
36    result = qa_chain(query.question)
37    
38    return {
39        "answer": result["result"],
40    }
Copy

1uvicorn app.chatbot_api:app --reload
Copy

1import streamlit as st
2import requests
3
4st.title("📚 Website Chatbot")
5
6query = st.text_input("Ask a question:")
7
8if query:
9    with st.spinner("Thinking..."):
10        response = requests.post("<http://localhost:8000/chat>", json={"question": query})
11        data = response.json()
12
13        st.write("**Answer:**", data["answer"])
Copy

1uvicorn app.chatbot_api:app --reload
Copy

1streamlit run app/chatbot_ui.py
Copy