Parent Document Retriever Implementation for RAG

Implementation of Parent Document Retriever for RAG

Parent Document Retriever is an architectural RAG pattern solving a fundamental contradiction: small chunks are needed for precise retrieval (better semantic precision), but wide context is needed for quality generation (full section, not 3 sentences). Solution: index small "child" chunks, but pass their "parent" large documents to the LLM.

Parent Document Retriever Architecture

Indexing:
├── Document (2000 tokens)
│   ├── Child chunk 1 (128 tokens) → embedding → index
│   ├── Child chunk 2 (128 tokens) → embedding → index
│   ├── Child chunk 3 (128 tokens) → embedding → index
│   └── Child chunk 4 (128 tokens) → embedding → index

Retrieval:
├── Query → search by child embeddings
├── Found child_chunk_3 (high relevance)
└── Return parent document (2000 tokens) → to LLM

Implementation with LangChain

from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryByteStore, LocalFileStore
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Qdrant
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Storage for parent documents (persistent)
store = LocalFileStore("./parent_docs_store")

# Splitters: child fine, parent coarse
child_splitter = RecursiveCharacterTextSplitter(
    chunk_size=200,
    chunk_overlap=20,
)
parent_splitter = RecursiveCharacterTextSplitter(
    chunk_size=2000,
    chunk_overlap=100,
)

vectorstore = Qdrant.from_texts(
    texts=[],  # Empty — filled via retriever
    embedding=embeddings,
    collection_name="child_chunks",
    url="http://localhost:6333",
)

retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,
    docstore=store,
    child_splitter=child_splitter,
    parent_splitter=parent_splitter,
)

# Indexing
retriever.add_documents(documents, ids=None)

# Query — will return parent documents
relevant_docs = retriever.invoke("procedure for approving purchase")
print(f"Found {len(relevant_docs)} parent documents")
print(f"Size of first: {len(relevant_docs[0].page_content)} chars")

Three-Level Hierarchy

For complex documents, use three levels: document → section → paragraph:

from langchain.retrievers import ParentDocumentRetriever

# Sub-chunk (for indexing) → chunk (parent) → section (grandparent)
sub_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=10)
chunk_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)

retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,
    docstore=store,
    child_splitter=sub_splitter,
    parent_splitter=chunk_splitter,
)

Practical Comparison of Approaches

Dataset: technical regulations (average document 3500 words, 20–40 sections).

Parent Document Retriever significantly improves context recall (+19%) with high faithfulness: child chunks precisely find needed section, parent documents provide full context.

Parent Document Caching

With high QPS, parent documents should be cached in Redis:

import redis
import json

redis_client = redis.Redis(host="localhost", port=6379)

class CachedParentDocumentRetriever:
    def __init__(self, base_retriever, ttl: int = 3600):
        self.retriever = base_retriever
        self.ttl = ttl

    def invoke(self, query: str) -> list:
        # Retrieval child chunks
        child_docs = self.retriever.vectorstore.similarity_search(query, k=5)

        # Load parents with cache
        parent_docs = []
        for child in child_docs:
            parent_id = child.metadata.get("doc_id")
            cache_key = f"parent:{parent_id}"

            cached = redis_client.get(cache_key)
            if cached:
                parent_docs.append(json.loads(cached))
            else:
                parent = self.retriever.docstore.mget([parent_id])[0]
                if parent:
                    redis_client.setex(cache_key, self.ttl, json.dumps(parent.dict()))
                    parent_docs.append(parent)

        return parent_docs

Timeline

• Setting up Parent Document Retriever: 2–3 days
• Tuning optimal chunk sizes: 2–3 days
• Testing and evaluation: 2–3 days
• Total: 1 week