Vec - Vector Database

High-performance vector database powered by Milvus for similarity search, semantic retrieval, and AI embeddings storage.

Overview

Vec provides a managed vector database service for storing and querying high-dimensional vectors. It's optimized for AI applications including:

Semantic search and retrieval
Recommendation systems
Image and audio similarity
RAG (Retrieval-Augmented Generation)
Anomaly detection

Quick Start

import { Tenzro } from 'tenzro';

const tenzro = new Tenzro({ apiKey: 'your-api-key' });

// Create a vector database
const db = await tenzro.vec.create({
  projectId: 'project-id',
  db_name: 'my-embeddings',
  dimension: 768,
  metric_type: 'COSINE',
  index_type: 'HNSW',
});

// Insert vectors with metadata
await tenzro.vec.insert(db.vec_db_id, [
  {
    id: 'doc-1',
    vector: [0.1, 0.2, ...], // 768-dimensional vector
    metadata: { title: 'Document 1', source: 'wiki' },
  },
  {
    id: 'doc-2',
    vector: [0.3, 0.4, ...],
    metadata: { title: 'Document 2', source: 'pdf' },
  },
]);

// Search for similar vectors
const results = await tenzro.vec.search(db.vec_db_id, {
  vector: queryVector,
  topK: 10,
  filter: { source: 'wiki' },
});

console.log(results);
// [{ id: 'doc-1', score: 0.95, metadata: {...} }, ...]

Database Configuration

Dimensions

The vector dimension must match your embedding model:

768 - Gemini text-embedding-004 (default)
1536 - OpenAI text-embedding-3-small
3072 - OpenAI text-embedding-3-large
384 - all-MiniLM-L6-v2

Metric Types

Metric	Description	Use Case
`COSINE`	Cosine similarity (normalized)	Text embeddings, semantic search
`L2`	Euclidean distance	Image features, spatial data
`IP`	Inner product	Recommendation, when vectors are normalized

Index Types

Index	Description	Best For
`HNSW`	Hierarchical Navigable Small World	Best balance of speed and accuracy
`IVF_FLAT`	Inverted File with Flat quantization	High accuracy, moderate speed
`IVF_SQ8`	Inverted File with Scalar Quantization	Memory efficient, large datasets

SDK Reference

Create Database

const db = await tenzro.vec.create({
  projectId: string,       // Required: Project ID
  db_name: string,         // Required: Database name
  description?: string,    // Optional: Description
  dimension: number,       // Required: Vector dimension (e.g., 768)
  metric_type: 'COSINE' | 'L2' | 'IP',  // Default: 'COSINE'
  index_type: 'HNSW' | 'IVF_FLAT' | 'IVF_SQ8',  // Default: 'HNSW'
  backend?: 'milvus',      // Default: 'milvus'
});

List Databases

const { data, count } = await tenzro.vec.list(projectId);

Insert Vectors

const result = await tenzro.vec.insert(vecDbId, [
  {
    id?: string,                    // Optional: Auto-generated if not provided
    vector: number[],               // Required: Vector array
    metadata?: Record<string, any>, // Optional: Filterable metadata
  },
]);
// Returns: { inserted: number, ids: string[] }

Search Vectors

const results = await tenzro.vec.search(vecDbId, {
  vector: number[],                 // Required: Query vector
  topK?: number,                    // Default: 10
  filter?: Record<string, any>,     // Optional: Metadata filter
});
// Returns: VecSearchResult[]

Get Vector

const vector = await tenzro.vec.getVector(vecDbId, vectorId);

Delete Vector

await tenzro.vec.deleteVector(vecDbId, vectorId);

Get Statistics

const stats = await tenzro.vec.getStats(vecDbId);
// Returns: { vectorCount, dimension, indexSize, memoryUsage }

RAG Example

Complete example using Vec for Retrieval-Augmented Generation:

import { Tenzro } from 'tenzro';

const tenzro = new Tenzro({ apiKey: process.env.TENZRO_API_KEY! });

// 1. Generate embeddings for your documents
async function embedDocuments(texts: string[]) {
  const { embeddings } = await tenzro.ai.embed({
    projectId: 'project-id',
    texts,
    taskType: 'RETRIEVAL_DOCUMENT',
    outputDimensionality: 768,
  });
  return embeddings;
}

// 2. Insert documents into Vec
async function indexDocuments(documents: { text: string; title: string }[]) {
  const embeddings = await embedDocuments(documents.map(d => d.text));

  await tenzro.vec.insert(vecDbId, documents.map((doc, i) => ({
    vector: embeddings[i],
    metadata: { text: doc.text, title: doc.title },
  })));
}

// 3. Search for relevant context
async function searchContext(query: string, topK = 5) {
  const { embeddings } = await tenzro.ai.embed({
    projectId: 'project-id',
    text: query,
    taskType: 'RETRIEVAL_QUERY',
    outputDimensionality: 768,
  });

  const results = await tenzro.vec.search(vecDbId, {
    vector: embeddings[0],
    topK,
  });

  return results.map(r => r.metadata.text).join('\n\n');
}

// 4. Generate answer with context
async function ragQuery(question: string) {
  const context = await searchContext(question);

  const response = await tenzro.ai.infer({
    projectId: 'project-id',
    model: 'gemini-2.5-flash',
    prompt: question,
    systemPrompt: `Answer based on this context:\n\n${context}`,
  });

  return response.responseText;
}

Metadata Filtering

Vec supports metadata filtering during search:

// Exact match
const results = await tenzro.vec.search(vecDbId, {
  vector: queryVector,
  topK: 10,
  filter: { category: 'technology' },
});

// Multiple conditions (AND)
const results = await tenzro.vec.search(vecDbId, {
  vector: queryVector,
  topK: 10,
  filter: {
    category: 'technology',
    year: 2024,
  },
});

Best Practices

Batch inserts: Insert vectors in batches of 100-1000 for best performance
Consistent dimensions: All vectors must have the same dimension
Index selection: Use HNSW for most cases, IVF_SQ8 for very large datasets
Metadata indexing: Keep metadata compact for faster filtering
Regular cleanup: Delete unused vectors to maintain performance

Limits

Resource	Limit
Max dimension	4096
Max vectors per database	10 million
Max metadata size	64 KB per vector
Max batch insert	10,000 vectors
Max topK	1000