# Endee — Full Content Reference

> This file contains the full plain-text content of Endee's key pages for AI crawlers and language models. Last updated: June 2026.

---

## What is Endee?

Endee is a high-performance vector database engineered for production AI workloads. It is designed to handle up to 1 billion vectors on a single node, delivering significant performance gains through optimized indexing and execution.

Endee is built by Endee Labs and powers low-latency, high-recall vector search at scale through its Vector Graph Engine (VGE). It offers Queryable Encryption for zero-knowledge enterprise security. Endee is available on managed Cloud (app.endee.io), and as an Enterprise on-prem deployment.

### Key Features

- Fast ANN (Approximate Nearest Neighbor) searches using the HNSW algorithm
- Multiple distance metrics: cosine, L2, and inner product
- Metadata support: attach and search with metadata and filters
- Advanced filtering with operators: $eq, $in, $range
- 5 quantization precision levels: BINARY, INT8, INT16, FLOAT16, FLOAT32
- Hybrid search: combine dense vector search with sparse BM25 keyword search
- Scalable to millions and billions of vectors
- SDKs for Python, TypeScript, Java, and Go

### Use Cases

- Semantic Search: search systems that understand meaning, not just keywords
- Recommendation Systems: personalized recommendations based on similarity matching
- RAG Applications: enhance LLM applications with relevant context retrieval
- Agentic AI: long-term memory and context retrieval for AI agents (LangChain, CrewAI, AutoGen, LlamaIndex)
- Image and Video Search: find similar images and videos using visual embeddings

---

## Quick Start

Source: https://docs.endee.io/quick-start

Get Endee running and make your first vector search in minutes.

### Step 1 — Run Endee with Docker

Prerequisite: Install Docker Desktop. Then run:

```
docker run \
  -p 8080:8080 \
  -v ./endee-data:/data \
  --name endee-server \
  endeeio/endee-server:latest
```

This starts Endee on localhost:8080. Open http://localhost:8080 to verify.

### Step 2 — Install the SDK

Python: pip install endee (requires Python 3.8+)
TypeScript: npm install endee (requires Node.js 18+)
Java: Maven dependency io.endee:endee-java-client:1.0.1 (requires Java 17+)
Go: go get github.com/endee-io/endee-go-client (requires Go 1.21+)

### Step 3 — Initialize the Client

Python:
  from endee import Endee
  client = Endee()

For authenticated local server:
  client = Endee("ndd-auth-token")
  client.set_base_url("http://0.0.0.0:8080/api/v1")

For Endee Serverless (app.endee.io):
  client = Endee("your-serverless-token")

### Step 4 — Create an Index

Python:
  client.create_index(
      name="my_index",
      dimension=384,
      space_type="cosine",
      precision=Precision.INT8
  )

Parameters:
- name: unique index name (alphanumeric + underscore, max 48 chars)
- dimension: dense vector dimensionality (max 10,000)
- space_type: cosine, l2, or ip
- M: HNSW graph connectivity (default 16)
- ef_construction: HNSW construction parameter (default 128)
- precision: BINARY, INT8, INT16, FLOAT16, or FLOAT32 (default INT8)

### Step 5 — Upsert Vectors

Maximum 1,000 vectors per upsert call. Vector dimension must match the index dimension.

Python:
  index = client.get_index(name="my_index")
  index.upsert([
      {
          "id": "doc1",
          "vector": [...],
          "meta": {"title": "First Document"},
          "filter": {"category": "tech"}
      }
  ])

Vector fields:
- id (required): unique string identifier
- vector (required): dense embedding array matching index dimension
- meta (optional): arbitrary metadata returned in query results
- filter (optional): key-value pairs used for filtered queries

### Step 6 — Search

Python:
  results = index.query(
      vector=[...],
      top_k=5,
      ef=128,
      include_vectors=False
  )

Query parameters:
- vector (required): query embedding matching index dimension
- top_k: number of results (default 10, max 512)
- ef: search quality — higher explores more candidates (default 128, max 1024)
- include_vectors: include stored vector data in results (default false)
- filter: filter conditions

### Step 7 — Filtered Query

