Introduction

Redis Vector Library (RedisVL) is the TypeScript/Node.js client for building AI applications on Redis.

Features

• Index Management — Schema design, data loading, and CRUD operations
• Vector Search — Similarity search with metadata filters and hybrid queries via VectorQuery
• Vectorizers — HuggingFace embeddings for semantic search
• Distance Normalization — User-friendly 0–1 similarity scores

Use Cases

• RAG Pipelines — Combine vector similarity search with metadata filtering to retrieve the most relevant context for your LLMs
• Recommendation Systems — Find similar items using vector similarity search

Getting Started

Option A: Install from npm:

npm install redis-vl

Option B: Install from source by cloning the repo and linking it locally:

git clone https://github.com/redis-developer/redis-vl-typescript.git
cd redis-vl-typescript
npm install
npm run build
npm link
# then in your project:
npm link redis-vl

Redis

Choose from multiple Redis deployment options:

1. Redis Cloud: Managed cloud database (free tier available)

2. Redis Stack: Docker image for development

   docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest

Enhance your experience and observability with the free Redis Insight GUI.

Overview

RedisVL is a TypeScript client for building AI applications on Redis. It sits on top of node-redis and handles the common patterns you need: managing indexes, loading data, generating embeddings, vector search, and techniques like semantic caching and LLM memory to improve the performance of your AI applications at scale.

What it does:

• Schema Management - Define indexes with YAML or objects
• Vector Search - Semantic similarity search with metadata filtering
• Data Operations - Batch loading with validation, TTL, and preprocessing
• Embeddings - Generate vectors with HuggingFace (local, no API key)
• Type Safety - Full TypeScript support

📚 Read the full documentation →

Features

Schema Definition

Define your data structure with fields for text, tags, numbers, geo locations, and vectors:

import { IndexSchema } from 'redis-vl';

const schema = IndexSchema.fromObject({
    index: { name: 'products', prefix: 'product:', storage_type: 'json' },
    fields: [
        { name: 'title', type: 'text' },
        { name: 'category', type: 'tag' },
        { name: 'price', type: 'numeric' },
        {
            name: 'embedding',
            type: 'vector',
            attrs: { algorithm: 'hnsw', dims: 768, distance_metric: 'cosine' },
        },
    ],
});

Learn more about schemas →

Index Operations

Create and manage search indexes:

import { createClient } from 'redis';
import { SearchIndex } from 'redis-vl';

const client = createClient();
await client.connect();

const index = new SearchIndex(schema, client);
await index.create();

Learn more about indexes →

Data Loading & Retrieval

Load documents and retrieve them by key:

const documents = [
    { id: '1', title: 'Product A', price: 99 },
    { id: '2', title: 'Product B', price: 149 },
];

// Load with explicit IDs
await index.load(documents, { idField: 'id' });

// Fetch documents
const doc = await index.fetch('1');
const docs = await index.fetchMany(['1', '2']);

Learn more about CRUD operations →

Vector Search

Perform semantic similarity search:

import { VectorQuery } from 'redis-vl';

// Create query
const query = new VectorQuery({
    vector: embedding,
    vectorField: 'embedding',
    filter: '@category:{electronics}',
    numResults: 10,
});

// Execute search
const results = await index.search(query);
results.documents.forEach((doc) => {
    console.log(`${doc.value.title} (score: ${doc.score})`);
});

Learn more about vector search →

Vectorizers

Generate embeddings for semantic search:

import { HuggingFaceVectorizer } from 'redis-vl';

const vectorizer = new HuggingFaceVectorizer({
    model: 'Xenova/all-MiniLM-L6-v2',
});

const embedding = await vectorizer.embed('Hello world');

// Use with data loading
await index.load(documents, {
    preprocess: async (doc) => ({
        ...doc,
        embedding: await vectorizer.embed(doc.content),
    }),
});

Learn more about vectorizers →

Coming Soon

• Hybrid Search - Combine vector, text, and numeric filters
• Range Queries - Vector search within distance range
• Semantic Caching - Cache LLM responses by similarity
• LLM Memory - Context management for AI agents
• Semantic Routing - Intent-based query classification
• More Vectorizers - OpenAI, Cohere, Azure, VertexAI

Helpful Links

For additional help, check out the following resources:

• Redis AI Recipes