Hyperspacedb Core

import { HyperspaceClient } from 'hyperspace-sdk-ts';

const client = new HyperspaceClient(
  process.env.HYPERSPACE_HOST ?? 'localhost:50051',
  process.env.HYPERSPACE_API_KEY ?? 'I_LOVE_HYPERSPACEDB'
);

from hyperspacedb import HyperspaceClient

client = HyperspaceClient(
    host=os.environ.get("HYPERSPACE_HOST", "localhost:50051"),
    api_key=os.environ.get("HYPERSPACE_API_KEY", "I_LOVE_HYPERSPACEDB")
)

import { HyperspaceClient, CollectionSchema } from 'hyperspace-sdk-ts';

// Simple single-component collection
const schema: CollectionSchema = {
  components: [
    {
      name: "main",
      metric: "cosine",   // cosine | l2 | lorentz | poincare | hybrid
      fullDimension: 1536,
      weight: 1.0
    }
  ],
  cascadePipeline: [
    { componentName: "main", cutoffDimension: 1536, storeInRam: true, rerankTopK: 100 }
  ]
};

await client.createCollection("my_memory", schema);

// Hybrid collection: 33 Lorentz dims + 768 Euclidean dims (total 801 dims)
const hybridSchema: CollectionSchema = {
  components: [
    { name: "hybrid_main", metric: "hybrid", fullDimension: 801, weight: 1.0 }
  ],
  cascadePipeline: [
    { componentName: "hybrid_main", cutoffDimension: 801, storeInRam: false, rerankTopK: 200 }
  ]
};
await client.createCollection("ontology_and_text", hybridSchema);

const collections = await client.listCollections();

await client.deleteCollection("my_memory"); // irreversible!

const id = await client.insert(
  [0.1, 0.2, ..., 0.9],  // float32 array, length = fullDimension
  { source: "user_chat", timestamp: "2026-07-14" },  // metadata
  "my_memory"
);

const id = await client.insertText(
  "The user asked about quantum entanglement.",
  { user_id: "u123", session: "sess_abc" },  // metadata
  "my_memory"
);

// batchInsert takes an array of {vector, metadata} objects
const ids = await client.batchInsert(
  [
    { vector: [...], metadata: { key: "val1" } },
    { vector: [...], metadata: { key: "val2" } },
  ],
  "my_memory"
);

const results = await client.search(
  queryVector,   // number[] | Float32Array | Float64Array
  10,            // top-k
  "my_memory",
  {
    filters: [...],    // optional Filter[]
    mrlDimension: 256, // optional: use truncated MRL dimension for faster search
    useWasserstein: false,
    includePayload: false,
  }
);
// results: Array<{ id, distance, metadata, typedMetadata, payload? }>

const results = await client.search(
  queryVector,
  10,
  "my_memory",
  {
    hybridQuery: "quantum entanglement",  // BM25 text query
    hybridAlpha: 0.5,  // 0.0 = pure BM25, 1.0 = pure vector, 0.5 = balanced
  }
);

const results = await client.searchText(
  "quantum physics papers",
  10,
  "my_memory",
  {
    hybridAlpha: 0.7,  // optional: blend vector score with BM25
  }
);

const results = await client.search(queryVector, 10, "my_memory", {
  filters: [
    { and: [
      { match: { key: "source", value: "research_paper" } },
      { range: { key: "year", gte: 2020 } }
    ]}
  ]
});

const points = await client.getPoints([1, 42, 99], "my_memory");

await client.delete(pointId, "my_memory");

await client.rebuildIndex("my_memory");  // optimize HNSW graph
await client.vacuum();                   // purge deleted vectors, reclaim disk