SeekStorm · AI Nav City

Core facts

Read by a script from the official API, not rewritten by a model.

Repository: https://github.com/SeekStorm/SeekStorm
License: Apache-2.0
Languages: Rust
Maintainer: SeekStorm
Homepage: https://seekstorm.com
Verified: 2026-11-02

What it is

SeekStorm can be embedded as a library, run as a multi-tenant server, or give agents search via MCP. The seekstorm component of SeekStorm is an in-process search library (lexical, vector, hybrid). SeekStorm is open source under the Apache License 2.0. SeekStorm has been in production since 2020.

Main features

SeekStorm has two first-class engines (inverted index + IVF ANN) behind one query planner.
Search can be lexical, vector or hybrid per query, fused with Reciprocal Rank Fusion (RRF).
SeekStorm supports multi-vector indexing, both from multiple fields and from multiple chunks per field.
Vector search supports cosine similarity, dot product and Euclidean distance, and vector precisions F32 and I8.
SeekStorm can also import and index externally generated embeddings.
SeekStorm provides stemming for 38 languages and has 6 tokenizers, including Chinese word segmentation.
SeekStorm has a built-in MCP server for RAG and agentic search.
SeekStorm supports geo proximity search, filtering and sorting, as well as one-way and multi-way synonyms.

Getting started

The MCP server is added to an MCP client configuration (Claude Desktop, Cursor, ...).
The MCP server runs as a child process over stdio and embeds SeekStorm directly, without requiring a server process or network connection.
If no index exists at SEEKSTORM_INDEX_PATH, the MCP server creates one with a default schema (title, body, path).
The MCP server exposes lexical, vector and hybrid search, plus document indexing, JSON/NDJSON ingestion, PDF indexing and index management as MCP tools.
The MASTER_KEY_SECRET environment variable should be set to a secret; otherwise generated API keys will be compromised.
An application can disable the SeekStorm default features in its cargo.toml.

From the README · bash

docker run -ti -p "8000:80" -v "$(pwd)/seekstorm_storage:/seekstorm_index:z" wolfgarbe/seekstorm_server

From the README · bash

cargo install seekstorm_mcp_server

From the README · json

{
  "mcpServers": {
    "seekstorm": {
      "command": "seekstorm_mcp_server",
      "env": { "SEEKSTORM_INDEX_PATH": "/path/to/seekstorm-index" }
    }
  }
}

From the README · bash

cargo add seekstorm serde_json
cargo add tokio --features full

From the README · rust

use std::path::Path;
use seekstorm::commit::Commit;
use seekstorm::index::{create_index, AccessType, Clustering, DocumentCompression, FrequentwordType, IndexDocuments, IndexMetaObject, LexicalSimilarity, NgramSet, StemmerType, StopwordType, TokenizerType};
use seekstorm::search::{QueryRewriting, QueryType, ResultType, Search, SearchMode};
use seekstorm::vector::Inference;

#[tokio::main]
async fn main() {
    // 1. Schema: which fields exist and how they are indexed
    let schema = serde_json::from_str(r#"[
        {"field":"title","field_type":"Text","store":true,"index_lexical":true},
        {"field":"body","field_type":"Text","store":true,"index_lexical":true}
    ]"#).unwrap();

    // 2. Create the index
    let meta = IndexMetaObject {
        id: 0,
        name: "quickstart".into(),
        lexical_similarity: LexicalSimilarity::Bm25f,
        tokenizer: TokenizerType::UnicodeAlphanumeric,
        stemmer: StemmerType::None,
        stop_words: StopwordType::None,
        frequent_words: FrequentwordType::English,
        ngram_indexing: NgramSet::NgramFF as u8,
        document_compression: DocumentCompression::Snappy,
        access_type: AccessType::Mmap,
        spelling_correction: None,
        query_completion: None,
        clustering: Clustering::None,
        inference: Inference::None,
        segment_number_bits:11
    };
    let mut index_arc = create_index(Path::new("./seekstorm_index"), meta, &schema, &Vec::new(), false, None).await.unwrap();

    // 3. Index documents
    let docs = r#"[{"title":"title1 test","body":"body1"}, {"title":"title2","body":"body2 test"}]"#;
    index_arc.index_documents(serde_json::from_str(docs).unwrap()).await;
    index_arc.commit().await;

    // 4. Search
    let result_object = index_arc.search(
        "test".to_string(), None, QueryType::Intersection, SearchMode::Lexical, false, 0, 10, ResultType::TopkCount, false,
        Vec::new(), Vec::new(), Vec::new(), Vec::new(), QueryRewriting::SearchOnly,
    ).await;

    println!("{} hits", result_object.result_count_total);
    for r in result_object.results.iter() {
        println!("doc {} score {}", r.doc_id, r.score);
    }
}

Who it is for

A SeekStorm index can be kept in RAM or in memory mapped files. SeekStorm supports SIMD on x86-64 (AVX2) and AArch64 (NEON). The same binary index works in the library, the server and the cloud.

An index is a plain directory tree of self-contained files, with no database engine needed. Backup and restore of an index is a file copy. The server is cross-platform and runs on Linux, Windows, and macOS, while other operating systems are not tested.

SeekStorm has client libraries and SDKs in Rust, Python, C#, Java and TypeScript. SeekStorm provides a Docker file and container image at Docker Hub. SeekStorm lists multi-tenancy index management.

SeekStorm lists API-key management. SeekStorm ingests local PDF files via console command, either a single file or all files in a directory.

Related tools listed on this site.