In today’s fast-paced world, information needs to be easily accessible, especially in complex fields like automotive technology. This project focuses on building a context-aware chatbot that integrates technical documentation using Retrieval-Augmented Generation (RAG). The chatbot provides users with precise answers based on the information retrieved from a car manual, specifically the MG ZS car manual. It retrieves relevant information from the manual and uses a large language model (LLM) to generate human-like responses.
The objective of this project is to create a chatbot that interprets and responds to warning messages from a car’s manual. The system leverages large language models (LLMs) to provide contextually accurate responses based on technical documentation. The chatbot retrieves information from the manual and generates answers to user queries about car warnings.
The first step is to split the technical documentation (the car manual) into smaller, manageable chunks. The RecursiveCharacterTextSplitter from LangChain was used to achieve this. This ensures that relevant information can be efficiently retrieved based on the user’s query.
from langchain_text_splitters import RecursiveCharacterTextSplitter
# Initialize the splitter
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
# Split the HTML document
splits = text_splitter.split_documents(car_docs)
The next step is to convert the document chunks into embeddings. These embeddings represent the semantic meaning of the text and allow the system to process it efficiently. The OpenAI Embeddings API is used to generate these embeddings.
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
# Initialize Chroma vectorstore with documents as splits
vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings(openai_api_key=openai_api_key))
After embedding the documents, a retriever is configured to fetch the most relevant document chunks based on the user’s query. This component is essential for the RAG model, as it retrieves context from the stored documents.
retriever = vectorstore.as_retriever()
To guide the LLM in generating useful responses, a custom prompt template is created. The prompt instructs the LLM to answer based on the retrieved context.
from langchain_core.prompts import ChatPromptTemplate
# Define the RAG prompt template
prompt = ChatPromptTemplate.from_template(
"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, just say that you don't know. Use three sentences maximum and keep the answer concise.\n"
"Question: {question} \nContext: {context} \nAnswer:"
)
The next step is to initialize the OpenAI GPT-4o-mini model, which will be used to generate responses based on the retrieved context.
from langchain_openai import ChatOpenAI
# Initialize LLM with gpt-4o-mini model
model = ChatOpenAI(openai_api_key=openai_api_key, model_name="gpt-4o-mini", temperature=0)
The retriever, prompt template, and LLM are connected in a single pipeline, known as the RAG chain. This chain processes the user query, retrieves relevant context, and generates a response.
from langchain_core.runnables import RunnablePassthrough
# Setup RAG chain
rag_chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| model
)
To test the system, a query such as:
query = "The Gasoline Particular Filter Full warning has appeared. What does this mean and what should I do about it?"
The model generates an accurate and concise response:
"The Gasoline Particular Filter Full warning indicates that the gasoline particulate filter is full. You should consult an MG Authorised Repairer as soon as possible for assistance."
The chatbot efficiently retrieves relevant context from the car manual and provides actionable answers to user queries. By implementing the RAG architecture, the system ensures that the responses are always grounded in the available documentation. This solution can be used in a variety of domains where retrieving context from technical documents is necessary.
This project illustrates how a combination of document retrieval, embeddings, and LLMs can be used to build a sophisticated question-answering system. The RAG-based approach allows for efficient handling of large amounts of information, providing users with precise and concise answers based on context.
You can visit the code here: Github