Dev

Cargo.toml

@@ -20,7 +20,6 @@ futures = "0.3"
 # Serialization
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-toml = "0.8"
 
 # Error handling
 thiserror = "2"
@@ -36,7 +35,7 @@ uuid = { version = "1.10", features = ["v4", "serde"] }
 chrono = { version = "0.4", default-features = false, features = ["serde", "clock"] }
 
 # Logging
-tracing = "0.1"
+tracing = { version = "0.1", features = ["attributes"] }
 
 # Rate limiting
 governor = "0.6"

README.md

@@ -37,7 +37,7 @@ vectorless = "0.1"
 ```
 
 ```rust
-use vectorless::client::{EngineBuilder, IndexContext, QueryContext};
+use vectorless::{EngineBuilder, IndexContext, QueryContext};
 
 #[tokio::main]
 async fn main() -> vectorless::Result<()> {

docs/docs/examples/batch-indexing.mdx

@@ -47,7 +47,7 @@ asyncio.run(main())
 ## Rust
 
 ```rust
-use vectorless::client::{Engine, EngineBuilder, IndexContext};
+use vectorless::{Engine, EngineBuilder, IndexContext};
 
 #[tokio::main]
 async fn main() -> vectorless::Result<()> {

docs/docs/examples/quick-query.mdx

@@ -48,7 +48,7 @@ asyncio.run(main())
 ## Rust
 
 ```rust
-use vectorless::client::{Engine, EngineBuilder, IndexContext, QueryContext};
+use vectorless::{Engine, EngineBuilder, IndexContext, QueryContext};
 use vectorless::StrategyPreference;
 
 #[tokio::main]

docs/docs/features/synonym-expansion.mdx

@@ -46,7 +46,7 @@ opts = IndexOptions(enable_synonym_expansion=False)
 The synonym expansion is controlled via `ReasoningIndexConfig`:
 
 ```rust
-use vectorless::document::ReasoningIndexConfig;
+use vectorless::ReasoningIndexConfig;
 
 let config = ReasoningIndexConfig::default()
     .with_synonym_expansion(true);

docs/docs/indexing/incremental.mdx

@@ -32,7 +32,7 @@ result = await engine.index(ctx)
 ### Rust
 
 ```rust
-use vectorless::client::{IndexContext, IndexMode};
+use vectorless::{IndexContext, IndexMode};
 
 let ctx = IndexContext::from_path("./report.pdf")
     .with_mode(IndexMode::Incremental);

docs/docs/sdk/rust.mdx

@@ -16,7 +16,7 @@ vectorless = "0.1"
 ## Engine
 
 ```rust
-use vectorless::client::{Engine, EngineBuilder};
+use vectorless::{Engine, EngineBuilder};
 
 let engine = EngineBuilder::new()
     .with_key("sk-...")
@@ -29,7 +29,7 @@ let engine = EngineBuilder::new()
 ## Indexing
 
 ```rust
-use vectorless::client::{IndexContext, IndexOptions, IndexMode};
+use vectorless::{IndexContext, IndexOptions, IndexMode};
 
 // From a file
 let result = engine.index(IndexContext::from_path("./report.pdf")).await?;
@@ -51,7 +51,7 @@ let result = engine.index(
 ## Querying
 
 ```rust
-use vectorless::client::QueryContext;
+use vectorless::QueryContext;
 use vectorless::StrategyPreference;
 
 let result = engine.query(

docs/src/pages/index.tsx

@@ -107,7 +107,7 @@ async def main():
 
 asyncio.run(main())`;
 
-const RUST_CODE = `use vectorless::client::{EngineBuilder, IndexContext, QueryContext};
+const RUST_CODE = `use vectorless::{EngineBuilder, IndexContext, QueryContext};
 
 #[tokio::main]
 async fn main() -> vectorless::Result<()> {

python/src/config.rs

@@ -55,28 +55,21 @@ impl PyConfig {
     ///
     /// Default: 10
     fn set_max_concurrent_requests(&mut self, max: usize) {
-        self.inner.concurrency.max_concurrent_requests = max;
+        self.inner.llm.throttle.max_concurrent_requests = max;
     }
 
     /// Set the rate limit (requests per minute).
     ///
     /// Default: 500
     fn set_requests_per_minute(&mut self, rpm: usize) {
-        self.inner.concurrency.requests_per_minute = rpm;
+        self.inner.llm.throttle.requests_per_minute = rpm;
     }
 
     /// Set the maximum iterations for retrieval search.
     fn set_max_iterations(&mut self, max: usize) {
         self.inner.retrieval.search.max_iterations = max;
     }
 
-    /// Set the retrieval temperature.
-    ///
-    /// Default: 0.0
-    fn set_temperature(&mut self, temp: f32) {
-        self.inner.retrieval.temperature = temp;
-    }
-
     /// Enable or disable metrics collection.
     ///
     /// Default: True

python/src/context.rs

@@ -5,7 +5,7 @@
 
 use pyo3::prelude::*;
 
-use ::vectorless::client::{DocumentFormat, IndexContext, IndexMode, IndexOptions, QueryContext};
+use ::vectorless::{DocumentFormat, IndexContext, IndexMode, IndexOptions, QueryContext};
 
 use super::error::VectorlessError;
 
@@ -31,7 +31,6 @@ fn parse_format(format: &str) -> PyResult<DocumentFormat> {
 ///     mode: Indexing mode - "default", "force", or "incremental".
 ///     generate_summaries: Whether to generate summaries. Default: True.
 ///     generate_description: Whether to generate document description. Default: False.
-///     include_text: Whether to include node text in the tree. Default: True.
 ///     generate_ids: Whether to generate node IDs. Default: True.
 ///     enable_synonym_expansion: Whether to expand keywords with LLM-generated
 ///         synonyms during indexing. Improves recall for differently-worded queries.
@@ -45,12 +44,11 @@ pub struct PyIndexOptions {
 #[pymethods]
 impl PyIndexOptions {
     #[new]
-    #[pyo3(signature = (mode="default", generate_summaries=true, generate_description=false, include_text=true, generate_ids=true, enable_synonym_expansion=false))]
+    #[pyo3(signature = (mode="default", generate_summaries=true, generate_description=false, generate_ids=true, enable_synonym_expansion=false))]
     fn new(
         mode: &str,
         generate_summaries: bool,
         generate_description: bool,
-        include_text: bool,
         generate_ids: bool,
         enable_synonym_expansion: bool,
     ) -> PyResult<Self> {
@@ -71,23 +69,21 @@ impl PyIndexOptions {
         }
         opts.generate_summaries = generate_summaries;
         opts.generate_description = generate_description;
-        opts.include_text = include_text;
         opts.generate_ids = generate_ids;
         opts.enable_synonym_expansion = enable_synonym_expansion;
         Ok(Self { inner: opts })
     }
 
     fn __repr__(&self) -> String {
         format!(
-            "IndexOptions(mode='{}', generate_summaries={}, generate_description={}, include_text={}, generate_ids={}, enable_synonym_expansion={})",
+            "IndexOptions(mode='{}', generate_summaries={}, generate_description={}, generate_ids={}, enable_synonym_expansion={})",
             match self.inner.mode {
                 IndexMode::Default => "default",
                 IndexMode::Force => "force",
                 IndexMode::Incremental => "incremental",
             },
             self.inner.generate_summaries,
             self.inner.generate_description,
-            self.inner.include_text,
             self.inner.generate_ids,
             self.inner.enable_synonym_expansion,
         )
@@ -270,18 +266,6 @@ impl PyQueryContext {
         Self { inner: ctx }
     }
 
-    /// Set whether to include the reasoning chain.
-    fn with_include_reasoning(&self, include: bool) -> Self {
-        let ctx = self.inner.clone().with_include_reasoning(include);
-        Self { inner: ctx }
-    }
-
-    /// Set the maximum tree traversal depth.
-    fn with_depth_limit(&self, depth: usize) -> Self {
-        let ctx = self.inner.clone().with_depth_limit(depth);
-        Self { inner: ctx }
-    }
-
     fn __repr__(&self) -> String {
         "QueryContext(...)".to_string()
     }

python/src/document.rs

@@ -5,7 +5,7 @@
 
 use pyo3::prelude::*;
 
-use ::vectorless::client::DocumentInfo;
+use ::vectorless::DocumentInfo;
 
 /// Information about an indexed document.
 #[pyclass(name = "DocumentInfo")]

python/src/engine.rs

@@ -8,7 +8,7 @@ use pyo3_async_runtimes::tokio::future_into_py;
 use std::sync::Arc;
 use tokio::runtime::Runtime;
 
-use ::vectorless::client::{Engine, EngineBuilder, IndexContext, QueryContext};
+use ::vectorless::{Engine, EngineBuilder, IndexContext, QueryContext};
 
 use super::config::PyConfig;
 use super::context::{PyIndexContext, PyQueryContext};
@@ -229,9 +229,6 @@ impl PyEngine {
     }
 
     /// Generate a complete metrics report.
-    ///
-    /// Returns:
-    ///     MetricsReport with LLM, Pilot, and Retrieval metrics.
     fn metrics_report(&self) -> PyMetricsReport {
         run_metrics_report(Arc::clone(&self.inner))
     }

python/src/error.rs

@@ -6,7 +6,7 @@
 use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 
-use ::vectorless::error::Error as RustError;
+use ::vectorless::Error as RustError;
 
 /// Python exception for vectorless errors.
 #[pyclass(extends = PyException, subclass)]

python/src/graph.rs

@@ -5,9 +5,7 @@
 
 use pyo3::prelude::*;
 
-use ::vectorless::graph::{
-    DocumentGraph, DocumentGraphNode, EdgeEvidence, GraphEdge, WeightedKeyword,
-};
+use ::vectorless::{DocumentGraph, DocumentGraphNode, EdgeEvidence, GraphEdge, WeightedKeyword};
 
 /// A keyword with weight from document analysis.
 #[pyclass(name = "WeightedKeyword")]

python/src/metrics.rs

@@ -5,9 +5,7 @@
 
 use pyo3::prelude::*;
 
-use ::vectorless::metrics::{
-    LlmMetricsReport, MetricsReport, PilotMetricsReport, RetrievalMetricsReport,
-};
+use ::vectorless::{LlmMetricsReport, MetricsReport, PilotMetricsReport, RetrievalMetricsReport};
 
 /// LLM usage metrics report.
 #[pyclass(name = "LlmMetricsReport")]
@@ -360,11 +358,6 @@ impl PyMetricsReport {
         self.inner.total_cost_usd()
     }
 
-    /// Overall success rate (0.0 - 1.0).
-    fn overall_success_rate(&self) -> f64 {
-        self.inner.overall_success_rate()
-    }
-
     fn __repr__(&self) -> String {
         format!(
             "MetricsReport(llm_calls={}, cost=${:.4}, queries={})",

python/src/results.rs

@@ -5,8 +5,8 @@
 
 use pyo3::prelude::*;
 
-use ::vectorless::client::{FailedItem, IndexItem, IndexResult, QueryResult, QueryResultItem};
-use ::vectorless::metrics::IndexMetrics;
+use ::vectorless::IndexMetrics;
+use ::vectorless::{FailedItem, IndexItem, IndexResult, QueryResult, QueryResultItem};
 
 // ============================================================
 // QueryResultItem

rust/Cargo.toml

@@ -22,7 +22,6 @@ futures = { workspace = true }
 # Serialization
 serde = { workspace = true }
 serde_json = { workspace = true }
-toml = { workspace = true }
 
 # Error handling
 thiserror = { workspace = true }

rust/examples/events.rs

@@ -22,8 +22,8 @@
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use vectorless::client::{EngineBuilder, IndexContext, QueryContext};
-use vectorless::events::{EventEmitter, IndexEvent, QueryEvent};
+use vectorless::{EngineBuilder, IndexContext, QueryContext};
+use vectorless::{EventEmitter, IndexEvent, QueryEvent};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {

rust/examples/flow.rs

@@ -20,8 +20,7 @@
 //! cargo run --example flow
 //! ```
 
-use vectorless::EngineBuilder;
-use vectorless::client::{IndexContext, IndexOptions, QueryContext};
+use vectorless::{EngineBuilder, IndexContext, IndexOptions, QueryContext};
 
 /// Sample markdown content for demonstration.
 const SAMPLE_MARKDOWN: &str = r#"