Python:
  results = index.query(
      vector=[...],
      top_k=5,
      filter=[
          {"category": {"$eq": "tech"}},
          {"score": {"$range": [80, 100]}}
      ]
  )

Filter operators:
- $eq: exact match — {"status": {"$eq": "published"}}
- $in: match any value in list — {"tags": {"$in": ["ai", "ml"]}}
- $range: numeric range inclusive — {"score": {"$range": [70, 95]}}

---

## Hybrid Search with BM25

Source: https://docs.endee.io/tutorials/hybrid-search

Hybrid search combines BM25 keyword matching with dense semantic vectors for better retrieval. BM25 catches exact term matches; dense vectors catch synonyms and paraphrases.

### What is BM25?

BM25 is a classic keyword ranking algorithm. It scores documents by how often search terms appear and down-weights common words like "the" in favour of rare, specific ones.

### Why Two Separate Embedding Functions?

BM25 treats documents and queries differently.
- .embed() — for documents: full BM25 with word frequency, word rarity, and document length adjustment
- .query_embed() — for queries: word rarity only, no length penalty so short queries are not penalized

Rule: always use .embed() for documents and .query_embed() for queries. Mixing them produces incorrect BM25 scores.

### Install Dependencies

pip install --upgrade endee-model endee sentence-transformers
pip install numpy==2.0.0

### Create a Hybrid Index

client.create_index(
    name="example_hybrid",
    dimension=384,
    space_type="cosine",
    sparse_model="endee_bm25",
)

sparse_model options:
- "endee_bm25": use when sparse vectors come from endee/bm25. Endee holds IDF weights server-side; client sends TF weights only.
- "default": use for SPLADE or any other BM25 model. Client must compute full IDF scores before sending.

### Upsert with Dense + Sparse Vectors

points = [
    {
        "id": doc["id"],
        "vector": corpus_dense[i].tolist(),
        "sparse_indices": corpus_sparse[i].indices.tolist(),
        "sparse_values": corpus_sparse[i].values.tolist(),
        "meta": {"title": doc["title"], "text": doc["text"]},
    }
    for i, doc in enumerate(CORPUS)
]
index.upsert(points)

### Run a Hybrid Query

hits = index.query(
    vector=query_dense_vec,
    sparse_indices=sv.indices.tolist(),
    sparse_values=sv.values.tolist(),
    top_k=3,
)

Key Takeaways:
- .embed() is for documents; .query_embed() is for queries — never swap them
- Sparse means most values are zero; only words that appear in the text get a score
- Documents produce ~90 non-zero tokens; short queries produce ~9
- The hybrid query flow: Query → [Dense Embed] → 384-dim vector + [BM25 Sparse] → sparse vector → Endee Hybrid ReRanking → Top-K

---

## LangChain Integration

Source: https://docs.endee.io/integrations/langchain-rag

Use Endee as a LangChain vector store for semantic search and RAG pipelines.

### Install

pip install -q langchain-endee langchain-huggingface sentence-transformers
pip install numpy==2.0.0

### Create Vector Store

from langchain_core.documents import Document
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_endee import EndeeVectorStore

embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

vector_store = EndeeVectorStore(
    index_name="rag_demo",
    api_token=API_TOKEN,
    base_url=BASE_URL,
    dimension=384,
    embedding=embeddings,
    space_type="cosine",
    precision="int16",
)

### Add Documents

documents = [
    Document(
        page_content="Python is a programming language known for readability.",
        metadata={"topic": "programming", "language": "python"},
    ),
]
vector_store.add_documents(documents)

### Semantic Search

results = vector_store.similarity_search("How to learn Python?", k=2)

scored = vector_store.similarity_search_with_score("memory safety", k=2)

### Filtered Search

results = vector_store.similarity_search(
    "semantic search",
    k=5,
    filter=[{"topic": {"$eq": "programming"}}],
)

### Use in RAG Pipeline

retriever = vector_store.as_retriever(search_kwargs={"k": 3})
docs = retriever.invoke("How do I learn Python?")
context = "\n\n".join([doc.page_content for doc in docs])
# Pass context to your LLM

