Code in 2_parent_document_retriever.ipynb file.

Think about that now we have created a RAG to acknowledge potential illnesses by introducing a few of their signs within the session. Within the occasion that now we have a Naive RAG, we might acquire a collection of potential illnesses that solely coincide in a single or two signs, leaving our device in a little bit of a nasty place.

This is a perfect case to make use of Mum or dad Doc Retriever. And the kind of approach consists of reducing giant chunks (mum or dad chunk) into even smaller items (little one chunk). By having small chunks, the knowledge they include is extra concentrated and subsequently, its informative worth will not be diluted between paragraphs of textual content.

There’s a small downside in all this:

• If we wish to be exact in looking for probably the most related paperwork, we have to break our paperwork into small chunks.
• However additionally it is essential to offer good context to the LLM, which is achieved by offering bigger chunks.

What has been mentioned could be seen within the following picture:

Plainly there isn’t a manner out of the issue, since once we improve the precision, the context is lowered, and vice versa. That is when this technique seems that may remedy our lives.

The principle concept is to additional chop the massive chunks (Mum or dad chunks/paperwork) into smaller chunks (Youngster Chunks/paperwork). As soon as that is executed, carry out the seek for probably the most related high Ok paperwork with the kid chunks, and return the dad and mom chunks to which the highest Ok little one doc belongs.

We have already got the primary concept, now let’s get it all the way down to earth. The easiest way to elucidate it’s step-by-step:

1. Receive the paperwork and create the massive chunks (Mum or dad chunks)
2. Carry out a cut up of every of the mum or dad chunks for the expansion of the little one chunks.
3. Save the kid chunks (Vector Representation) within the Vector Retailer.
4. Save the mum or dad chunks in reminiscence (We don’t have to create their vector illustration).

What has been mentioned could be seen within the following picture:

This will appear very advanced to create, since now we have to create a brand new database with the small chunks, save the mum or dad chunks in reminiscence. Moreover, know which mum or dad chunk every little one chunk belongs to. Thank goodness Langchain exists and the way in which to construct it’s tremendous easy.

Certainly you’ve got come to the conclusion that it’s essential to create a brand new vector retailer for this technique. Moreover, within the case of opinions of the John Wick motion pictures, akin to the information supply with CSV recordsdata, it’s not essential to carry out the primary cut up (mum or dad chunks). It is because we will take into account every row of our csv recordsdata to be a piece in itself.

General, let’s visualize the next picture that displays how this technique works:

Going to code it’s represented as follows:

from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
# paperwork = Learn csv recordsdata. Test jupyter pocket book for extra particulars
parent_docs = paperwork
# Embedding Mannequin
embeddings = OpenAIEmbeddings(mannequin="text-embedding-3-small")
# Splitters
child_splitter = RecursiveCharacterTextSplitter(chunk_size=200)
# We do not want a mum or dad splitter as a result of the information cames from CSV file, and every row is a mum or dad doc.
# parent_splitter = RecursiveCharacterTextSplitter(chunk_size=800)
# Shops
retailer = InMemoryStore()
vectorstore = Chroma(embedding_function=embeddings, collection_name="fullDoc", persist_directory="./JohnWick_db_parentsRD")
parent_document_retriever = ParentDocumentRetriever(
vectorstore=vectorstore,
docstore=retailer,
child_splitter=child_splitter,
# parent_splitter =parent_splitter
)

One thing intuitive about what occurs right here is that the variety of chunks within the vector retailer (variety of little one chunks) must be a lot larger than the variety of paperwork saved in reminiscence (mum or dad chunks). With the next code we will examine it:

print(f"Variety of mum or dad chunks  is: {len(listing(retailer.yield_keys()))}")
print(f"Variety of little one chunks is: {len(parent_document_retriever.vectorstore.get()['ids'])}")
'''
Variety of mum or dad chunks  is: 75
Variety of little one chunks is: 3701
'''

Nice, we might have already got our Mum or dad Doc Retriever, we simply have to create our RAG based mostly on this retriever and that might be it. It will be executed precisely the identical as within the earlier technique. I connect the code for creating the chain in langchain. To see extra particulars, check out the jupyter pocket book.

setup_and_retrieval = RunnableParallel({"query": RunnablePassthrough(), "context": parent_document_retriever })
output_parser = StrOutputParser()
parent_retrieval_chain = setup_and_retrieval | rag_prompt | chat_model | output_parser

Be aware that it’s precisely the identical as within the earlier case, solely with the small distinction that within the “setup_and_retrieval” variable, we configure that we wish to use our “parent_document_retriever”, as an alternative of the “naive_retriever”.