Retrieval-Augmented Generation

Retrieval-augmented generation connects a generative model to a searchable knowledge source. Instead of relying only on model weights, the system fetches relevant documents and places them into the prompt or context.

How does chunk size affect retrieval quality?

Chunk size affects retrieval quality because it changes how much information each indexed unit contains and how precisely that unit can match a user's query . The main tradeoff is between retrieval precision and context preservation . Smaller chunks can improve precision Smaller chunks usually cover a narrower topic. This can make it easier for the retriever to find the exact passage that matches a specific query. For example, a small chunk containing only: may rank very well for a query about API timeout. If that same fact is buried inside a much larger chunk containing authentication, logging, deployment, and billing information, the retrieval signal may become less focused. But very small chunks can lose context If chunks are too small, important relationships may be broken apart. For example: If a question requires understanding both statements together, retrieving only one chunk may produce incomplete context. Very small chunks can also separate: Definitions from explanations Headings from their content Conditions from outcomes Steps in a workflow Larger chunks preserve more context Larger chunks can keep several related sentences or paragraphs together. This is useful when answers depend on broader context, such as: Procedures Policies Multi step workflows Technical explanations However, larger chunks may include more irrelevant content. Large chunks can reduce retrieval precision If one chunk covers many topics, its embedding or retrieval representation must summarize all of them. This can make the chunk less strongly associated with any one specific topic. As a result, the retriever may: Rank the chunk lower than expected Return broad but less focused passages Send unnecessary text to the language model Chunk size also affects ranking diversity Very small chunks may create many highly similar neighboring chunks. Retrieval can then return several nearly identical passages instead of diverse evidence. Very large chunks create the opposite problem: fewer retrieval units exist, but each one contains more mixed information. Chunk size interacts with overlap Overlap can reduce the risk of losing context at chunk boundaries. For example: But increasing both chunk size and overlap can create significant duplication. Too much duplication may cause several similar chunks to rank together. Chunk size affects prompt efficiency Retrieved chunks eventually become part of the context sent to the language model. If chunks are very large: Fewer chunks fit into the available context window. More irrelevant text may consume tokens. If chunks are reasonably focused, the system can combine evidence from several relevant locations. The effect depends on the query Different queries may prefer different chunk sizes. A factual query such as: may benefit from a small, focused chunk. A broader query such as: may require a larger chunk containing several related steps. How should retrieval quality be tested? Evaluate several candidate chunk sizes using representative queries. For each size, measure or inspect: Whether the correct evidence appears in the top results Whether retrieved chunks contain enough context Whether irrelevant content dominates the result Whether multiple returned chunks are duplicates Whether downstream answers improve Do not choose a chunk size only because it is commonly used elsewhere. For the definition of chunk size itself, see “What is chunk size in RAG?” . In short, smaller chunks usually improve retrieval precision, while larger chunks preserve more context. The best retrieval quality comes from finding a size that balances both and validating it with real queries.

What happens when RAG chunks are too small?

When RAG chunks are too small , they may become highly precise but lose the surrounding context needed to understand the information correctly. Small chunks are not always bad, but making them too small can create several retrieval problems. 1. Important context gets separated A statement may depend on the sentence or paragraph around it. For example: If the retriever returns only the first chunk, the answer may miss the condition in the second chunk. 2. Definitions can be separated from explanations A very small chunk may contain only part of a concept. For example: One chunk contains the term. Another chunk contains the definition. A third chunk contains the example. Retrieving only one of them can produce incomplete context. 3. Multi step processes can become fragmented Workflows, procedures, and policies often require several related steps. If every step becomes a separate tiny chunk, the retriever may need to find many chunks to reconstruct the full process. This makes retrieval and prompt construction more complex. 4. More chunks must be searched and ranked Smaller chunks increase the total number of indexed items. This can lead to: More candidates during retrieval More ranking work More storage for embeddings and metadata More chances of returning nearly identical neighboring chunks 5. Similar neighboring chunks can dominate results If a document is split into many tiny chunks, several chunks may contain very similar language. The top retrieval results may then look like: This reduces result diversity and can crowd out other useful evidence. 6. Small chunks depend more on metadata A tiny chunk may not make sense without its: Section heading Parent heading Page number Document title Good metadata becomes more important as chunk size decreases. 7. More overlap may be needed Overlap can help preserve context between very small chunks. But increasing overlap creates more duplicated text in the index. This can increase storage and cause repeated retrieval results. 8. Answers may become incomplete If the language model receives several isolated facts without the relationships between them, it may produce an answer that is technically based on retrieved evidence but still incomplete or misleading. When small chunks are useful Small chunks can work well for: Short factual records FAQ entries Product attributes Error code definitions Highly structured data They are most effective when each chunk can stand on its own. How to know chunks are too small Look for symptoms such as: Correct chunks are retrieved but lack enough context. Several adjacent chunks are needed for one answer. Top results contain many near duplicates. Headings or conditions are frequently separated from the content they explain. Answer quality improves significantly when neighboring chunks are added. For the opposite problem, see “What happens when RAG chunks are too large?” . In short, RAG chunks that are too small can fragment meaning, increase retrieval overhead, and produce incomplete context. A good chunk should be focused enough for precise retrieval while still containing enough information to stand on its own.

