Struct VectorizerClient 

pub struct VectorizerClient { /* private fields */ }

Vectorizer REST client with optional master/replica topology support. Public surface is identical to the pre-phase4 monolithic VectorizerClient; the methods are now organised across per-surface impl blocks (see module docs).

Implementations

impl VectorizerClient

pub async fn list_collections(&self) -> Result<Vec<Collection>>

List every collection visible to the authenticated principal. Accepts both the legacy bare-array response and the newer {collections: [...]} wrapper.

pub async fn create_collection( &self, name: &str, dimension: usize, metric: Option<SimilarityMetric>, ) -> Result<CollectionInfo>

Create a new collection. The returned CollectionInfo is synthesised from the server’s create-response plus the arguments — the server response only carries the collection name today.

pub async fn delete_collection(&self, name: &str) -> Result<()>

Delete a collection by name.

pub async fn get_collection_info( &self, collection: &str, ) -> Result<CollectionInfo>

Fetch metadata for a collection (vector count, dimension, metric, timestamps, indexing status).

impl VectorizerClient

pub async fn health_check(&self) -> Result<HealthStatus>

Check server health.

pub async fn login(&self, username: &str, password: &str) -> Result<JwtToken>

Exchange a (username, password) pair for a JWT via POST /auth/login. The returned token is not retained by self — the transport was built with whatever credential (or none) was passed at construction. To use the JWT for subsequent requests, construct a new client with ClientConfig::api_key = Some(jwt.access_token); the HTTP transport recognises the three-segment JWT shape and sends it as Authorization: Bearer … rather than X-API-Key.

When the server runs with auth.enabled: false this endpoint may 404 — callers running against a no-auth dev server don’t need to call login at all.

impl VectorizerClient

pub async fn discover( &self, query: &str, include_collections: Option<Vec<String>>, exclude_collections: Option<Vec<String>>, max_bullets: Option<usize>, broad_k: Option<usize>, focus_k: Option<usize>, ) -> Result<Value>

End-to-end discovery pipeline with intelligent search and LLM-style bullet generation.

pub async fn filter_collections( &self, query: &str, include: Option<Vec<String>>, exclude: Option<Vec<String>>, ) -> Result<Value>

Pre-filter collections by name patterns.

pub async fn score_collections( &self, query: &str, name_match_weight: Option<f32>, term_boost_weight: Option<f32>, signal_boost_weight: Option<f32>, ) -> Result<Value>

Rank collections by relevance to a query. The three weights must each be in [0.0, 1.0] when supplied.

pub async fn expand_queries( &self, query: &str, max_expansions: Option<usize>, include_definition: Option<bool>, include_features: Option<bool>, include_architecture: Option<bool>, ) -> Result<Value>

Generate query variations (definition / features / architecture-style expansions, capped by max_expansions).

impl VectorizerClient

pub async fn get_file_content( &self, collection: &str, file_path: &str, max_size_kb: Option<usize>, ) -> Result<Value>

Retrieve the complete content of an indexed file.

pub async fn list_files_in_collection( &self, collection: &str, filter_by_type: Option<Vec<String>>, min_chunks: Option<usize>, max_results: Option<usize>, sort_by: Option<&str>, ) -> Result<Value>

List indexed files in a collection, optionally filtered by extension and minimum chunk count.

pub async fn get_file_summary( &self, collection: &str, file_path: &str, summary_type: Option<&str>, max_sentences: Option<usize>, ) -> Result<Value>

Get an extractive or structural summary of one indexed file.

pub async fn get_file_chunks_ordered( &self, collection: &str, file_path: &str, start_chunk: Option<usize>, limit: Option<usize>, include_context: Option<bool>, ) -> Result<Value>

Retrieve chunks in original file order for progressive reading. Pair with start_chunk + limit to page.

pub async fn get_project_outline( &self, collection: &str, max_depth: Option<usize>, include_summaries: Option<bool>, highlight_key_files: Option<bool>, ) -> Result<Value>

Generate a hierarchical project structure overview.

pub async fn get_related_files( &self, collection: &str, file_path: &str, limit: Option<usize>, similarity_threshold: Option<f32>, include_reason: Option<bool>, ) -> Result<Value>

Find semantically-related files by vector similarity.

