Merge pull request #1108 from vinodkiran/FEATURE/redis-vectorstore

Feature/RedisVectorStore

packages/components/credentials/RedisCacheUrlApi.credential.ts

@@ -0,0 +1,25 @@
+import { INodeParams, INodeCredential } from '../src/Interface'
+
+class RedisCacheUrlApi implements INodeCredential {
+    label: string
+    name: string
+    version: number
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Redis Cache URL'
+        this.name = 'redisCacheUrlApi'
+        this.version = 1.0
+        this.inputs = [
+            {
+                label: 'Redis URL',
+                name: 'redisUrl',
+                type: 'string',
+                default: '127.0.0.1'
+            }
+        ]
+    }
+}
+
+module.exports = { credClass: RedisCacheUrlApi }

packages/components/nodes/cache/RedisCache/RedisCache.ts

@@ -30,7 +30,7 @@ class RedisCache implements INode {
             name: 'credential',
             type: 'credential',
             optional: true,
-            credentialNames: ['redisCacheApi']
+            credentialNames: ['redisCacheApi', 'redisCacheUrlApi']
         }
         this.inputs = [
             {
@@ -48,17 +48,24 @@ class RedisCache implements INode {
         const ttl = nodeData.inputs?.ttl as string
 
         const credentialData = await getCredentialData(nodeData.credential ?? '', options)
-        const username = getCredentialParam('redisCacheUser', credentialData, nodeData)
+        const redisUrl = getCredentialParam('redisUrl', credentialData, nodeData)
-        const password = getCredentialParam('redisCachePwd', credentialData, nodeData)
-        const portStr = getCredentialParam('redisCachePort', credentialData, nodeData)
-        const host = getCredentialParam('redisCacheHost', credentialData, nodeData)
 
-        const client = new Redis({
+        let client: Redis
-            port: portStr ? parseInt(portStr) : 6379,
+        if (!redisUrl || redisUrl === '') {
-            host,
+            const username = getCredentialParam('redisCacheUser', credentialData, nodeData)
-            username,
+            const password = getCredentialParam('redisCachePwd', credentialData, nodeData)
-            password
+            const portStr = getCredentialParam('redisCachePort', credentialData, nodeData)
-        })
+            const host = getCredentialParam('redisCacheHost', credentialData, nodeData)
+
+            client = new Redis({
+                port: portStr ? parseInt(portStr) : 6379,
+                host,
+                username,
+                password
+            })
+        } else {
+            client = new Redis(redisUrl)
+        }
 
         const redisClient = new LangchainRedisCache(client)
 

packages/components/nodes/cache/RedisCache/RedisEmbeddingsCache.ts

@@ -30,7 +30,7 @@ class RedisEmbeddingsCache implements INode {
             name: 'credential',
             type: 'credential',
             optional: true,
-            credentialNames: ['redisCacheApi']
+            credentialNames: ['redisCacheApi', 'redisCacheUrlApi']
         }
         this.inputs = [
             {
@@ -63,17 +63,25 @@ class RedisEmbeddingsCache implements INode {
         const underlyingEmbeddings = nodeData.inputs?.embeddings as Embeddings
 
         const credentialData = await getCredentialData(nodeData.credential ?? '', options)
-        const username = getCredentialParam('redisCacheUser', credentialData, nodeData)
+        const redisUrl = getCredentialParam('redisUrl', credentialData, nodeData)
-        const password = getCredentialParam('redisCachePwd', credentialData, nodeData)
+
-        const portStr = getCredentialParam('redisCachePort', credentialData, nodeData)
+        let client: Redis
-        const host = getCredentialParam('redisCacheHost', credentialData, nodeData)
+        if (!redisUrl || redisUrl === '') {
+            const username = getCredentialParam('redisCacheUser', credentialData, nodeData)
+            const password = getCredentialParam('redisCachePwd', credentialData, nodeData)
+            const portStr = getCredentialParam('redisCachePort', credentialData, nodeData)
+            const host = getCredentialParam('redisCacheHost', credentialData, nodeData)
+
+            client = new Redis({
+                port: portStr ? parseInt(portStr) : 6379,
+                host,
+                username,
+                password
+            })
+        } else {
+            client = new Redis(redisUrl)
+        }
 
-        const client = new Redis({
-            port: portStr ? parseInt(portStr) : 6379,
-            host,
-            username,
-            password
-        })
         ttl ??= '3600'
         let ttlNumber = parseInt(ttl, 10)
         const redisStore = new RedisByteStore({

packages/components/nodes/vectorstores/Redis/RedisSearchBase.ts

@@ -0,0 +1,215 @@
+import {
+    getBaseClasses,
+    getCredentialData,
+    getCredentialParam,
+    ICommonObject,
+    INodeData,
+    INodeOutputsValue,
+    INodeParams
+} from '../../../src'
+
+import { Embeddings } from 'langchain/embeddings/base'
+import { VectorStore } from 'langchain/vectorstores/base'
+import { Document } from 'langchain/document'
+import { createClient, SearchOptions } from 'redis'
+import { RedisVectorStore } from 'langchain/vectorstores/redis'
+import { escapeSpecialChars, unEscapeSpecialChars } from './utils'
+
+export abstract class RedisSearchBase {
+    label: string
+    name: string
+    version: number
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+    credential: INodeParams
+    outputs: INodeOutputsValue[]
+    redisClient: ReturnType<typeof createClient>
+
+    protected constructor() {
+        this.type = 'Redis'
+        this.icon = 'redis.svg'
+        this.category = 'Vector Stores'
+        this.baseClasses = [this.type, 'VectorStoreRetriever', 'BaseRetriever']
+        this.credential = {
+            label: 'Connect Credential',
+            name: 'credential',
+            type: 'credential',
+            credentialNames: ['redisCacheUrlApi', 'redisCacheApi']
+        }
+        this.inputs = [
+            {
+                label: 'Embeddings',
+                name: 'embeddings',
+                type: 'Embeddings'
+            },
+            {
+                label: 'Index Name',
+                name: 'indexName',
+                placeholder: '<VECTOR_INDEX_NAME>',
+                type: 'string'
+            },
+            {
+                label: 'Replace Index?',
+                name: 'replaceIndex',
+                description: 'Selecting this option will delete the existing index and recreate a new one',
+                default: false,
+                type: 'boolean'
+            },
+            {
+                label: 'Content Field',
+                name: 'contentKey',
+                description: 'Name of the field (column) that contains the actual content',
+                type: 'string',
+                default: 'content',
+                additionalParams: true,
+                optional: true
+            },
+            {
+                label: 'Metadata Field',
+                name: 'metadataKey',
+                description: 'Name of the field (column) that contains the metadata of the document',
+                type: 'string',
+                default: 'metadata',
+                additionalParams: true,
+                optional: true
+            },
+            {
+                label: 'Vector Field',
+                name: 'vectorKey',
+                description: 'Name of the field (column) that contains the vector',
+                type: 'string',
+                default: 'content_vector',
+                additionalParams: true,
+                optional: true
+            },
+            {
+                label: 'Top K',
+                name: 'topK',
+                description: 'Number of top results to fetch. Default to 4',
+                placeholder: '4',
+                type: 'number',
+                additionalParams: true,
+                optional: true
+            }
+        ]
+        this.outputs = [
+            {
+                label: 'Redis Retriever',
+                name: 'retriever',
+                baseClasses: this.baseClasses
+            },
+            {
+                label: 'Redis Vector Store',
+                name: 'vectorStore',
+                baseClasses: [this.type, ...getBaseClasses(RedisVectorStore)]
+            }
+        ]
+    }
+
+    abstract constructVectorStore(
+        embeddings: Embeddings,
+        indexName: string,
+        replaceIndex: boolean,
+        docs: Document<Record<string, any>>[] | undefined
+    ): Promise<VectorStore>
+
+    async init(nodeData: INodeData, _: string, options: ICommonObject, docs: Document<Record<string, any>>[] | undefined): Promise<any> {
+        const credentialData = await getCredentialData(nodeData.credential ?? '', options)
+        const indexName = nodeData.inputs?.indexName as string
+        let contentKey = nodeData.inputs?.contentKey as string
+        let metadataKey = nodeData.inputs?.metadataKey as string
+        let vectorKey = nodeData.inputs?.vectorKey as string
+        const embeddings = nodeData.inputs?.embeddings as Embeddings
+        const topK = nodeData.inputs?.topK as string
+        const replaceIndex = nodeData.inputs?.replaceIndex as boolean
+        const k = topK ? parseFloat(topK) : 4
+        const output = nodeData.outputs?.output as string
+
+        let redisUrl = getCredentialParam('redisUrl', credentialData, nodeData)
+        if (!redisUrl || redisUrl === '') {
+            const username = getCredentialParam('redisCacheUser', credentialData, nodeData)
+            const password = getCredentialParam('redisCachePwd', credentialData, nodeData)
+            const portStr = getCredentialParam('redisCachePort', credentialData, nodeData)
+            const host = getCredentialParam('redisCacheHost', credentialData, nodeData)
+
+            redisUrl = 'redis://' + username + ':' + password + '@' + host + ':' + portStr
+        }
+
+        this.redisClient = createClient({ url: redisUrl })
+        await this.redisClient.connect()
+
+        const vectorStore = await this.constructVectorStore(embeddings, indexName, replaceIndex, docs)
+        if (!contentKey || contentKey === '') contentKey = 'content'
+        if (!metadataKey || metadataKey === '') metadataKey = 'metadata'
+        if (!vectorKey || vectorKey === '') vectorKey = 'content_vector'
+
+        const buildQuery = (query: number[], k: number, filter?: string[]): [string, SearchOptions] => {
+            const vectorScoreField = 'vector_score'
+
+            let hybridFields = '*'
+            // if a filter is set, modify the hybrid query
+            if (filter && filter.length) {
+                // `filter` is a list of strings, then it's applied using the OR operator in the metadata key
+                hybridFields = `@${metadataKey}:(${filter.map(escapeSpecialChars).join('|')})`
+            }
+
+            const baseQuery = `${hybridFields} => [KNN ${k} @${vectorKey} $vector AS ${vectorScoreField}]`
+            const returnFields = [metadataKey, contentKey, vectorScoreField]
+
+            const options: SearchOptions = {
+                PARAMS: {
+                    vector: Buffer.from(new Float32Array(query).buffer)
+                },
+                RETURN: returnFields,
+                SORTBY: vectorScoreField,
+                DIALECT: 2,
+                LIMIT: {
+                    from: 0,
+                    size: k
+                }
+            }
+
+            return [baseQuery, options]
+        }
+
+        vectorStore.similaritySearchVectorWithScore = async (
+            query: number[],
+            k: number,
+            filter?: string[]
+        ): Promise<[Document, number][]> => {
+            const results = await this.redisClient.ft.search(indexName, ...buildQuery(query, k, filter))
+            const result: [Document, number][] = []
+
+            if (results.total) {
+                for (const res of results.documents) {
+                    if (res.value) {
+                        const document = res.value
+                        if (document.vector_score) {
+                            const metadataString = unEscapeSpecialChars(document[metadataKey] as string)
+                            result.push([
+                                new Document({
+                                    pageContent: document[contentKey] as string,
+                                    metadata: JSON.parse(metadataString)
+                                }),
+                                Number(document.vector_score)
+                            ])
+                        }
+                    }
+                }
+            }
+            return result
+        }
+
+        if (output === 'retriever') {
+            return vectorStore.asRetriever(k)
+        } else if (output === 'vectorStore') {
+            ;(vectorStore as any).k = k
+            return vectorStore
+        }
+        return vectorStore
+    }
+}

packages/components/nodes/vectorstores/Redis/Redis_Existing.ts

@@ -0,0 +1,42 @@
+import { ICommonObject, INode, INodeData } from '../../../src/Interface'
+import { Embeddings } from 'langchain/embeddings/base'
+import { VectorStore } from 'langchain/vectorstores/base'
+import { RedisVectorStore, RedisVectorStoreConfig } from 'langchain/vectorstores/redis'
+import { Document } from 'langchain/document'
+
+import { RedisSearchBase } from './RedisSearchBase'
+
+class RedisExisting_VectorStores extends RedisSearchBase implements INode {
+    constructor() {
+        super()
+        this.label = 'Redis Load Existing Index'
+        this.name = 'RedisIndex'
+        this.version = 1.0
+        this.description = 'Load existing index from Redis (i.e: Document has been upserted)'
+
+        // Remove deleteIndex from inputs as it is not applicable while fetching data from Redis
+        let input = this.inputs.find((i) => i.name === 'deleteIndex')
+        if (input) this.inputs.splice(this.inputs.indexOf(input), 1)
+    }
+
+    async constructVectorStore(
+        embeddings: Embeddings,
+        indexName: string,
+        // eslint-disable-next-line unused-imports/no-unused-vars
+        replaceIndex: boolean,
+        _: Document<Record<string, any>>[]
+    ): Promise<VectorStore> {
+        const storeConfig: RedisVectorStoreConfig = {
+            redisClient: this.redisClient,
+            indexName: indexName
+        }
+
+        return new RedisVectorStore(embeddings, storeConfig)
+    }
+
+    async init(nodeData: INodeData, _: string, options: ICommonObject): Promise<any> {
+        return super.init(nodeData, _, options, undefined)
+    }
+}
+
+module.exports = { nodeClass: RedisExisting_VectorStores }

packages/components/nodes/vectorstores/Redis/Redis_Upsert.ts

@@ -0,0 +1,61 @@
+import { ICommonObject, INode, INodeData } from '../../../src/Interface'
+import { Embeddings } from 'langchain/embeddings/base'
+import { Document } from 'langchain/document'
+
+import { flatten } from 'lodash'
+import { RedisSearchBase } from './RedisSearchBase'
+import { VectorStore } from 'langchain/vectorstores/base'
+import { RedisVectorStore, RedisVectorStoreConfig } from 'langchain/vectorstores/redis'
+import { escapeAllStrings } from './utils'
+
+class RedisUpsert_VectorStores extends RedisSearchBase implements INode {
+    constructor() {
+        super()
+        this.label = 'Redis Upsert Document'
+        this.name = 'RedisUpsert'
+        this.version = 1.0
+        this.description = 'Upsert documents to Redis'
+        this.inputs.unshift({
+            label: 'Document',
+            name: 'document',
+            type: 'Document',
+            list: true
+        })
+    }
+
+    async constructVectorStore(
+        embeddings: Embeddings,
+        indexName: string,
+        replaceIndex: boolean,
+        docs: Document<Record<string, any>>[]
+    ): Promise<VectorStore> {
+        const storeConfig: RedisVectorStoreConfig = {
+            redisClient: this.redisClient,
+            indexName: indexName
+        }
+        if (replaceIndex) {
+            let response = await this.redisClient.ft.dropIndex(indexName)
+            if (process.env.DEBUG === 'true') {
+                // eslint-disable-next-line no-console
+                console.log(`Redis Vector Store :: Dropping index [${indexName}], Received Response [${response}]`)
+            }
+        }
+        return await RedisVectorStore.fromDocuments(docs, embeddings, storeConfig)
+    }
+
+    async init(nodeData: INodeData, _: string, options: ICommonObject): Promise<any> {
+        const docs = nodeData.inputs?.document as Document[]
+
+        const flattenDocs = docs && docs.length ? flatten(docs) : []
+        const finalDocs = []
+        for (let i = 0; i < flattenDocs.length; i += 1) {
+            const document = new Document(flattenDocs[i])
+            escapeAllStrings(document.metadata)
+            finalDocs.push(document)
+        }
+
+        return super.init(nodeData, _, options, flattenDocs)
+    }
+}
+
+module.exports = { nodeClass: RedisUpsert_VectorStores }

packages/components/nodes/vectorstores/Redis/redis.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128" id="redis"><path fill="#A41E11" d="M121.8 93.1c-6.7 3.5-41.4 17.7-48.8 21.6-7.4 3.9-11.5 3.8-17.3 1s-42.7-17.6-49.4-20.8c-3.3-1.6-5-2.9-5-4.2v-12.7s48-10.5 55.8-13.2c7.8-2.8 10.4-2.9 17-.5s46.1 9.5 52.6 11.9v12.5c0 1.3-1.5 2.7-4.9 4.4z"></path><path fill="#D82C20" d="M121.8 80.5c-6.7 3.5-41.4 17.7-48.8 21.6-7.4 3.9-11.5 3.8-17.3 1-5.8-2.8-42.7-17.7-49.4-20.9-6.6-3.2-6.8-5.4-.3-7.9 6.5-2.6 43.2-17 51-19.7 7.8-2.8 10.4-2.9 17-.5s41.1 16.1 47.6 18.5c6.7 2.4 6.9 4.4.2 7.9z"></path><path fill="#A41E11" d="M121.8 72.5c-6.7 3.5-41.4 17.7-48.8 21.6-7.4 3.8-11.5 3.8-17.3 1-5.8-2.8-42.7-17.7-49.4-20.9-3.3-1.6-5-2.9-5-4.2v-12.7s48-10.5 55.8-13.2c7.8-2.8 10.4-2.9 17-.5s46.1 9.5 52.6 11.9v12.5c0 1.3-1.5 2.7-4.9 4.5z"></path><path fill="#D82C20" d="M121.8 59.8c-6.7 3.5-41.4 17.7-48.8 21.6-7.4 3.8-11.5 3.8-17.3 1-5.8-2.8-42.7-17.7-49.4-20.9s-6.8-5.4-.3-7.9c6.5-2.6 43.2-17 51-19.7 7.8-2.8 10.4-2.9 17-.5s41.1 16.1 47.6 18.5c6.7 2.4 6.9 4.4.2 7.9z"></path><path fill="#A41E11" d="M121.8 51c-6.7 3.5-41.4 17.7-48.8 21.6-7.4 3.8-11.5 3.8-17.3 1-5.8-2.7-42.7-17.6-49.4-20.8-3.3-1.6-5.1-2.9-5.1-4.2v-12.7s48-10.5 55.8-13.2c7.8-2.8 10.4-2.9 17-.5s46.1 9.5 52.6 11.9v12.5c.1 1.3-1.4 2.6-4.8 4.4z"></path><path fill="#D82C20" d="M121.8 38.3c-6.7 3.5-41.4 17.7-48.8 21.6-7.4 3.8-11.5 3.8-17.3 1s-42.7-17.6-49.4-20.8-6.8-5.4-.3-7.9c6.5-2.6 43.2-17 51-19.7 7.8-2.8 10.4-2.9 17-.5s41.1 16.1 47.6 18.5c6.7 2.4 6.9 4.4.2 7.8z"></path><path fill="#fff" d="M80.4 26.1l-10.8 1.2-2.5 5.8-3.9-6.5-12.5-1.1 9.3-3.4-2.8-5.2 8.8 3.4 8.2-2.7-2.2 5.4zM66.5 54.5l-20.3-8.4 29.1-4.4z"></path><ellipse cx="38.4" cy="35.4" fill="#fff" rx="15.5" ry="6"></ellipse><path fill="#7A0C00" d="M93.3 27.7l17.2 6.8-17.2 6.8z"></path><path fill="#AD2115" d="M74.3 35.3l19-7.6v13.6l-1.9.8z"></path></svg>

packages/components/nodes/vectorstores/Redis/utils.ts

@@ -0,0 +1,25 @@
+/*
+ * Escapes all '-' characters.
+ * Redis Search considers '-' as a negative operator, hence we need
+ * to escape it
+ */
+export const escapeSpecialChars = (str: string) => {
+    return str.replaceAll('-', '\\-')
+}
+
+export const escapeAllStrings = (obj: object) => {
+    Object.keys(obj).forEach((key: string) => {
+        // @ts-ignore
+        let item = obj[key]
+        if (typeof item === 'object') {
+            escapeAllStrings(item)
+        } else if (typeof item === 'string') {
+            // @ts-ignore
+            obj[key] = escapeSpecialChars(item)
+        }
+    })
+}
+
+export const unEscapeSpecialChars = (str: string) => {
+    return str.replaceAll('\\-', '-')
+}