What happens when RAG chunks are too large?

When RAG chunks are too large , each chunk may contain too many topics or details, which can reduce retrieval precision and waste context window space. Large chunks preserve more surrounding context, but beyond a certain point the extra text can make retrieval less focused. 1. Several topics may be mixed together A large chunk may contain unrelated subjects such as: Authentication Billing Logging Deployment If a user asks only about authentication, the retriever may still return a chunk containing all four topics. This increases the amount of irrelevant information passed downstream. 2. Retrieval precision can decrease Retrieval works best when an indexed unit represents a reasonably focused concept. If one chunk covers many topics, its retrieval representation must represent all of them at once. As a result, the chunk may be only moderately similar to a specific query instead of strongly matching it. 3. Embedding meaning can become diluted When embeddings are used, a large multi topic chunk is represented by one vector. That vector summarizes the entire chunk rather than one precise fact. For example, a chunk containing both API security and billing rules may not represent either topic as clearly as two separate focused chunks. 4. More irrelevant text reaches the language model Once a large chunk is retrieved, the entire chunk may be included in the prompt. This can: Consume more tokens Increase processing cost Increase latency Distract the model from the most relevant evidence The goal of retrieval is not just to find the correct document, but to provide the most useful evidence with minimal unnecessary content. 5. Fewer chunks fit into the context window If each retrieved chunk is very large, only a small number of chunks may fit into the model's available context. This can reduce evidence diversity. For example, instead of retrieving relevant passages from five documents, the system may only have room for two very large chunks. 6. Reranking becomes less precise A reranker may know that a large chunk contains relevant information, but it still has to rank the whole chunk as one unit. A smaller focused passage can often be ranked more accurately because the relevant information is easier to isolate. 7. Citations may become less specific If a retrieved chunk spans several pages or sections, the final answer may point to a broad source location rather than the exact passage supporting the claim. More focused chunks usually make source attribution easier. 8. Large chunks may hide the exact answer A chunk can technically contain the correct answer while surrounding it with so much unrelated text that the key evidence becomes harder to identify. For example: A focused timeout chunk would provide a stronger retrieval signal for a timeout query. When larger chunks are useful Larger chunks can still be appropriate when: The answer requires several related paragraphs The content describes a workflow or procedure Individual sentences depend heavily on surrounding context The source section is already focused on one topic The problem is not large chunks by themselves, but large chunks that contain more information than the retrieval task needs . How to know chunks are too large Look for symptoms such as: Retrieved passages contain substantial irrelevant text. Specific queries return broad sections instead of precise evidence. Relevant chunks rank lower than expected. Prompt token usage is high compared with the amount of useful evidence. Only a few retrieved sources fit into the final context. Smaller test chunks improve retrieval metrics or answer quality. For the opposite problem, see “What happens when RAG chunks are too small?” . In short, RAG chunks that are too large can mix topics, dilute retrieval signals, consume unnecessary context window space, and reduce precision. A good chunk should preserve enough context without carrying large amounts of unrelated information.

What is chunk overlap in RAG?

