Struct PipelineExecutor 

pub struct PipelineExecutor { /* private fields */ }

Pipeline executor for document indexing.

Uses PipelineOrchestrator internally for stage management. Supports both preset configurations and custom stage pipelines.

Example

// Default pipeline
let executor = PipelineExecutor::new();
let result = executor.execute(input, options).await?;

// With LLM enhancement
let executor = PipelineExecutor::with_llm(client);

// Custom pipeline using orchestrator
let orchestrator = PipelineOrchestrator::new()
    .stage(ParseStage::new())
    .stage_with_priority(MyCustomStage::new(), 50)
    .stage(BuildStage::new());
let executor = PipelineExecutor::from_orchestrator(orchestrator);

Implementations

impl PipelineExecutor

pub fn new() -> Self

Create a new pipeline executor with default stages.

Default stages (in order):

1. parse - Parse document into raw nodes
2. build - Build tree structure
3. enrich - Add metadata and cross-references
4. optimize - Optimize tree structure

pub fn with_llm(client: LlmClient) -> Self

Create a pipeline with LLM enhancement.

Stages (in order):

1. parse - Parse document
2. build - Build tree
3. enhance - LLM-based enhancement (summaries)
4. enrich - Add metadata
5. optimize - Optimize tree

pub fn from_orchestrator(orchestrator: PipelineOrchestrator) -> Self

Create from a custom orchestrator.

Use this for full control over stage ordering and dependencies.

Example

let orchestrator = PipelineOrchestrator::new()
    .stage_with_priority(ParseStage::new(), 10)
    .stage_with_priority(MyAnalysisStage::new(), 25)
    .stage_with_priority(BuildStage::new(), 20)
    .stage_with_deps(MyValidationStage::new(), 50, &["build"]);

let executor = PipelineExecutor::from_orchestrator(orchestrator);

pub fn add_stage(self, stage: impl IndexStage + 'static) -> Self

Add a stage with default priority.

The stage will be added after existing stages with the same priority.

pub fn add_stage_with_priority( self, stage: impl IndexStage + 'static, priority: i32, ) -> Self

Add a stage with custom priority.

Lower priority = earlier execution.

pub fn add_stage_with_deps( self, stage: impl IndexStage + 'static, priority: i32, depends_on: &[&str], ) -> Self

Add a stage with priority and dependencies.

The stage will run after all specified dependencies.

pub fn with_persistence(self, workspace: Workspace) -> Self

Add persistence stage with async workspace.

pub fn stage_names(&self) -> Result<Vec<&str>>

Get the list of stage names in execution order.

pub fn stage_count(&self) -> usize

Get the number of stages.

pub async fn execute( &mut self, input: IndexInput, options: PipelineOptions, ) -> Result<IndexResult>

Execute the pipeline.

Stages are executed in dependency-resolved order.

Trait Implementations

impl Default for PipelineExecutor

fn default() -> Self

Returns the “default value” for a type.