Endee + LangChain: Quick Start

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

Install & Setup

Install the required libraries for LangChain and Endee integration.


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

Authentication

Choose your connection method: local server or serverless cloud.

Local Server: If your server has NDD_AUTH_TOKEN set, pass the same token when initializing:


API_TOKEN = "ndd-auth-token"
BASE_URL = "http://127.0.0.1:8080/api/v1"

Endee Serverless: Go to https://app.endee.io , create a token, then pass it here:


API_TOKEN = "your-serverless-token"
BASE_URL = ""  # leave empty for serverless

Import & Create Vector Store

Import libraries and create a vector store connected to Endee.


from langchain_core.documents import Document
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_endee import EndeeVectorStore
 
# Load embedding model
embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
vector_store.embedding = embeddings
 
# Create vector store (use API_TOKEN and BASE_URL from above)
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 contain text and metadata fields that can be searched and filtered.


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

Search

Find similar documents by semantic meaning using query embeddings.


# Basic search
results = vector_store.similarity_search("How to learn Python?", k=2)
for doc in results:
    print(doc.page_content)
 
# Search with scores
scored = vector_store.similarity_search_with_score("memory safety", k=2)
for doc, score in scored:
    print(f"{score:.3f} - {doc.page_content}")

Filter Results

Restrict search to specific documents using metadata filters.


# Only AI/programming documents
results = vector_store.similarity_search(
    "semantic search",
    k=5,
    filter=[{"topic": {"$eq": "programming"}}],
)
 
# Multiple topics
results = vector_store.similarity_search(
    "search algorithms",
    k=5,
    filter=[{"topic": {"$in": ["programming", "database"]}}],
)

CRUD Operations

Add, retrieve, update, and delete documents after initial indexing.


# Add more documents
new_ids = vector_store.add_texts(
    texts=["Go is a concurrent language"],
    metadatas=[{"topic": "programming", "language": "go"}],
)
 
# Fetch by ID
docs = vector_store.get_by_ids(new_ids)
 
# Update metadata (no re-embedding)
vector_store.update_filters([
    {"id": new_ids[0], "filter": {"topic": "programming", "difficulty": "intermediate"}},
])
 
# Delete
vector_store.delete(ids=[new_ids[0]])

Use in RAG Pipeline

Wrap the vector store as a retriever to use in LangChain chains and with LLMs.


# Create retriever
retriever = vector_store.as_retriever(search_kwargs={"k": 3})
 
# With filter
retriever = vector_store.as_retriever(
    search_kwargs={"k": 3, "filter": [{"topic": {"$eq": "programming"}}]},
)
 
# Use with LLM
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 (Dense + BM25)

Combine semantic search with keyword matching for better results on both meaning and exact terms.


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,
)
hybrid_store.add_documents(documents)
 
# Search uses both dense + keyword matching
results = hybrid_store.similarity_search("Python programming", k=3)

Cleanup

Delete the indexes.


client.delete_index("rag_demo")
client.delete_index("hybrid_demo")

Key Methods

Each method handles a specific operation in the vector search workflow.

Method	What it does
`add_documents(docs)`	Embed and store documents
`similarity_search(query, k)`	Find k similar documents
`similarity_search_with_score(query, k)`	Same + 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

Simple guidelines for common scenarios.

Metadata - Add fields to filter later
k=3 or k=5 - Usually enough for RAG context
Filters - Use $eq, $in, $range operators
Hybrid - Better when keywords matter (search “Python” finds it, not just meaning)
Precision - int16 is default, cuts memory in half vs float32