Chunk overlap in RAG is the amount of content intentionally repeated between two neighboring chunks. It is used to reduce the chance that important information is lost when a document is split at a chunk boundary. Simple example Suppose the chunk size is 500 tokens and the overlap is 50 tokens. The chunks may look like: The last 50 tokens of one chunk are repeated at the beginning of the next chunk. Why overlap is useful Important information often spans a boundary. For example: If the split happens between those two parts, each chunk may contain only part of the statement. Overlap increases the chance that at least one chunk contains enough of the complete idea to be retrieved and understood. What overlap helps preserve Overlap can help keep together: A sentence and its continuation A heading and the first paragraph below it A definition and its explanation Consecutive steps in a process Conditions and their outcomes Overlap is not a separate chunking strategy Overlap is usually a configuration applied to a chunking method . It can be used with: Fixed size chunking Recursive chunking Sentence based chunking Some structure based strategies Too little overlap If overlap is too small, important context may still be split across neighboring chunks. This is more likely when: Sentences are long Concepts span several paragraphs Fixed size boundaries are used Too much overlap Excessive overlap creates duplicated content in the index. This can cause: More chunks to store More embeddings to generate Higher ingestion cost Similar chunks appearing together in search results Less diversity in the retrieved evidence For example, if neighboring chunks are mostly identical, the retriever may return several versions of the same passage. Overlap should not compensate for poor chunking If natural document boundaries are available, it is usually better to preserve them rather than relying on very large overlap. For example, keeping a paragraph intact is generally cleaner than splitting it arbitrarily and then duplicating half of it into the next chunk. Sentence overlap Overlap does not always have to be measured in tokens. A sentence based strategy might repeat one complete sentence: This can preserve cleaner context than repeating an arbitrary token range. How much overlap should be used? There is no universal percentage that works for every RAG system. The right amount depends on: Chunk size Document structure Typical sentence length Query complexity Retrieval quality How often important information crosses boundaries Test several overlap values using representative queries and check whether retrieval improves without creating excessive duplication. Signs overlap may be too high Look for: Nearly identical chunks dominating top results High index size relative to source content Increased embedding cost with little retrieval improvement Repeated evidence consuming prompt space For the broader chunk size tradeoff, see “What is chunk size in RAG?” . In short, chunk overlap repeats a small amount of neighboring content so information crossing a chunk boundary is less likely to be lost. It can improve context continuity, but excessive overlap creates duplication and can reduce retrieval diversity.

How much chunk overlap should you use in RAG?

There is no universal chunk overlap value that works best for every RAG system . The right overlap depends on how large the chunks are, how documents are structured, how often important information crosses boundaries, and whether overlap actually improves retrieval quality. Start with the reason for using overlap Overlap exists to reduce context loss at chunk boundaries. For example, if a sentence begins near the end of one chunk and finishes in the next, some repeated content can help ensure that at least one chunk contains enough of the complete idea. Think about overlap relative to chunk size Overlap should usually be considered together with chunk size rather than as an isolated number. For example: means that about 10% of each neighboring chunk is repeated. If the chunk size changes, the same overlap value may behave very differently. Use less overlap when boundaries are already good If the chunking strategy preserves natural boundaries such as: Headings Paragraphs Complete sentences FAQ entries Table sections then only a small amount of overlap may be needed. Well formed boundaries reduce the risk that important context is split in the first place. Use more overlap when boundaries are artificial More overlap may be useful when: Fixed size chunking is used Sentences are often split near boundaries Concepts frequently span several sentences Retrieved chunks often lack the preceding or following context Even then, overlap should be increased carefully because duplication also increases. What happens when overlap is too small? If overlap is too small: Important context may still be separated. A condition may be disconnected from its result. A heading may be separated from the explanation below it. Multi sentence ideas may be split across chunks. What happens when overlap is too large? If overlap is too large: The index stores a lot of repeated text. More embeddings must be created. Storage and ingestion cost increase. Several nearly identical chunks may appear in top retrieval results. Repeated evidence consumes prompt space. Very large overlap can therefore reduce retrieval diversity. A practical way to choose overlap Use a small candidate overlap first, then evaluate real queries. Check whether: Important boundary spanning information is still being lost. Retrieved chunks are understandable on their own. Top results contain too many near duplicates. Increasing overlap improves answer quality. The improvement is worth the added index size and token usage. Then adjust the value gradually. Consider sentence level overlap Overlap does not have to be measured only in tokens. A sentence based splitter may repeat one complete sentence between neighboring chunks. For example: This can preserve context more cleanly than repeating an arbitrary number of tokens. Do not use overlap to fix poor chunk boundaries If a document has clear structure, preserving that structure is usually better than compensating with very large overlap. For example, keeping a paragraph intact is generally preferable to cutting through it and repeating half of the paragraph in the next chunk. Evaluate overlap together with chunk size Chunk size and overlap interact. A configuration should therefore be tested as a pair, such as: Compare retrieval quality, duplication, prompt usage, and downstream answer quality across the alternatives. For the definition of overlap itself, see “What is chunk overlap in RAG?” . In short, use enough overlap to protect important context at chunk boundaries, but not so much that the index becomes dominated by duplicated text. The right value should be selected together with chunk size and validated using representative retrieval queries.

