RedisVectorStore 통합

1. 올바른 데이터 타입 사용: 문서 메타데이터가 스키마 필드 타입과 일치하는지 확인
2. GEO 필드: 문자열 형식 "longitude,latitude" 사용 (예: "-122.4194,37.7749")
3. TIMESTAMP 필드: Date 객체 또는 숫자(Unix 타임스탬프) 사용
4. TAG 필드용 배열: 배열은 자동으로 TAG 필드로 추론됨
5. 샘플 데이터로 테스트: 대량 인덱싱 전에 몇 개 문서로 스키마 검증

fluent API로 고급 필터링 (Advanced filtering with the fluent API)

FluentRedisVectorStore는 복잡한 메타데이터 필터를 구축하기 위한 강력한 fluent API를 제공해요. 이 API는 다양한 필드 유형과 논리 연산을 지원하는 타입 안전한 필터 구성을 제공해요.

필터 빌더 import:

import {
  FluentRedisVectorStore,
  Tag,
  Num,
  Text,
  Geo,
  Timestamp,
  Custom,
} from "@langchain/redis";

간단한 태그 필터링:

// Filter for electronics category
const electronicsFilter = Tag("category").eq("electronics");
const results = await vectorStore.similaritySearch(
  "high quality device",
  5,
  electronicsFilter
);

숫자 범위 필터링:

// Filter for products between $20-$500
const priceFilter = Num("price").between(20, 500);
const results = await vectorStore.similaritySearch(
  "quality product",
  5,
  priceFilter
);

// Other numeric operations
Num("price").eq(99.99);           // Exact match
Num("price").gt(50);              // Greater than
Num("price").gte(50);             // Greater than or equal
Num("price").lt(100);             // Less than
Num("price").lte(100);            // Less than or equal
Num("price").between(20, 100);   // Between (inclusive)

텍스트 검색 필터링:

// Search for titles containing "programming"
const textFilter = Text("title").wildcard("*programming*");
const results = await vectorStore.similaritySearch(
  "learning guide",
  5,
  textFilter
);

// Other text operations
Text("title").eq("exact title");           // Exact match
Text("description").match("guide");        // Text match
Text("title").wildcard("*JavaScript*");    // Wildcard search

지리 필터링:

// Find items within 50km of San Francisco
const geoFilter = Geo("location").within(-122.4194, 37.7749, 50, "km");
const results = await vectorStore.similaritySearch(
  "local products",
  5,
  geoFilter
);

// Geo coordinates are stored as [longitude, latitude]
const doc = {
  pageContent: "Product description",
  metadata: {
    location: [-122.4194, 37.7749], // [longitude, latitude]
  },
};

타임스탬프 필터링:

// Find items created after March 1, 2023
const timestampFilter = Timestamp("created_at").gt(new Date("2023-03-01"));
const results = await vectorStore.similaritySearch(
  "recent items",
  5,
  timestampFilter
);

// Note: Timestamps are stored as Unix epoch timestamps (numbers)
// Date objects are automatically converted during serialization
// and returned as numbers during deserialization
const createdDate = new Date((doc.metadata.created_at as number) * 1000);

AND를 사용한 복잡한 결합 필터링:

// Electronics under $400 in California
const complexFilter = Tag("category")
  .eq("electronics")
  .and(Num("price").lt(400))
  .and(Geo("location").within(-119.4179, 36.7783, 500, "km"));

const results = await vectorStore.similaritySearch(
  "affordable electronics",
  5,
  complexFilter
);

OR 필터링:

// Books OR items under $30
const orFilter = Tag("category").eq("books").or(Num("price").lt(30));
const results = await vectorStore.similaritySearch(
  "affordable items",
  5,
  orFilter
);

여러 태그 값:

// TechCorp OR ViewTech brands
const multiTagFilter = Tag("brand").eq(["TechCorp", "ViewTech"]);
const results = await vectorStore.similaritySearch(
  "branded products",
  5,
  multiTagFilter
);

부정 필터링 (Negation):

// NOT electronics
const negationFilter = Tag("category").ne("electronics");
const results = await vectorStore.similaritySearch(
  "non-electronic items",
  5,
  negationFilter
);

