Businesses today handle a large volume of queries from customers, sales teams, and internal stakeholders. Manually responding to these queries is a slow and inefficient process, often leading to delays and inconsistent answers. A query resolution system powered by AI ensures fast, accurate, and scalable responses. It works by retrieving relevant information and generating precise answers using Retrieval-Augmented Generation<\/a> (RAG). In this article, I will be sharing with you my journey of building a RAG-based query resolution system using LangChain<\/a>, ChromaDB<\/a>, and CrewAI<\/a>.<\/p>\n Now, manual responses take time and may, therefore, lead to delays. Customers expect instant replies, and businesses need quick access to accurate information. An AI-driven system automates query handling, reducing workload and improving consistency. It enhances productivity, speeds up decision-making, and provides reliable responses across different sectors.<\/p>\n An AI-powered query resolution system is useful in customer support, where it automates responses and improves customer satisfaction. In sales and marketing, it provides real-time product details and customer insights. Industries like finance, healthcare, education, and e-commerce benefit from automated query handling, ensuring smooth operations and better user experiences.<\/p>\n Before diving into the implementation, let\u2019s first understand how a Retrieval-Augmented Generation (RAG) system works.<\/p>\n The architecture consists of three key stages: Indexing, Retrieval, and Generation.<\/p>\n The system first processes and stores relevant documents to make them easily searchable. Here\u2019s how the indexing process works:<\/p>\n When a user submits a query, the system retrieves relevant data before generating a response. Here are the steps involved in query processing and retrieval:<\/p>\n To generate a well-informed response, the system augments the query with retrieved data. Given below are the steps involved in response generation.<\/p>\n Now that you know how RAG systems work, let\u2019s learn how to build a RAG-based query resolution system.<\/p>\n In this article, I will walk you through building a RAG-based Query Resolution System that efficiently answers learner queries using an AI agent. To keep things simple, I will demonstrate a simplified version of the project and explain how it works.<\/p>\n Before building a RAG-based query resolution system, the most important factor to consider is data \u2013 specifically, the types of data required for effective retrieval. A well-structured knowledge base is essential, as the accuracy and relevance of responses depend on the quality of the data available. Below are the key data types that should be considered for different purposes:<\/p>\n Selecting the right data sources was crucial for our learner query resolution system, to ensure accurate and relevant responses. Initially, I experimented with different types of data to determine which provided the best results. First, I used PowerPoint slides (PPTs), but they didn\u2019t yield comprehensive answers as expected. Next, I incorporated common queries, which improved response accuracy but lacked sufficient context. Then, I tested past discussions, which helped in making responses more relevant by leveraging previous learner interactions. However, the most effective approach turned out to be using subtitles from course videos, as they provided structured and detailed content directly related to learner queries. This approach helps in providing quick and relevant answers, making it useful for e-learning platforms and educational support systems.<\/p>\n Before coding, it is important to structure the Query Resolution System. The best way to do this is by defining the key tasks it needs to perform.<\/p>\n The system will handle three main tasks:<\/p>\n To achieve this, the system is divided into three components, each handling a specific function. This ensures efficiency and scalability.<\/p>\n The system consists of:<\/p>\n Each component ensures efficient query resolution, personalized responses, and smooth content retrieval. Now that we have our structure, let\u2019s move on to implementation.<\/p>\n Now that we have our structure, let\u2019s move on to implementation.<\/span><\/p>\n To build the AI-powered learning support system, we first need to import essential libraries.<\/p>\n Let\u2019s understand these libraries.<\/p>\n To use OpenAI\u2019s API for embeddings, we must load the API key and configure the model settings.<\/p>\n Step 1:<\/strong> Read the API key from a local text file.<\/p>\n Step 2:<\/strong> Store the API key as an environment variable so it can be accessed by other components.<\/p>\n Step3:<\/strong> Specify the OpenAI model to be used for processing embeddings.<\/p>\n By setting up these configurations, we ensure seamless integration with OpenAI\u2019s API, allowing our system to process and store embeddings efficiently.<\/p>\n Subtitles often contain valuable insights from video lectures, making them a rich source of structured content for AI-based retrieval systems. Extracting and processing subtitle data effectively allows for efficient search and retrieval of relevant information when answering learner queries.<\/p>\n To preserve educational insights, we are using pysrt to read and preprocess text from SRT files. This ensures the extracted content is structured and ready for further processing and storage..<\/p>\n Since courses may have multiple subtitle files, we systematically organize and iterate through course materials stored in predefined folders. This allows for seamless text extraction and further processing.<\/p>\n This extracted text forms the foundation of our AI-driven learning support system, enabling advanced retrieval and query resolution.<\/p>\n In this part, we will break down the process of storing course subtitles in ChromaDB, including text chunking, embedding generation, persistence, and cost estimation.<\/p>\n a. Persistent Directory for ChromaDB<\/b><\/p>\n The persist_directory is a folder path where the stored data will be saved, allowing us to retain embeddings even after restarting the program. Without this, the database would reset after each execution.<\/p>\n ChromaDB is used as a vector database to store and retrieve embeddings efficiently.<\/p>\n b. Splitting Text into Smaller Chunks<\/b><\/p>\n Large documents (like entire course subtitles) exceed token limits for embeddings. To handle this, we use RecursiveCharacterTextSplitter to break text into smaller, overlapping chunks to improve search accuracy.<\/p>\n Each chunk is 1,000 characters long, ensuring that the text is broken into manageable pieces. To maintain context between chunks, 200 characters from the previous chunk are included in the next one. This overlap helps preserve important details and improves retrieval accuracy.<\/p>\n c. Initializing OpenAI Embeddings and ChromaDB Vector Store<\/b><\/p>\n We need to convert text into numerical vector representations for similarity search. OpenAI\u2019s embeddings allow us to encode our course content into a format that can be searched efficiently.<\/p>\n Here, OpenAIEmbeddings() initializes the embedding model using our OpenAI API key (openai_api_key). This ensures that every text chunk gets converted into a high-dimensional vector representation.<\/p>\n d. Initializing ChromaDB<\/b><\/p>\n Now, we store these vector embeddings in ChromaDB.<\/p>\n The collection_name=\u201dcourse_materials\u201d creates a dedicated collection in ChromaDB to organize all course-related embeddings. The embedding_function=embeddings specifies OpenAI embeddings for converting text into numerical vectors. The persist_directory=persist_directory ensures that all stored embeddings remain available in .\/subtitles_db\/, even after restarting the program.<\/p>\n Before adding documents to the vector database, it is essential to estimate the cost of token usage. Since OpenAI charges per 1,000 tokens, we calculate the expected cost to manage expenses efficiently.<\/p>\n a. Defining Pricing Parameters<\/b><\/p>\n Since OpenAI charges per 1,000 tokens, we estimate the cost before adding documents.<\/p>\n The COST_PER_1K_TOKENS = 0.0001 defines the cost per 1,000 tokens when using OpenAI embeddings. The TOKENS_PER_CHUNK_ESTIMATE = 750 estimates that each 1,000-character chunk contains about 750 tokens. The total_tokens and total_cost variables track the total processed data and cost incurred during execution. The start_time variable records the starting time to measure how long the process takes.<\/p>\n We want to avoid reprocessing courses that are already stored in the vector database. So for that we are querying ChromaDB to check if the course already exists. If the course is not found, we extract and store its subtitle data.<\/p>\n The subtitles are extracted using the extract_text_from_srt() function. Multiple subtitle files are then joined together using \\n\\n\\n\\n to improve readability. A Document object is created, storing the full subtitle text along with its metadata. Finally, the text is split into smaller chunks using text_splitter.split_documents() for efficient processing and retrieval.<\/p>\n c. Estimating Token Usage and Cost<\/b><\/p>\n Before adding the chunks to ChromaDB, we estimate the cost.<\/p>\n The chunk_count represents the number of chunks generated after splitting the text. The batch_tokens estimates the total number of tokens based on the chunk count. The batch_cost calculates the estimated cost for processing the current course. The total_tokens and total_cost accumulate values across all courses to track overall processing and expenses.<\/p>\n d. Adding Chunks to ChromaDB<\/b><\/p>\n The processed chunks are stored in ChromaDB for efficient retrieval. A message is displayed, indicating the number of chunks added and the estimated processing cost.<\/p>\n Once all courses are processed, we calculate and display the final results.<\/p>\n The total processing time is calculated using (end_time \u2013 start_time). The system then displays the number of chunks processed, the estimated token usage, and the overall cost. Finally, it provides a summary of the entire embedding process.<\/p>\n Output:<\/strong><\/p>\n From the output, we can see that a total of 739 chunks were processed in 10 seconds, with an estimated cost of $0.0554.<\/p>\n Once the subtitles are stored in ChromaDB, the system needs a way to retrieve relevant content when a learner submits a query. This retrieval process is handled using similarity search, which identifies stored text segments which are most relevant to the input query.<\/p>\n How it Works:<\/p>\n Example queries:<\/p>\n The output consists of the retrieved content from ChromaDB, filtered by course name and question, using similarity search to find the most relevant information.<\/p>\n This mechanism ensures that when a learner submits a question, they receive relevant and contextually accurate information from stored course materials.<\/p>\n Once relevant course material is retrieved from ChromaDB, the next step is to use an AI-powered agent to formulate meaningful responses to learner queries. CrewAI is used to define an intelligent agent responsible for analyzing queries and generating well-structured responses.<\/p>\n Now, let\u2019s see how it works.<\/p>\n The query answering agent is created with a clear role and backstory to guide its behavior when responding to learner queries.<\/p>\n Let\u2019s understand what is happening in the code block. Firstly, we are providing the role as Learning Support Specialist since the agent acts as a virtual tutor that answers student queries. Then, we define the goal, ensuring that the agent prioritizes accuracy and clarity in its responses. Lastly, we set verbose=False, which keeps the execution silent unless debugging is needed. This well-defined agent role ensures that responses are helpful, structured, and aligned with the educational platform\u2019s tone.<\/p>\n After defining the agent, we need to assign it a task<\/p>\n Let\u2019s break down the task provided to the AI agent. The query handling involves processing {query}, which represents the learner\u2019s question. The response should be concise (under 100 words) and accurate. When using course content, {relevant_content} is extracted from subtitles stored in ChromaDB, and the AI must correct any spelling errors before including the content in its response.<\/p>\n If past discussions exist, {thread} helps maintain continuity. Learner queries start with \u201clearner\u201d, while past responses begin with \u201csupport\u201d, allowing the agent to provide context-aware answers. Personalization is achieved using {learner_name}\u2014the agent\u00a0 addresses students by their first name or defaults to \u201cHi\u201d if uncertain.<\/p>\n To make responses more engaging, the AI adds a positive closing statement, such as \u201cHope you found this helpful!\u201d or \u201cFeel free to reach out anytime.\u201d If the AI is unsure about an answer, it explicitly states: \u201cSorry, I am not sure about this, I will get back to you.\u201d This approach ensures politeness, clarity, and a structured response format, enhancing learner engagement and trust.<\/p>\n Now that we have both the agent and the task, we initialize CrewAI, which enables the agent to process queries dynamically.<\/p>\n The agents=[query_answer_agent] parameter adds the Learning Support Specialist agent to the crew. The tasks=[query_answering_task] assigns the query answering task to this agent. Setting verbose=False keeps the output minimal unless debugging is needed. CrewAI enables the system to process multiple learner queries simultaneously, making it scalable and efficient for dynamic query handling.<\/p>\n Why Use CrewAI for Query Answering?<\/strong><\/p>\n By implementing this AI-powered answering system, learners receive well-informed responses tailored to their specific queries.<\/p>\n Once the AI agent is set up, it needs to dynamically process learner queries stored in a structured dataset.<\/p>\n The below code processes learner queries stored in a CSV file and generates responses using an AI agent. It first loads the dataset containing learner queries, course details, and discussion threads. The reply_to_query function extracts relevant details like the learner\u2019s name, course name, and current query. If previous discussions exist, they are retrieved for context. If the query contains an image, it is skipped. The function then fetches related course materials from ChromaDB and sends the query, relevant content, and past discussions to the AI agent for generating a structured response.<\/p>\n Testing the function, it is executed for one query (index=1)<\/p>\n From this we can see that it works fine just for one index.<\/p>\n Now, iterating through all queries, processing each one while handling potential errors. This ensures efficient automation of query resolution, allowing multiple learner queries to be processed dynamically.<\/p>\n Why is This Step Important?<\/strong><\/p>\n This step ensures that every learner query is analyzed, contextualized, and answered effectively, enhancing the overall learning experience.<\/p>\n Output:<\/strong><\/p>\n From the output we can see that the process of replying to the query has become automated\u00a0 followed by question and then answer.<\/p>\n To upgrade the RAG-Based Query Resolution System, several enhancements can be made:<\/p>\n This RAG-Based Query Resolution System leverages LangChain, ChromaDB, and CrewAI to automate learner support efficiently. It extracts subtitles, stores them as embeddings in ChromaDB, and retrieves relevant content using similarity search. A CrewAI agent processes queries, references past discussions, and generates structured responses, ensuring accuracy and personalization.<\/p>\n The system enhances scalability, retrieval efficiency, and response quality, making self-paced learning more interactive. Future improvements include multi-modal support, better retrieval optimization, and enhanced response generation. By automating query resolution, this system streamlines learning support, providing learners with faster, context-aware responses and improving overall engagement.<\/p>\n A. LangChain is a framework for building applications powered by language models (LLMs). It helps in processing, retrieving, and generating responses from text-based data. In this project, LangChain is used for splitting text into chunks, generating embeddings, and retrieving course materials efficiently.<\/p>\n<\/p><\/div>\n A. ChromaDB is a vector database designed for storing and retrieving embeddings. It converts course materials into numerical representations, allowing similarity-based searches to find relevant content when a learner submits a query.<\/p>\n<\/p><\/div>\n A. CrewAI enables the creation of AI agents that handle tasks dynamically. In this project, it powers a Learning Support Specialist agent that retrieves course materials, processes past discussions, and generates structured responses for learner queries.<\/p>\n<\/p><\/div>\n A. OpenAI embeddings convert text into numerical vectors, making it easier to perform similarity searches. This helps in efficiently retrieving relevant course materials based on a learner\u2019s query.<\/p>\n<\/p><\/div>\n A. The system uses pysrt to extract text from subtitle (SRT) files. The extracted content is then chunked, embedded using OpenAI embeddings, and stored in ChromaDB for retrieval when needed.<\/p>\n<\/p><\/div>\n A. Yes, the system is scalable and can process multiple learner queries dynamically using CrewAI\u2019s task management. This ensures quick and efficient responses.<\/p>\n<\/p><\/div>\n A. Future enhancements include multi-modal support for images and videos, better retrieval optimization, and improved response generation techniques to provide even more accurate and contextual answers.<\/p>\n<\/p><\/div>\n<\/p><\/div>\nWhy Do We Need an AI-powered Query Resolution System?<\/h2>\n
Understanding the RAG Workflow<\/h2>\n
![\"RAG-based](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/03\/Artboard-1-copy-21.webp\")
1. Building a Vector Store (Document Processing & Storage)<\/h4>\n
\n
2. Query Processing & Retrieval<\/h4>\n
\n
3. Augmentation & Response Generation<\/h4>\n
\n
Building a RAG-based Query Resolution System<\/h2>\n
Selecting the Right Data for Query Resolution<\/h3>\n
\n
Structuring the Query Resolution System<\/h3>\n
\n
\n
Implementation Steps<\/h2>\n
1. Importing Libraries<\/h3>\n
import pysrt\nfrom langchain.text_splitter import RecursiveCharacterTextSplitter\nfrom langchain.schema import Document\nfrom langchain.embeddings import OpenAIEmbeddings\nfrom langchain.vectorstores import Chroma\nfrom crewai import Agent, Task, Crew \nimport pandas as pd\nimport ast<\/code><\/pre>\n\n
2. Setting Up the Environment<\/h3>\n
with open('\/home\/janvi\/Downloads\/openai.txt', 'r') as file:\n openai_api_key = file.read()<\/code><\/pre>\nos.environ['OPENAI_API_KEY'] = openai_api_key\n<\/code><\/pre>\nos.environ[\"OPENAI_MODEL_NAME\"] = 'gpt-4o-mini'\n<\/code><\/pre>\n3. Extracting and Storing Subtitle Data<\/h3>\n
def extract_text_from_srt(srt_path):\n \"\"\"Extracts text from an SRT subtitle file using pysrt.\"\"\"\n subs = pysrt.open(srt_path)\n text = \" \".join(sub.text for sub in subs)\n return text<\/code><\/pre>\n# Define course names and their respective folder paths\ncourse_folders = {\n \"Introduction to Deep Learning using PyTorch\": \"C:\\M\\Code\\GAI\\Learn_queries\\Subtitle_Introduction_to_Deep_Learning_Using_Pytorch\",\n \"Building Production-Ready RAG systems using LlamaIndex\": \"C:\\M\\Code\\GAI\\Learn_queries\\Subtitle of Building Production-Ready RAG systems using LlamaIndex\",\n \"Introduction to LangChain - Building Generative AI Apps & Agents\": \"C:\\M\\Code\\GAI\\Learn_queries\\Subtitle_introduction_to_langchain_using_agentic_ai\"\n}\n\n\n# Dictionary to store course names and their respective .srt file paths\ncourse_srt_files = {}\n\n\n# Iterate through course folder mappings\nfor course, folder_path in course_folders.items():\n srt_files = []\n \n # Walk through the directory to find .srt files\n for root, _, files in os.walk(folder_path):\n srt_files.extend(os.path.join(root, file) for file in files if file.endswith(\".srt\"))\n \n # Add to dictionary if there are .srt files\n if srt_files:\n course_srt_files[course] = srt_files<\/code><\/pre>\nStep 2: Storing Subtitles in ChromaDB<\/h4>\n
persist_directory = \".\/subtitles_db\"\n<\/code><\/pre>\n# Text splitter to break documents into smaller chunks\ntext_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)<\/code><\/pre>\n# Initialize OpenAI embeddings\nembeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)<\/code><\/pre>\n# Initialize Chroma vectorstore with persistent directory\nvectorstore = Chroma(\n collection_name=\"course_materials\",\n embedding_function=embeddings,\n persist_directory=persist_directory\n)\n<\/code><\/pre>\nStep 3: Estimating Cost of Storing Course Data<\/h4>\n
import time\n\n\n# OpenAI Pricing (adjust based on the model being used)\nCOST_PER_1K_TOKENS = 0.0001 # Cost per 1K tokens for 'text-embedding-ada-002'\nTOKENS_PER_CHUNK_ESTIMATE = 750 # Approximate tokens per 1000-character chunk\n\n\n# Track total tokens and cost\ntotal_tokens = 0\ntotal_cost = 0\n\n\n# Start timing\nstart_time = time.time()\n<\/code><\/pre>\nb. Checking and Adding Courses to ChromaDB<\/h4>\n
# Add new courses to the vectorstore if they don't already exist\nfor course, srt_list in course_srt_files.items():\n # Check if the course already exists in the vectorstore\n existing_docs = vectorstore._collection.get(where={\"course\": course})\n if not existing_docs['ids']:\n # Course not found, add it\n srt_texts = [extract_text_from_srt(srt) for srt in srt_list]\n course_text = \"\\n\\n\\n\\n\".join(srt_texts) # Join SRT texts with four new lines\n doc = Document(page_content=course_text, metadata={\"course\": course})\n chunks = text_splitter.split_documents([doc])<\/code><\/pre>\n # Estimate cost before adding documents\n chunk_count = len(chunks)\n batch_tokens = chunk_count * TOKENS_PER_CHUNK_ESTIMATE\n batch_cost = (batch_tokens \/ 1000) * COST_PER_1K_TOKENS\n total_tokens += batch_tokens\n total_cost += batch_cost<\/code><\/pre>\n vectorstore.add_documents(chunks)\n print(f\"Added course: {course} (Chunks: {chunk_count}, Cost: ${batch_cost:.4f})\")\n else:\n print(f\"Course already exists: {course}\")<\/code><\/pre>\n# End timing\nend_time = time.time()\n\n\n# Display cost and time\nprint(f\"\\nCourse Embeddings Update Completed! \ud83d\ude80\")\nprint(f\"Total Chunks Processed: {total_tokens \/\/ TOKENS_PER_CHUNK_ESTIMATE}\")\nprint(f\"Estimated Total Tokens: {total_tokens}\")\nprint(f\"Estimated Cost: ${total_cost:.4f}\")\nprint(f\"Total Time Taken: {end_time - start_time:.2f} seconds\")\n<\/code><\/pre>\n![\"Building](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/03\/Output1.webp\")
<\/figure>\n4. Querying and Responding to Learner Queries<\/h3>\n
\n
# Define retrieval tool with metadata filtering\ndef retrieve_course_materials(query: str, course = course):\n \"\"\"Retrieves course materials filtered by course name.\"\"\"\n filter_dict = {\"course\": course}\n results = vectorstore.similarity_search(query, k=3, filter=filter_dict)\n return \"\\n\\n\".join([doc.page_content for doc in results])<\/code><\/pre>\ncourse_name = \"Introduction to Deep Learning using PyTorch\"\nquestion = \"What is gradient descent?\"\ncontext = retrieve_course_materials(query=question, course= course_name)\nprint(context)<\/code><\/pre>\n![\"Building](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/03\/output2-1.webp\")
<\/figure>\nWhy is Similarity Search Used?<\/h4>\n
\n
5. Implementing the AI Query Answering Agent<\/h3>\n
Step 1: Defining the Agent<\/h4>\n
# Define the agent with a well-structured role and backstory\nquery_answer_agent = Agent(\n role = \"Learning Support Specialist\",\n goal = \"You help learners with their queries with the best possible response\",\n backstory = \"\"\"You lead the Learners Query resolution department of \n an Ed tech company focussed on self paced courses on topics related to \n Data Science, Machine Learning and Generative AI. You respond to learner\n queries related to course content, assignments, technical and administrative issues. \n You are polite, diplomatic and take ownership of things which could be \n imporved in your oragnisation.\n \n \"\"\",\n verbose = False,\n)\n<\/code><\/pre>\nStep 2: Defining the Task<\/h4>\n
query_answering_task = Task(\n description= \"\"\"\n Answer the learner queries to the best of your abilities. Try to keep your response concise with less than 100 words.\n Here is the query: {query}\n\n\n Here is similar content from the course extracted from subtitles, which you should use only when required: {relevant_content} . \n Since this content is extracted from course subtitles, there may be spelling errors, make sure to correct these, while using this information in your response.\n\n\n There may be some previous discussion with the learner on this thread. Here is the python list of past discussions: {thread} . \n In this thread, the content which starts with 'learner' is the question by the student and the content which starts with 'support' \n is the response given by you. Use this past discussion appropriatly to come with a great reply.\n\n\n This is the full name of the learner: {learner_name}\n Address each learner by their first name, if you are not sure what the first name is, simply start with Hi.\n Also mention some appropriate and encouraging comforting lines at the end of the reponse, like \"hope you found this helpful\", \n \"I hope this information is useful. Keep up the great work!\", \"Glad to assist! Feel free to reach out anytime.\" etc.\n\n\n If you are not sure about the answer mention - \"Sorry, I am not sure about this, I will get back to you\"\n\n\n \"\"\",\n expected_output = \"A crisp accurate response to the query\",\n agent=query_answer_agent)\n<\/code><\/pre>\nStep 3: Initializing the CrewAI Instance<\/h4>\n
# Create the Crew\nresponse_crew = Crew(\n agents=[query_answer_agent],\n tasks=[query_answering_task],\n verbose=False\n)\n<\/code><\/pre>\n\n
Step 4: Generating Responses for Multiple Learner\u2019s Queries<\/h4>\n
df = pd.read_csv(filepath_or_buffer=\"C:\\M\\Code\\GAI\\Learn_queries\/filtered_data_top3_courses.csv\")\ndef reply_to_query(df_new=df_new, index=1):\n learner_name = df_new.iloc[index][\"thread_starter\"]\n course_name = df_new.iloc[index][\"course\"]\n if df_new.iloc[index]['number_of_replies']>1:\n thread = ast.literal_eval(df_new.iloc[index][\"modified_thread\"])\n else:\n thread = []\n question = df_new.iloc[index][\"current_query\"]\n if df_new.iloc[index]['has_image'] == True:\n return \" \"\n \n\n\n context = retrieve_course_materials(query = question , course=course_name)\n\n\n response_result = response_crew.kickoff(inputs={\"query\": question, \"relevant_content\": context, \"thread\": thread, \"learner_name\": learner_name})\n print('Q: ', question)\n print('\\n')\n print('A: ', response_result)\n print('\\n\\n')<\/code><\/pre>\nreply_to_query(df, index=1)<\/code><\/pre>\n![\"sample](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/03\/Output3-1.webp\")
<\/figure>\nfor i in range(len(df)):\n try:\n reply_to_query(df, index=i)\n except:\n print(\"Error in index number: \", i)\n continue<\/code><\/pre>\n\n
![\"sample](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/03\/Output4-1.webp\")
<\/figure>\nFuture Improvements<\/h2>\n
\n
Conclusion<\/h2>\n
Frequently Asked Questions<\/h2>\n
![\"Janvi](\"https:\/\/av-eks-lekhak.s3.amazonaws.com\/media\/lekhak-profile-images\/converted_image_ToTu2tx.webp\")
<\/p>\n