How does chunk overlap affect retrieval quality?

Chunk overlap affects retrieval quality by changing how much context is shared between neighboring chunks. Used carefully, overlap can help retrieval find complete ideas that cross chunk boundaries. Used excessively, it can create duplicated chunks that reduce result diversity and waste prompt space. How overlap can improve retrieval Important information does not always end exactly where a chunk boundary occurs. For example: If the split occurs between those two parts, one chunk may contain only half of the idea. With overlap, some of the surrounding text is repeated so that at least one neighboring chunk is more likely to contain the complete statement. Overlap can improve boundary recall Without overlap, a query related to information near a chunk boundary may fail to retrieve enough context. Repeating a small boundary region increases the chance that relevant terms and their surrounding explanation appear together in a retrievable unit. This can improve recall for boundary spanning information. Too much overlap creates duplicate retrieval results If neighboring chunks share a large percentage of their content, their embeddings and text become very similar. The top results may then contain several almost identical chunks. For example: This reduces retrieval diversity because several result slots are spent on repeated evidence. Overlap can affect ranking Repeated phrases may appear in several neighboring chunks. When those phrases strongly match the query, multiple overlapping chunks can all rank highly. This is useful if the alternatives contain different surrounding context, but wasteful if they are nearly duplicates. Overlap affects prompt efficiency Retrieved chunks are usually added to the language model's context. If several overlapping chunks contain the same text, repeated tokens consume prompt space without adding much new evidence. That can leave less room for: Other relevant sources Additional sections of the same document Conversation context Instructions and generated output Overlap interacts with chunk size The same overlap value behaves differently depending on chunk size. For example: So overlap should be evaluated as a proportion of the chunking configuration, not just as an isolated number. Better boundaries can reduce the need for overlap If chunks already follow natural boundaries such as paragraphs, headings, or complete sentences, less overlap may be necessary. If chunks are created using arbitrary fixed size boundaries, overlap may provide more value. This is why overlap and chunking strategy should be tuned together. How to evaluate overlap quality Compare several overlap settings using the same representative queries. Check: Whether boundary spanning evidence is retrieved Whether correct passages appear in the top results Whether top results contain many near duplicates Whether retrieval covers diverse useful sources Whether downstream answers become more complete Whether additional overlap increases prompt and indexing cost without improving quality The best overlap is the smallest amount that reliably preserves needed boundary context without creating unnecessary duplication. For choosing the amount itself, see “How much chunk overlap should you use in RAG?” . In short, chunk overlap can improve retrieval by preserving context across boundaries, but excessive overlap can fill search results with duplicates and waste context window space. Retrieval quality improves when overlap is large enough to protect continuity but small enough to preserve result diversity.

What is contextual chunking in RAG?