pub async fn search_by_file_type( &self, collection: &str, query: &str, file_types: Vec<String>, limit: Option<usize>, return_full_files: Option<bool>, ) -> Result<Value>

Semantic search filtered by file type. Empty file_types is rejected — pass at least one extension.

pub async fn upload_file( &self, file_bytes: Vec<u8>, filename: &str, collection_name: &str, options: UploadFileOptions, ) -> Result<FileUploadResponse>

Upload a file for automatic text extraction, chunking, and indexing.

Arguments

• file_bytes - File content as bytes
• filename - Name of the file (used for extension detection)
• collection_name - Target collection name
• options - Upload options (chunk size, overlap, metadata)

Example

use vectorizer_sdk::{VectorizerClient, ClientConfig, UploadFileOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::default();
    let client = VectorizerClient::new(config)?;

    let file_bytes = std::fs::read("document.pdf")?;
    let options = UploadFileOptions::default();

    let response = client.upload_file(
        file_bytes,
        "document.pdf",
        "my-docs",
        options
    ).await?;

    println!("Uploaded: {} chunks created", response.chunks_created);
    Ok(())
}

pub async fn upload_file_content( &self, content: &str, filename: &str, collection_name: &str, options: UploadFileOptions, ) -> Result<FileUploadResponse>

Upload file content directly as a string. Convenience wrapper around Self::upload_file.

Example

use vectorizer_sdk::{VectorizerClient, ClientConfig, UploadFileOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VectorizerClient::new(ClientConfig::default())?;
    let code = r#"fn main() { println!("Hello!"); }"#;
    let response = client.upload_file_content(
        code, "main.rs", "rust-code", UploadFileOptions::default()
    ).await?;
    println!("Uploaded: {} vectors created", response.vectors_created);
    Ok(())
}

pub async fn get_upload_config(&self) -> Result<FileUploadConfig>

Get file upload configuration from the server (max file size, allowed extensions, default chunk settings).

Example

use vectorizer_sdk::{VectorizerClient, ClientConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VectorizerClient::new(ClientConfig::default())?;
    let upload_config = client.get_upload_config().await?;
    println!("Max file size: {}MB", upload_config.max_file_size_mb);
    Ok(())
}

impl VectorizerClient

pub async fn list_graph_nodes( &self, collection: &str, ) -> Result<ListNodesResponse>

List every node in a collection’s graph.

pub async fn get_graph_neighbors( &self, collection: &str, node_id: &str, ) -> Result<GetNeighborsResponse>

Get neighbours of a specific node.

pub async fn find_related_nodes( &self, collection: &str, node_id: &str, request: FindRelatedRequest, ) -> Result<FindRelatedResponse>

Find related nodes within N hops.

pub async fn find_graph_path( &self, request: FindPathRequest, ) -> Result<FindPathResponse>

Find the shortest path between two nodes.

pub async fn create_graph_edge( &self, request: CreateEdgeRequest, ) -> Result<CreateEdgeResponse>

Create an explicit edge between two nodes.

pub async fn delete_graph_edge(&self, edge_id: &str) -> Result<()>

Delete an edge by id.

pub async fn list_graph_edges( &self, collection: &str, ) -> Result<ListEdgesResponse>

List every edge in a collection.

pub async fn discover_graph_edges( &self, collection: &str, request: DiscoverEdgesRequest, ) -> Result<DiscoverEdgesResponse>

Discover SIMILAR_TO edges for an entire collection.

pub async fn discover_graph_edges_for_node( &self, collection: &str, node_id: &str, request: DiscoverEdgesRequest, ) -> Result<DiscoverEdgesResponse>

Discover SIMILAR_TO edges for one specific node.

pub async fn get_graph_discovery_status( &self, collection: &str, ) -> Result<DiscoveryStatusResponse>

Get discovery status for a collection.

impl VectorizerClient

pub async fn qdrant_list_collections(&self) -> Result<Value>

List all collections (Qdrant-compatible).

pub async fn qdrant_get_collection(&self, name: &str) -> Result<Value>

Get one collection’s metadata (Qdrant-compatible).

pub async fn qdrant_create_collection( &self, name: &str, config: &Value, ) -> Result<Value>

Create a collection (Qdrant-compatible).

pub async fn qdrant_upsert_points( &self, collection: &str, points: &Value, wait: bool, ) -> Result<Value>

Upsert points into a collection (Qdrant-compatible).

