Initial push

packages/components/README.md

@@ -0,0 +1,17 @@
+<!-- markdownlint-disable MD030 -->
+
+# Flowise Components
+
+Apps integration for Flowise. Contain Nodes and Credentials.
+
+![Flowise](https://github.com/FlowiseAI/Flowise/blob/main/images/flowise.gif?raw=true)
+
+Install:
+
+```bash
+npm i flowise-components
+```
+
+## License
+
+Source code in this repository is made available under the [MIT License](https://github.com/FlowiseAI/Flowise/blob/master/LICENSE.md).

packages/components/gulpfile.ts

@@ -0,0 +1,9 @@
+import gulp from 'gulp'
+
+const { src, dest } = gulp
+
+function copyIcons() {
+    return src(['nodes/**/*.{jpg,png,svg}']).pipe(dest('dist/nodes'))
+}
+
+exports.default = copyIcons

packages/components/nodes/agents/MRLKAgentLLM/MRLKAgentLLM.ts

@@ -0,0 +1,58 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+
+class MRLKAgentLLM implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'MRLK Agent for LLMs'
+        this.name = 'mrlkAgentLLM'
+        this.type = 'AgentExecutor'
+        this.category = 'Agents'
+        this.icon = 'agent.svg'
+        this.description = 'Agent that uses the ReAct Framework to decide what action to take, optimized to be used with LLMs'
+        this.inputs = [
+            {
+                label: 'Allowed Tools',
+                name: 'tools',
+                type: 'Tool',
+                list: true
+            },
+            {
+                label: 'LLM Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            }
+        ]
+    }
+
+    async getBaseClasses(): Promise<string[]> {
+        return ['AgentExecutor']
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const { initializeAgentExecutor } = await import('langchain/agents')
+
+        const model = nodeData.inputs?.model
+        const tools = nodeData.inputs?.tools
+
+        const executor = await initializeAgentExecutor(tools, model, 'zero-shot-react-description', true)
+
+        return executor
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const executor = nodeData.instance
+        const result = await executor.call({ input })
+
+        return result?.output
+    }
+}
+
+module.exports = { nodeClass: MRLKAgentLLM }

packages/components/nodes/agents/MRLKAgentLLM/agent.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-robot" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
+   <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+   <path d="M7 7h10a2 2 0 0 1 2 2v1l1 1v3l-1 1v3a2 2 0 0 1 -2 2h-10a2 2 0 0 1 -2 -2v-3l-1 -1v-3l1 -1v-1a2 2 0 0 1 2 -2z"></path>
+   <path d="M10 16h4"></path>
+   <circle cx="8.5" cy="11.5" r=".5" fill="currentColor"></circle>
+   <circle cx="15.5" cy="11.5" r=".5" fill="currentColor"></circle>
+   <path d="M9 7l-1 -4"></path>
+   <path d="M15 7l1 -4"></path>
+</svg>

packages/components/nodes/chains/LLMChain/LLMChain.ts

@@ -0,0 +1,61 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+
+class LLMChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'LLM Chain'
+        this.name = 'llmChain'
+        this.type = 'LLMChain'
+        this.icon = 'chain.svg'
+        this.category = 'Chains'
+        this.description = 'Chain to run queries against LLMs'
+        this.inputs = [
+            {
+                label: 'LLM',
+                name: 'llm',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Prompt',
+                name: 'prompt',
+                type: 'BasePromptTemplate'
+            }
+        ]
+    }
+
+    async getBaseClasses(): Promise<string[]> {
+        const { LLMChain } = await import('langchain/chains')
+        return getBaseClasses(LLMChain)
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const { LLMChain } = await import('langchain/chains')
+
+        const llm = nodeData.inputs?.llm
+        const prompt = nodeData.inputs?.prompt
+
+        const chain = new LLMChain({ llm, prompt })
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const prompt = nodeData.instance.prompt.inputVariables // ["product"]
+        if (prompt.length > 1) throw new Error('Prompt can only contains 1 literal string {}. Multiples are found')
+
+        const chain = nodeData.instance
+        const res = await chain.run(input)
+
+        return res
+    }
+}
+
+module.exports = { nodeClass: LLMChain_Chains }

