In this story, I have a super quick tutorial showing you how to create an AI for your PDF with local graph rag, Lang chain, and local LLM to make a powerful agent chatbot for your business or personal use. Graph rag is an RAG that combines Knowledge Graph and generative AI technology to answer inquiries that were difficult to handle with conventional RAGs. In my last video of graph rag, we used API to develop a Knowledge Graph, but this time we are creating an advanced algorithm in which we have full control of our data. That sounds great, isn't it? But here's the kicker: with this method, you can completely tweak and customize your app to fit your needs perfectly. I wanted to create this story to walk you through the most straightforward method I found so you can get things set up and improve your AI chatbot knowledge. Let me give you a quick demo of a live chatbot to show you what I mean. Let me give you a simple example: what is RAG Checker? If you haven't seen this video, I highly

recommend it rag Checker is way better than ragas. If you look at how the local ragraph generates the output, you will see that when a user asks a question, it converts the question into a vector and searches through the stored vectors to find the most relevant chunks of information. We use dextrus algorithm, which finds the shortest path between points to explore the knowledge graph. We start with nodes most closely related to the user's question. As it explores each node, it adds the information to a growing context. If this context doesn't fully answer the question, it looks at neighboring nodes and updates their importance based on connection strength. It continues this process until it finds a complete answer. If it can't find a complete answer from the graph, it uses a large language model to generate one based on the accumulated context. The knowledge graph is then visualized with nodes representing the chunks of text and edges showing how they're related. The edges are colored light blue to indicate the strength of the connections. The path used to find the answer is high.

highlighted with curved dashed arrows, and the start and end points of this path are marked in green and red. Definitely stay tuned throughout the end of this video. If you guys haven't followed me, I highly recommend that you do so, so you can stay up to date with the latest AI news. Lastly, make sure you guys subscribe, turn the notification bell, like this video, and check out previous videos because there is a lot of content that you will definitely benefit from. So, with that thought, let's get right back into the video. Now, let's get on with the guide on how to build an AI chatbot using local graph rag. When it came to building this chatbot, I had many options. I spent a few weeks upskilling and exploring the various technologies available. I have become familiar with Lang chain, Spacey, scar, natural language toolkit, and other libraries that allow us to easily define and interact with different types of abstractions, which makes it easy to build powerful chatbots. I defined a document processor that handles documents by

splitting them into smaller parts, creating embeddings, and then comparing these embeddings to find similarities. We make a function to process the document. Then, it creates a vector store where each chunk of text is stored along with its embedding, which makes it easier to search and compare different chunks later. Sometimes, you have a lot of text to process, and it is slow to do it all at once. It helps break the text into smaller batches, creating embedding for each batch, and combining them into one extensive list. It then compares all those embeddings to see how similar they are to each other. I use cosine similarity, a fancy way of measuring how close two things are in a mathematical sense. I then create a Knowledge Graph to organize information and show how different ideas are connected. Imagine it as building a map where each idea or piece of information is a point, a node, and lines, edges, connect these points if they are similar or related. At the core of this class is a graph structure built with NetworkX. I also use a lemmatizer, simplifying words to their base form.

ensuring that similar concepts are accurately identified and compared. The concept cache acts as a memory bank, storing previously identified concepts to prevent redundant processing, which speeds up the operation. The edges threshold determines how similar two concepts need to be before they are connected in the graph. Next, I made a build graph function to integrate all these components. It adds each document split as a node in the graph, creates embeddings to help the system analyze and identify similarities, uses a large language model to extract key concepts from each split, and finally connects nodes with edges if their concepts are sufficiently similar. In this part, I create the create embedding function that takes documents sections and creates embeddings for each document. We collect the text from each section and use the embedding model to convert these texts into numerical embeddings. It then returns an array of these embeddings, with each entry representing a document section. Next, we create a compute function to calculate the similarity between these embeddings. Measuring the cosine similarity determines how alike different sections of the document are. Cosine similarity compares two sets of numbers or vectors with

values close to one indicating high similarity. Lastly, I use the Spacey model function to load a specific NLP model from Spacey if necessary. It is a tool used for understanding and processing text. Let's create the extract qua Concepts and entities function, which is responsible for extracting important concepts and named entities such as names of people or places from a given piece of text. It uses both Spacey and a large language model (LLM) to achieve this. It checks if the content has already been processed and cached to avoid redundant work. If not, it uses Spacey to find named entities. Then, we use the underscore extract Concepts function to extract concepts from multiple document sections simultaneously to speed up the process. It used ThreadPoolExecutor to handle various tasks simultaneously, where each task involves calling the extract Concepts and entities function for a different document section. As each task is completed, it updates the graph with the concepts found using tqdm to show the progress. Next, we make add edges, which add connections or edges between document sections in a graph based on

