Skip to main content

Module client

vectorless

Module client 

Source
Expand description

High-level client API for document indexing and retrieval.

This module provides the main entry point for using vectorless:

  • Engine — The main client for indexing and querying documents
  • EngineBuilder — Builder pattern for client configuration
  • IndexContext — Unified input for document indexing
  • Session — Multi-document session management

§Architecture

The client module is organized into specialized sub-modules:

client/
├── mod.rs           → Re-exports and documentation
├── engine.rs        → Main orchestrator
├── builder.rs       → Builder pattern
├── index_context.rs → Index input types
├── types.rs         → Public API types
├── context.rs       → Request context and configuration
├── session.rs       → Session management
├── indexer.rs       → Document indexing operations
├── retriever.rs     → Query and retrieval operations
├── workspace.rs     → Workspace CRUD operations
└── events.rs        → Event system and callbacks

§Quick Start

use vectorless::client::{Engine, EngineBuilder, IndexContext};

// Create a client with default settings
let client = EngineBuilder::new()
    .with_workspace("./my_workspace")
    .build()
    .await?;

// Index a document from file
let doc_id = client.index(IndexContext::from_path("./document.md")).await?;

// Index HTML content directly
let html = "<html><body><h1>Title</h1><p>Content</p></body></html>";
let doc_id2 = client.index(
    IndexContext::from_content(html, vectorless::parser::DocumentFormat::Html)
        .with_name("webpage")
).await?;

// Query the document
let result = client.query(&doc_id, "What is this?").await?;
println!("{}", result.content);

// List all documents
for doc in client.list_documents().await? {
    println!("{}: {}", doc.id, doc.name);
}

§Session-Based Operations

For multi-document operations, use sessions:

let client = EngineBuilder::new()
    .with_workspace("./workspace")
    .build()
    .await?;

let session = client.session().await;

// Index multiple documents
let doc1 = session.index(IndexContext::from_path("./doc1.md")).await?;
let doc2 = session.index(IndexContext::from_path("./doc2.md")).await?;

// Query across all documents
let results = session.query_all("What is the architecture?").await?;

§Events and Progress

Monitor operation progress with events:

let events = EventEmitter::new()
    .on_index(|e| match e {
        IndexEvent::Complete { doc_id } => println!("Indexed: {}", doc_id),
        _ => {}
    });

let client = EngineBuilder::new()
    .with_events(events)
    .build()
    .await?;

§Features

  • Document Indexing — Parse and index Markdown, PDF, and text files
  • Tree-Based Structure — Documents organized as hierarchical trees
  • Workspace Persistence — Save and load indexed documents
  • Session Management — Multi-document operations with caching
  • Event System — Progress callbacks and monitoring

Re-exports§

pub use events::AsyncEventHandler;
pub use events::Event;
pub use events::EventEmitter;
pub use events::EventHandler;
pub use events::IndexEvent;
pub use events::QueryEvent;
pub use events::WorkspaceEvent;

Modules§

events
Event system for client operations.

Structs§

ClientContext
Request context for client operations.
DocumentInfo
Document info for listing.
Engine
The main Engine client.
EngineBuilder
Builder for creating a Engine client.
FeatureFlags
Feature flags for request.
IndexContext
Context for document indexing operations.
IndexOptions
Options for indexing a document.
IndexedDocument
An indexed document with its tree structure and metadata.
IndexerClient
Document indexing client.
IndexerConfig
Indexer configuration.
NodeContext
Node context information.
PageContent
Content for a single page.
QueryResult
Result of a document query.
RequestContextConfig
Request-specific configuration overrides.
RetrieverClient
Document retrieval client.
RetrieverClientConfig
Retriever configuration.
Session
Session for managing multiple documents.
SessionConfig
Session configuration.
SessionStats
Session statistics.
ValidationResult
Document validation result.
WorkspaceClient
Workspace management client.
WorkspaceClientConfig
Workspace client configuration.
WorkspaceStats
Workspace statistics.

Enums§

BuildError
Error during client build.
ClientError
Client error types.
EvictionPolicy
Cache eviction policy.
IndexMode
Document indexing behavior mode.
IndexSource
The source of document content for indexing.
PreloadStrategy
Document preload strategy.