VectorRAG.Net 0.1.17

VectorRAG.Net

VectorRAG.Net is a high-performance,.NET-native vector database library for semantic search and RAG (Retrieval-Augmented Generation):

Fast ANN search (LSH candidates → exact rerank by dot/cosine) Low-latency hot path with careful allocations Document chunking for RAG Metadata + filtering Optional hybrid search (vector + BM25 full-text) Persistence:save/load database snapshots Runtime metrics

This is a library-first product:you embed it into your application and expose REST/gRPC/etc. yourself.

🚀 Performance Benchmarks

The goal of VectorRAG.Net is low-latency embedded vector search for .NET applications (in-process,without network/RPC overhead).

Environment OS:Windows 11 CPU:Intel Core i5-11400F (6C/12T) .NET:8.0.23 BenchmarkDotNet:0.15.8

Workload Documents:10,000 Embedding dimension:64 (deterministic synthetic embeddings for reproducibility) TopK:5 Vector search:Random Hyperplane LSH candidates → exact rerank by dot Hybrid search:Vector + BM25 (hashed term IDs,DF cutoff enabled) Grouping:GroupByParentDocument = true

Results

Throughput note: based on the benchmark mean,vector-only search corresponds to ~66,000 queries/second per thread in this synthetic setup. Real-world throughput depends on embedding dimension (e.g. 768/1536),candidate limits,text distributions,metadata filtering,and CPU scaling.

Important:These benchmarks measure in-process compute only. If you host the library behind HTTP/gRPC,transport and serialization overhead will increase end-to-end latency.

Project structure

SlidingRank.FastOps (Core Engine) EmbeddingMatrix — dense float[] storage for N×Dim RandomHyperplaneLshIndex — Random Hyperplane LSH (Signed Random Projections) SimdFloatMath — SIMD dot/L2 helpers EmbeddingAnnSearch — optimized ANN search (LSH + rerank),including low-allocation paths

VectorRAG.Net (RAG Layer) VectorRAGDatabase — indexing,search,chunking-based RAG storage,updates,persistence,metrics ChunkingOptions — chunking configuration IEmbeddingModel + adapters (e.g. OpenAIEmbeddingModel) RAGPipeline helper for context building Internal BM25 index for hybrid search

Quick start

Create database

using SlidingRank.FastOps;
using VectorRAG.Net;

var lsh = new EmbeddingLshConfig(
 Bands:24,
 BitsPerBand:12,
 MaxCandidates:2048,
 Seed:1337);

var options = new VectorRagDatabaseOptions
{
 InitialCapacity = 8192,
 QueryCacheCapacity = 1000,
 NormalizeVectorsOnAdd = false,
 NormalizeQueryOnSearch = false,
 DefaultChunking = new ChunkingOptions
 {
 Strategy = ChunkingStrategy.FixedChars,
 ChunkSize = 1000,
 ChunkOverlap = 200
 }
};

var db = new VectorRAGDatabase(dimension:1536,lshConfig:lsh,options:options);

Embedding model (example:OpenAI)

IEmbeddingModel model = new OpenAIEmbeddingModel(
 apiKey:"sk-...",
 model:"text-embedding-3-small",
 dimension:1536);

Upsert a document (RAG-friendly chunking)

await db.UpsertTextDocumentAsync(
 externalId:"faq_000123",
 text:File.ReadAllText("faq_000123.txt"),
 metadata:new DocumentMetadata { Department = "Support",IsActive = true },
 embeddingModel:model);

Search (vector only)

var qVec = await model.GenerateEmbeddingAsync("how do I reset my password?");
var results = db.Search(qVec,new SearchOptions { TopK = 5,UseHybrid = false });

Hybrid search (vector + BM25)

var q = "reset password";
var qVec = await model.GenerateEmbeddingAsync(q);

var results = db.Search(qVec,new SearchOptions
{
 TopK = 5,
 UseHybrid = true,
 TextQuery = q,
 Alpha = 0.7f
});

Persistence

await db.SaveAsync("C:/rag/snap_2026_02_08");
await db.LoadAsync("C:/rag/snap_2026_02_08");

Metrics

var m = db.GetMetrics();
Console.WriteLine($"active={m.RecordsActive}/{m.RecordsTotal},avg={m.AvgQueryMs:0.00} ms");

🏢 Example Use Cases

1. Banking / Compliance Knowledge Base

var q = "AML compliance requirements for cryptocurrency";
var qVec = await embeddingModel.GenerateEmbeddingAsync(q);

var results = db.Search(qVec,new SearchOptions
{
 TopK = 5,
 UseHybrid = true,
 TextQuery = q,
 Alpha = 0.7f,
 Filter = md => md.Department == "Compliance" && md.IsActive,
 GroupByParentDocument = true
});

2. E-commerce Product Search (with metadata filtering)

var qVec = await embeddingModel.GenerateEmbeddingAsync("wireless noise cancelling headphones");

var results = db.Search(qVec,new SearchOptions
{
 TopK = 10,
 UseHybrid = false,
 Filter = md => md.Attributes != null
 && md.Attributes.TryGetValue("category",out var c) && c == "electronics"
 && md.Attributes.TryGetValue("price",out var p) && int.Parse(p) <= 1000
});

3. Customer Support RAG Chatbot (retrieve + build context)

var q = "How do I reset my password?";
var qVec = await embeddingModel.GenerateEmbeddingAsync(q);

var results = db.Search(qVec,new SearchOptions
{
 TopK = 5,
 UseHybrid = true,
 TextQuery = q,
 Alpha = 0.7f,
 Filter = md => md.Department == "Support" && md.IsActive
});

var pipeline = new RAGPipeline(embeddingModel);
var context = pipeline.BuildPromptContext(results,maxTokens:3500);
// context -> prompt -> LLM

🔧 Integration Notes

VectorRAG.Net is library-first. You can embed it into: Console applications Windows services / Linux daemons Background workers ASP.NET Core / gRPC (optional — you host it yourself)

Persistence is file-based and works well for: local deployments container volumes scheduled snapshotting (e.g. nightly)

📈 Scaling Guidance

Single process Use batching for ingestion (AddBatch / document upserts in batches). Tune LSH config (Bands,BitsPerBand,MaxCandidates) for your recall/latency target. Keep embeddings normalized if using dot≈cosine.

Multi-process / sharding (application-level) For very large collections you can shard at the application layer: split documents by tenant/department/time range query multiple shards in parallel merge topK results

🔐 Security & Compliance (Status)

The core library does not enforce authentication/authorization by itself (it is an embedded engine). Security is handled by the host application.

Roadmap / optional add-ons (not included in the core package): encryption-at-rest for persisted snapshots document-level permissions (RBAC hooks) audit logging hooks hosted REST/gRPC templates

🆚 Why VectorRAG.Net?

.NET-native embedded engine (no external DB required) Focus on low latency and controlled allocations RAG-friendly features:chunking,metadata filtering,hybrid retrieval,context assembly Suitable for enterprise workloads where predictable performance matters

📦 Editions

Note:This table describes the intended product packaging. Actual availability depends on the packages and licensing you publish.

Commercial licensing & support

Community Edition:free to use for developers and startups. Professional / Enterprise:paid subscriptions with additional features and support.

Contact for pricing, invoices, and licensing: Email: vipvodu@yandex.ru Telegram: @vipvodu