Node.js SDK

npm install @memvid/sdk
# or
pnpm add @memvid/sdk
# or
yarn add @memvid/sdk

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

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

// Add documents
await mem.put({
  title: 'Meeting Notes',
  text: 'Alice mentioned she works at Anthropic...',
  enableEmbedding: true
});

// Search
const results = await mem.find('who works at AI companies?');
console.log(results.hits);

// Ask questions with AI
const answer = await mem.ask('What does Alice do?', {
  model: 'gpt-4o-mini',
  modelApiKey: process.env.OPENAI_API_KEY
});
console.log(answer.text);

// Close when done
await mem.close();

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

// Vercel AI SDK
const vercel = await use('vercel-ai', 'knowledge.mv2');
const tools = vercel.tools;

// LangChain.js
const langchain = await use('langchain', 'knowledge.mv2');
const retriever = langchain.asRetriever();

// LlamaIndex
const llamaindex = await use('llamaindex', 'knowledge.mv2');

// OpenAI Function Calling
const openai = await use('openai', 'knowledge.mv2');
const functions = openai.functions;

// Google ADK
const googleAdk = await use('google-adk', 'knowledge.mv2');

// Semantic Kernel
const sk = await use('semantic-kernel', 'knowledge.mv2');

import {
  OpenAIEmbeddings,
  GeminiEmbeddings,
  MistralEmbeddings,
  CohereEmbeddings,
  VoyageEmbeddings,
  NvidiaEmbeddings,
  LOCAL_EMBEDDING_MODELS
} from '@memvid/sdk';

// OpenAI
const openai = new OpenAIEmbeddings({
  apiKey: process.env.OPENAI_API_KEY,
  model: 'text-embedding-3-small'
});

// Gemini
const gemini = new GeminiEmbeddings({
  apiKey: process.env.GEMINI_API_KEY
});

// Mistral
const mistral = new MistralEmbeddings({
  apiKey: process.env.MISTRAL_API_KEY
});

// Local (no API required)
await mem.put({
  text: 'content',
  enableEmbedding: true,
  embeddingModel: LOCAL_EMBEDDING_MODELS.BGE_SMALL
});

// Extract facts using rules engine
const result = await mem.enrich('rules');

// View extracted cards
const { cards, count } = await mem.memories();
console.log(`Extracted ${count} memory cards`);

// Get entity state (O(1) lookup)
const alice = await mem.state('Alice');
console.log(alice.slots);
// { employer: 'Anthropic', role: 'Engineer' }

// Add memory cards manually
await mem.addMemoryCards([
  { entity: 'Alice', slot: 'employer', value: 'Anthropic' },
  { entity: 'Bob', slot: 'team', value: 'Infrastructure' }
]);

// Export facts
const json = await mem.exportFacts('json');
const csv = await mem.exportFacts('csv', 'Alice');

// Start recording
const sessionId = await mem.sessionStart('Debug Session');

// Perform operations (all recorded)
await mem.put({ title: 'Notes', text: 'Content...' });
await mem.find('test query');

// Add checkpoint
await mem.sessionCheckpoint();

// End session
const summary = await mem.sessionEnd();
console.log(`Recorded ${summary.actionCount} actions`);

// Replay with different parameters
const replay = await mem.sessionReplay(sessionId, {
  adaptive: true,
  topK: 20
});
console.log(`Match rate: ${(replay.matchRate * 100).toFixed(1)}%`);

// Delete session
await mem.sessionDelete(sessionId);

import type {
  PutInput,
  PutManyInput,
  FindInput,
  AskInput,
  MemoryCard,
  MemoryCardInput,
  EntityState,
  FrameInfo,
  TableInfo,
  SessionSummary,
  MemvidErrorCode
} from '@memvid/sdk';

const options: FindInput = {
  mode: 'auto',
  k: 5,
  adaptive: true,
  minRelevancy: 0.5
};

const putInput: PutInput = {
  title: 'Document',
  text: 'Content...',
  enableEmbedding: true,
  embeddingModel: 'bge-small'
};

import {
  MemvidError,
  CapacityExceededError,
  LockedError,
  VecDimensionMismatchError,
  EmbeddingFailedError,
  EncryptedFileError
} from '@memvid/sdk';

try {
  await mem.put({ title: 'Doc', text: 'Content' });
} catch (error) {
  if (error instanceof CapacityExceededError) {
    console.error('Storage full:', error.details);
  } else if (error instanceof LockedError) {
    console.error('File locked, try read-only mode');
  } else if (error instanceof VecDimensionMismatchError) {
    console.error('Embedding dimension mismatch:', error.details);
  } else if (error instanceof EmbeddingFailedError) {
    console.error('Embedding failed:', error.details);
  } else if (error instanceof EncryptedFileError) {
    console.error('File is encrypted, use unlock() first');
  } else if (error instanceof MemvidError) {
    console.error(`Error [${error.code}]: ${error.message}`);
  } else {
    throw error;
  }
}