Contextual chunking in RAG means enriching a chunk with enough information about its source so the chunk still makes sense when it is retrieved by itself. A normal chunk may contain a correct fact but lose important context such as the document name, section, subject, date, product, or entity it refers to. Contextual chunking tries to restore that missing information before the chunk is indexed. Simple example Imagine a financial report contains this sentence: By itself, the chunk does not say which company, reporting period, or business unit it describes. A contextualized version might become: The original information remains, but the chunk now carries enough surrounding context to be easier to retrieve correctly. Where does the added context come from? Context can come from information such as: Document title Section and subsection headings Parent hierarchy Product or entity name Reporting period Nearby paragraphs Document summary A short chunk specific description generated from the larger document The goal is not to copy the whole document into every chunk. The added context should be concise and useful for retrieval. How contextual chunking works A common ingestion flow is: One well known implementation, often called Contextual Retrieval , creates a short chunk specific explanation using the overall document and prepends it to the chunk before creating embeddings and lexical indexes. Why can this improve retrieval? Retrievers only see what is represented in the indexed chunk. If a chunk contains phrases such as: "the company" "this policy" "the previous version" "it expires after 30 minutes" the missing subject may make the chunk difficult to match to a user's query. Adding concise source context gives the retriever more meaningful terms and relationships to work with. Contextual chunking is different from chunk overlap Chunk overlap repeats part of one neighboring chunk inside another. Contextual chunking adds information that explains where the chunk belongs and what it refers to . Overlap mainly protects boundary continuity. Contextualization mainly improves the chunk's standalone meaning. It is also different from semantic chunking Semantic chunking decides where to split based on changes in meaning. Contextual chunking improves what information is attached to a chunk after or during splitting . The two techniques can be used together. Metadata versus contextual text Metadata such as document title, page number, and heading path can be stored in separate fields. Contextual text is usually included in the text representation used for retrieval, so it directly influences semantic or lexical matching. A practical system may preserve both: Original chunk text for generation and citation Metadata for filtering and traceability Contextualized text for retrieval Benefits Contextual chunking can help: Disambiguate isolated passages Preserve document level meaning Improve retrieval of references and pronouns Make small chunks more understandable Improve matching when the important subject appears outside the chunk Limitations It adds ingestion work and may require an additional model call or preprocessing step. Poorly generated context can also introduce noise or incorrect assumptions, so the contextual text should be concise, grounded in the source, and evaluated. In short, contextual chunking enriches each RAG chunk with concise information about its broader document or section so the chunk remains understandable and easier to retrieve when separated from its original context.

How is contextual chunking different from regular chunking?

Regular chunking splits a document into smaller retrieval units and indexes the text largely as it appears in the source. Contextual chunking adds concise information about the chunk's broader document or section before that chunk is indexed. The difference is not mainly where the document is split. It is how much surrounding meaning each stored retrieval unit carries with it . Regular chunking A normal chunk might contain: If that sentence is retrieved by itself, it may be unclear what the limit refers to. The missing context could have appeared in the heading or earlier paragraph: A regular chunking pipeline may preserve that heading as metadata, but the indexed chunk text itself might still be only the sentence. Contextual chunking A contextualized version could be: The added text gives the retriever important context even when the chunk is separated from its original document location. The main difference Regular chunking asks: Where should this document be split? Contextual chunking additionally asks: What information does this chunk need so it still makes sense when retrieved alone? How retrieval can differ Suppose a user asks: A regular chunk containing only "The limit is 25 MB per file" may not strongly match words such as "document" or "upload". A contextualized chunk containing those concepts has a stronger semantic and lexical connection to the query. Contextual chunking does not replace good splitting A poorly formed chunk does not automatically become good simply because context is added. A practical pipeline can still use: Structure based chunking Recursive chunking Sentence based chunking Semantic chunking and then enrich the resulting chunks with context. Contextualization is therefore often an additional ingestion step , not a replacement for the underlying chunking strategy. Metadata and contextual text are not identical Regular RAG systems often attach metadata such as: Document title Page number Section heading Source URL Metadata can be used for filtering, citations, or application logic. Contextual chunking typically places useful source context into the text representation used for retrieval, so that information can directly influence embedding or lexical matching. A system may use both metadata and contextualized text. Cost and complexity Regular chunking is usually cheaper and simpler because the pipeline can split and index the text directly. Contextual chunking may require: Examining the wider document Generating a chunk specific description Additional model calls or processing More tokens in the indexed representation This added work is useful only if it improves retrieval enough to justify the cost. When contextual chunking is especially useful It can help when chunks frequently contain ambiguous references such as: "the company" "this policy" "the previous release" "the limit" "it" or "they" It is also useful when important identifying information appears in a heading or earlier section rather than inside the chunk itself. When regular chunking may be enough Regular chunking can work well when: Each chunk is already self contained Headings are included directly in the chunk Records are naturally independent Retrieval already performs well In those cases, adding generated context may provide little benefit. For the full concept, see “What is contextual chunking in RAG?” . In short, regular chunking mainly creates smaller retrieval units, while contextual chunking enriches those units with concise information from the broader source so they remain meaningful and easier to retrieve when viewed independently.

What is parent-child chunking in RAG?