packages/components/nodes/chains/LLMChain/chain.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-dna" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
+   <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+   <path d="M14.828 14.828a4 4 0 1 0 -5.656 -5.656a4 4 0 0 0 5.656 5.656z"></path>
+   <path d="M9.172 20.485a4 4 0 1 0 -5.657 -5.657"></path>
+   <path d="M14.828 3.515a4 4 0 0 0 5.657 5.657"></path>
+</svg>

packages/components/nodes/llms/OpenAI/OpenAI.ts

@@ -0,0 +1,83 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+
+class OpenAI_LLMs implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    description: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'OpenAI'
+        this.name = 'openAI'
+        this.type = 'OpenAI'
+        this.icon = 'openai.png'
+        this.category = 'LLMs'
+        this.description = 'Wrapper around OpenAI large language models'
+        this.inputs = [
+            {
+                label: 'OpenAI Api Key',
+                name: 'openAIApiKey',
+                type: 'password'
+            },
+            {
+                label: 'Model Name',
+                name: 'modelName',
+                type: 'options',
+                options: [
+                    {
+                        label: 'text-davinci-003',
+                        name: 'text-davinci-003'
+                    },
+                    {
+                        label: 'text-davinci-002',
+                        name: 'text-davinci-002'
+                    },
+                    {
+                        label: 'text-curie-001',
+                        name: 'text-curie-001'
+                    },
+                    {
+                        label: 'text-babbage-001',
+                        name: 'text-babbage-001'
+                    }
+                ],
+                default: 'text-davinci-003',
+                optional: true
+            },
+            {
+                label: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                default: 0.7,
+                optional: true
+            }
+        ]
+    }
+
+    async getBaseClasses(): Promise<string[]> {
+        const { OpenAI } = await import('langchain/llms')
+        return getBaseClasses(OpenAI)
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const { OpenAI } = await import('langchain/llms')
+
+        const temperature = nodeData.inputs?.temperature as string
+        const modelName = nodeData.inputs?.modelName as string
+        const openAIApiKey = nodeData.inputs?.openAIApiKey as string
+
+        const model = new OpenAI({
+            temperature: parseInt(temperature, 10),
+            modelName,
+            openAIApiKey
+        })
+        return model
+    }
+}
+
+module.exports = { nodeClass: OpenAI_LLMs }

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

@@ -0,0 +1,56 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses, getInputVariables } from '../../../src/utils'
+
+class PromptTemplate_Prompts implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Prompt Template'
+        this.name = 'promptTemplate'
+        this.type = 'PromptTemplate'
+        this.icon = 'prompt.svg'
+        this.category = 'Prompts'
+        this.description = 'Schema to represent a basic prompt for an LLM. Template can only contains 1 literal string {}'
+        this.inputs = [
+            {
+                label: 'Template',
+                name: 'template',
+                type: 'string',
+                rows: 5,
+                default: 'What is a good name for a company that makes {product}?',
+                placeholder: 'What is a good name for a company that makes {product}?'
+            }
+        ]
+    }
+
+    async getBaseClasses(): Promise<string[]> {
+        const { PromptTemplate } = await import('langchain/prompts')
+        return getBaseClasses(PromptTemplate)
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const { PromptTemplate } = await import('langchain/prompts')
+
+        const template = nodeData.inputs?.template as string
+        const inputVariables = getInputVariables(template)
+
+        try {
+            const prompt = new PromptTemplate({
+                template,
+                inputVariables: inputVariables
+            })
+            return prompt
+        } catch (e) {
+            throw new Error(e)
+        }
+    }
+}
+
+module.exports = { nodeClass: PromptTemplate_Prompts }

