Getting Started with REM

pip install rem-vectordb

from rem import REM

client = REM(api_key="rem_your_api_key_here")

collection = client.create_collection(
    name="my-collection",
    dimension=1536,        # Match your embedding model
    metric="cosine"        # cosine | euclidean | dot_product
)

collection.upsert([
    {"id": "doc-1", "values": [0.1, 0.2, ...], "metadata": {"source": "wiki"}},
    {"id": "doc-2", "values": [0.3, 0.4, ...], "metadata": {"source": "blog"}},
])

results = collection.query(
    vector=[0.1, 0.2, ...],
    top_k=10,
    filter={"source": "wiki"}
)

for match in results.matches:
    print(f"{match.id}: {match.score:.4f}")

# Fetch vectors by ID (for RAG source retrieval)
fetched = collection.fetch(ids=["doc-1", "doc-2"])

# Delete vectors by ID (for GDPR compliance)
deleted = collection.delete(ids=["doc-1"])

from rem import REM

client = REM(api_key="rem_your_api_key_here")

curl -X GET https://api.getrem.online/v1/collections \
  -H "X-API-Key: rem_your_api_key_here"

collection = client.create_collection(
    name="products",
    dimension=384,
    metric="cosine",                     # "cosine" | "euclidean" | "dot_product"
    encrypted_fields=["email", "pii"],   # Optional: AES-256-GCM encryption
)

collections = client.list_collections()
for col in collections:
    print(f"{col.name} — {col.dimension}d, {col.metric}")

client.delete_collection("collection_id")

collection.upsert([
    {
        "id": "prod-001",
        "values": [0.12, -0.34, 0.56, ...],  # Must match collection dimension
        "metadata": {
            "category": "electronics",
            "price": 299.99,
            "in_stock": True
        }
    },
    {
        "id": "prod-002",
        "values": [0.78, 0.91, -0.23, ...],
        "metadata": {
            "category": "clothing",
            "price": 49.99,
            "in_stock": False
        }
    }
])

result = collection.fetch(ids=["prod-001", "prod-002"])
for vec in result.vectors:
    print(f"{vec.id}: {len(vec.values)} dimensions")

result = collection.delete(ids=["prod-001"])
print(f"Deleted {result.deleted_count} vectors")

results = collection.query(
    vector=[0.12, -0.34, 0.56, ...],
    top_k=10
)

results = collection.query(
    vector=[0.12, -0.34, 0.56, ...],
    top_k=5,
    filter={
        "category": "electronics",
        "price": {"$lte": 500},
        "in_stock": True
    }
)

results = collection.query(
    vector=[0.12, -0.34, 0.56, ...],
    top_k=5,
    include_values=True  # Returns original (deobfuscated) vectors
)

{
  "matches": [
    {
      "id": "prod-001",
      "score": 0.9542,
      "metadata": {"category": "electronics", "price": 299.99}
    },
    {
      "id": "prod-003",
      "score": 0.8891,
      "metadata": {"category": "electronics", "price": 149.99}
    }
  ]
}

results = collection.query(
    vector=embed("wireless headphones"),
    query_text="noise cancelling",   # BM25 keyword search
    top_k=10
)

# Pure vector search (default)
results = collection.query(vector=embed("query"), hybrid_alpha=0.0)

# Balanced hybrid (50/50)
results = collection.query(
    vector=embed("query"),
    query_text="keywords",
    hybrid_alpha=0.5
)

# Pure keyword search (no vector needed)
results = collection.query(
    query_text="exact phrase match",
    hybrid_alpha=1.0
)

results = collection.query_batch([
    {
        "vector": embed("wireless headphones"),
        "top_k": 5,
        "filter": {"category": "electronics"}
    },
    {
        "vector": embed("running shoes"),
        "top_k": 5,
        "filter": {"category": "sports"}
    },
    {
        "query_text": "bluetooth speaker",
        "top_k": 3,
        "hybrid_alpha": 1.0
    }
])

# results is a list of QueryResult, one per query
for i, result in enumerate(results):
    print(f"Query {i}: {len(result.matches)} matches")

# Create collection with encrypted fields
collection = client.create_collection(
    name="user-data",
    dimension=384,
    encrypted_fields=["email", "phone", "ssn"]  # AES-256-GCM
)

# Upsert — encrypted fields are handled automatically
collection.upsert([{
    "id": "user-1",
    "values": embed("John Doe profile"),
    "metadata": {
        "name": "John Doe",       # Stored as plaintext (filterable)
        "email": "john@example.com",  # Encrypted on miners
        "phone": "+1-555-0100",       # Encrypted on miners
        "ssn": "123-45-6789",         # Encrypted on miners
        "role": "admin"           # Stored as plaintext (filterable)
    }
}])

# Query — encrypted fields are auto-decrypted in results
results = collection.query(
    vector=embed("admin users"),
    filter={"role": "admin"},  # Only plaintext fields can be filtered
    top_k=10
)
# results include decrypted email, phone, ssn

pip install rem-vectordb[langchain]

from rem.integrations.langchain import REMVectorStore
from langchain_openai import OpenAIEmbeddings

# Create vector store
store = REMVectorStore(
    api_key="rem_xxx",
    collection_name="docs",
    embedding=OpenAIEmbeddings()
)

# Add documents
store.add_texts(
    texts=["REM is a decentralized vector database", "Powered by 2000+ miners"],
    metadatas=[{"source": "docs"}, {"source": "marketing"}]
)

# Similarity search
results = store.similarity_search("What is REM?", k=5)
for doc in results:
    print(doc.page_content)

# Search with scores
results_with_scores = store.similarity_search_with_score("What is REM?", k=5)
for doc, score in results_with_scores:
    print(f"{score:.4f}: {doc.page_content}")

# Search with metadata filter
results = store.similarity_search(
    "vector database",
    k=5,
    filter={"source": "docs"}
)

# Delete documents
store.delete(ids=["doc-id-1", "doc-id-2"])

# Create from texts (one-liner)
store = REMVectorStore.from_texts(
    texts=["Hello", "World"],
    embedding=OpenAIEmbeddings(),
    api_key="rem_xxx",
    collection_name="quickstart"
)

pip install rem-vectordb[llamaindex]

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from rem.integrations.llamaindex import REMVectorStore

# Create vector store
vector_store = REMVectorStore(
    api_key="rem_xxx",
    collection_name="docs",
    dimension=1536
)

# Build index from documents
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(
    documents,
    vector_store=vector_store
)

# Query
query_engine = index.as_query_engine()
response = query_engine.query("What is REM Network?")
print(response)

# Use existing index
index = VectorStoreIndex.from_vector_store(vector_store)
retriever = index.as_retriever(similarity_top_k=5)
nodes = retriever.retrieve("vector database")

pip install rem-vectordb              # Core SDK
pip install rem-vectordb[langchain]   # + LangChain integration
pip install rem-vectordb[llamaindex]  # + LlamaIndex integration

from rem import REM

client = REM(
    api_key="rem_xxx",                          # Required
    base_url="https://api.getrem.online",       # Optional (default)
    timeout=30,                                  # Request timeout in seconds
)

from rem import AsyncREM

async with AsyncREM(api_key="rem_xxx") as client:
    collection = await client.create_collection("docs", dimension=384)
    await collection.upsert([...])
    results = await collection.query(vector=[...], top_k=10)