Upload 309 files

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+images/flowise.gif filter=lfs diff=lfs merge=lfs -text

CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+-   Using welcoming and inclusive language
+-   Being respectful of differing viewpoints and experiences
+-   Gracefully accepting constructive criticism
+-   Focusing on what is best for the community
+-   Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+-   The use of sexualized language or imagery and unwelcome sexual attention or
+    advances
+-   Trolling, insulting/derogatory comments, and personal or political attacks
+-   Public or private harassment
+-   Publishing others' private information, such as a physical or electronic
+    address, without explicit permission
+-   Other conduct which could reasonably be considered inappropriate in a
+    professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at hello@flowiseai.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,127 @@
+<!-- markdownlint-disable MD030 -->
+
+# Contributing to Flowise
+
+We appreciate any form of contributions.
+
+## ⭐ Star
+
+Star and share the [Github Repo](https://github.com/FlowiseAI/Flowise).
+
+## 🙋 Q&A
+
+Search up for any questions in [Q&A section](https://github.com/FlowiseAI/Flowise/discussions/categories/q-a), if you can't find one, don't hesitate to create one. It might helps others that have similar question.
+
+## 🙌 Share Chatflow
+
+Yes! Sharing how you use Flowise is a way of contribution. Export your chatflow as JSON, attach a screenshot and share it in [Show and Tell section](https://github.com/FlowiseAI/Flowise/discussions/categories/show-and-tell).
+
+## 💡 Ideas
+
+Ideas are welcome such as new feature, apps integration, and blockchain networks. Submit in [Ideas section](https://github.com/FlowiseAI/Flowise/discussions/categories/ideas).
+
+## 🐞 Report Bugs
+
+Found an issue? [Report it](https://github.com/FlowiseAI/Flowise/issues/new/choose).
+
+## 👨‍💻 Contribute to Code
+
+Not sure what to contribute? Some ideas:
+
+-   Create new components from Langchain
+-   Update existing components such as extending functionality, fixing bugs
+-   Add new chatflow ideas
+
+### Developers
+
+Flowise has 3 different modules in a single mono repository.
+
+-   `server`: Node backend to serve API logics
+-   `ui`: React frontend
+-   `components`: Langchain components
+
+#### Prerequisite
+
+-   Install Yarn
+    ```bash
+    npm i -g yarn
+    ```
+
+#### Step by step
+
+1. Fork the official [Flowise Github Repository](https://github.com/FlowiseAI/Flowise).
+
+2. Clone your forked repository.
+
+3. Create a new branch, see [guide](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-and-deleting-branches-within-your-repository). Naming conventions:
+
+    - For feature branch: `feature/<Your New Feature>`
+    - For bug fix branch: `bugfix/<Your New Bugfix>`.
+
+4. Switch to the newly created branch.
+
+5. Go into repository folder
+
+    ```bash
+    cd Flowise
+    ```
+
+6. Install all dependencies of all modules:
+
+    ```bash
+    yarn install
+    ```
+
+7. Build all the code:
+
+    ```bash
+    yarn build
+    ```
+
+8. Start the app on [http://localhost:3000](http://localhost:3000)
+
+    ```bash
+    yarn start
+    ```
+
+9. For development, run
+
+    ```bash
+    yarn dev
+    ```
+
+    Any changes made in `packages/ui` or `packages/server` will be reflected on [http://localhost:8080](http://localhost:8080)
+
+    For changes made in `packages/components`, run `yarn build` again to pickup the changes.
+
+10. After making all the changes, run
+
+    ```bash
+    yarn build
+    ```
+
+    and
+
+    ```bash
+    yarn start
+    ```
+
+    to make sure everything works fine in production.
+
+11. Commit code and submit Pull Request from forked branch pointing to [Flowise master](https://github.com/FlowiseAI/Flowise/tree/master).
+
+## 📖 Contribute to Docs
+
+In-Progress
+
+## 🏷️ Pull Request process
+
+A member of the FlowiseAI team will automatically be notified/assigned when you open a pull request. You can also reach out to us on [Discord](https://discord.gg/jbaHfsRVBW).
+
+## 📃 Contributor License Agreement
+
+Before we can merge your contribution you have to sign our [Contributor License Agreement (CLA)](https://cla-assistant.io/FlowiseAI/Flowise). The CLA contains the terms and conditions under which the contribution is submitted. You need to do this only once for your first pull request. Keep in mind that without a signed CLA we cannot merge your contribution.
+
+## 📜 Code of Conduct
+
+This project and everyone participating in it are governed by the Code of Conduct which can be found in the [file](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to hello@flowiseai.com.

LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2023 FlowiseAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -1,10 +1,120 @@
----
-title: Langflowise
-emoji: 🏆
-colorFrom: purple
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<!-- markdownlint-disable MD030 -->
+
+# Flowise - LangchainJS UI
+
+<a href="https://github.com/FlowiseAI/Flowise">
+<img width="100%" src="https://github.com/FlowiseAI/Flowise/blob/main/images/flowise.gif?raw=true"></a>
+
+Drag & drop UI to build your customized LLM flow using [LangchainJS](https://github.com/hwchase17/langchainjs)
+
+## ⚡Quick Start
+
+1. Install Flowise
+    ```bash
+    npm install -g flowise
+    ```
+2. Start Flowise
+
+    ```bash
+    npx flowise start
+    ```
+
+3. Open [http://localhost:3000](http://localhost:3000)
+
+## 🐳 Docker
+
+1. Go to `docker` folder at the root of the project
+2. Create `.env` file and specify the `PORT` (refer to `.env.example`)
+3. `docker-compose up -d`
+4. Open [http://localhost:3000](http://localhost:3000)
+5. You can bring the containers down by `docker-compose stop`
+
+## 👨‍💻 Developers
+
+Flowise has 3 different modules in a single mono repository.
+
+-   `server`: Node backend to serve API logics
+-   `ui`: React frontend
+-   `components`: Langchain components
+
+### Prerequisite
+
+-   Install Yarn
+    ```bash
+    npm i -g yarn
+    ```
+
+### Setup
+
+1. Clone the repository
+
+    ```bash
+    git clone https://github.com/FlowiseAI/Flowise.git
+    ```
+
+2. Go into repository folder
+
+    ```bash
+    cd Flowise
+    ```
+
+3. Install all dependencies of all modules:
+
+    ```bash
+    yarn install
+    ```
+
+4. Build all the code:
+
+    ```bash
+    yarn build
+    ```
+
+5. Start the app:
+
+    ```bash
+    yarn start
+    ```
+
+    You can now access the app on [http://localhost:3000](http://localhost:3000)
+
+6. For development build:
+
+    ```bash
+    yarn dev
+    ```
+
+    Any code changes will reload the app automatically on [http://localhost:8080](http://localhost:8080)
+
+## 🔒 Authentication
+
+To enable app level authentication, add `USERNAME` and `PASSWORD` to the `.env` file in `packages/server`:
+
+```
+USERNAME=user
+PASSWORD=1234
+```
+
+## 📖 Documentation
+
+Coming soon
+
+## 💻 Cloud Hosted
+
+Coming soon
+
+## 🌐 Self Host
+
+Coming soon
+
+## 🙋 Support
+
+Feel free to ask any questions, raise problems, and request new features in [discussion](https://github.com/FlowiseAI/Flowise/discussions)
+
+## 🙌 Contributing
+
+See [contributing guide](CONTRIBUTING.md). Reach out to us at [Discord](https://discord.gg/jbaHfsRVBW) if you have any questions or issues.
+
+## 📄 License
+
+Source code in this repository is made available under the [MIT License](LICENSE.md).

babel.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+    presets: [
+        '@babel/preset-typescript',
+        [
+            '@babel/preset-env',
+            {
+                targets: {
+                    node: 'current'
+                }
+            }
+        ]
+    ]
+}

docker/.env.example

@@ -0,0 +1 @@
+PORT=3000

docker/Dockerfile

@@ -0,0 +1,13 @@
+FROM node:18-alpine
+
+USER root
+
+RUN apk add --no-cache git
+RUN apk add --no-cache python3 py3-pip make g++
+
+# You can install a specific version like: flowise@1.0.0
+RUN npm install -g flowise
+
+WORKDIR /data
+
+CMD "flowise"

docker/docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3.1'
+
+services:
+    flowise:
+        image: flowiseai/flowise
+        restart: always
+        environment:
+            - PORT=${PORT}
+        ports:
+            - '${PORT}:${PORT}'
+        volumes:
+            - ~/.flowise:/root/.flowise
+        command: /bin/sh -c "sleep 3; flowise start"

package.json

@@ -0,0 +1,56 @@
+{
+    "name": "flowise",
+    "version": "1.2.6",
+    "private": true,
+    "homepage": "https://flowiseai.com",
+    "workspaces": [
+        "packages/*",
+        "flowise",
+        "ui",
+        "components"
+    ],
+    "scripts": {
+        "build": "turbo run build",
+        "build-force": "turbo run build --force",
+        "dev": "turbo run dev --parallel",
+        "start": "run-script-os",
+        "start:windows": "cd packages/server/bin && run start",
+        "start:default": "cd packages/server/bin && ./run start",
+        "clean": "npm exec -ws -- rimraf dist build",
+        "format": "prettier --write \"**/*.{ts,tsx,md}\"",
+        "test": "turbo run test",
+        "lint": "eslint \"**/*.{js,jsx,ts,tsx,json,md}\"",
+        "lint-fix": "yarn lint --fix",
+        "quick": "pretty-quick --staged",
+        "postinstall": "husky install"
+    },
+    "lint-staged": {
+        "*.{js,jsx,ts,tsx,json,md}": "eslint --fix"
+    },
+    "devDependencies": {
+        "turbo": "1.7.4",
+        "@babel/preset-env": "^7.19.4",
+        "@babel/preset-typescript": "7.18.6",
+        "@types/express": "^4.17.13",
+        "@typescript-eslint/typescript-estree": "^5.39.0",
+        "eslint": "^8.24.0",
+        "eslint-config-prettier": "^8.3.0",
+        "eslint-config-react-app": "^7.0.1",
+        "eslint-plugin-jsx-a11y": "^6.6.1",
+        "eslint-plugin-markdown": "^3.0.0",
+        "eslint-plugin-prettier": "^3.4.0",
+        "eslint-plugin-react": "^7.26.1",
+        "eslint-plugin-react-hooks": "^4.6.0",
+        "eslint-plugin-unused-imports": "^2.0.0",
+        "husky": "^8.0.1",
+        "lint-staged": "^13.0.3",
+        "prettier": "^2.7.1",
+        "pretty-quick": "^3.1.3",
+        "rimraf": "^3.0.2",
+        "run-script-os": "^1.1.6",
+        "typescript": "^4.8.4"
+    },
+    "engines": {
+        "node": ">=18.15.0"
+    }
+}

packages/components/.env.example

@@ -0,0 +1 @@
+DEBUG=true

packages/components/README.md

@@ -0,0 +1,25 @@
+<!-- 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
+```
+
+## Debug
+
+To view all the logs, create an `.env` file and add:
+
+```
+DEBUG=true
+```
+
+## 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/AutoGPT/AutoGPT.ts

@@ -0,0 +1,98 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { BaseChatModel } from 'langchain/chat_models/base'
+import { AutoGPT } from 'langchain/experimental/autogpt'
+import { Tool } from 'langchain/tools'
+import { VectorStoreRetriever } from 'langchain/vectorstores/base'
+
+class AutoGPT_Agents implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'AutoGPT'
+        this.name = 'autoGPT'
+        this.type = 'AutoGPT'
+        this.category = 'Agents'
+        this.icon = 'autogpt.png'
+        this.description = 'Autonomous agent with chain of thoughts for self-guided task completion'
+        this.baseClasses = ['AutoGPT']
+        this.inputs = [
+            {
+                label: 'Allowed Tools',
+                name: 'tools',
+                type: 'Tool',
+                list: true
+            },
+            {
+                label: 'Chat Model',
+                name: 'model',
+                type: 'BaseChatModel'
+            },
+            {
+                label: 'Vector Store Retriever',
+                name: 'vectorStoreRetriever',
+                type: 'BaseRetriever'
+            },
+            {
+                label: 'AutoGPT Name',
+                name: 'aiName',
+                type: 'string',
+                placeholder: 'Tom',
+                optional: true
+            },
+            {
+                label: 'AutoGPT Role',
+                name: 'aiRole',
+                type: 'string',
+                placeholder: 'Assistant',
+                optional: true
+            },
+            {
+                label: 'Maximum Loop',
+                name: 'maxLoop',
+                type: 'number',
+                default: 5,
+                optional: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseChatModel
+        const vectorStoreRetriever = nodeData.inputs?.vectorStoreRetriever as VectorStoreRetriever
+        let tools = nodeData.inputs?.tools as Tool[]
+        tools = tools.flat()
+        const aiName = (nodeData.inputs?.aiName as string) || 'AutoGPT'
+        const aiRole = (nodeData.inputs?.aiRole as string) || 'Assistant'
+        const maxLoop = nodeData.inputs?.maxLoop as string
+
+        const autogpt = AutoGPT.fromLLMAndTools(model, tools, {
+            memory: vectorStoreRetriever,
+            aiName,
+            aiRole
+        })
+
+        autogpt.maxIterations = parseInt(maxLoop, 10)
+
+        return autogpt
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const executor = nodeData.instance as AutoGPT
+        try {
+            const res = await executor.run([input])
+            return res || 'I have completed all my tasks.'
+        } catch (e) {
+            console.error(e)
+            throw new Error(e)
+        }
+    }
+}
+
+module.exports = { nodeClass: AutoGPT_Agents }

packages/components/nodes/agents/BabyAGI/BabyAGI.ts

@@ -0,0 +1,62 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { BabyAGI } from './core'
+import { BaseChatModel } from 'langchain/chat_models/base'
+import { VectorStore } from 'langchain/vectorstores'
+
+class BabyAGI_Agents implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'BabyAGI'
+        this.name = 'babyAGI'
+        this.type = 'BabyAGI'
+        this.category = 'Agents'
+        this.icon = 'babyagi.jpg'
+        this.description = 'Task Driven Autonomous Agent which creates new task and reprioritizes task list based on objective'
+        this.baseClasses = ['BabyAGI']
+        this.inputs = [
+            {
+                label: 'Chat Model',
+                name: 'model',
+                type: 'BaseChatModel'
+            },
+            {
+                label: 'Vector Store',
+                name: 'vectorStore',
+                type: 'VectorStore'
+            },
+            {
+                label: 'Task Loop',
+                name: 'taskLoop',
+                type: 'number',
+                default: 3
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseChatModel
+        const vectorStore = nodeData.inputs?.vectorStore as VectorStore
+        const taskLoop = nodeData.inputs?.taskLoop as string
+
+        const babyAgi = BabyAGI.fromLLM(model, vectorStore, parseInt(taskLoop, 10))
+        return babyAgi
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const executor = nodeData.instance as BabyAGI
+        const objective = input
+
+        const res = await executor.call({ objective })
+        return res
+    }
+}
+
+module.exports = { nodeClass: BabyAGI_Agents }

packages/components/nodes/agents/BabyAGI/core.ts

@@ -0,0 +1,266 @@
+import { LLMChain } from 'langchain/chains'
+import { BaseChatModel } from 'langchain/chat_models/base'
+import { VectorStore } from 'langchain/dist/vectorstores/base'
+import { Document } from 'langchain/document'
+import { PromptTemplate } from 'langchain/prompts'
+
+class TaskCreationChain extends LLMChain {
+    constructor(prompt: PromptTemplate, llm: BaseChatModel) {
+        super({ prompt, llm })
+    }
+
+    static from_llm(llm: BaseChatModel): LLMChain {
+        const taskCreationTemplate: string =
+            'You are a task creation AI that uses the result of an execution agent' +
+            ' to create new tasks with the following objective: {objective},' +
+            ' The last completed task has the result: {result}.' +
+            ' This result was based on this task description: {task_description}.' +
+            ' These are incomplete tasks list: {incomplete_tasks}.' +
+            ' Based on the result, create new tasks to be completed' +
+            ' by the AI system that do not overlap with incomplete tasks.' +
+            ' Return the tasks as an array.'
+
+        const prompt = new PromptTemplate({
+            template: taskCreationTemplate,
+            inputVariables: ['result', 'task_description', 'incomplete_tasks', 'objective']
+        })
+
+        return new TaskCreationChain(prompt, llm)
+    }
+}
+
+class TaskPrioritizationChain extends LLMChain {
+    constructor(prompt: PromptTemplate, llm: BaseChatModel) {
+        super({ prompt, llm })
+    }
+
+    static from_llm(llm: BaseChatModel): TaskPrioritizationChain {
+        const taskPrioritizationTemplate: string =
+            'You are a task prioritization AI tasked with cleaning the formatting of and reprioritizing' +
+            ' the following task list: {task_names}.' +
+            ' Consider the ultimate objective of your team: {objective}.' +
+            ' Do not remove any tasks. Return the result as a numbered list, like:' +
+            ' #. First task' +
+            ' #. Second task' +
+            ' Start the task list with number {next_task_id}.'
+        const prompt = new PromptTemplate({
+            template: taskPrioritizationTemplate,
+            inputVariables: ['task_names', 'next_task_id', 'objective']
+        })
+        return new TaskPrioritizationChain(prompt, llm)
+    }
+}
+
+class ExecutionChain extends LLMChain {
+    constructor(prompt: PromptTemplate, llm: BaseChatModel) {
+        super({ prompt, llm })
+    }
+
+    static from_llm(llm: BaseChatModel): LLMChain {
+        const executionTemplate: string =
+            'You are an AI who performs one task based on the following objective: {objective}.' +
+            ' Take into account these previously completed tasks: {context}.' +
+            ' Your task: {task}.' +
+            ' Response:'
+
+        const prompt = new PromptTemplate({
+            template: executionTemplate,
+            inputVariables: ['objective', 'context', 'task']
+        })
+
+        return new ExecutionChain(prompt, llm)
+    }
+}
+
+async function getNextTask(
+    taskCreationChain: LLMChain,
+    result: string,
+    taskDescription: string,
+    taskList: string[],
+    objective: string
+): Promise<any[]> {
+    const incompleteTasks: string = taskList.join(', ')
+    const response: string = await taskCreationChain.predict({
+        result,
+        task_description: taskDescription,
+        incomplete_tasks: incompleteTasks,
+        objective
+    })
+
+    const newTasks: string[] = response.split('\n')
+
+    return newTasks.filter((taskName) => taskName.trim()).map((taskName) => ({ task_name: taskName }))
+}
+
+interface Task {
+    task_id: number
+    task_name: string
+}
+
+async function prioritizeTasks(
+    taskPrioritizationChain: LLMChain,
+    thisTaskId: number,
+    taskList: Task[],
+    objective: string
+): Promise<Task[]> {
+    const next_task_id = thisTaskId + 1
+    const task_names = taskList.map((t) => t.task_name).join(', ')
+    const response = await taskPrioritizationChain.predict({ task_names, next_task_id, objective })
+    const newTasks = response.split('\n')
+    const prioritizedTaskList: Task[] = []
+
+    for (const taskString of newTasks) {
+        if (!taskString.trim()) {
+            // eslint-disable-next-line no-continue
+            continue
+        }
+        const taskParts = taskString.trim().split('. ', 2)
+        if (taskParts.length === 2) {
+            const task_id = parseInt(taskParts[0].trim(), 10)
+            const task_name = taskParts[1].trim()
+            prioritizedTaskList.push({ task_id, task_name })
+        }
+    }
+
+    return prioritizedTaskList
+}
+
+export async function get_top_tasks(vectorStore: VectorStore, query: string, k: number): Promise<string[]> {
+    const docs = await vectorStore.similaritySearch(query, k)
+    let returnDocs: string[] = []
+    for (const doc of docs) {
+        returnDocs.push(doc.metadata.task)
+    }
+    return returnDocs
+}
+
+async function executeTask(vectorStore: VectorStore, executionChain: LLMChain, objective: string, task: string, k = 5): Promise<string> {
+    const context = await get_top_tasks(vectorStore, objective, k)
+    return executionChain.predict({ objective, context, task })
+}
+
+export class BabyAGI {
+    taskList: Array<Task> = []
+
+    taskCreationChain: TaskCreationChain
+
+    taskPrioritizationChain: TaskPrioritizationChain
+
+    executionChain: ExecutionChain
+
+    taskIdCounter = 1
+
+    vectorStore: VectorStore
+
+    maxIterations = 3
+
+    constructor(
+        taskCreationChain: TaskCreationChain,
+        taskPrioritizationChain: TaskPrioritizationChain,
+        executionChain: ExecutionChain,
+        vectorStore: VectorStore,
+        maxIterations: number
+    ) {
+        this.taskCreationChain = taskCreationChain
+        this.taskPrioritizationChain = taskPrioritizationChain
+        this.executionChain = executionChain
+        this.vectorStore = vectorStore
+        this.maxIterations = maxIterations
+    }
+
+    addTask(task: Task) {
+        this.taskList.push(task)
+    }
+
+    printTaskList() {
+        // eslint-disable-next-line no-console
+        console.log('\x1b[95m\x1b[1m\n*****TASK LIST*****\n\x1b[0m\x1b[0m')
+        // eslint-disable-next-line no-console
+        this.taskList.forEach((t) => console.log(`${t.task_id}: ${t.task_name}`))
+    }
+
+    printNextTask(task: Task) {
+        // eslint-disable-next-line no-console
+        console.log('\x1b[92m\x1b[1m\n*****NEXT TASK*****\n\x1b[0m\x1b[0m')
+        // eslint-disable-next-line no-console
+        console.log(`${task.task_id}: ${task.task_name}`)
+    }
+
+    printTaskResult(result: string) {
+        // eslint-disable-next-line no-console
+        console.log('\x1b[93m\x1b[1m\n*****TASK RESULT*****\n\x1b[0m\x1b[0m')
+        // eslint-disable-next-line no-console
+        console.log(result)
+    }
+
+    getInputKeys(): string[] {
+        return ['objective']
+    }
+
+    getOutputKeys(): string[] {
+        return []
+    }
+
+    async call(inputs: Record<string, any>): Promise<string> {
+        const { objective } = inputs
+        const firstTask = inputs.first_task || 'Make a todo list'
+        this.addTask({ task_id: 1, task_name: firstTask })
+        let numIters = 0
+        let loop = true
+        let finalResult = ''
+
+        while (loop) {
+            if (this.taskList.length) {
+                this.printTaskList()
+
+                // Step 1: Pull the first task
+                const task = this.taskList.shift()
+                if (!task) break
+                this.printNextTask(task)
+
+                // Step 2: Execute the task
+                const result = await executeTask(this.vectorStore, this.executionChain, objective, task.task_name)
+                const thisTaskId = task.task_id
+                finalResult = result
+                this.printTaskResult(result)
+
+                // Step 3: Store the result in Pinecone
+                const docs = new Document({ pageContent: result, metadata: { task: task.task_name } })
+                this.vectorStore.addDocuments([docs])
+
+                // Step 4: Create new tasks and reprioritize task list
+                const newTasks = await getNextTask(
+                    this.taskCreationChain,
+                    result,
+                    task.task_name,
+                    this.taskList.map((t) => t.task_name),
+                    objective
+                )
+                newTasks.forEach((newTask) => {
+                    this.taskIdCounter += 1
+                    // eslint-disable-next-line no-param-reassign
+                    newTask.task_id = this.taskIdCounter
+                    this.addTask(newTask)
+                })
+                this.taskList = await prioritizeTasks(this.taskPrioritizationChain, thisTaskId, this.taskList, objective)
+            }
+
+            numIters += 1
+            if (this.maxIterations !== null && numIters === this.maxIterations) {
+                // eslint-disable-next-line no-console
+                console.log('\x1b[91m\x1b[1m\n*****TASK ENDING*****\n\x1b[0m\x1b[0m')
+                loop = false
+                this.taskList = []
+            }
+        }
+
+        return finalResult
+    }
+
+    static fromLLM(llm: BaseChatModel, vectorstore: VectorStore, maxIterations = 3): BabyAGI {
+        const taskCreationChain = TaskCreationChain.from_llm(llm)
+        const taskPrioritizationChain = TaskPrioritizationChain.from_llm(llm)
+        const executionChain = ExecutionChain.from_llm(llm)
+        return new BabyAGI(taskCreationChain, taskPrioritizationChain, executionChain, vectorstore, maxIterations)
+    }
+}

packages/components/nodes/agents/ConversationalAgent/ConversationalAgent.ts

@@ -0,0 +1,115 @@
+import { ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { initializeAgentExecutorWithOptions, AgentExecutor, InitializeAgentExecutorOptions } from 'langchain/agents'
+import { Tool } from 'langchain/tools'
+import { BaseChatMemory, ChatMessageHistory } from 'langchain/memory'
+import { getBaseClasses } from '../../../src/utils'
+import { AIChatMessage, HumanChatMessage } from 'langchain/schema'
+import { BaseLanguageModel } from 'langchain/base_language'
+
+class ConversationalAgent_Agents implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Conversational Agent'
+        this.name = 'conversationalAgent'
+        this.type = 'AgentExecutor'
+        this.category = 'Agents'
+        this.icon = 'agent.svg'
+        this.description = 'Conversational agent for a chat model. It will utilize chat specific prompts'
+        this.baseClasses = [this.type, ...getBaseClasses(AgentExecutor)]
+        this.inputs = [
+            {
+                label: 'Allowed Tools',
+                name: 'tools',
+                type: 'Tool',
+                list: true
+            },
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Memory',
+                name: 'memory',
+                type: 'BaseChatMemory'
+            },
+            {
+                label: 'System Message',
+                name: 'systemMessage',
+                type: 'string',
+                rows: 4,
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Human Message',
+                name: 'humanMessage',
+                type: 'string',
+                rows: 4,
+                optional: true,
+                additionalParams: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        let tools = nodeData.inputs?.tools as Tool[]
+        tools = tools.flat()
+        const memory = nodeData.inputs?.memory as BaseChatMemory
+        const humanMessage = nodeData.inputs?.humanMessage as string
+        const systemMessage = nodeData.inputs?.systemMessage as string
+
+        const obj: InitializeAgentExecutorOptions = {
+            agentType: 'chat-conversational-react-description',
+            verbose: process.env.DEBUG === 'true' ? true : false
+        }
+
+        const agentArgs: any = {}
+        if (humanMessage) {
+            agentArgs.humanMessage = humanMessage
+        }
+        if (systemMessage) {
+            agentArgs.systemMessage = systemMessage
+        }
+
+        if (Object.keys(agentArgs).length) obj.agentArgs = agentArgs
+
+        const executor = await initializeAgentExecutorWithOptions(tools, model, obj)
+        executor.memory = memory
+        return executor
+    }
+
+    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
+        const executor = nodeData.instance as AgentExecutor
+        const memory = nodeData.inputs?.memory as BaseChatMemory
+
+        if (options && options.chatHistory) {
+            const chatHistory = []
+            const histories: IMessage[] = options.chatHistory
+
+            for (const message of histories) {
+                if (message.type === 'apiMessage') {
+                    chatHistory.push(new AIChatMessage(message.message))
+                } else if (message.type === 'userMessage') {
+                    chatHistory.push(new HumanChatMessage(message.message))
+                }
+            }
+            memory.chatHistory = new ChatMessageHistory(chatHistory)
+            executor.memory = memory
+        }
+        const result = await executor.call({ input })
+
+        return result?.output
+    }
+}
+
+module.exports = { nodeClass: ConversationalAgent_Agents }

packages/components/nodes/agents/MRKLAgentChat/MRKLAgentChat.ts

@@ -0,0 +1,59 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { initializeAgentExecutorWithOptions, AgentExecutor } from 'langchain/agents'
+import { getBaseClasses } from '../../../src/utils'
+import { Tool } from 'langchain/tools'
+import { BaseLanguageModel } from 'langchain/base_language'
+
+class MRKLAgentChat_Agents implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'MRKL Agent for Chat Models'
+        this.name = 'mrklAgentChat'
+        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 Chat Models'
+        this.baseClasses = [this.type, ...getBaseClasses(AgentExecutor)]
+        this.inputs = [
+            {
+                label: 'Allowed Tools',
+                name: 'tools',
+                type: 'Tool',
+                list: true
+            },
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        let tools = nodeData.inputs?.tools as Tool[]
+        tools = tools.flat()
+        const executor = await initializeAgentExecutorWithOptions(tools, model, {
+            agentType: 'chat-zero-shot-react-description',
+            verbose: process.env.DEBUG === 'true' ? true : false
+        })
+        return executor
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const executor = nodeData.instance as AgentExecutor
+        const result = await executor.call({ input })
+
+        return result?.output
+    }
+}
+
+module.exports = { nodeClass: MRKLAgentChat_Agents }

packages/components/nodes/agents/MRKLAgentLLM/MRKLAgentLLM.ts

@@ -0,0 +1,60 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { initializeAgentExecutorWithOptions, AgentExecutor } from 'langchain/agents'
+import { Tool } from 'langchain/tools'
+import { getBaseClasses } from '../../../src/utils'
+import { BaseLanguageModel } from 'langchain/base_language'
+
+class MRKLAgentLLM_Agents implements INode {
+    label: string
+    name: string
+    description: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'MRKL Agent for LLMs'
+        this.name = 'mrklAgentLLM'
+        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.baseClasses = [this.type, ...getBaseClasses(AgentExecutor)]
+        this.inputs = [
+            {
+                label: 'Allowed Tools',
+                name: 'tools',
+                type: 'Tool',
+                list: true
+            },
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        let tools = nodeData.inputs?.tools as Tool[]
+        tools = tools.flat()
+
+        const executor = await initializeAgentExecutorWithOptions(tools, model, {
+            agentType: 'zero-shot-react-description',
+            verbose: process.env.DEBUG === 'true' ? true : false
+        })
+        return executor
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const executor = nodeData.instance as AgentExecutor
+        const result = await executor.call({ input })
+
+        return result?.output
+    }
+}
+
+module.exports = { nodeClass: MRKLAgentLLM_Agents }

packages/components/nodes/chains/ConversationChain/ConversationChain.ts

@@ -0,0 +1,97 @@
+import { ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { ConversationChain } from 'langchain/chains'
+import { getBaseClasses } from '../../../src/utils'
+import { ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate } from 'langchain/prompts'
+import { BufferMemory, ChatMessageHistory } from 'langchain/memory'
+import { BaseChatModel } from 'langchain/chat_models/base'
+import { AIChatMessage, HumanChatMessage } from 'langchain/schema'
+
+const systemMessage = `The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.`
+
+class ConversationChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Conversation Chain'
+        this.name = 'conversationChain'
+        this.type = 'ConversationChain'
+        this.icon = 'chain.svg'
+        this.category = 'Chains'
+        this.description = 'Chat models specific conversational chain with memory'
+        this.baseClasses = [this.type, ...getBaseClasses(ConversationChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseChatModel'
+            },
+            {
+                label: 'Memory',
+                name: 'memory',
+                type: 'BaseMemory'
+            },
+            {
+                label: 'System Message',
+                name: 'systemMessagePrompt',
+                type: 'string',
+                rows: 4,
+                additionalParams: true,
+                optional: true,
+                placeholder: 'You are a helpful assistant that write codes'
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseChatModel
+        const memory = nodeData.inputs?.memory as BufferMemory
+        const prompt = nodeData.inputs?.systemMessagePrompt as string
+
+        const obj: any = {
+            llm: model,
+            memory
+        }
+
+        const chatPrompt = ChatPromptTemplate.fromPromptMessages([
+            SystemMessagePromptTemplate.fromTemplate(prompt ? `${prompt}\n${systemMessage}` : systemMessage),
+            new MessagesPlaceholder(memory.memoryKey ?? 'chat_history'),
+            HumanMessagePromptTemplate.fromTemplate('{input}')
+        ])
+        obj.prompt = chatPrompt
+
+        const chain = new ConversationChain(obj)
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
+        const chain = nodeData.instance as ConversationChain
+        const memory = nodeData.inputs?.memory as BufferMemory
+
+        if (options && options.chatHistory) {
+            const chatHistory = []
+            const histories: IMessage[] = options.chatHistory
+
+            for (const message of histories) {
+                if (message.type === 'apiMessage') {
+                    chatHistory.push(new AIChatMessage(message.message))
+                } else if (message.type === 'userMessage') {
+                    chatHistory.push(new HumanChatMessage(message.message))
+                }
+            }
+            memory.chatHistory = new ChatMessageHistory(chatHistory)
+            chain.memory = memory
+        }
+
+        const res = await chain.call({ input })
+        return res?.response
+    }
+}
+
+module.exports = { nodeClass: ConversationChain_Chains }

packages/components/nodes/chains/ConversationalRetrievalQAChain/ConversationalRetrievalQAChain.ts

@@ -0,0 +1,99 @@
+import { BaseLanguageModel } from 'langchain/base_language'
+import { ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+import { ConversationalRetrievalQAChain } from 'langchain/chains'
+import { BaseRetriever } from 'langchain/schema'
+
+const default_qa_template = `Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
+
+{context}
+
+Question: {question}
+Helpful Answer:`
+
+const qa_template = `Use the following pieces of context to answer the question at the end.
+
+{context}
+
+Question: {question}
+Helpful Answer:`
+
+class ConversationalRetrievalQAChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Conversational Retrieval QA Chain'
+        this.name = 'conversationalRetrievalQAChain'
+        this.type = 'ConversationalRetrievalQAChain'
+        this.icon = 'chain.svg'
+        this.category = 'Chains'
+        this.description = 'Document QA - built on RetrievalQAChain to provide a chat history component'
+        this.baseClasses = [this.type, ...getBaseClasses(ConversationalRetrievalQAChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Vector Store Retriever',
+                name: 'vectorStoreRetriever',
+                type: 'BaseRetriever'
+            },
+            {
+                label: 'System Message',
+                name: 'systemMessagePrompt',
+                type: 'string',
+                rows: 4,
+                additionalParams: true,
+                optional: true,
+                placeholder:
+                    'I want you to act as a document that I am having a conversation with. Your name is "AI Assistant". You will provide me with answers from the given info. If the answer is not included, say exactly "Hmm, I am not sure." and stop after that. Refuse to answer any question not about the info. Never break character.'
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const vectorStoreRetriever = nodeData.inputs?.vectorStoreRetriever as BaseRetriever
+        const systemMessagePrompt = nodeData.inputs?.systemMessagePrompt as string
+
+        const chain = ConversationalRetrievalQAChain.fromLLM(model, vectorStoreRetriever, {
+            verbose: process.env.DEBUG === 'true' ? true : false,
+            qaTemplate: systemMessagePrompt ? `${systemMessagePrompt}\n${qa_template}` : default_qa_template
+        })
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
+        const chain = nodeData.instance as ConversationalRetrievalQAChain
+        let chatHistory = ''
+
+        if (options && options.chatHistory) {
+            const histories: IMessage[] = options.chatHistory
+            chatHistory = histories
+                .map((item) => {
+                    return item.message
+                })
+                .join('')
+        }
+
+        const obj = {
+            question: input,
+            chat_history: chatHistory ? chatHistory : []
+        }
+
+        const res = await chain.call(obj)
+
+        return res?.text
+    }
+}
+
+module.exports = { nodeClass: ConversationalRetrievalQAChain_Chains }

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

@@ -0,0 +1,133 @@
+import { ICommonObject, INode, INodeData, INodeOutputsValue, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+import { LLMChain } from 'langchain/chains'
+import { BaseLanguageModel } from 'langchain/base_language'
+
+class LLMChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+    outputs: INodeOutputsValue[]
+
+    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.baseClasses = [this.type, ...getBaseClasses(LLMChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Prompt',
+                name: 'prompt',
+                type: 'BasePromptTemplate'
+            },
+            {
+                label: 'Chain Name',
+                name: 'chainName',
+                type: 'string',
+                placeholder: 'Name Your Chain',
+                optional: true
+            }
+        ]
+        this.outputs = [
+            {
+                label: 'LLM Chain',
+                name: 'llmChain',
+                baseClasses: [this.type, ...getBaseClasses(LLMChain)]
+            },
+            {
+                label: 'Output Prediction',
+                name: 'outputPrediction',
+                baseClasses: ['string']
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData, input: string): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const prompt = nodeData.inputs?.prompt
+        const output = nodeData.outputs?.output as string
+        const promptValues = prompt.promptValues as ICommonObject
+
+        if (output === this.name) {
+            const chain = new LLMChain({ llm: model, prompt, verbose: process.env.DEBUG === 'true' ? true : false })
+            return chain
+        } else if (output === 'outputPrediction') {
+            const chain = new LLMChain({ llm: model, prompt, verbose: process.env.DEBUG === 'true' ? true : false })
+            const inputVariables = chain.prompt.inputVariables as string[] // ["product"]
+            const res = await runPrediction(inputVariables, chain, input, promptValues)
+            // eslint-disable-next-line no-console
+            console.log('\x1b[92m\x1b[1m\n*****OUTPUT PREDICTION*****\n\x1b[0m\x1b[0m')
+            // eslint-disable-next-line no-console
+            console.log(res)
+            return res
+        }
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const inputVariables = nodeData.instance.prompt.inputVariables as string[] // ["product"]
+        const chain = nodeData.instance as LLMChain
+        const promptValues = nodeData.inputs?.prompt.promptValues as ICommonObject
+
+        const res = await runPrediction(inputVariables, chain, input, promptValues)
+        // eslint-disable-next-line no-console
+        console.log('\x1b[93m\x1b[1m\n*****FINAL RESULT*****\n\x1b[0m\x1b[0m')
+        // eslint-disable-next-line no-console
+        console.log(res)
+        return res
+    }
+}
+
+const runPrediction = async (inputVariables: string[], chain: LLMChain, input: string, promptValues: ICommonObject) => {
+    if (inputVariables.length === 1) {
+        const res = await chain.run(input)
+        return res
+    } else if (inputVariables.length > 1) {
+        let seen: string[] = []
+
+        for (const variable of inputVariables) {
+            seen.push(variable)
+            if (promptValues[variable]) {
+                seen.pop()
+            }
+        }
+
+        if (seen.length === 0) {
+            // All inputVariables have fixed values specified
+            const options = {
+                ...promptValues
+            }
+            const res = await chain.call(options)
+            return res?.text
+        } else if (seen.length === 1) {
+            // If one inputVariable is not specify, use input (user's question) as value
+            const lastValue = seen.pop()
+            if (!lastValue) throw new Error('Please provide Prompt Values')
+            const options = {
+                ...promptValues,
+                [lastValue]: input
+            }
+            const res = await chain.call(options)
+            return res?.text
+        } else {
+            throw new Error(`Please provide Prompt Values for: ${seen.join(', ')}`)
+        }
+    } else {
+        const res = await chain.run(input)
+        return res
+    }
+}
+
+module.exports = { nodeClass: LLMChain_Chains }

packages/components/nodes/chains/RetrievalQAChain/RetrievalQAChain.ts

@@ -0,0 +1,57 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { RetrievalQAChain } from 'langchain/chains'
+import { BaseRetriever } from 'langchain/schema'
+import { getBaseClasses } from '../../../src/utils'
+import { BaseLanguageModel } from 'langchain/base_language'
+
+class RetrievalQAChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Retrieval QA Chain'
+        this.name = 'retrievalQAChain'
+        this.type = 'RetrievalQAChain'
+        this.icon = 'chain.svg'
+        this.category = 'Chains'
+        this.description = 'QA chain to answer a question based on the retrieved documents'
+        this.baseClasses = [this.type, ...getBaseClasses(RetrievalQAChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Vector Store Retriever',
+                name: 'vectorStoreRetriever',
+                type: 'BaseRetriever'
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const vectorStoreRetriever = nodeData.inputs?.vectorStoreRetriever as BaseRetriever
+
+        const chain = RetrievalQAChain.fromLLM(model, vectorStoreRetriever, { verbose: process.env.DEBUG === 'true' ? true : false })
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const chain = nodeData.instance as RetrievalQAChain
+        const obj = {
+            query: input
+        }
+        const res = await chain.call(obj)
+        return res?.text
+    }
+}
+
+module.exports = { nodeClass: RetrievalQAChain_Chains }

packages/components/nodes/chains/SqlDatabaseChain/SqlDatabaseChain.ts

@@ -0,0 +1,93 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { SqlDatabaseChain, SqlDatabaseChainInput } from 'langchain/chains'
+import { getBaseClasses } from '../../../src/utils'
+import { DataSource } from 'typeorm'
+import { SqlDatabase } from 'langchain/sql_db'
+import { BaseLanguageModel } from 'langchain/base_language'
+
+class SqlDatabaseChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Sql Database Chain'
+        this.name = 'sqlDatabaseChain'
+        this.type = 'SqlDatabaseChain'
+        this.icon = 'sqlchain.svg'
+        this.category = 'Chains'
+        this.description = 'Answer questions over a SQL database'
+        this.baseClasses = [this.type, ...getBaseClasses(SqlDatabaseChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Database',
+                name: 'database',
+                type: 'options',
+                options: [
+                    {
+                        label: 'SQlite',
+                        name: 'sqlite'
+                    }
+                ],
+                default: 'sqlite'
+            },
+            {
+                label: 'Database File Path',
+                name: 'dbFilePath',
+                type: 'string',
+                placeholder: 'C:/Users/chinook.db'
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const databaseType = nodeData.inputs?.database as 'sqlite'
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const dbFilePath = nodeData.inputs?.dbFilePath
+
+        const chain = await getSQLDBChain(databaseType, dbFilePath, model)
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const databaseType = nodeData.inputs?.database as 'sqlite'
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const dbFilePath = nodeData.inputs?.dbFilePath
+
+        const chain = await getSQLDBChain(databaseType, dbFilePath, model)
+        const res = await chain.run(input)
+        return res
+    }
+}
+
+const getSQLDBChain = async (databaseType: 'sqlite', dbFilePath: string, llm: BaseLanguageModel) => {
+    const datasource = new DataSource({
+        type: databaseType,
+        database: dbFilePath
+    })
+
+    const db = await SqlDatabase.fromDataSourceParams({
+        appDataSource: datasource
+    })
+
+    const obj: SqlDatabaseChainInput = {
+        llm,
+        database: db,
+        verbose: process.env.DEBUG === 'true' ? true : false
+    }
+
+    const chain = new SqlDatabaseChain(obj)
+    return chain
+}
+
+module.exports = { nodeClass: SqlDatabaseChain_Chains }

packages/components/nodes/chains/VectorDBQAChain/VectorDBQAChain.ts

@@ -0,0 +1,57 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+import { VectorDBQAChain } from 'langchain/chains'
+import { BaseLanguageModel } from 'langchain/base_language'
+import { VectorStore } from 'langchain/vectorstores'
+
+class VectorDBQAChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'VectorDB QA Chain'
+        this.name = 'vectorDBQAChain'
+        this.type = 'VectorDBQAChain'
+        this.icon = 'chain.svg'
+        this.category = 'Chains'
+        this.description = 'QA chain for vector databases'
+        this.baseClasses = [this.type, ...getBaseClasses(VectorDBQAChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Vector Store',
+                name: 'vectorStore',
+                type: 'VectorStore'
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const vectorStore = nodeData.inputs?.vectorStore as VectorStore
+
+        const chain = VectorDBQAChain.fromLLM(model, vectorStore, { verbose: process.env.DEBUG === 'true' ? true : false })
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string): Promise<string> {
+        const chain = nodeData.instance as VectorDBQAChain
+        const obj = {
+            query: input
+        }
+        const res = await chain.call(obj)
+        return res?.text
+    }
+}
+
+module.exports = { nodeClass: VectorDBQAChain_Chains }

packages/components/nodes/chatmodels/AzureChatOpenAI/AzureChatOpenAI.ts

@@ -0,0 +1,144 @@
+import { OpenAIBaseInput } from 'langchain/dist/types/openai-types'
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+import { AzureOpenAIInput, ChatOpenAI } from 'langchain/chat_models/openai'
+
+class AzureChatOpenAI_ChatModels implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    description: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Azure ChatOpenAI'
+        this.name = 'azureChatOpenAI'
+        this.type = 'AzureChatOpenAI'
+        this.icon = 'Azure.svg'
+        this.category = 'Chat Models'
+        this.description = 'Wrapper around Azure OpenAI large language models that use the Chat endpoint'
+        this.baseClasses = [this.type, ...getBaseClasses(ChatOpenAI)]
+        this.inputs = [
+            {
+                label: 'Azure OpenAI Api Key',
+                name: 'azureOpenAIApiKey',
+                type: 'password'
+            },
+            {
+                label: 'Model Name',
+                name: 'modelName',
+                type: 'options',
+                options: [
+                    {
+                        label: 'gpt-4',
+                        name: 'gpt-4'
+                    },
+                    {
+                        label: 'gpt-4-32k',
+                        name: 'gpt-4-32k'
+                    },
+                    {
+                        label: 'gpt-35-turbo',
+                        name: 'gpt-35-turbo'
+                    }
+                ],
+                default: 'gpt-35-turbo',
+                optional: true
+            },
+            {
+                label: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                default: 0.9,
+                optional: true
+            },
+            {
+                label: 'Azure OpenAI Api Instance Name',
+                name: 'azureOpenAIApiInstanceName',
+                type: 'string',
+                placeholder: 'YOUR-INSTANCE-NAME'
+            },
+            {
+                label: 'Azure OpenAI Api Deployment Name',
+                name: 'azureOpenAIApiDeploymentName',
+                type: 'string',
+                placeholder: 'YOUR-DEPLOYMENT-NAME'
+            },
+            {
+                label: 'Azure OpenAI Api Version',
+                name: 'azureOpenAIApiVersion',
+                type: 'options',
+                options: [
+                    {
+                        label: '2023-03-15-preview',
+                        name: '2023-03-15-preview'
+                    }
+                ],
+                default: '2023-03-15-preview'
+            },
+            {
+                label: 'Max Tokens',
+                name: 'maxTokens',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Frequency Penalty',
+                name: 'frequencyPenalty',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Presence Penalty',
+                name: 'presencePenalty',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Timeout',
+                name: 'timeout',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const azureOpenAIApiKey = nodeData.inputs?.azureOpenAIApiKey as string
+        const modelName = nodeData.inputs?.modelName as string
+        const temperature = nodeData.inputs?.temperature as string
+        const azureOpenAIApiInstanceName = nodeData.inputs?.azureOpenAIApiInstanceName as string
+        const azureOpenAIApiDeploymentName = nodeData.inputs?.azureOpenAIApiDeploymentName as string
+        const azureOpenAIApiVersion = nodeData.inputs?.azureOpenAIApiVersion as string
+        const maxTokens = nodeData.inputs?.maxTokens as string
+        const frequencyPenalty = nodeData.inputs?.frequencyPenalty as string
+        const presencePenalty = nodeData.inputs?.presencePenalty as string
+        const timeout = nodeData.inputs?.timeout as string
+
+        const obj: Partial<AzureOpenAIInput> & Partial<OpenAIBaseInput> = {
+            temperature: parseInt(temperature, 10),
+            modelName,
+            azureOpenAIApiKey,
+            azureOpenAIApiInstanceName,
+            azureOpenAIApiDeploymentName,
+            azureOpenAIApiVersion
+        }
+
+        if (maxTokens) obj.maxTokens = parseInt(maxTokens, 10)
+        if (frequencyPenalty) obj.frequencyPenalty = parseInt(frequencyPenalty, 10)
+        if (presencePenalty) obj.presencePenalty = parseInt(presencePenalty, 10)
+        if (timeout) obj.timeout = parseInt(timeout, 10)
+
+        const model = new ChatOpenAI(obj)
+        return model
+    }
+}
+
+module.exports = { nodeClass: AzureChatOpenAI_ChatModels }

packages/components/nodes/chatmodels/ChatAnthropic/ChatAnthropic.ts

@@ -0,0 +1,136 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+import { AnthropicInput, ChatAnthropic } from 'langchain/chat_models/anthropic'
+
+class ChatAnthropic_ChatModels implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    description: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'ChatAnthropic'
+        this.name = 'chatAnthropic'
+        this.type = 'ChatAnthropic'
+        this.icon = 'chatAnthropic.png'
+        this.category = 'Chat Models'
+        this.description = 'Wrapper around ChatAnthropic large language models that use the Chat endpoint'
+        this.baseClasses = [this.type, ...getBaseClasses(ChatAnthropic)]
+        this.inputs = [
+            {
+                label: 'ChatAnthropic Api Key',
+                name: 'anthropicApiKey',
+                type: 'password'
+            },
+            {
+                label: 'Model Name',
+                name: 'modelName',
+                type: 'options',
+                options: [
+                    {
+                        label: 'claude-v1',
+                        name: 'claude-v1'
+                    },
+                    {
+                        label: 'claude-v1-100k',
+                        name: 'claude-v1-100k'
+                    },
+                    {
+                        label: 'claude-v1.0',
+                        name: 'claude-v1.0'
+                    },
+                    {
+                        label: 'claude-v1.2',
+                        name: 'claude-v1.2'
+                    },
+                    {
+                        label: 'claude-v1.3',
+                        name: 'claude-v1.3'
+                    },
+                    {
+                        label: 'claude-v1.3-100k',
+                        name: 'claude-v1.3-100k'
+                    },
+                    {
+                        label: 'claude-instant-v1',
+                        name: 'claude-instant-v1'
+                    },
+                    {
+                        label: 'claude-instant-v1-100k',
+                        name: 'claude-instant-v1-100k'
+                    },
+                    {
+                        label: 'claude-instant-v1.0',
+                        name: 'claude-instant-v1.0'
+                    },
+                    {
+                        label: 'claude-instant-v1.1',
+                        name: 'claude-instant-v1.1'
+                    },
+                    {
+                        label: 'claude-instant-v1.1-100k',
+                        name: 'claude-instant-v1.1-100k'
+                    }
+                ],
+                default: 'claude-v1',
+                optional: true
+            },
+            {
+                label: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                default: 0.9,
+                optional: true
+            },
+            {
+                label: 'Max Tokens',
+                name: 'maxTokensToSample',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Top P',
+                name: 'topP',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Top K',
+                name: 'topK',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const temperature = nodeData.inputs?.temperature as string
+        const modelName = nodeData.inputs?.modelName as string
+        const anthropicApiKey = nodeData.inputs?.anthropicApiKey as string
+        const maxTokensToSample = nodeData.inputs?.maxTokensToSample as string
+        const topP = nodeData.inputs?.topP as string
+        const topK = nodeData.inputs?.topK as string
+
+        const obj: Partial<AnthropicInput> & { anthropicApiKey?: string } = {
+            temperature: parseInt(temperature, 10),
+            modelName,
+            anthropicApiKey
+        }
+
+        if (maxTokensToSample) obj.maxTokensToSample = parseInt(maxTokensToSample, 10)
+        if (topP) obj.topP = parseInt(topP, 10)
+        if (topK) obj.topK = parseInt(topK, 10)
+
+        const model = new ChatAnthropic(obj)
+        return model
+    }
+}
+
+module.exports = { nodeClass: ChatAnthropic_ChatModels }

packages/components/nodes/chatmodels/ChatLocalAI/ChatLocalAI.ts

@@ -0,0 +1,92 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+import { OpenAIChat } from 'langchain/llms/openai'
+import { OpenAIChatInput } from 'langchain/chat_models/openai'
+
+class ChatLocalAI_ChatModels implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    description: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'ChatLocalAI'
+        this.name = 'chatLocalAI'
+        this.type = 'ChatLocalAI'
+        this.icon = 'localai.png'
+        this.category = 'Chat Models'
+        this.description = 'Use local LLMs like llama.cpp, gpt4all using LocalAI'
+        this.baseClasses = [this.type, 'BaseChatModel', ...getBaseClasses(OpenAIChat)]
+        this.inputs = [
+            {
+                label: 'Base Path',
+                name: 'basePath',
+                type: 'string',
+                placeholder: 'http://localhost:8080/v1'
+            },
+            {
+                label: 'Model Name',
+                name: 'modelName',
+                type: 'string',
+                placeholder: 'gpt4all-lora-quantized.bin'
+            },
+            {
+                label: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                default: 0.9,
+                optional: true
+            },
+            {
+                label: 'Max Tokens',
+                name: 'maxTokens',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Top Probability',
+                name: 'topP',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Timeout',
+                name: 'timeout',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const temperature = nodeData.inputs?.temperature as string
+        const modelName = nodeData.inputs?.modelName as string
+        const maxTokens = nodeData.inputs?.maxTokens as string
+        const topP = nodeData.inputs?.topP as string
+        const timeout = nodeData.inputs?.timeout as string
+        const basePath = nodeData.inputs?.basePath as string
+
+        const obj: Partial<OpenAIChatInput> & { openAIApiKey?: string } = {
+            temperature: parseInt(temperature, 10),
+            modelName,
+            openAIApiKey: 'sk-'
+        }
+
+        if (maxTokens) obj.maxTokens = parseInt(maxTokens, 10)
+        if (topP) obj.topP = parseInt(topP, 10)
+        if (timeout) obj.timeout = parseInt(timeout, 10)
+
+        const model = new OpenAIChat(obj, { basePath })
+
+        return model
+    }
+}
+
+module.exports = { nodeClass: ChatLocalAI_ChatModels }

packages/components/nodes/chatmodels/ChatOpenAI/ChatOpenAI.ts

@@ -0,0 +1,130 @@
+import { INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
+import { ChatOpenAI, OpenAIChatInput } from 'langchain/chat_models/openai'
+
+class ChatOpenAI_ChatModels implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    description: string
+    baseClasses: string[]
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'ChatOpenAI'
+        this.name = 'chatOpenAI'
+        this.type = 'ChatOpenAI'
+        this.icon = 'openai.png'
+        this.category = 'Chat Models'
+        this.description = 'Wrapper around OpenAI large language models that use the Chat endpoint'
+        this.baseClasses = [this.type, ...getBaseClasses(ChatOpenAI)]
+        this.inputs = [
+            {
+                label: 'OpenAI Api Key',
+                name: 'openAIApiKey',
+                type: 'password'
+            },
+            {
+                label: 'Model Name',
+                name: 'modelName',
+                type: 'options',
+                options: [
+                    {
+                        label: 'gpt-4',
+                        name: 'gpt-4'
+                    },
+                    {
+                        label: 'gpt-4-0314',
+                        name: 'gpt-4-0314'
+                    },
+                    {
+                        label: 'gpt-4-32k-0314',
+                        name: 'gpt-4-32k-0314'
+                    },
+                    {
+                        label: 'gpt-3.5-turbo',
+                        name: 'gpt-3.5-turbo'
+                    },
+                    {
+                        label: 'gpt-3.5-turbo-0301',
+                        name: 'gpt-3.5-turbo-0301'
+                    }
+                ],
+                default: 'gpt-3.5-turbo',
+                optional: true
+            },
+            {
+                label: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                default: 0.9,
+                optional: true
+            },
+            {
+                label: 'Max Tokens',
+                name: 'maxTokens',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Top Probability',
+                name: 'topP',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Frequency Penalty',
+                name: 'frequencyPenalty',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Presence Penalty',
+                name: 'presencePenalty',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            },
+            {
+                label: 'Timeout',
+                name: 'timeout',
+                type: 'number',
+                optional: true,
+                additionalParams: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const temperature = nodeData.inputs?.temperature as string
+        const modelName = nodeData.inputs?.modelName as string
+        const openAIApiKey = nodeData.inputs?.openAIApiKey as string
+        const maxTokens = nodeData.inputs?.maxTokens as string
+        const topP = nodeData.inputs?.topP as string
+        const frequencyPenalty = nodeData.inputs?.frequencyPenalty as string
+        const presencePenalty = nodeData.inputs?.presencePenalty as string
+        const timeout = nodeData.inputs?.timeout as string
+
+        const obj: Partial<OpenAIChatInput> & { openAIApiKey?: string } = {
+            temperature: parseInt(temperature, 10),
+            modelName,
+            openAIApiKey
+        }
+
+        if (maxTokens) obj.maxTokens = parseInt(maxTokens, 10)
+        if (topP) obj.topP = parseInt(topP, 10)
+        if (frequencyPenalty) obj.frequencyPenalty = parseInt(frequencyPenalty, 10)
+        if (presencePenalty) obj.presencePenalty = parseInt(presencePenalty, 10)
+        if (timeout) obj.timeout = parseInt(timeout, 10)
+
+        const model = new ChatOpenAI(obj)
+        return model
+    }
+}
+
+module.exports = { nodeClass: ChatOpenAI_ChatModels }