packages/components/nodes/prompts/PromptTemplate/prompt.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-terminal-2" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
+   <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+   <path d="M8 9l3 3l-3 3"></path>
+   <path d="M13 15l3 0"></path>
+   <path d="M3 4m0 2a2 2 0 0 1 2 -2h14a2 2 0 0 1 2 2v12a2 2 0 0 1 -2 2h-14a2 2 0 0 1 -2 -2z"></path>
+</svg>

packages/components/nodes/tools/Calculator/Calculator.ts

@@ -0,0 +1,33 @@
+import { INode } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+
+class Calculator implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+
+    constructor() {
+        this.label = 'Calculator'
+        this.name = 'calculator'
+        this.type = 'Calculator'
+        this.icon = 'calculator.svg'
+        this.category = 'Tools'
+        this.description = 'Perform calculations on response'
+    }
+
+    async getBaseClasses(): Promise<string[]> {
+        const { Calculator } = await import('langchain/tools')
+        return getBaseClasses(Calculator)
+    }
+
+    async init(): Promise<any> {
+        const { Calculator } = await import('langchain/tools')
+        return new Calculator()
+    }
+}
+
+module.exports = { nodeClass: Calculator }

packages/components/nodes/tools/Calculator/calculator.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-calculator" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
+   <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+   <path d="M4 3m0 2a2 2 0 0 1 2 -2h12a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-12a2 2 0 0 1 -2 -2z"></path>
+   <path d="M8 7m0 1a1 1 0 0 1 1 -1h6a1 1 0 0 1 1 1v1a1 1 0 0 1 -1 1h-6a1 1 0 0 1 -1 -1z"></path>
+   <path d="M8 14l0 .01"></path>
+   <path d="M12 14l0 .01"></path>
+   <path d="M16 14l0 .01"></path>
+   <path d="M8 17l0 .01"></path>
+   <path d="M12 17l0 .01"></path>
+   <path d="M16 17l0 .01"></path>
+</svg>

packages/components/nodes/tools/SerpAPI/SerpAPI.ts

@@ -0,0 +1,42 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+
+class SerpAPI implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Serp API'
+        this.name = 'serpAPI'
+        this.type = 'SerpAPI'
+        this.icon = 'serp.png'
+        this.category = 'Tools'
+        this.description = 'Wrapper around SerpAPI - a real-time API to access Google search results'
+        this.inputs = [
+            {
+                label: 'Serp Api Key',
+                name: 'apiKey',
+                type: 'password'
+            }
+        ]
+    }
+
+    async getBaseClasses(): Promise<string[]> {
+        const { SerpAPI } = await import('langchain/tools')
+        return getBaseClasses(SerpAPI)
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const { SerpAPI } = await import('langchain/tools')
+        const apiKey = nodeData.inputs?.apiKey as string
+        return new SerpAPI(apiKey)
+    }
+}
+
+module.exports = { nodeClass: SerpAPI }

packages/components/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "flowise-components",
+    "version": "1.0.0",
+    "description": "Flowiseai Components",
+    "main": "dist/src/index",
+    "types": "dist/src/index.d.ts",
+    "scripts": {
+        "build": "tsc && gulp",
+        "dev": "tsc --watch"
+    },
+    "keywords": [],
+    "homepage": "https://flowiseai.com",
+    "author": {
+        "name": "Henry Heng",
+        "email": "henryheng@flowiseai.com"
+    },
+    "license": "SEE LICENSE IN LICENSE.md",
+    "dependencies": {
+        "axios": "^0.27.2",
+        "dotenv": "^16.0.0",
+        "express": "^4.17.3",
+        "form-data": "^4.0.0",
+        "langchain": "^0.0.44",
+        "moment": "^2.29.3",
+        "node-fetch": "2",
+        "ws": "^8.9.0"
+    },
+    "devDependencies": {
+        "@types/gulp": "4.0.9",
+        "@types/ws": "^8.5.3",
+        "gulp": "^4.0.2",
+        "typescript": "^4.8.4"
+    }
+}

