Vector & lexical search.
Faster than instant. Is “faster than instant” even possible? Human visual perception can recognize changes at surprisingly short timescales. Research has demonstrated visual processing on the order of 13 milliseconds. SeekStorm averages 0.3 ms per query in our benchmark^* — roughly 43× below that 13 ms reference point. Why go that fast if humans can't notice the difference? Because “instant” is a human-perception concept, not an engineering target. 1. Tail latency
Average latency isn't enough. Search infrastructure needs headroom for thousands of concurrent queries, complex queries, and traffic spikes. 2. Machines don't perceive like humans
Real-time systems, high-frequency applications, and AI agents can issue requests at machine speed — often many in parallel. 3. Latency compounds
When search is one step in a larger application or agent workflow, every millisecond adds up. ^* benchmark: SeekStorm 3.3.5 library, lexical search over 5M English Wikipedia documents; queries derived from the AOL query dataset. 0.3 ms average query latency.

        
pip install seekstorm-client-pure-py

from seekstorm_client import SeekStorm, CreateIndexRequest, SearchRequestObject

client = SeekStorm(
  base_url="http://127.0.0.1:80", 
  apikey_base64="YOUR_APIKEY_BASE64"
)

schema = [
    {"field": "title", "field_type": "Text", "store": True, "index_lexical": True},
]

create_request = CreateIndexRequest(
    index_name="demo_index",
    schema=schema,
    similarity="Bm25f",
    tokenizer="UnicodeAlphanumeric",
    stemmer="None",
    document_compression="Snappy",
    ngram_indexing=0,
)

index_id = client.create_index(create_request).index_id
client.index_document(index_id, {"title": "rust search"})
client.commit_index(index_id)

query = SearchRequestObject(query_string="rust search", offset=0, length=10)
result = client.query_index(index_id, query)
print(f"total hits: {result.count_total}")

client.close()

npm install seekstorm_client_ts
      
import { FieldType, SeekStormClient } from "seekstorm_client_ts";

const client = new SeekStormClient({
  baseUrl: "http://127.0.0.1:80",
  apiKey: "YOUR_APIKEY_BASE64",
});

const indexId = await client.createIndex({
  index_name: "demo_index",
  schema: [{field: "title", field_type: FieldType.Text, store: true, index_lexical: true}]
});

await client.indexDocument(indexId, { title: "rust search" });
await client.commitIndex(indexId);

const result = await client.search(indexId, { query: "rust search", length: 10 });
console.log(`total hits: ${result.count_total}`);

cargo add seekstorm_client_rs tokio serde_json

use seekstorm_client_rs::{RestClient, CreateIndexRequest, Document, SearchRequestObject};
use std::sync::LazyLock;
use std::error::Error;

pub static BASE_URL: &str = "http://127.0.0.1:80";
pub static API_KEY: &str = "YOUR_APIKEY_BASE64";
pub static CLIENT: LazyLock = LazyLock::new(|| RestClient::new());

#[tokio::main]
async fn main() -> Result<(), Box> {
    let schema = serde_json::from_str(
        r#"[{"field":"title","field_type":"Text","store":true,"index_lexical":true}]"#,
    )?;

    let create_index_request = CreateIndexRequest {
        index_name: "demo_index".into(),
        schema,
        ..Default::default()
    };

    let index_id = CLIENT
        .create_index(BASE_URL, API_KEY, &create_index_request)
        .await?
        .index_id;

    let document: Document = serde_json::from_str(r#"{"title":"rust search"}"#)?;
    CLIENT.index_document(BASE_URL, API_KEY, index_id, &document).await?;
    CLIENT.commit_index(BASE_URL, API_KEY, index_id).await?;

    let search_request = SearchRequestObject {
        query_string: "rust search".into(),
        length: 10,
        ..Default::default()
    };

    let result = CLIENT.query_index(BASE_URL, API_KEY, index_id, search_request).await?;
    println!("total hits: {}", result.count_total);

    Ok(())
}

dotnet add package SeekStorm.Client

using SeekStorm.Client;

var client = new SeekStormClient(
    baseUrl: "http://localhost:80",
    apiKeyBase64: "YOUR_APIKEY_BASE64"
);

var createIndex = await client.CreateIndexAsync(new CreateIndexRequest
{
    IndexName = "demo_index",
    Schema = new List>
    {
        new()
        {
            ["field"] = "title",
            ["field_type"] = "Text",
            ["store"] = true,
            ["index_lexical"] = true
        }
    }
});

await client.IndexDocumentAsync(createIndex.IndexId, new Dictionary
{
    ["title"] = "rust search"
});

await client.CommitIndexAsync(createIndex.IndexId);

var result = await client.QueryIndexAsync(createIndex.IndexId, new SearchRequestObject
{
    QueryString = "rust search",
    Length = 10
});

Console.WriteLine($"Total hits: {result.CountTotal}");

implementation 'com.seekstorm:seekstorm-client:1.0'

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.seekstorm.client.SeekStormClient;
import com.seekstorm.client.model.SearchRequest;
import com.seekstorm.client.model.SearchResponse;

ObjectMapper mapper = new ObjectMapper();

SeekStormClient client = SeekStormClient.builder()
    .baseUrl("http://127.0.0.1:80")
    .apiKey("YOUR_APIKEY_BASE64")
    .build();

JsonNode createIndexRequest = mapper.createObjectNode()
    .put("index_name", "demo")
    .set("schema", mapper.createArrayNode()
        .add(mapper.createObjectNode()
            .put("field", "title")
            .put("field_type", "Text")
            .put("store", true)
            .put("index_lexical", true)));

long indexId = client.createIndex(createIndexRequest);

JsonNode document = mapper.createObjectNode()
    .put("title", "rust search");
client.indexDocument(String.valueOf(indexId), document);
client.commitIndex(String.valueOf(indexId));

SearchRequest request = SearchRequest.builder("rust search")
    .length(10)
    .build();

SearchResponse result = client.search(String.valueOf(indexId), request);
System.out.println("Total hits: " + result.countTotal());

go get github.com/seekstorm/seekstorm-go

import "github.com/seekstorm/seekstorm-go"
client := seekstorm.NewClient("http://localhost:80")
result := client.Search("my_index", "rust search")