pub async fn qdrant_search_points( &self, collection: &str, vector: &[f32], limit: Option<usize>, filter: Option<&Value>, with_payload: bool, with_vector: bool, ) -> Result<Value>

Search points (Qdrant-compatible).

pub async fn qdrant_delete_points( &self, collection: &str, point_ids: &[Value], wait: bool, ) -> Result<Value>

Delete points by id (Qdrant-compatible).

pub async fn qdrant_retrieve_points( &self, collection: &str, point_ids: &[Value], with_payload: bool, with_vector: bool, ) -> Result<Value>

Retrieve points by id (Qdrant-compatible).

pub async fn qdrant_count_points( &self, collection: &str, filter: Option<&Value>, ) -> Result<Value>

Count points (Qdrant-compatible).

pub async fn qdrant_list_collection_snapshots( &self, collection: &str, ) -> Result<Value>

List snapshots for a collection (Qdrant-compatible).

pub async fn qdrant_create_collection_snapshot( &self, collection: &str, ) -> Result<Value>

Create a snapshot for a collection (Qdrant-compatible).

pub async fn qdrant_delete_collection_snapshot( &self, collection: &str, snapshot_name: &str, ) -> Result<Value>

Delete a snapshot (Qdrant-compatible).

pub async fn qdrant_recover_collection_snapshot( &self, collection: &str, location: &str, ) -> Result<Value>

Recover a collection from a snapshot location (Qdrant-compatible).

pub async fn qdrant_list_all_snapshots(&self) -> Result<Value>

List all snapshots across collections (Qdrant-compatible).

pub async fn qdrant_create_full_snapshot(&self) -> Result<Value>

Create a full-cluster snapshot (Qdrant-compatible).

pub async fn qdrant_list_shard_keys(&self, collection: &str) -> Result<Value>

List shard keys for a collection (Qdrant-compatible).

pub async fn qdrant_create_shard_key( &self, collection: &str, shard_key: &Value, ) -> Result<Value>

Create a shard key (Qdrant-compatible).

pub async fn qdrant_delete_shard_key( &self, collection: &str, shard_key: &Value, ) -> Result<Value>

Delete a shard key (Qdrant-compatible).

pub async fn qdrant_get_cluster_status(&self) -> Result<Value>

Get cluster status (Qdrant-compatible).

pub async fn qdrant_cluster_recover(&self) -> Result<Value>

Trigger a cluster recovery on the current peer (Qdrant-compatible).

pub async fn qdrant_remove_peer(&self, peer_id: &str) -> Result<Value>

Remove a peer from the cluster (Qdrant-compatible).

pub async fn qdrant_list_metadata_keys(&self) -> Result<Value>

List metadata keys (Qdrant-compatible).

pub async fn qdrant_get_metadata_key(&self, key: &str) -> Result<Value>

Get one metadata key (Qdrant-compatible).

pub async fn qdrant_update_metadata_key( &self, key: &str, value: &Value, ) -> Result<Value>

Update one metadata key (Qdrant-compatible).

pub async fn qdrant_query_points( &self, collection: &str, request: &Value, ) -> Result<Value>

Query points using the Qdrant 1.7+ Query API.

pub async fn qdrant_batch_query_points( &self, collection: &str, request: &Value, ) -> Result<Value>

Batch-query points using the Qdrant 1.7+ Query API.

pub async fn qdrant_query_points_groups( &self, collection: &str, request: &Value, ) -> Result<Value>

Query points with grouping (Qdrant 1.7+ Query API).

pub async fn qdrant_search_points_groups( &self, collection: &str, request: &Value, ) -> Result<Value>

Search points with grouping (Qdrant Search Groups API).

pub async fn qdrant_search_matrix_pairs( &self, collection: &str, request: &Value, ) -> Result<Value>

Search matrix pairs (Qdrant Search Matrix API).

pub async fn qdrant_search_matrix_offsets( &self, collection: &str, request: &Value, ) -> Result<Value>

Search matrix offsets (Qdrant Search Matrix API).

impl VectorizerClient

pub async fn search_vectors( &self, collection: &str, query: &str, limit: Option<usize>, score_threshold: Option<f32>, ) -> Result<SearchResponse>

Text search against one collection. The server embeds the query with the collection’s provider, runs ANN search, and returns up to limit (default 10) hits scored above the optional score_threshold.