원시 RediSearch 문법을 사용한 커스텀 필터:

// Use raw RediSearch query syntax for advanced cases
const customFilter = Custom("(@category:{electronics} @price:[0 400])");
const results = await vectorStore.similaritySearch(
  "affordable tech",
  5,
  customFilter
);

FluentRedisVectorStore로 완전한 필터링 예제

FluentRedisVectorStore의 다양한 필터링 기능을 보여주는 종합적인 예제예요:

import { createClient } from "redis";
import { OpenAIEmbeddings } from "@langchain/openai";
import {
  FluentRedisVectorStore,
  Tag,
  Num,
  Text,
  Geo,
  Timestamp,
} from "@langchain/redis";
import { Document } from "@langchain/core/documents";

// Connect to Redis
const client = createClient({
  url: process.env.REDIS_URL ?? "redis://localhost:6379",
});
await client.connect();

// Sample documents with rich metadata
const docs = [
  new Document({
    metadata: {
      category: "electronics",
      price: 299.99,
      title: "Wireless Bluetooth Headphones",
      location: [-122.4194, 37.7749], // San Francisco
      created_at: new Date("2023-01-15"),
      brand: "TechCorp",
      rating: 4.5,
    },
    pageContent:
      "High-quality wireless Bluetooth headphones with noise cancellation",
  }),
  new Document({
    metadata: {
      category: "books",
      price: 24.99,
      title: "JavaScript Programming Guide",
      location: [-74.006, 40.7128], // New York
      created_at: new Date("2023-03-20"),
      author: "John Smith",
      pages: 450,
    },
    pageContent:
      "Comprehensive guide to modern JavaScript programming techniques",
  }),
];

// Create FluentRedisVectorStore with metadata schema
const vectorStore = await FluentRedisVectorStore.fromDocuments(
  docs,
  new OpenAIEmbeddings(),
  {
    redisClient: client,
    indexName: "advanced_products",
    customSchema: [
      { name: "category", type: "tag" },
      { name: "price", type: "numeric", options: { sortable: true } },
      { name: "title", type: "text", options: { weight: 2.0 } },
      { name: "location", type: "geo" },
      { name: "created_at", type: "numeric", options: { sortable: true } },
      { name: "brand", type: "tag" },
      { name: "author", type: "tag" },
      { name: "rating", type: "numeric" },
      { name: "pages", type: "numeric" },
    ],
  }
);

// Example: Complex filtering - Electronics under $400 near San Francisco
const complexFilter = Tag("category")
  .eq("electronics")
  .and(Num("price").lt(400))
  .and(Geo("location").within(-122.4194, 37.7749, 100, "km"));

const results = await vectorStore.similaritySearch(
  "affordable electronics",
  5,
  complexFilter
);

// Cleanup
await vectorStore.delete({ deleteAll: true });
await client.disconnect();

레거시 API로 고급 필터링 (Advanced filtering with the legacy API)

레거시 RedisVectorStore는 similaritySearchVectorWithScoreAndMetadata 메서드를 사용한 메타데이터 필터링을 제공해요:

// Search with TAG filtering
const tagFilterResults =
  await vectorStoreWithSchema.similaritySearchVectorWithScoreAndMetadata(
    await embeddings.embedQuery("programming tutorial"),
    3,
    {
      category: "programming", // Exact tag match
      tags: ["javascript", "frontend"], // Multiple tag OR search
    }
  );

console.log("Tag filter results:");
for (const [doc, score] of tagFilterResults) {
  console.log(`* [SIM=${score.toFixed(3)}] ${doc.pageContent}`);
  console.log(`  Metadata: ${JSON.stringify(doc.metadata)}`);
}

// Search with NUMERIC range filtering
const numericFilterResults =
  await vectorStoreWithSchema.similaritySearchVectorWithScoreAndMetadata(
    await embeddings.embedQuery("high quality content"),
    5,
    {
      score: { min: 90, max: 100 }, // Score between 90 and 100
      category: ["programming", "ai"], // Multiple categories
    }
  );

