Indexes

Indexes are the vector stores where your data lives. Every vector you upsert belongs to an index.

Index Types

Endee supports two types of indexes:

Dense Indexes

Dense indexes enable semantic search: finding items based on meaning rather than exact keyword matches. Each vector is a list of numbers, one number per dimension, representing the meaning of your content.

Use dense indexes when you want to:

Find semantically similar documents
Power recommendation systems
Enable image/video similarity search

Python


from endee import Endee, Precision
 
client = Endee()
 
client.create_index(
    name="my_index",
    dimension=384,       # must match your embedding model's output size
    space_type="cosine",
    precision=Precision.INT16
)

TypeScript


import { Endee, Precision } from 'endee';
 
const client = new Endee();
 
await client.createIndex({
  name: 'my_index',
  dimension: 384,
  spaceType: 'cosine',
  precision: Precision.INT16,
});

Java


import io.endee.client.Endee;
import io.endee.client.types.CreateIndexOptions;
import io.endee.client.types.Precision;
import io.endee.client.types.SpaceType;
 
Endee client = new Endee();
 
client.createIndex(
    CreateIndexOptions.builder("my_index", 384)  // must match your embedding model's output size
        .spaceType(SpaceType.COSINE)
        .precision(Precision.INT16)
        .build()
);

Hybrid Indexes

Hybrid indexes combine dense vector search with sparse vector search (e.g keyword matching). This gives you the best of both worlds: semantic similarity and exact term matching in a single query.

Use hybrid indexes for:

Document retrieval in RAG pipelines
Search where both meaning and keywords matter
Any use case where dense-only search misses exact terminology

Python


client.create_index(
    name="hybrid_index",
    dimension=384,
    sparse_model="endee_bm25",  # enables hybrid search with BM25
    space_type="cosine",
    precision=Precision.INT16
)

TypeScript


await client.createIndex({
  name: 'hybrid_index',
  dimension: 384,
  sparseModel: 'endee_bm25',
  spaceType: 'cosine',
  precision: Precision.INT16,
});

Java


client.createIndex(
    CreateIndexOptions.builder("hybrid_index", 384)
        .spaceType(SpaceType.COSINE)
        .precision(Precision.INT16)
        .sparseModel("default")
        .build()
);

The endee-model BM25 sparse embedding library is currently available for Python and TypeScript only. Java supports hybrid indexes using the default sparse model. Bring your own sparse vectors generated from any BM25 implementation.

Sparse Model Options:

Model	Description
default	Bring your own sparse vectors (you provide custom indices and values)
endee_bm25	Use Endee’s BM25 model via the endee-model package to generate sparse vectors. See Sparse Vectors (BM25)

See the Sparse Vectors (BM25) guide for installing endee-model and generating BM25 embeddings.

The sparse_model parameter

For sparse_model you have two options depending on which sparse model you use:

sparse_model="endee_bm25" — use this when your sparse vectors come from endee/bm25. Endee holds the IDF weights on its server and applies them automatically, so you only need to send the TF weights from your client.
sparse_model="default" — use this for SPLADE models or any other BM25 model. In this case Endee treats the values you send as final scores and does no further calculation. If you are using another BM25 model (not endee/bm25), you must compute the full IDF scores yourself on the client before sending them.

Index Parameters

When creating an index, configure the following parameters:

Parameter	Description	Default
Name	Unique name for your index	Required
Dimension	Dense vector dimensionality (max 10,000)	Required
Space Type	Distance metric: cosine, l2, or ip (inner product)	Required
Sparse Model	Enables hybrid search: default or endee_bm25	None
M	HNSW graph connectivity (higher values improve recall, more memory)	16
EF Construction	HNSW build-time parameter (higher values improve index quality)	128
Precision	Vector quantization level (see Precision)	INT8

Python


# All parameters explicitly set
client.create_index(
    name="my_index",
    dimension=768,
    space_type="cosine",
    M=32,          # higher connectivity = better recall, more memory
    ef_con=200,    # higher = better index quality, slower build
    precision=Precision.FLOAT32
)

TypeScript


await client.createIndex({
  name: 'my_index',
  dimension: 768,
  spaceType: 'cosine',
  M: 32,
  efCon: 200,
  precision: Precision.FLOAT32,
});

Java


// All parameters explicitly set
client.createIndex(
    CreateIndexOptions.builder("my_index", 768)
        .spaceType(SpaceType.COSINE)
        .m(32)       // higher connectivity = better recall, more memory
        .efCon(200)  // higher = better index quality, slower build
        .precision(Precision.FLOAT32)
        .build()
);

Distance Metrics

Choose the appropriate distance metric based on your embedding model and use case:

Metric	Value	Description	Best For
Cosine	cosine	Measures the angle between vectors (direction only)	Text embeddings, normalized vectors
L2	l2	Euclidean distance (magnitude and direction)	Image embeddings, spatial data
Inner Product	ip	Dot product similarity	Maximum inner product search (e.g., recommendation)

Most embedding models (e.g., Sentence Transformers, OpenAI) produce normalized vectors. Use cosine by default.

HNSW Algorithm

Both index types use the HNSW (Hierarchical Navigable Small World) algorithm for Approximate Nearest Neighbor (ANN) searches. The two build-time parameters (M and EF Construction) control the quality vs. memory/build-time trade-off.

Parameter	Effect of Increasing
M	Higher recall, more memory usage
EF Construction	Better index quality, slower build time

The defaults (M=16, EF Construction=128) are good starting points for most workloads.

EF Construction is a build-time parameter set when creating the index — it controls index quality and cannot be changed without recreating the index. EF (also called ef_search) is a separate query-time parameter that controls how many candidates are explored per search query. The two are independent. See Search: Query Parameters.

Index Management

List Indexes

Python


indexes = client.list_indexes()
for idx in indexes:
    print(idx)

TypeScript


const indexes = await client.listIndexes();
for (const idx of indexes) {
  console.log(idx);
}

Java


List<String> indexes = client.listIndexes();
indexes.forEach(System.out::println);

Get Index

Returns a handle to an existing index for querying and upserting.

Python


index = client.get_index("my_index")

TypeScript


const index = await client.getIndex('my_index');

Java


Index index = client.getIndex("my_index");

Delete Index

Deletion is irreversible. All vectors in the index are permanently removed.

Python


client.delete_index("my_index")

TypeScript


await client.deleteIndex('my_index');

Java


client.deleteIndex("my_index");