Parent child chunking in RAG is a chunking approach that keeps two levels of text: Child chunks are smaller pieces used for precise retrieval. Parent chunks are larger sections that provide broader context. The system searches using the smaller child chunks, but after finding a relevant child it can return the corresponding larger parent section to the language model. Why use two chunk sizes? Small chunks are usually easier to retrieve precisely because they contain fewer unrelated topics. But very small chunks may not contain enough surrounding context to answer a question correctly. Parent child chunking tries to get the benefits of both: Simple example Imagine a documentation section about authentication: A query such as: may match Child 3: Token expiration very strongly. Instead of sending only that small child chunk to the language model, the RAG system can fetch the larger Authentication parent section so the answer also has related context. How the retrieval flow works A typical flow is: The exact implementation can vary, but the important idea is that retrieval and generation do not have to use the same chunk size. Parent child relationships Every child chunk needs a reliable link to its parent. Useful fields may include: parent id child id Document ID Section heading Heading path Page range This lets the system move from a retrieved child to the correct larger source section. Advantages Parent child chunking can: Improve retrieval precision with small chunks Preserve richer context for generation Reduce the need to make every indexed chunk very large Keep related paragraphs together during answer generation Work well with structured documents containing clear sections Potential limitations It also adds complexity. The system must: Store two chunk levels Maintain parent child mappings Decide how large parents and children should be Avoid returning the same parent repeatedly when several children from it match If multiple child chunks from the same parent are retrieved, the pipeline should usually deduplicate the parent before constructing the final context. Parent child chunking vs chunk overlap Chunk overlap repeats neighboring text to preserve boundary context. Parent child chunking instead stores a hierarchy: small chunks identify relevant locations, and larger parent chunks provide the surrounding context. They can be used together, but they solve different problems. When is parent child chunking useful? It is especially useful when: Documents contain large logical sections. Specific facts must be retrieved precisely. Answers often need more context than a small chunk provides. Document hierarchy can be preserved during ingestion. In short, parent child chunking separates retrieval granularity from generation context: small child chunks help find the right passage, while larger parent chunks give the language model enough surrounding information to produce a complete answer.

How does parent-child chunking work in RAG?

Parent child chunking works by separating retrieval granularity from generation context. The system creates a larger parent chunk , splits it into smaller child chunks , searches over the children, and then uses the matching child's parent to provide richer context to the language model. 1. Create parent chunks First, the document is divided into relatively large logical sections. A parent might be: A chapter A documentation section Several related paragraphs A policy section A page group For example: Parents should be large enough to preserve useful surrounding context without becoming excessively broad. 2. Split each parent into child chunks Each parent is then divided into smaller retrieval units. For example: The child chunks are smaller and more focused, which makes them easier to match precisely to a query. 3. Store the parent child mapping Every child needs a reference to its parent. A simplified record might contain: This relationship lets the retriever move from a small matching child to its larger source context. 4. Index the child chunks The child chunks are usually embedded and stored in the retrieval index. The parent text may be stored separately in a document store, database, or another collection. The important point is that the smaller children are searched , because they provide a more focused retrieval signal. 5. Retrieve relevant children When a user asks a question, the query is compared with the indexed child chunks. For example: The system now knows that C3 belongs to Parent P1. 6. Expand the child result to its parent Instead of sending only C3 to the language model, the pipeline retrieves Parent P1. That parent may include related information about token creation, expiration rules, and refresh behavior. This gives the model more complete context than the small child alone. 7. Deduplicate parent chunks Several retrieved children may belong to the same parent. For example: The final context usually should not contain Parent P1 three times. The pipeline should deduplicate parent IDs before adding the parent text to the prompt. 8. Build the final generation context After parent expansion and deduplication, the selected parent chunks are assembled into the context sent to the language model. A simplified flow is: Why this works The design uses different chunk sizes for different purposes: Children optimize retrieval precision. Parents optimize contextual completeness. This avoids forcing one chunk size to satisfy both goals. Important design decisions A parent child system still needs tuning. You need to decide: How large parent chunks should be How small child chunks should be Whether children should overlap How many children to retrieve How many unique parents to include How parents should be ordered or reranked before generation Parent child chunking works best when the document hierarchy is preserved reliably during ingestion. For the basic idea behind the technique, see “What is parent child chunking in RAG?” . In short, parent child chunking indexes small child chunks for precise search, uses their parent IDs to recover larger source sections, deduplicates those parents, and sends the richer parent context to the language model for answer generation.