packages/components/src/Interface.ts

@@ -0,0 +1,83 @@
+/**
+ * Types
+ */
+
+export type NodeParamsType =
+    | 'asyncOptions'
+    | 'options'
+    | 'string'
+    | 'number'
+    | 'boolean'
+    | 'password'
+    | 'json'
+    | 'code'
+    | 'date'
+    | 'file'
+    | 'folder'
+
+export type CommonType = string | number | boolean | undefined | null
+
+/**
+ * Others
+ */
+
+export interface ICommonObject {
+    [key: string]: any | CommonType | ICommonObject | CommonType[] | ICommonObject[]
+}
+
+export interface IAttachment {
+    content: string
+    contentType: string
+    size?: number
+    filename?: string
+}
+
+export interface INodeOptionsValue {
+    label: string
+    name: string
+    description?: string
+}
+
+export interface INodeParams {
+    label: string
+    name: string
+    type: NodeParamsType | string
+    default?: CommonType | ICommonObject | ICommonObject[]
+    description?: string
+    options?: Array<INodeOptionsValue>
+    optional?: boolean | INodeDisplay
+    rows?: number
+    list?: boolean
+    placeholder?: string
+}
+
+export interface INodeExecutionData {
+    [key: string]: CommonType | CommonType[] | ICommonObject | ICommonObject[]
+}
+
+export interface INodeDisplay {
+    [key: string]: string[] | string
+}
+
+export interface INodeProperties {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description?: string
+    filePath?: string
+}
+
+export interface INode extends INodeProperties {
+    inputs?: INodeParams[]
+    getBaseClasses?(): Promise<string[]>
+    getInstance?(nodeData: INodeData): Promise<string>
+    run?(nodeData: INodeData, input: string): Promise<string>
+}
+
+export interface INodeData extends INodeProperties {
+    inputs?: ICommonObject
+    instance?: any
+}

packages/components/src/index.ts

@@ -0,0 +1,2 @@
+export * from './Interface'
+export * from './utils'

packages/components/src/utils.ts