their similarity and shared concepts. It calculates how similar each section is to every other section using embeddings. If their similarity score exceeds a certain threshold for each pair of sections, it finds shared concepts and calculates an edge weight based on both similarity and shared concepts. Finally, it updates the graph with these connections, detailing the similarity score, edge weight, and shared concepts while using tqdm to track progress. Then we create an edge weight function to calculate the maximum possible shared concepts and the proportion of actual shared concepts. It combines these with a similarity score using alpha and beta to weigh their importance. The final edge weight indicates how strong the link is between the two sections. Then the litiz concept function simplifies a concept by converting it to lowercase, splitting it into words, and reducing each word to its root form using a lemmatizer. It then combines these root words back into a single string. We define the query engine class to help answer questions using various information sources. It relies on three main components: vector store, which holds numerical representations of text.

Knowledge Graph: a structure for storing and connecting information about different topics, and a large language model that helps understand and generate text. I initialize the query engine, storing these components and setting a limit on how much context it can handle simultaneously (Max context length). It also creates a specialized tool, answer check chain, to verify the completeness of answers. The create answer check chain method sets up a system to determine whether the provided context fully answers the query through a prompt that asks if the context completes the answer. The check answer uses this chain to evaluate whether the provided context answers the query. It sends the query and context to the chain, which then assesses if the context fully answers the question and returns a tuple indicating whether the answer is complete. So, let's make the expand context function to improve query understanding through the exploration of a Knowledge Graph and the gathering of additional information from related documents. It starts with setting up some key variables to keep track of the expanded context, checking the node, and any answers or concepts it has found. The function uses a priority queue to see and

explore the most similar nodes to the initial documents, adding them to the queue based on how strongly they are connected. It then looks at the nodes with the highest priority, adds their content to the context, and checks if this new information answers the query. If the answer isn't complete, it continues to explore neighboring nodes that bring in new concepts and update their priorities. If it still doesn't find a full answer, it uses a large language model (LLM) to create an answer based on all the gathered context. In summary, expanding context improves understanding through careful exploration and expansion of relevant information in the knowledge graph. Then I make the visualized traversal function in the visualizer class to create a detailed visual map of a graph and highlight a specific path through it. It starts with creating a new graph, which copies nodes and edges from the original graph. Then it makes a large plot area using Matplotlib to draw the graph. The function calculates the positions of each node using a layout algorithm and draws the edges in colors that represent their weights, with heavier edges shown.

in different colors. The nodes are displayed in light blue. The function uses red curved arrows to highlight the path through the graph calculated to ensure smooth curves between nodes. It labels each node with its position in the path and any associated concepts, placing these labels on the plot. The start and end nodes of the path are highlighted in light green and light coral, respectively, to make them easy to identify. Finally, the function displays this interactive and informative plot using Streamlit, making it easy to understand complex graph data. We created the graph R class designed to handle document processing and querying in a sophisticated way. When you create an instance, it initializes all the necessary tools: a large language model to generate responses, an embedding model to convert text into numerical formats, a document processor to split and process documents, and a knowledge graph to organize and connect information. When processing documents, the class breaks them into chunks, converts these chunks into embeddings, and then builds a graph that connects all the pieces of information. Once the documents are processed, we can ask questions and the

class will search the graph for relevant information. It shows how it found the answer and provides the response. Finally, we create the main function that sets up a Streamlit app that lets users interact with a PDF document through a chat interface. Users can upload their PDF files. Once a file is uploaded, the app temporarily saves it and processes it. If the PDF is processed successfully, the app initializes chat history with a welcome message and sets up containers for displaying chat messages and input forms. Users can enter their questions about the PDF in a text input box. When they submit a query, the app uses graph R A to process the document and respond. In this video, we explain how graph rack technology can help us answer global and complex questions more accurately, which is crucial for many application scenarios. Combined with the Llama 3 Model, we have improved process proc in efficiency and speed and effectively reduced costs. It is good news for individual users, researchers, and businesses to create a powerful chatbot.

Local GraphRAG + Langchain + Local LLM = Easy AI/Chat for your Docs

Data Analyst @ Marketing | Web Scripting | Artificial Intelligent | Business Intelligence | blockchain I'll help you gain knowledge for an easier experience