Struct ParentDocumentRetriever 

pub struct ParentDocumentRetriever<S: ChunkedDocumentStoreTrait = ChunkedDocumentStore> { /* private fields */ }

A parent/child document retriever.

On ingestion, documents are split into small chunks (leaves) for indexing; any leaf hit returns the entire parent document. This differs from ChunkedBM25Retriever’s AutoMerging (gated by hit ratio; returns leaf chunks when the threshold is not met): ParentDocument is the classic RAG pattern of “small-chunk recall, full document fed to the LLM” — the leaf chunks provide precise hits, while the whole parent document gives the LLM complete context.

Internally it wraps a ChunkedBM25Retriever in an RwLock: retrieval takes the read lock, ingestion takes the write lock, so it can implement RetrieverTrait (whose methods all take &self). Combined with RetrieverRunnable it can plug directly into an LCEL chain:

let retriever = Arc::new(ParentDocumentRetriever::new(store));
let chain = RetrieverRunnable::new(retriever, 4).pipe(prompt).pipe(llm);

Implementations

impl<S: ChunkedDocumentStoreTrait> ParentDocumentRetriever<S>

pub fn new(store: Arc<S>) -> Self

Creates a retriever with the default configuration.

pub fn with_config(store: Arc<S>, config: AutoMergingConfig) -> Self

Creates a retriever with the specified AutoMerging configuration.

leaf_chunk_size in the config determines the leaf-chunk granularity; under the ParentDocument semantics merge_threshold does not take part in hit decisions (any leaf hit returns the parent document), but it still constrains how the underlying index is chunked.

pub fn inner(&self) -> &RwLock<ChunkedBM25Retriever<S>>

Returns the inner retriever reference, for direct access to the underlying index.

For example, read-only retrieval uses retriever.inner().read().await; ingestion uses .write().await.

Trait Implementations

impl<S: ChunkedDocumentStoreTrait> RetrieverTrait for ParentDocumentRetriever<S>

fn retrieve<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, k: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<Document>, RetrieverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves relevant documents

fn retrieve_with_scores<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, k: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<SearchResult>, RetrieverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves relevant documents (with scores)

fn add_documents<'life0, 'async_trait>( &'life0 self, documents: Vec<Document>, ) -> Pin<Box<dyn Future<Output = Result<(), RetrieverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Adds documents