### Hybrid Search with LangChain

from langchain_endee import RetrievalMode, EndeeModelSparse

sparse = EndeeModelSparse()

hybrid_store = EndeeVectorStore(
    index_name="hybrid_demo",
    api_token=API_TOKEN,
    base_url=BASE_URL,
    dimension=384,
    embedding=embeddings,
    retrieval_mode=RetrievalMode.HYBRID,
    sparse_embedding=sparse,
)

### Key Methods

- add_documents(docs): embed and store documents
- similarity_search(query, k): find k similar documents
- similarity_search_with_score(query, k): same with similarity scores
- get_by_ids(ids): fetch documents by ID
- update_filters(updates): change metadata without re-embedding
- delete(ids=...): delete documents
- as_retriever(...): create a retriever for RAG pipelines

Quick Tips:
- Add metadata fields to filter later
- k=3 or k=5 is usually enough for RAG context
- Use $eq, $in, $range filter operators
- Hybrid mode is better when exact keyword matches matter
- int16 precision cuts memory in half vs float32

---

## Deployments

Endee offers three deployment options:

1. Local / Self-hosted
   - Run via Docker: docker run -p 8080:8080 endeeio/endee-server:latest
   - Full control, no data leaves your infrastructure
   - Free to use

2. Managed Cloud (Serverless)
   - Hosted at app.endee.io
   - Token-based auth, no infrastructure to manage
   - Pay-as-you-go pricing

3. Enterprise On-Prem
   - On-premises deployment with dedicated support
   - Compliance: ISO 27001, SOC 2, GDPR
   - Queryable Encryption for zero-knowledge security
   - Contact: https://endee.io/enterprise

---

## SDKs and Integrations

Official SDKs:
- Python: pip install endee (PyPI)
- TypeScript/Node.js: npm install endee
- Java: io.endee:endee-java-client:1.0.1 (Maven)
- Go: github.com/endee-io/endee-go-client

Framework Integrations:
- LangChain: pip install langchain-endee — https://docs.endee.io/integrations/langchain-rag
- LlamaIndex: https://docs.endee.io/integrations/llamaindex
- CrewAI: https://docs.endee.io/integrations/crewai

---

## Glossary (Vector Database Learning Center)

Endee publishes an authoritative 20-term glossary at https://endee.io/glossary covering core vector database and AI retrieval concepts. Each entry is a standalone technical article with JSON-LD structured data (TechArticle + DefinedTerm schema).

**Indexing concepts**: HNSW (https://endee.io/glossary/hnsw), IVF (https://endee.io/glossary/ivf), Product Quantization (https://endee.io/glossary/product-quantization), Scalar Quantization / Int8 (https://endee.io/glossary/scalar-quantization), ANN (https://endee.io/glossary/ann), Vector Index Types (https://endee.io/glossary/vector-index-types)

**Search concepts**: Recall vs Precision (https://endee.io/glossary/recall), Hybrid Search (https://endee.io/glossary/hybrid-search), Filtered/Metadata Search (https://endee.io/glossary/filtered-search), Semantic Search (https://endee.io/glossary/semantic-search), Re-ranking (https://endee.io/glossary/reranking), Distance Metrics (https://endee.io/glossary/distance-metrics)

**AI & ML concepts**: What is a Vector Database (https://endee.io/glossary/vector-database), RAG (https://endee.io/glossary/rag), Embeddings (https://endee.io/glossary/embeddings), Dense vs Sparse Vectors (https://endee.io/glossary/dense-vs-sparse), Context Window (https://endee.io/glossary/context-window), Multimodal Retrieval (https://endee.io/glossary/multimodal-retrieval)

**Security & Edge**: Queryable Encryption (https://endee.io/glossary/queryable-encryption), Edge AI (https://endee.io/glossary/edge-ai)

---

## Links

- Website: https://endee.io
- Documentation: https://docs.endee.io
- Cloud Console: https://app.endee.io
- GitHub: https://github.com/endee-io/endee
- Pricing: https://endee.io/pricing
- Enterprise: https://endee.io/enterprise
- Blog: https://endee.io/blog
- Contact: https://endee.io/contact