Embedding Models

# CLI: Enable embeddings with built-in model
memvid put knowledge.mv2 --input document.pdf --embedding

# Python SDK
from memvid_sdk import create

mem = create("knowledge.mv2", enable_vec=True, enable_lex=True)
mem.put(
    "Document",
    "docs",
    {},
    text="Your content here",
    enable_embedding=True,
    embedding_model="bge-small",
)

// Node.js SDK
import { create } from '@memvid/sdk';

const mem = await create('knowledge.mv2');
await mem.put({ text: 'Your content here', title: 'Document', enableEmbedding: true });

# Recommended: High quality (1024 dimensions)
ollama pull mxbai-embed-large

# Alternative: Faster, smaller (768 dimensions)
ollama pull nomic-embed-text

from memvid_sdk import create
from memvid_sdk.embeddings import OllamaEmbeddings

# Initialize embedder (uses localhost:11434 by default)
embedder = OllamaEmbeddings(model='mxbai-embed-large')
print(f"Model: {embedder.model_name} ({embedder.dimension} dimensions)")

# Create memory with vector index
mem = create('knowledge.mv2', enable_vec=True, enable_lex=True)

# Store with embeddings
documents = [
    {"title": "Doc 1", "label": "kb", "text": "Machine learning fundamentals..."},
    {"title": "Doc 2", "label": "kb", "text": "Deep neural networks..."},
]
frame_ids = mem.put_many(documents, embedder=embedder)

# Search with query embedding
query = "How do neural networks work?"
results = mem.find(query, k=5, mode="sem", embedder=embedder)

import { create, OllamaEmbeddings } from '@memvid/sdk';

// Initialize embedder
const embedder = new OllamaEmbeddings({ model: 'mxbai-embed-large' });
console.log(`Model: ${embedder.modelName} (${embedder.dimension} dimensions)`);

// Create memory
const mem = await create('knowledge.mv2', 'basic', { enableLex: true, enableVec: true });

// Ingest with embeddings
for (const doc of documents) {
  const embedding = await embedder.embedQuery(doc.text);
  await mem.put({
    title: doc.title,
    text: doc.text,
    label: doc.label,
    embedding,
    embeddingIdentity: { provider: 'ollama', model: 'mxbai-embed-large', dimension: 1024 },
  });
}
await mem.seal();

// Search
const queryEmbedding = await embedder.embedQuery('How do neural networks work?');
const results = await mem.find('neural networks', { k: 5, mode: 'auto', queryEmbedding });

# Connect to remote Ollama server
embedder = OllamaEmbeddings(
    model='mxbai-embed-large',
    base_url='http://gpu-server:11434'
)

// Node.js
const embedder = new OllamaEmbeddings({
  model: 'mxbai-embed-large',
  baseUrl: 'http://gpu-server:11434',
});

export OPENAI_API_KEY=sk-your-key-here

# Use OpenAI for embeddings
memvid put knowledge.mv2 --input document.pdf --embedding -m openai-small

# Specify exact model
memvid put knowledge.mv2 --input docs/ --embedding -m openai-large

from memvid_sdk import create
from memvid_sdk.embeddings import OpenAIEmbeddings

# Initialize embedder
embedder = OpenAIEmbeddings(model='text-embedding-3-small')
print(f"Model: {embedder.model_name} ({embedder.dimension} dimensions)")

# Create memory with vector index
mem = create('knowledge.mv2', enable_vec=True, enable_lex=True)

# Store + embed in batch (vector index required for semantic search)
documents = [
    {"title": "Doc 1", "label": "kb", "text": "Machine learning fundamentals..."},
    {"title": "Doc 2", "label": "kb", "text": "Deep neural networks..."},
]
frame_ids = mem.put_many(documents, embedder=embedder)

# Search with query embedding
query = "How do neural networks work?"
results = mem.find(query, k=5, mode="sem", embedder=embedder)

export NVIDIA_API_KEY=nvapi-your-key-here

from memvid_sdk import create
from memvid_sdk.embeddings import NvidiaEmbeddings

mem = create("knowledge.mv2", enable_vec=True, enable_lex=True)
embedder = NvidiaEmbeddings(model="nvidia/nv-embed-v1")  # uses NVIDIA_API_KEY