pub async fn intelligent_search( &self, request: IntelligentSearchRequest, ) -> Result<IntelligentSearchResponse>

Intelligent search — multi-query expansion + MMR diversification + domain term boosting.

pub async fn semantic_search( &self, request: SemanticSearchRequest, ) -> Result<SemanticSearchResponse>

Semantic search — advanced reranking + similarity-threshold filtering on top of the base text search.

pub async fn contextual_search( &self, request: ContextualSearchRequest, ) -> Result<ContextualSearchResponse>

Context-aware search with metadata filtering and contextual reranking.

pub async fn multi_collection_search( &self, request: MultiCollectionSearchRequest, ) -> Result<MultiCollectionSearchResponse>

Multi-collection search with cross-collection reranking and aggregation.

pub async fn hybrid_search( &self, request: HybridSearchRequest, ) -> Result<HybridSearchResponse>

Hybrid search combining dense and sparse vectors with one of three scoring algorithms (RRF, weighted, alpha-blending).

impl VectorizerClient

pub async fn get_vector( &self, collection: &str, vector_id: &str, ) -> Result<Vector>

Fetch one vector by id.

Server caveat (observed on hivehub/vectorizer:3.0.x): the GET /collections/{c}/vectors/{id} endpoint currently returns HTTP 200 with a synthetic uniform-vector payload ([0.1, 0.1, …]) even for ids that don’t exist. Callers that need real miss detection should probe via [VectorizerClient::list_vectors] or search and not trust an Ok(Vector) as proof of existence until the server fix ships.

pub async fn insert_texts( &self, collection: &str, texts: Vec<BatchTextRequest>, ) -> Result<BatchResponse>

Insert a batch of texts into a collection. The server embeds each entry with the collection’s configured provider (BM25 by default; FastEmbed ONNX when selected in config.yml).

Wire contract: the server’s POST /insert_texts handler expects { "collection": "<name>", "texts": [...] } — the collection is a top-level field in the JSON body, not a path segment. The earlier POST /collections/{c}/documents path this method used was never served (the 3.0.x server returns 404 for it) and has been removed.

Per-entry id field: the server reassigns every inserted vector a server-generated UUID regardless of what the caller sent. The original client id is stashed as client_id on the response entry. Callers that need idempotency by client id should key off the client_id round-trip, not the server-assigned UUID.

pub async fn embed_text( &self, text: &str, model: Option<&str>, ) -> Result<EmbeddingResponse>

Generate an embedding for text using either the supplied model name or the server default.

impl VectorizerClient

pub fn base_url(&self) -> &str

Get the base URL the client is configured against.

pub fn new(config: ClientConfig) -> Result<Self>

Create a new client with the given configuration.

pub fn new_default() -> Result<Self>

Create a new client with default configuration.

pub fn new_with_url(base_url: &str) -> Result<Self>

Create a client with a custom base URL.

pub fn new_with_api_key(base_url: &str, api_key: &str) -> Result<Self>

Create a client with a custom base URL + API key.

pub fn from_connection_string( connection_string: &str, api_key: Option<&str>, ) -> Result<Self>

Create a client from a full connection string (http(s)://host[:port] or umicp://host[:port]).

pub fn protocol(&self) -> Protocol

Returns the protocol the client is currently using.

pub async fn with_master<F, Fut, T>(&self, callback: F) -> Result<T>

where F: FnOnce(VectorizerClient) -> Fut, Fut: Future<Output = Result<T>>,

Execute a callback with master transport for read-your-writes scenarios. All operations within the callback are routed to master.

pub fn with_transport( transport: Arc<dyn Transport>, base_url: impl Into<String>, ) -> Self

Construct a VectorizerClient directly from a custom Transport implementation. Test-only / advanced use.

The dispatcher fields (master_transport, replica_transports, is_replica_mode) are all left empty — the client behaves as a single-transport instance. Used by mock-based tests to swap the real HTTP backend out for an in-memory one without touching the per-surface modules.

This entry point is the RPC-readiness regression guard (phase 4 task 2.4): if any per-surface module accidentally hard-codes HttpTransport or reqwest::Client, the MockTransport integration test in tests/mock_transport_regression.rs stops compiling. The same Transport trait the crate::rpc backend will plug into from phase6_sdk-rust-rpc is what mocks ride here.