Struct VectorDB 

pub struct VectorDB { /* private fields */ }

Base de datos vectorial embebida.

VectorDB es la interfaz principal para interactuar con la base de datos. Permite insertar, buscar, actualizar y eliminar vectores con sus metadatos.

Características

• Thread-safe: Puede usarse desde múltiples hilos
• Búsqueda rápida: Encuentra los k vecinos más cercanos
• Metadata flexible: Asocia información adicional a cada vector

Ejemplo

use minimemory::{VectorDB, Config, Distance};

let db = VectorDB::new(Config::new(3)).unwrap();

// Insertar vectores
db.insert("vec1", &[1.0, 0.0, 0.0], None).unwrap();
db.insert("vec2", &[0.0, 1.0, 0.0], None).unwrap();

// Buscar similares
let results = db.search(&[1.0, 0.1, 0.0], 1).unwrap();
assert_eq!(results[0].id, "vec1");

Implementations

impl VectorDB

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

Crea una nueva base de datos vectorial en memoria.

Argumentos

• config - Configuración con dimensiones, métrica y tipo de índice

Ejemplo

use minimemory::{VectorDB, Config};

let db = VectorDB::new(Config::new(128)).unwrap();

pub fn with_fulltext( config: Config, indexed_fields: Vec<String>, ) -> Result<Self>

Crea una nueva base de datos con soporte para full-text search.

Argumentos

• config - Configuración con dimensiones, métrica y tipo de índice
• indexed_fields - Campos de metadata a indexar para BM25 (ej: [“title”, “content”])

Ejemplo

use minimemory::{VectorDB, Config};

let db = VectorDB::with_fulltext(
    Config::new(384),
    vec!["title".into(), "content".into()]
).unwrap();

pub fn open<P: AsRef<Path>>(path: P) -> Result<Self>

Abre una base de datos desde un archivo.

Carga los vectores del archivo a memoria y reconstruye el índice.

Argumentos

• path - Ruta al archivo .mmdb

Ejemplo

use minimemory::VectorDB;

let db = VectorDB::open("my_database.mmdb").unwrap();

pub fn open_with_fulltext<P: AsRef<Path>>( path: P, indexed_fields: Vec<String>, ) -> Result<Self>

Abre una base de datos con soporte full-text.

Carga los vectores y reconstruye el índice BM25.

Argumentos

• path - Ruta al archivo .mmdb
• indexed_fields - Campos de metadata a indexar para BM25

pub fn insert( &self, id: impl Into<VectorId>, vector: &[f32], metadata: Option<Metadata>, ) -> Result<()>

Inserta un vector con ID y metadata opcional.

Argumentos

• id - Identificador único del vector
• vector - Slice de f32 con las dimensiones correctas
• metadata - Metadata opcional asociada al vector

Errores

• DimensionMismatch: Si el vector no tiene las dimensiones configuradas
• AlreadyExists: Si ya existe un vector con ese ID

Ejemplo

use minimemory::{VectorDB, Config, Metadata};

let db = VectorDB::new(Config::new(3)).unwrap();

// Sin metadata
db.insert("vec1", &[1.0, 2.0, 3.0], None).unwrap();

// Con metadata
let mut meta = Metadata::new();
meta.insert("label", "importante");
db.insert("vec2", &[4.0, 5.0, 6.0], Some(meta)).unwrap();

pub fn insert_document( &self, id: impl Into<VectorId>, vector: Option<&[f32]>, metadata: Option<Metadata>, ) -> Result<()>

Inserta un documento con vector opcional.

Permite insertar documentos solo con metadata (sin vector), útil para almacenar datos como en MongoDB.

Argumentos

• id - Identificador único del documento
• vector - Vector opcional (None para documentos metadata-only)
• metadata - Metadata del documento

Ejemplo

use minimemory::{VectorDB, Config, Metadata};

let db = VectorDB::with_fulltext(
    Config::new(3),
    vec!["title".into(), "content".into()]
).unwrap();

// Documento sin vector (solo metadata)
let mut meta = Metadata::new();
meta.insert("title", "Mi post de blog");
meta.insert("content", "Contenido del post...");
db.insert_document("post-1", None, Some(meta)).unwrap();