mem.put_many(
    [{"title": "Doc", "label": "kb", "text": "Vector search with NVIDIA embeddings."}],
    embedder=embedder,
)
res = mem.find("nvidia embeddings", mode="sem", embedder=embedder)

import { create, NvidiaEmbeddings } from '@memvid/sdk';

const mem = await create('knowledge.mv2');
const embedder = new NvidiaEmbeddings({ model: 'nvidia/nv-embed-v1' }); // uses NVIDIA_API_KEY
await mem.putMany([{ title: 'Doc', text: 'Vector search with NVIDIA embeddings.' }], { embedder });
const res = await mem.find('nvidia embeddings', { mode: 'sem', embedder });

import { create, OpenAIEmbeddings } from '@memvid/sdk';

// Initialize embedder (uses OPENAI_API_KEY env var)
const embedder = new OpenAIEmbeddings({ model: 'text-embedding-3-small' });
console.log(`Model: ${embedder.modelName} (${embedder.dimension} dimensions)`);

// Create memory
const mem = await create('knowledge.mv2');

// Store + embed in batch (vector index required for semantic search)
await mem.putMany(
  [
    { title: 'Doc 1', text: 'Machine learning fundamentals...' },
    { title: 'Doc 2', text: 'Deep neural networks...' },
  ],
  { embedder }
);
await mem.seal();

// Query using the same embedder (keeps dimensions consistent)
const results = await mem.find('How do neural networks work?', { mode: 'sem', k: 5, embedder });

export COHERE_API_KEY=your-key-here

from memvid_sdk.embeddings import CohereEmbeddings, get_embedder

# Direct initialization
embedder = CohereEmbeddings(model='embed-english-v3.0')

# Or use factory
embedder = get_embedder('cohere', model='embed-multilingual-v3.0')

# Generate embeddings
embeddings = embedder.embed_documents(['Text 1', 'Text 2'])
query_vec = embedder.embed_query('search query')

import { CohereEmbeddings, getEmbedder } from '@memvid/sdk';

// Direct initialization
const embedder = new CohereEmbeddings({ model: 'embed-english-v3.0' });

// Or use factory
const embedder2 = getEmbedder('cohere', { model: 'embed-multilingual-v3.0' });

const embeddings = await embedder.embedDocuments(['Text 1', 'Text 2']);

export VOYAGE_API_KEY=your-key-here

from memvid_sdk.embeddings import VoyageEmbeddings

embedder = VoyageEmbeddings(model='voyage-3')
embeddings = embedder.embed_documents(['def hello(): pass', 'function hello() {}'])

import { VoyageEmbeddings } from '@memvid/sdk';

const embedder = new VoyageEmbeddings({ model: 'voyage-code-3' });
const embeddings = await embedder.embedDocuments(['def hello(): pass']);

pip install sentence-transformers

from memvid_sdk.embeddings import get_embedder

# Use any sentence-transformers model
embedder = get_embedder('huggingface', model='all-MiniLM-L6-v2')
print(f"Model: {embedder.model_name} ({embedder.dimension} dimensions)")

embeddings = embedder.embed_documents(['Text 1', 'Text 2'])

from memvid_sdk import create
from memvid_sdk.embeddings import OpenAIEmbeddings

# Setup
embedder = OpenAIEmbeddings()
mem = create('knowledge.mv2', enable_vec=True, enable_lex=True)

documents = [
    {"title": "Doc 1", "label": "research", "text": "Content 1..."},
    {"title": "Doc 2", "label": "research", "text": "Content 2..."},
]
frame_ids = mem.put_many(documents, embedder=embedder)

query = "What is the main finding?"
results = mem.find(query, k=10, mode="sem", embedder=embedder)

# CLI
memvid put knowledge.mv2 --input docs/ --embedding --vector-compression

# Python
from memvid_sdk import create

mem = create("knowledge.mv2", enable_vec=True, enable_lex=True)
mem.put("Doc", "kb", {}, text="...", enable_embedding=True, vector_compression=True)

memvid ask knowledge.mv2 --question "What is machine learning?" --mode hybrid --no-rerank