Struct LlmPilot 

pub struct LlmPilot { /* private fields */ }

LLM-based Pilot implementation.

Uses an LLM client to provide semantic navigation guidance at key decision points during tree search.

Architecture

┌─────────────────────────────────────────────────────────────┐
│                         LlmPilot                             │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │ Context     │  │ Prompt      │  │ Response    │         │
│  │ Builder     │─▶│ Builder     │─▶│ Parser      │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
│                                                              │
│  ┌─────────────┐  ┌───────────────────────┐                │
│  │ Budget      │  │ LlmExecutor           │                │
│  │ Controller  │  │ (throttle+retry+fall) │                │
│  └─────────────┘  └───────────────────────┘                │
│                                                              │
│  ┌─────────────┐  ┌───────────────────────┐                │
│  │ Memo        │  │ (cache LLM decisions) │                │
│  │ Store       │  │                       │                │
│  └─────────────┘  └───────────────────────┘                │
└─────────────────────────────────────────────────────────────┘

Example

use vectorless::retrieval::pilot::{LlmPilot, PilotConfig};
use vectorless::llm::{LlmClient, LlmExecutor};

let client = LlmClient::for_model("gpt-4o-mini");
let pilot = LlmPilot::new(client, PilotConfig::default());

// Or with executor for unified throttle/retry/fallback
let executor = LlmExecutor::for_model("gpt-4o-mini");
let pilot = LlmPilot::with_executor(executor, PilotConfig::default());

// Use in search
if pilot.should_intervene(&state) {
    let decision = pilot.decide(&state).await;
}

Implementations

impl LlmPilot

pub fn new(client: LlmClient, config: PilotConfig) -> Self

Create a new LLM-based Pilot.

pub fn with_executor(executor: LlmExecutor, config: PilotConfig) -> Self

Create a Pilot with LlmExecutor for unified throttle/retry/fallback.

pub fn with_shared_executor( executor: Arc<LlmExecutor>, config: PilotConfig, ) -> Self

Create a Pilot with shared executor (for sharing throttle/fallback across pilots).

pub fn with_builders( client: LlmClient, config: PilotConfig, context_builder: ContextBuilder, prompt_builder: PromptBuilder, ) -> Self

Create with custom builders.

pub fn with_executor_mut(self, executor: LlmExecutor) -> Self

Add an executor to an existing pilot.

pub fn with_learner(self, learner: Arc<PilotLearner>) -> Self

Add a feedback learner to the pilot.

pub fn with_feedback_store(self, store: Arc<FeedbackStore>) -> Self

Add a feedback learner from a feedback store.

pub fn with_memo_store(self, store: MemoStore) -> Self

Add a memo store for caching decisions.

When enabled, the pilot will cache LLM decisions based on context fingerprints, avoiding redundant API calls for similar navigation scenarios.

pub fn has_executor(&self) -> bool

Check if using LlmExecutor (unified throttle/retry/fallback).

pub fn has_learner(&self) -> bool

Check if using feedback learner.

pub fn has_memo_store(&self) -> bool

Check if using memo store.

pub fn learner(&self) -> Option<&PilotLearner>

Get the feedback learner (if any).

pub fn memo_store(&self) -> Option<&MemoStore>

Get the memo store (if any).

pub fn record_feedback(&self, record: FeedbackRecord)

Record feedback for a decision.

Trait Implementations

impl Debug for LlmPilot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Pilot for LlmPilot

fn name(&self) -> &str

Get the name of this Pilot implementation.

fn should_intervene(&self, state: &SearchState<'_>) -> bool

Determine if Pilot should intervene at this point.

fn decide<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, state: &'life1 SearchState<'life2>, ) -> Pin<Box<dyn Future<Output = PilotDecision> + Send + 'async_trait>>

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

Make a navigation decision.

fn guide_start<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 DocumentTree, query: &'life2 str, ) -> Pin<Box<dyn Future<Output = Option<PilotDecision>> + Send + 'async_trait>>

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

Provide guidance before search starts.

fn guide_backtrack<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, state: &'life1 SearchState<'life2>, ) -> Pin<Box<dyn Future<Output = Option<PilotDecision>> + Send + 'async_trait>>

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

Provide guidance during backtracking.

fn config(&self) -> &PilotConfig

Get the current configuration.

fn is_active(&self) -> bool

Check if this Pilot is actually capable of providing guidance.

fn reset(&self)

Reset internal state for a new query.