Merge branch 'main' into feature/ChatHistory2

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/memory/RedisBackedChatMemory/RedisBackedChatMemory.ts

@@ -1,9 +1,9 @@
-import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { INode, INodeData, INodeParams, ICommonObject } from '../../../src/Interface'
-import { getBaseClasses } from '../../../src/utils'
+import { getBaseClasses, getCredentialData, getCredentialParam } from '../../../src/utils'
-import { ICommonObject } from '../../../src'
 import { BufferMemory, BufferMemoryInput } from 'langchain/memory'
-import { RedisChatMessageHistory, RedisChatMessageHistoryInput } from 'langchain/stores/message/redis'
+import { RedisChatMessageHistory, RedisChatMessageHistoryInput } from 'langchain/stores/message/ioredis'
-import { createClient } from 'redis'
+import { mapStoredMessageToChatMessage, BaseMessage } from 'langchain/schema'
+import { Redis } from 'ioredis'
 
 class RedisBackedChatMemory_Memory implements INode {
     label: string
@@ -15,23 +15,25 @@ class RedisBackedChatMemory_Memory implements INode {
     category: string
     baseClasses: string[]
     inputs: INodeParams[]
+    credential: INodeParams
 
     constructor() {
         this.label = 'Redis-Backed Chat Memory'
         this.name = 'RedisBackedChatMemory'
-        this.version = 1.0
+        this.version = 2.0
         this.type = 'RedisBackedChatMemory'
         this.icon = 'redis.svg'
         this.category = 'Memory'
         this.description = 'Summarizes the conversation and stores the memory in Redis server'
         this.baseClasses = [this.type, ...getBaseClasses(BufferMemory)]
+        this.credential = {
+            label: 'Connect Credential',
+            name: 'credential',
+            type: 'credential',
+            optional: true,
+            credentialNames: ['redisCacheApi', 'redisCacheUrlApi']
+        }
         this.inputs = [
-            {
-                label: 'Base URL',
-                name: 'baseURL',
-                type: 'string',
-                default: 'redis://localhost:6379'
-            },
             {
                 label: 'Session Id',
                 name: 'sessionId',
@@ -60,11 +62,11 @@ class RedisBackedChatMemory_Memory implements INode {
     }
 
     async init(nodeData: INodeData, _: string, options: ICommonObject): Promise<any> {
-        return initalizeRedis(nodeData, options)
+        return await initalizeRedis(nodeData, options)
     }
 
     async clearSessionMemory(nodeData: INodeData, options: ICommonObject): Promise<void> {
-        const redis = initalizeRedis(nodeData, options)
+        const redis = await initalizeRedis(nodeData, options)
         const sessionId = nodeData.inputs?.sessionId as string
         const chatId = options?.chatId as string
         options.logger.info(`Clearing Redis memory session ${sessionId ? sessionId : chatId}`)
@@ -73,8 +75,7 @@ class RedisBackedChatMemory_Memory implements INode {
     }
 }
 
-const initalizeRedis = (nodeData: INodeData, options: ICommonObject): BufferMemory => {
+const initalizeRedis = async (nodeData: INodeData, options: ICommonObject): Promise<BufferMemory> => {
-    const baseURL = nodeData.inputs?.baseURL as string
     const sessionId = nodeData.inputs?.sessionId as string
     const sessionTTL = nodeData.inputs?.sessionTTL as number
     const memoryKey = nodeData.inputs?.memoryKey as string
@@ -83,10 +84,29 @@ const initalizeRedis = (nodeData: INodeData, options: ICommonObject): BufferMemo
     let isSessionIdUsingChatMessageId = false
     if (!sessionId && chatId) isSessionIdUsingChatMessageId = true
 
-    const redisClient = createClient({ url: baseURL })
+    const credentialData = await getCredentialData(nodeData.credential ?? '', options)
+    const redisUrl = getCredentialParam('redisUrl', credentialData, nodeData)
+
+    let client: Redis
+    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)
+    }
+
     let obj: RedisChatMessageHistoryInput = {
         sessionId: sessionId ? sessionId : chatId,
-        client: redisClient
+        client
     }
 
     if (sessionTTL) {
@@ -98,6 +118,24 @@ const initalizeRedis = (nodeData: INodeData, options: ICommonObject): BufferMemo
 
     const redisChatMessageHistory = new RedisChatMessageHistory(obj)
 
+    redisChatMessageHistory.getMessages = async (): Promise<BaseMessage[]> => {
+        const rawStoredMessages = await client.lrange(sessionId ? sessionId : chatId, 0, -1)
+        const orderedMessages = rawStoredMessages.reverse().map((message) => JSON.parse(message))
+        return orderedMessages.map(mapStoredMessageToChatMessage)
+    }
+
+    redisChatMessageHistory.addMessage = async (message: BaseMessage): Promise<void> => {
+        const messageToAdd = [message].map((msg) => msg.toDict())
+        await client.lpush(sessionId ? sessionId : chatId, JSON.stringify(messageToAdd[0]))
+        if (sessionTTL) {
+            await client.expire(sessionId ? sessionId : chatId, sessionTTL)
+        }
+    }
+
+    redisChatMessageHistory.clear = async (): Promise<void> => {
+        await client.del(sessionId ? sessionId : chatId)
+    }
+
     const memory = new BufferMemoryExtended({
         memoryKey,
         chatHistory: redisChatMessageHistory,

packages/components/nodes/prompts/ChatPromptTemplate/ChatPromptTemplate.ts

@@ -51,7 +51,7 @@ class ChatPromptTemplate_Prompts implements INode {
     async init(nodeData: INodeData): Promise<any> {
         const systemMessagePrompt = nodeData.inputs?.systemMessagePrompt as string
         const humanMessagePrompt = nodeData.inputs?.humanMessagePrompt as string
-        const promptValuesStr = nodeData.inputs?.promptValues as string
+        const promptValuesStr = nodeData.inputs?.promptValues
 
         const prompt = ChatPromptTemplate.fromMessages([
             SystemMessagePromptTemplate.fromTemplate(systemMessagePrompt),
@@ -60,7 +60,11 @@ class ChatPromptTemplate_Prompts implements INode {
 
         let promptValues: ICommonObject = {}
         if (promptValuesStr) {
-            promptValues = JSON.parse(promptValuesStr)
+            try {
+                promptValues = typeof promptValuesStr === 'object' ? promptValuesStr : JSON.parse(promptValuesStr)
+            } catch (exception) {
+                throw new Error("Invalid JSON in the ChatPromptTemplate's promptValues: " + exception)
+            }
         }
         // @ts-ignore
         prompt.promptValues = promptValues

packages/components/nodes/prompts/FewShotPromptTemplate/FewShotPromptTemplate.ts

@@ -80,7 +80,7 @@ class FewShotPromptTemplate_Prompts implements INode {
     }
 
     async init(nodeData: INodeData): Promise<any> {
-        const examplesStr = nodeData.inputs?.examples as string
+        const examplesStr = nodeData.inputs?.examples
         const prefix = nodeData.inputs?.prefix as string
         const suffix = nodeData.inputs?.suffix as string
         const exampleSeparator = nodeData.inputs?.exampleSeparator as string
@@ -88,7 +88,15 @@ class FewShotPromptTemplate_Prompts implements INode {
         const examplePrompt = nodeData.inputs?.examplePrompt as PromptTemplate
 
         const inputVariables = getInputVariables(suffix)
-        const examples: Example[] = JSON.parse(examplesStr)
+
+        let examples: Example[] = []
+        if (examplesStr) {
+            try {
+                examples = typeof examplesStr === 'object' ? examplesStr : JSON.parse(examplesStr)
+            } catch (exception) {
+                throw new Error("Invalid JSON in the FewShotPromptTemplate's examples: " + exception)
+            }
+        }
 
         try {
             const obj: FewShotPromptTemplateInput = {

packages/components/nodes/prompts/PromptTemplate/PromptTemplate.ts

@@ -43,11 +43,15 @@ class PromptTemplate_Prompts implements INode {
 
     async init(nodeData: INodeData): Promise<any> {
         const template = nodeData.inputs?.template as string
-        const promptValuesStr = nodeData.inputs?.promptValues as string
+        const promptValuesStr = nodeData.inputs?.promptValues
 
         let promptValues: ICommonObject = {}
         if (promptValuesStr) {
-            promptValues = JSON.parse(promptValuesStr)
+            try {
+                promptValues = typeof promptValuesStr === 'object' ? promptValuesStr : JSON.parse(promptValuesStr)
+            } catch (exception) {
+                throw new Error("Invalid JSON in the PromptTemplate's promptValues: " + exception)
+            }
         }
 
         const inputVariables = getInputVariables(template)

packages/components/nodes/textsplitters/RecursiveCharacterTextSplitter/RecursiveCharacterTextSplitter.ts

@@ -51,7 +51,7 @@ class RecursiveCharacterTextSplitter_TextSplitters implements INode {
     async init(nodeData: INodeData): Promise<any> {
         const chunkSize = nodeData.inputs?.chunkSize as string
         const chunkOverlap = nodeData.inputs?.chunkOverlap as string
-        const separators = nodeData.inputs?.separators as string
+        const separators = nodeData.inputs?.separators
 
         const obj = {} as RecursiveCharacterTextSplitterParams
 
@@ -59,7 +59,7 @@ class RecursiveCharacterTextSplitter_TextSplitters implements INode {
         if (chunkOverlap) obj.chunkOverlap = parseInt(chunkOverlap, 10)
         if (separators) {
             try {
-                obj.separators = JSON.parse(separators)
+                obj.separators = typeof separators === 'object' ? separators : JSON.parse(separators)
             } catch (e) {
                 throw new Error(e)
             }

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('\\-', '-')
+}