向量与全文搜索。
比瞬时还要快。 「比瞬时还快」真的可能吗？ 人类的视觉感知能够察觉极短时间尺度内的变化。研究表明视觉处理速度可达约 13 毫秒。 在我们的基准测试^*中，SeekStorm 平均每次查询仅需 0.3 毫秒——比 13 毫秒这一参考值快约 43 倍。 既然人类察觉不到差异，为什么还要追求这样的速度？ 因为「瞬时」是一个人类感知层面的概念，而不是工程目标。 1. 尾部延迟
平均延迟还不够。搜索基础设施需要为数千个并发查询、复杂查询和流量高峰预留余量。 2. 机器的感知方式与人类不同
实时系统、高频应用和 AI 智能体可以机器的速度发出请求——往往是大量并行请求。 3. 延迟会累积
当搜索只是更大应用或智能体工作流中的一个环节时，每一毫秒都会累加。 ^* 基准测试：SeekStorm 3.3.5 库，对 500 万篇英文维基百科文档进行全文搜索；查询来自 AOL 查询数据集。平均查询延迟 0.3 毫秒。

        
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")