// Documento con vector
let mut meta2 = Metadata::new();
meta2.insert("title", "Post con embedding");
db.insert_document("post-2", Some(&[0.1, 0.2, 0.3]), Some(meta2)).unwrap();

pub fn insert_batch( &self, vectors: &[(impl AsRef<str>, &[f32], Option<Metadata>)], ) -> Result<()>

Inserta múltiples vectores en lote.

Argumentos

• vectors - Slice de tuplas (id, vector, metadata)

Nota

Si alguna inserción falla, las anteriores no se revierten.

pub fn search(&self, query: &[f32], k: usize) -> Result<Vec<SearchResult>>

Busca los k vecinos más cercanos al vector de consulta.

Argumentos

• query - Vector de consulta
• k - Número de resultados a retornar

Retorna

Vector de SearchResult ordenado por distancia (menor primero).

Errores

• DimensionMismatch: Si el query no tiene las dimensiones correctas

Ejemplo

use minimemory::{VectorDB, Config};

let db = VectorDB::new(Config::new(3)).unwrap();
db.insert("a", &[1.0, 0.0, 0.0], None).unwrap();
db.insert("b", &[0.0, 1.0, 0.0], None).unwrap();

let results = db.search(&[1.0, 0.1, 0.0], 2).unwrap();
println!("Más cercano: {}", results[0].id);

pub fn get( &self, id: &str, ) -> Result<Option<(Option<Vec<f32>>, Option<Metadata>)>>

Obtiene un documento por su ID.

Retorna

Some((vector, metadata)) si existe, None si no. El vector puede ser None para documentos metadata-only.

pub fn delete(&self, id: &str) -> Result<bool>

Elimina un vector por su ID.

Retorna

true si el vector existía y fue eliminado, false si no existía.

pub fn update( &self, id: impl Into<VectorId>, vector: &[f32], metadata: Option<Metadata>, ) -> Result<()>

Actualiza un documento existente.

Internamente elimina el documento anterior e inserta el nuevo.

Argumentos

• id - ID del documento a actualizar
• vector - Nuevo vector
• metadata - Nueva metadata (reemplaza la anterior)

pub fn update_document( &self, id: impl Into<VectorId>, vector: Option<&[f32]>, metadata: Option<Metadata>, ) -> Result<()>

Actualiza un documento con vector opcional.

Argumentos

• id - ID del documento a actualizar
• vector - Nuevo vector (opcional)
• metadata - Nueva metadata (reemplaza la anterior)

pub fn contains(&self, id: &str) -> bool

Verifica si un vector existe en la base de datos.

pub fn len(&self) -> usize

Retorna el número de vectores en la base de datos.

pub fn list_ids(&self) -> Result<Vec<VectorId>>

Retorna todos los IDs de documentos.

pub fn is_empty(&self) -> bool

Verifica si la base de datos está vacía.

pub fn clear(&self)

Elimina todos los vectores de la base de datos.

pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()>

Guarda la base de datos a un archivo .mmdb.

Argumentos

• path - Ruta donde guardar el archivo

Ejemplo

use minimemory::{VectorDB, Config};

let db = VectorDB::new(Config::new(3)).unwrap();
db.insert("a", &[1.0, 2.0, 3.0], None).unwrap();
db.save("my_database.mmdb").unwrap();

pub fn dimensions(&self) -> usize

Retorna las dimensiones configuradas.

pub fn distance(&self) -> Distance

Retorna la métrica de distancia configurada.

pub fn has_fulltext(&self) -> bool

Verifica si el full-text search está habilitado.

pub fn bm25_fields(&self) -> &[String]

Retorna los campos indexados para BM25.

pub fn create_partial_index( &self, name: &str, config: PartialIndexConfig, ) -> Result<()>

Crea un nuevo índice parcial.

Un índice parcial solo incluye documentos que cumplen con el filtro especificado. Esto mejora el rendimiento de búsquedas sobre subconjuntos específicos de datos.

Argumentos

• name - Nombre único para el índice
• config - Configuración con filtro y tipo de índice

Ejemplo

use minimemory::{VectorDB, Config, Filter};
use minimemory::partial_index::PartialIndexConfig;