console.log("Numeric filter results:");
for (const [doc, score] of numericFilterResults) {
  console.log(`* [SIM=${score.toFixed(3)}] ${doc.pageContent}`);
  console.log(
    `  Score: ${doc.metadata.score}, Category: ${doc.metadata.category}`
  );
}

// Search with TEXT field filtering
const textFilterResults =
  await vectorStoreWithSchema.similaritySearchVectorWithScoreAndMetadata(
    await embeddings.embedQuery("development guide"),
    3,
    {
      description: "comprehensive guide", // Text search in description field
      score: { min: 85 }, // Minimum score of 85
    }
  );

console.log("Text filter results:");
for (const [doc, score] of textFilterResults) {
  console.log(`* [SIM=${score.toFixed(3)}] ${doc.pageContent}`);
  console.log(`  Description: ${doc.metadata.description}`);
}

숫자 범위 쿼리 옵션 (Numeric range query options)

숫자 필드에 대해 다양한 범위 쿼리를 지정할 수 있어요:

// Exact value match
{ score: 95 }

// Range with both min and max
{ score: { min: 80, max: 100 } }

// Only minimum value
{ score: { min: 90 } }

// Only maximum value
{ score: { max: 95 } }

성능 이점 (Performance benefits)

커스텀 스키마와 fluent 필터링 API를 사용하면 여러 성능 이점이 있어요:

1. 인덱스된 메타데이터 필드: 개별 메타데이터 필드를 별도로 인덱싱해 벡터 검색 전에 빠른 사전 필터링 가능
2. 타입 최적화 쿼리: 숫자·태그·지리·텍스트 필드는 최적화된 RediSearch 쿼리 구조 사용
3. 벡터 비교 감소: 필터가 벡터 유사도 계산 전에 적용되어 계산 오버헤드 감소
4. 더 나은 쿼리 계획: Redis가 필드 타입과 인덱스에 기반해 쿼리를 최적화
5. 타입 안전성: fluent API가 필터 구축에 컴파일 타임 타입 검사 제공

이전 버전 호환성 (Backward compatibility)

RedisVectorStore와 FluentRedisVectorStore 모두 현재 지원·유지관리되고 있어요. 그러나 RedisVectorStore는 레거시로 간주되며 향후 주요 릴리스에서 deprecate될 수 있어요. RedisVectorStore를 사용하는 기존 코드는 변경 없이 계속 작동할 거예요.

마이그레이션 고려 사항:

• customSchema 구성 키를 유지하되 객체 기반 형식에서 { name, type, options } 필드 배열로 전환
• 객체 또는 문자열 필터를 fluent 필터 표현식(Tag, Num, Text, Geo, Timestamp, Custom)으로 교체
• GEO 스키마 필드와 Timestamp() 필터 헬퍼는 FluentRedisVectorStore에서만 사용 가능
• 메타데이터 저장 방식이 다름: FluentRedisVectorStore는 메타데이터를 개별 필드로 인덱싱하며 레거시 JSON-blob 메타데이터와 호환되지 않음. FluentRedisVectorStore를 기존 레거시 인덱스에 연결하기보다 새 인덱스를 만들고 문서를 다시 수집해야 함

API reference

모든 기능과 구성에 대한 자세한 문서:

• RedisVectorStore API reference
• FluentRedisVectorStore API reference

출처: 문서

본문

RedisVectorStore와 FluentRedisVectorStore는 RediSearch를 사용하는 Redis용 벡터 스토어 통합이에요. @langchain/redis 패키지에서 createClient로 연결하고 인스턴스화해요. FluentRedisVectorStore는 타입 안전한 fluent 필터링 API(Tag·Num·Text·Geo·Timestamp·Custom)와 GEO·타임스탬프 필드, 배열 기반 customSchema를 제공하며, 레거시 RedisVectorStore는 객체 기반 스키마·similaritySearchVectorWithScoreAndMetadata를 제공해요. 문서 추가·삭제(deleteAll/ID), similaritySearch·similaritySearchWithScore·asRetriever()를 지원해요.

더 알아보기 (Learn more)

• LangChain JavaScript 벡터 스토어 통합 문서