@@ -0,0 +1,144 @@
+import * as fs from 'fs'
+import * as path from 'path'
+
+export const numberOrExpressionRegex = '^(\\d+\\.?\\d*|{{.*}})$' //return true if string consists only numbers OR expression {{}}
+export const notEmptyRegex = '(.|\\s)*\\S(.|\\s)*' //return true if string is not empty or blank
+
+export const getBaseClasses = (targetClass: any) => {
+    const baseClasses: string[] = []
+
+    if (targetClass instanceof Function) {
+        let baseClass = targetClass
+
+        while (baseClass) {
+            const newBaseClass = Object.getPrototypeOf(baseClass)
+            if (newBaseClass && newBaseClass !== Object && newBaseClass.name) {
+                baseClass = newBaseClass
+                baseClasses.push(baseClass.name)
+            } else {
+                break
+            }
+        }
+    }
+    return baseClasses
+}
+
+/**
+ * Serialize axios query params
+ *
+ * @export
+ * @param {any} params
+ * @param {boolean} skipIndex // Set to true if you want same params to be: param=1&param=2 instead of: param[0]=1&param[1]=2
+ * @returns {string}
+ */
+export function serializeQueryParams(params: any, skipIndex?: boolean): string {
+    const parts: any[] = []
+
+    const encode = (val: string) => {
+        return encodeURIComponent(val)
+            .replace(/%3A/gi, ':')
+            .replace(/%24/g, '$')
+            .replace(/%2C/gi, ',')
+            .replace(/%20/g, '+')
+            .replace(/%5B/gi, '[')
+            .replace(/%5D/gi, ']')
+    }
+
+    const convertPart = (key: string, val: any) => {
+        if (val instanceof Date) val = val.toISOString()
+        else if (val instanceof Object) val = JSON.stringify(val)
+
+        parts.push(encode(key) + '=' + encode(val))
+    }
+
+    Object.entries(params).forEach(([key, val]) => {
+        if (val === null || typeof val === 'undefined') return
+
+        if (Array.isArray(val)) val.forEach((v, i) => convertPart(`${key}${skipIndex ? '' : `[${i}]`}`, v))
+        else convertPart(key, val)
+    })
+
+    return parts.join('&')
+}
+
+/**
+ * Handle error from try catch
+ *
+ * @export
+ * @param {any} error
+ * @returns {string}
+ */
+export function handleErrorMessage(error: any): string {
+    let errorMessage = ''
+
+    if (error.message) {
+        errorMessage += error.message + '. '
+    }
+
+    if (error.response && error.response.data) {
+        if (error.response.data.error) {
+            if (typeof error.response.data.error === 'object') errorMessage += JSON.stringify(error.response.data.error) + '. '
+            else if (typeof error.response.data.error === 'string') errorMessage += error.response.data.error + '. '
+        } else if (error.response.data.msg) errorMessage += error.response.data.msg + '. '
+        else if (error.response.data.Message) errorMessage += error.response.data.Message + '. '
+        else if (typeof error.response.data === 'string') errorMessage += error.response.data + '. '
+    }
+
+    if (!errorMessage) errorMessage = 'Unexpected Error.'
+
+    return errorMessage
+}
+
+/**
+ * Returns the path of node modules package
+ * @param {string} packageName
+ * @returns {string}
+ */
+export const getNodeModulesPackagePath = (packageName: string): string => {
+    const checkPaths = [
+        path.join(__dirname, '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', '..', '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', '..', '..', '..', 'node_modules', packageName)
+    ]
+    for (const checkPath of checkPaths) {
+        if (fs.existsSync(checkPath)) {
+            return checkPath
+        }
+    }
+    return ''
+}
+
+/**
+ * Get input variables
+ * @param {string} paramValue
+ * @returns {boolean}
+ */
+export const getInputVariables = (paramValue: string): string[] => {
+    let returnVal = paramValue
+    const variableStack = []
+    const inputVariables = []
+    let startIdx = 0
+    const endIdx = returnVal.length - 1
+
+    while (startIdx < endIdx) {
+        const substr = returnVal.substring(startIdx, startIdx + 1)
+
+        // Store the opening double curly bracket
+        if (substr === '{') {
+            variableStack.push({ substr, startIdx: startIdx + 1 })
+        }
+
+        // Found the complete variable
+        if (substr === '}' && variableStack.length > 0 && variableStack[variableStack.length - 1].substr === '{') {
+            const variableStartIdx = variableStack[variableStack.length - 1].startIdx
+            const variableEndIdx = startIdx
+            const variableFullPath = returnVal.substring(variableStartIdx, variableEndIdx)
+            inputVariables.push(variableFullPath)
+            variableStack.pop()
+        }
+        startIdx += 1
+    }
+    return inputVariables
+}

packages/components/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "lib": ["ES2020"],
+        "experimentalDecorators": true /* Enable experimental support for TC39 stage 2 draft decorators. */,
+        "emitDecoratorMetadata": true /* Emit design-type metadata for decorated declarations in source files. */,
+        "target": "ES2020", // or higher
+        "outDir": "./dist/",
+        "resolveJsonModule": true,
+        "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */,
+        "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+        "strict": true /* Enable all strict type-checking options. */,
+        "skipLibCheck": true /* Skip type checking all .d.ts files. */,
+        "sourceMap": true,
+        "strictPropertyInitialization": false,
+        "useUnknownInCatchVariables": false,
+        "declaration": true,
+        "module": "commonjs",
+        "moduleResolution": "node16"
+    },
+    "include": ["src", "nodes"]
+}