let db = VectorDB::new(Config::new(384)).unwrap();

// Crear índice parcial para documentos de categoría "tech"
db.create_partial_index(
    "tech_docs",
    PartialIndexConfig::new(Filter::eq("category", "tech"))
).unwrap();

// Crear índice HNSW para documentos activos
db.create_partial_index(
    "active_docs",
    PartialIndexConfig::new(Filter::eq("status", "active"))
        .with_hnsw(16, 200)
).unwrap();

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

Elimina un índice parcial.

Errores

Retorna error si el índice no existe.

pub fn list_partial_indexes(&self) -> Vec<PartialIndexStats>

Lista todos los índices parciales y sus estadísticas.

pub fn search_partial( &self, index_name: &str, query: &[f32], k: usize, ) -> Result<Vec<SearchResult>>

Busca en un índice parcial específico.

Esta búsqueda es más rápida que buscar en todo el índice principal cuando se trabaja con subconjuntos de datos.

Argumentos

• index_name - Nombre del índice parcial
• query - Vector de consulta
• k - Número máximo de resultados

Ejemplo

// Buscar solo en documentos de tecnología (más rápido)
let results = db.search_partial("tech_docs", &query_vector, 10).unwrap();

for result in results {
    println!("{}: {:.4}", result.id, result.distance);
}

pub fn rebuild_partial_index(&self, index_name: &str) -> Result<usize>

Reconstruye un índice parcial con los documentos actuales.

Útil después de cambios masivos en los datos o para optimizar el índice.

Retorna

Número de documentos añadidos al índice.

pub fn has_partial_index(&self, name: &str) -> bool

Verifica si existe un índice parcial con el nombre dado.

pub fn insert_chunk(&self, chunk: &Chunk, vector: Option<&[f32]>) -> Result<()>

Inserta un chunk de documento con su metadata.

Método de conveniencia para insertar chunks generados por el módulo chunking. El contenido del chunk se almacena en el campo “content” de la metadata.

Argumentos

• chunk - Chunk a insertar
• vector - Vector embedding opcional para el chunk

Ejemplo

use minimemory::{VectorDB, Config};
use minimemory::chunking::{chunk_markdown, ChunkConfig};

let db = VectorDB::with_fulltext(
    Config::new(384),
    vec!["content".into(), "heading".into()]
).unwrap();

let result = chunk_markdown("# Title\nContent here", &ChunkConfig::default()).unwrap();

for chunk in result.chunks {
    // Generar embedding con tu modelo preferido
    let embedding = generate_embedding(&chunk.content);
    db.insert_chunk(&chunk, Some(&embedding)).unwrap();
}

pub fn insert_chunks<'a>( &self, chunks: impl IntoIterator<Item = (&'a Chunk, Option<Vec<f32>>)>, ) -> Result<()>

Inserta múltiples chunks en lote.

Argumentos

• chunks - Iterator de tuplas (chunk, vector_opcional)

Ejemplo

use minimemory::{VectorDB, Config};
use minimemory::chunking::{chunk_markdown, ChunkConfig};

let db = VectorDB::with_fulltext(Config::new(384), vec!["content".into()]).unwrap();
let result = chunk_markdown(content, &ChunkConfig::default()).unwrap();

// Con embeddings pregenerados
let chunks_with_vectors: Vec<_> = result.chunks.iter()
    .map(|c| (c, Some(generate_embedding(&c.content))))
    .collect();

db.insert_chunks(chunks_with_vectors).unwrap();

pub fn ingest_markdown( &self, content: &str, config: &ChunkConfig, ) -> Result<usize>

Procesa e inserta un documento Markdown completo.

Combina chunking + inserción en una sola operación. Útil para documentos sin embeddings (solo BM25/keyword search).

Argumentos

• content - Contenido Markdown
• config - Configuración de chunking

Retorna

Número de chunks insertados.

Ejemplo

use minimemory::{VectorDB, Config};
use minimemory::chunking::ChunkConfig;

let db = VectorDB::with_fulltext(
    Config::new(3), // dimensiones no importan para keyword search
    vec!["content".into(), "heading".into()]
).unwrap();

