FluxIndex.Storage.PostgreSQL 0.19.0

FluxIndex

RAG library for .NET 10.0 - Build semantic search and retrieval systems with vector + keyword hybrid search.

Key Features

• Hybrid Search - Vector (semantic) + Keyword (BM25) with automatic strategy selection
• High Performance - Embedding cache (100% faster), batch indexing (24ms/1K chunks)
• Local Reranking - Cross-encoder neural reranking with automatic algorithmic fallback
• Graph Traversal - BFS/DFS, Dijkstra shortest path, PageRank-style importance
• Vector Quantization - Scalar (Int8/Int4), Product Quantization, Binary (32x compression)
• Multiple Storage - SQLite, PostgreSQL with pgvector
• AI Provider Agnostic - Core provides abstract base classes, bring your own embedding service
• Document Processing - PDF/DOCX/TXT via FileFlux, web crawling via WebFlux
• MCP Server - Model Context Protocol for AI assistant integration
• Production Ready - Redis caching, clean architecture, .NET 10.0

Quick Start

dotnet add package FluxIndex.SDK
dotnet add package FluxIndex.Storage.SQLite

using FluxIndex.SDK;
using FluxIndex.Storage.SQLite;

// 1. Setup (InMemory embedding for testing)
// UseSQLite() selects the provider; AddSQLiteStorage() registers it. Both are required —
// Build() throws if you name a store without registering it.
var context = FluxIndexContext.CreateBuilder()
    .UseSQLite("fluxindex.db")
    .AddSQLiteStorage()
    .Build();

// 2. Index
await context.Indexer.IndexDocumentAsync(
    "FluxIndex is a RAG library for .NET", "doc-001");

// 3. Search
var results = await context.Retriever.SearchAsync("RAG library", maxResults: 5);

Note (testing embedder): without a registered IEmbeddingService the builder falls back to InMemoryEmbeddingService, whose vectors are deterministic but not semantically meaningful — similarity scores cluster near 0, so with the default minScore a search typically returns no results. Pass minScore: 0 while smoke-testing, and register a real embedding service (below) for meaningful retrieval.

Using Custom Embedding Service

FluxIndex is AI provider-agnostic. Extend EmbeddingServiceBase for your preferred provider:

// Example: LMSupply embedding (local ONNX-based, no API key)
public class LMSupplyEmbedder : EmbeddingServiceBase, IAsyncDisposable
{
    private readonly IEmbeddingModel _model;
    private LMSupplyEmbedder(IEmbeddingModel model) => _model = model;

    public static async Task<LMSupplyEmbedder> CreateAsync(string modelId = "default")
    {
        var model = await LocalEmbedder.LoadAsync(modelId);
        return new LMSupplyEmbedder(model);
    }

    protected override async Task<float[]> EmbedCoreAsync(string text, CancellationToken ct)
        => await _model.EmbedAsync(text, ct);

    public override int GetEmbeddingDimension() => _model.Dimensions;
    public override string GetModelName() => _model.ModelId;
    public ValueTask DisposeAsync() => _model.DisposeAsync();
}

// Register and use
var context = FluxIndexContext.CreateBuilder()
    .UseSQLite("fluxindex.db")
    .AddSQLiteStorage()
    .ConfigureServices(s => s.AddSingleton<IEmbeddingService>(
        LMSupplyEmbedder.CreateAsync().GetAwaiter().GetResult()))
    .Build();

MCP Server

FluxIndex provides Model Context Protocol (MCP) server for AI assistant integration.

Available Tools: search, memorize, unmemorize, status

See FluxIndex.MCP for integration details.

Performance

Full benchmarks: BENCHMARK_RESULTS.md

Package Structure

Package	NuGet	Description
FluxIndex.Core		Interfaces, abstract base classes, and core logic
FluxIndex.SDK		All-in-one SDK with FileFlux, WebFlux, FluxCurator, FluxImprover
FluxIndex.Storage.SQLite		SQLite vector store
FluxIndex.Storage.PostgreSQL		PostgreSQL with pgvector
FluxIndex.Storage.Neo4j		Neo4j graph database
FluxIndex.Storage.Qdrant		Qdrant vector database
FluxIndex.Cache.Redis		Redis semantic cache

Moved: File-to-vector synchronization (formerly FluxIndex.Extensions.FileVault) was extracted to the FluxFeed repository in 0.16.0. Install FluxFeed for git-like file tracking / folder-monitoring document ingestion; it feeds into FluxIndex.

Storage capability matrix

Metadata filtering (SearchAsync(..., filters:)) is honored by every store — stores without native pushdown fall back to a correctness backstop applied before the topK trim. Native pushdown matters for recall/performance at scale:

Filter semantics: equality on every key/value pair (AND). Values compare by their JSON text representation ("true", invariant-culture numbers, ordinal strings). The same semantics apply in the SDK's Retriever, so a value that round-trips through a JSON column still matches the raw value you filter on.

Filters match chunk metadata. The metadata argument of Indexer.IndexDocumentAsync(content, documentId, metadata) and IndexChunksAsync(chunks, documentId, metadata) is copied onto that document's chunks for exactly this reason — a chunk's own metadata wins on key collision:

await context.Indexer.IndexDocumentAsync(
    "tenant content", "doc-001", new() { ["workspace_id"] = "ws-a" });

var scoped = await context.Retriever.SearchAsync(
    "content", filter: new() { ["workspace_id"] = "ws-a" });

await vectorStore.DeleteByFilterAsync(new() { ["workspace_id"] = "ws-a" });

Limitation (keyword leg): HybridSearchAsync/KeywordSearchAsync resolve their BM25 leg through IDocumentRepository, which currently has an in-memory implementation only. With a persistent store the keyword leg therefore sees only documents this process indexed, and after a restart hybrid search effectively degrades to vector-only. Vector search and metadata filtering are unaffected.

Which package do I need?

Minimal setup — bring your own embedding service, no native binaries:

dotnet add package FluxIndex.Core
dotnet add package FluxIndex.Storage.SQLite

Full SDK — includes document processing (PDF, DOCX, HWP, web crawling):

dotnet add package FluxIndex.SDK
dotnet add package FluxIndex.Storage.SQLite

Documentation

• Guide - Quick start and configuration
• Reference - Architecture and API reference
• Advanced RAG - HyDE, Contextual Retrieval, Query Expansion
• Philosophy - Core principles and design philosophy

Examples

• RealQualityTest - LMSupply + SQLite integration
• WebFluxSample - Web crawling with WebFlux
• ChunkingQualityTest - FileFlux chunking analysis
• FileFluxIndexSample - Document indexing workflow

Requirements

• .NET 10.0 or later
• SQLite or PostgreSQL

License

MIT License - see LICENSE file.

Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.