Advanced Usage

This guide covers document deletion, index management, and persistence with Endee and LangChain.

Deleting Documents

Delete by ID

Remove specific documents by their unique ID:


# Delete a document by ID
id_to_delete = ids[0]  # Delete the first document
print(f"Deleting document with ID: {id_to_delete}")
 
vector_store.delete(ids=[id_to_delete])
 
# Verify deletion by searching
query = "Python programming language"
results_after_delete = vector_store.similarity_search(query, k=1)
 
print(f"\nResults after deletion for query '{query}':")
for i, doc in enumerate(results_after_delete):
    print(f"Result {i+1}: {doc.page_content}")

Delete Multiple Documents

Delete multiple documents at once:


# Delete multiple documents by ID
vector_store.delete(ids=["doc1", "doc2", "doc3"])

Deleting by Filter

Delete documents based on metadata filters:


# Delete documents by filter
filter_to_delete = [{"category": {"$eq": "programming"}}]
print(f"Deleting documents with filter: {filter_to_delete}")
 
vector_store.delete(filter=filter_to_delete)
 
# Verify deletion by searching
programming_query = "JavaScript programming"
results_after_filter_delete = vector_store.similarity_search(programming_query, k=2)
 
print(f"\nResults after filter deletion for query '{programming_query}':")
for i, doc in enumerate(results_after_filter_delete):
    print(f"Result {i+1}: {doc.page_content}")
    print(f"Metadata: {doc.metadata}")

Filter Deletion Examples


# Delete all AI-related documents
vector_store.delete(filter=[{"category": {"$eq": "ai"}}])
 
# Delete documents with specific difficulty
vector_store.delete(filter=[{"difficulty": {"$eq": "advanced"}}])
 
# Delete with multiple conditions
vector_store.delete(filter=[
    {"category": {"$eq": "database"}},
    {"type": {"$eq": "vector"}}
])

Persistence and Reconnection

Endee stores your vectors in the cloud. Reconnect to an existing index in future sessions:


# To reconnect to an existing index, use the same parameters
def reconnect_to_index(api_token, index_name):
    # Initialize the vector store with existing index
    reconnected_store = EndeeVectorStore.from_params(
        embedding=OpenAIEmbeddings(),
        api_token=api_token,
        index_name=index_name,
        dimension=1536
    )
    return reconnected_store
 
# Example usage
reconnected_store = reconnect_to_index(endee_api_token, index_name)
results = reconnected_store.similarity_search("What are vector databases?", k=1)
print(results)
 
print(f"To reconnect to this index in the future, use:")
print(f"API Token: {endee_api_token}")
print(f"Index Name: {index_name}")

Important: Save your index_name to reconnect to your data later.

Index Cleanup

Delete an entire index when you’re done:


# Delete the index using the Endee client
nd.delete_index(index_name)
print(f"Index {index_name} deleted")

Warning: Deleting an index permanently removes all stored vectors and cannot be undone.

Methods Reference

EndeeVectorStore Methods

Method	Description
`from_params(...)`	Create a new EndeeVectorStore instance
`add_texts(texts, metadatas)`	Add documents to the vector store
`similarity_search(query, k, filter)`	Search for similar documents
`similarity_search_with_score(query, k, filter)`	Search with similarity scores
`as_retriever(search_kwargs)`	Create a LangChain retriever
`delete(ids, filter)`	Delete documents by ID or filter

Delete Method Parameters

Parameter	Type	Description
`ids`	`list[str]`	List of document IDs to delete
`filter`	`list[dict]`	Filter conditions for deletion

Complete Example


from endee_langchain import EndeeVectorStore
from langchain_openai import OpenAIEmbeddings
from endee.endee_client import Endee
import os
import time
 
# Setup
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
endee_api_token = "your-endee-api-token"
 
# Initialize Endee client
nd = Endee(token=endee_api_token)
 
# Create vector store
embedding_model = OpenAIEmbeddings()
timestamp = int(time.time())
index_name = f"advanced_demo_{timestamp}"
 
vector_store = EndeeVectorStore.from_params(
    embedding=embedding_model,
    api_token=endee_api_token,
    index_name=index_name,
    dimension=1536,
    space_type="cosine"
)
 
# Add documents
texts = ["Python is great", "JavaScript is popular", "Rust is fast"]
metadatas = [
    {"language": "python", "difficulty": "beginner"},
    {"language": "javascript", "difficulty": "intermediate"},
    {"language": "rust", "difficulty": "advanced"}
]
 
ids = vector_store.add_texts(texts=texts, metadatas=metadatas)
print(f"Added {len(ids)} documents")
 
# Search
results = vector_store.similarity_search("programming languages", k=2)
print(f"Found {len(results)} results")
 
# Delete by ID
vector_store.delete(ids=[ids[0]])
print(f"Deleted document: {ids[0]}")
 
# Delete by filter
vector_store.delete(filter=[{"difficulty": {"$eq": "advanced"}}])
print("Deleted advanced documents")
 
# Cleanup - delete entire index
nd.delete_index(index_name)
print(f"Index {index_name} deleted")

Best Practices

Save index names — Store your index names for reconnection
Use meaningful IDs — Provide custom IDs in metadata for easier management
Batch operations — Add multiple documents at once for better performance
Filter before delete — Verify filter results with a search before deleting
Handle errors — Wrap deletion operations in try-catch blocks