let markdown = "# Title\nContent...";
let count = db.ingest_markdown(markdown, &ChunkConfig::default()).unwrap();
println!("Ingested {} chunks", count);

pub fn ingest_markdown_file( &self, path: &Path, config: &ChunkConfig, ) -> Result<usize>

Procesa e inserta un archivo Markdown.

Argumentos

• path - Ruta al archivo Markdown
• config - Configuración de chunking

Retorna

Número de chunks insertados.

pub fn hybrid_search( &self, params: HybridSearchParams, ) -> Result<Vec<HybridSearchResult>>

Búsqueda híbrida con parámetros configurables.

Permite combinar búsqueda vectorial, keyword (BM25), y filtros de metadata.

Argumentos

• params - Parámetros de búsqueda híbrida

Ejemplo

use minimemory::{VectorDB, Config, HybridSearchParams, Filter};

let db = VectorDB::with_fulltext(
    Config::new(3),
    vec!["title".into(), "content".into()]
).unwrap();

// Búsqueda híbrida: vector + keyword
let params = HybridSearchParams::hybrid(
    vec![0.1, 0.2, 0.3],
    "rust programming",
    10
);
let results = db.hybrid_search(params).unwrap();

pub fn keyword_search( &self, query: &str, k: usize, ) -> Result<Vec<HybridSearchResult>>

Búsqueda por keywords usando BM25.

Requiere que la DB haya sido creada con with_fulltext.

Argumentos

• query - Texto a buscar
• k - Número de resultados

Ejemplo

use minimemory::{VectorDB, Config};

let db = VectorDB::with_fulltext(
    Config::new(3),
    vec!["title".into(), "content".into()]
).unwrap();

let results = db.keyword_search("rust programming", 10).unwrap();

pub fn filter_search( &self, filter: Filter, limit: usize, ) -> Result<Vec<HybridSearchResult>>

Búsqueda solo por filtros de metadata.

No realiza ranking por similitud, solo filtra documentos.

Argumentos

• filter - Filtro de metadata
• limit - Número máximo de resultados

Ejemplo

use minimemory::{VectorDB, Config, Filter};

let db = VectorDB::new(Config::new(3)).unwrap();

let results = db.filter_search(
    Filter::eq("category", "tech"),
    100
).unwrap();

pub fn search_with_filter( &self, query: &[f32], k: usize, filter: Filter, ) -> Result<Vec<SearchResult>>

Búsqueda vectorial con filtro de metadata.

Combina búsqueda por similitud vectorial con filtrado de metadata.

Argumentos

• query - Vector de consulta
• k - Número de resultados
• filter - Filtro de metadata

Ejemplo

use minimemory::{VectorDB, Config, Filter};

let db = VectorDB::new(Config::new(3)).unwrap();

let results = db.search_with_filter(
    &[0.1, 0.2, 0.3],
    10,
    Filter::eq("category", "tech")
).unwrap();

pub fn list_documents( &self, filter: Option<Filter>, order: Option<OrderBy>, limit: usize, offset: usize, ) -> Result<PagedResult<HybridSearchResult>>

List documents with optional filter, ordering, and pagination.

This is the most SQL-like query method: SELECT * WHERE filter ORDER BY field LIMIT k OFFSET n.

Example

use minimemory::{VectorDB, Config, Filter, OrderBy, PagedResult};

let db = VectorDB::with_fulltext(Config::new(3), vec!["title".into()])?;

// SELECT * WHERE status='active' ORDER BY created_at DESC LIMIT 10 OFFSET 0
let page = db.list_documents(
    Some(Filter::eq("status", "active")),
    Some(OrderBy::desc("created_at")),
    10,
    0,
)?;

pub fn filter_search_ordered( &self, filter: Filter, order: OrderBy, limit: usize, offset: usize, ) -> Result<PagedResult<HybridSearchResult>>

Filter search with ordering and pagination.

Like filter_search but with ORDER BY and OFFSET support.

pub fn search_paged( &self, query: &[f32], limit: usize, offset: usize, ) -> Result<PagedResult<SearchResult>>

Vector search with pagination.

Like search but returns PagedResult with total count.