Flowise Changes

.dockerignore

@@ -0,0 +1,7 @@
+node_modules
+dist
+build
+
+**/node_modules
+**/build
+**/dist

.eslintrc.js

@@ -0,0 +1,28 @@
+module.exports = {
+    extends: [
+        'eslint:recommended',
+        'plugin:markdown/recommended',
+        'plugin:react/recommended',
+        'plugin:react/jsx-runtime',
+        'plugin:react-hooks/recommended',
+        'plugin:jsx-a11y/recommended',
+        'plugin:prettier/recommended'
+    ],
+    settings: {
+        react: {
+            version: 'detect'
+        }
+    },
+    parser: '@typescript-eslint/parser',
+    ignorePatterns: ['**/node_modules', '**/dist', '**/build', '**/package-lock.json'],
+    plugins: ['unused-imports'],
+    rules: {
+        '@typescript-eslint/explicit-module-boundary-types': 'off',
+        'no-unused-vars': 'off',
+        'unused-imports/no-unused-imports': 'warn',
+        'unused-imports/no-unused-vars': ['warn', { vars: 'all', varsIgnorePattern: '^_', args: 'after-used', argsIgnorePattern: '^_' }],
+        'no-undef': 'off',
+        'no-console': [process.env.CI ? 'error' : 'warn', { allow: ['warn', 'error', 'info'] }],
+        'prettier/prettier': 'error'
+    }
+}

.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
+*.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,45 @@
+# editor
+.idea
+.vscode
+
+# dependencies
+**/node_modules
+**/package-lock.json
+**/yarn.lock
+
+## logs
+**/*.log
+
+## build
+**/dist
+**/build
+
+## temp
+**/tmp
+**/temp
+
+## test
+**/coverage
+
+# misc
+.DS_Store
+
+## env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+.env
+
+## turbo
+.turbo
+
+## secrets
+**/*.key
+**/api.json
+
+## uploads
+**/uploads
+
+## compressed
+**/*.tgz

.husky/pre-commit

@@ -0,0 +1,5 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+yarn quick # prettify
+yarn lint-staged # eslint lint(also include prettify but prettify support more file extensions than eslint, so run prettify first)

.prettierignore

@@ -0,0 +1,3 @@
+**/node_modules
+**/dist
+**/build

.prettierrc.js

@@ -0,0 +1,9 @@
+module.exports = {
+    printWidth: 140,
+    singleQuote: true,
+    jsxSingleQuote: true,
+    trailingComma: 'none',
+    tabWidth: 4,
+    semi: false,
+    endOfLine: 'auto'
+}

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 [email protected]. 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 [email protected].

Dockerfile

@@ -0,0 +1,33 @@
+# Build local monorepo image
+# docker build --no-cache -t  flowise .
+
+# Run image
+# docker run -d -p 3000:3000 flowise
+
+FROM node:18-alpine
+RUN apk add --update libc6-compat python3 make g++
+
+WORKDIR /usr/src/packages
+
+# Copy root package.json and lockfile
+COPY package.json yarn.loc[k] ./
+
+# Copy components package.json
+COPY packages/components/package.json ./packages/components/package.json
+
+# Copy ui package.json
+COPY packages/ui/package.json ./packages/ui/package.json
+
+# Copy server package.json
+COPY packages/server/package.json ./packages/server/package.json
+
+RUN yarn install
+
+# Copy app source
+COPY . .
+
+RUN yarn build
+
+EXPOSE 7860
+
+CMD [ "yarn", "start" ]

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

@@ -5,6 +5,7 @@ colorFrom: gray
 colorTo: pink
 sdk: docker
 pinned: false
+app_port: 7860
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

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,3 @@
+PORT=3000
+# FLOWISE_USERNAME=user
+# FLOWISE_PASSWORD=1234

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: [email protected]
+RUN npm install -g flowise
+
+WORKDIR /data
+
+CMD "flowise"

docker/README.md

@@ -0,0 +1,24 @@
+# Flowise Docker Hub Image
+
+Starts Flowise from [DockerHub Image](https://hub.docker.com/repository/docker/flowiseai/flowise/general)
+
+## Usage
+
+1. Create `.env` file and specify the `PORT` (refer to `.env.example`)
+2. `docker-compose up -d`
+3. Open [http://localhost:3000](http://localhost:3000)
+4. You can bring the containers down by `docker-compose stop`
+
+## With Authrorization
+
+1. Create `.env` file and specify the `PORT`, `FLOWISE_USERNAME`, and `FLOWISE_PASSWORD` (refer to `.env.example`)
+2. Pass `FLOWISE_USERNAME` and `FLOWISE_PASSWORD` to the `docker-compose.yml` file:
+    ```
+    environment:
+        - PORT=${PORT}
+        - FLOWISE_USERNAME=${FLOWISE_USERNAME}
+        - FLOWISE_PASSWORD=${FLOWISE_PASSWORD}
+    ```
+3. `docker-compose up -d`
+4. Open [http://localhost:3000](http://localhost:3000)
+5. You can bring the containers down by `docker-compose stop`

docker/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3.1'
+
+services:
+    flowise:
+        image: flowiseai/flowise
+        restart: always
+        environment:
+            - PORT=${PORT}
+            - FLOWISE_USERNAME=${FLOWISE_USERNAME}
+            - FLOWISE_PASSWORD=${FLOWISE_PASSWORD}
+        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.11",
+    "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,99 @@
+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'
+import { flatten } from 'lodash'
+
+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 = flatten(tools)
+        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,63 @@
+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 k = (vectorStore as any)?.k ?? 4
+
+        const babyAgi = BabyAGI.fromLLM(model, vectorStore, parseInt(taskLoop, 10), k)
+        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,270 @@
+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
+
+    topK = 4
+
+    constructor(
+        taskCreationChain: TaskCreationChain,
+        taskPrioritizationChain: TaskPrioritizationChain,
+        executionChain: ExecutionChain,
+        vectorStore: VectorStore,
+        maxIterations: number,
+        topK: number
+    ) {
+        this.taskCreationChain = taskCreationChain
+        this.taskPrioritizationChain = taskPrioritizationChain
+        this.executionChain = executionChain
+        this.vectorStore = vectorStore
+        this.maxIterations = maxIterations
+        this.topK = topK
+    }
+
+    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, this.topK)
+                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, topK = 4): 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, topK)
+    }
+}

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

@@ -0,0 +1,116 @@
+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'
+import { flatten } from 'lodash'
+
+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 = flatten(tools)
+        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,60 @@
+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'
+import { flatten } from 'lodash'
+
+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 = flatten(tools)
+        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,61 @@
+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'
+import { flatten } from 'lodash'
+
+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 = flatten(tools)
+
+        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/ApiChain/GETApiChain.ts

@@ -0,0 +1,129 @@
+import { ICommonObject, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { APIChain } from 'langchain/chains'
+import { CustomChainHandler, getBaseClasses } from '../../../src/utils'
+import { BaseLanguageModel } from 'langchain/base_language'
+import { PromptTemplate } from 'langchain/prompts'
+
+export const API_URL_RAW_PROMPT_TEMPLATE = `You are given the below API Documentation:
+{api_docs}
+Using this documentation, generate the full API url to call for answering the user question.
+You should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
+
+Question:{question}
+API url:`
+
+export const API_RESPONSE_RAW_PROMPT_TEMPLATE =
+    'Given this {api_response} response for {api_url}. use the given response to answer this {question}'
+
+class GETApiChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'GET API Chain'
+        this.name = 'getApiChain'
+        this.type = 'GETApiChain'
+        this.icon = 'apichain.svg'
+        this.category = 'Chains'
+        this.description = 'Chain to run queries against GET API'
+        this.baseClasses = [this.type, ...getBaseClasses(APIChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'API Documentation',
+                name: 'apiDocs',
+                type: 'string',
+                description:
+                    'Description of how API works. Please refer to more <a target="_blank" href="https://github.com/hwchase17/langchain/blob/master/langchain/chains/api/open_meteo_docs.py">examples</a>',
+                rows: 4
+            },
+            {
+                label: 'Headers',
+                name: 'headers',
+                type: 'json',
+                additionalParams: true,
+                optional: true
+            },
+            {
+                label: 'URL Prompt',
+                name: 'urlPrompt',
+                type: 'string',
+                description: 'Prompt used to tell LLMs how to construct the URL. Must contains {api_docs} and {question}',
+                default: API_URL_RAW_PROMPT_TEMPLATE,
+                rows: 4,
+                additionalParams: true
+            },
+            {
+                label: 'Answer Prompt',
+                name: 'ansPrompt',
+                type: 'string',
+                description:
+                    'Prompt used to tell LLMs how to return the API response. Must contains {api_response}, {api_url}, and {question}',
+                default: API_RESPONSE_RAW_PROMPT_TEMPLATE,
+                rows: 4,
+                additionalParams: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const apiDocs = nodeData.inputs?.apiDocs as string
+        const headers = nodeData.inputs?.headers as string
+        const urlPrompt = nodeData.inputs?.urlPrompt as string
+        const ansPrompt = nodeData.inputs?.ansPrompt as string
+
+        const chain = await getAPIChain(apiDocs, model, headers, urlPrompt, ansPrompt)
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const apiDocs = nodeData.inputs?.apiDocs as string
+        const headers = nodeData.inputs?.headers as string
+        const urlPrompt = nodeData.inputs?.urlPrompt as string
+        const ansPrompt = nodeData.inputs?.ansPrompt as string
+
+        const chain = await getAPIChain(apiDocs, model, headers, urlPrompt, ansPrompt)
+        if (options.socketIO && options.socketIOClientId) {
+            const handler = new CustomChainHandler(options.socketIO, options.socketIOClientId, 2)
+            const res = await chain.run(input, [handler])
+            return res
+        } else {
+            const res = await chain.run(input)
+            return res
+        }
+    }
+}
+
+const getAPIChain = async (documents: string, llm: BaseLanguageModel, headers: string, urlPrompt: string, ansPrompt: string) => {
+    const apiUrlPrompt = new PromptTemplate({
+        inputVariables: ['api_docs', 'question'],
+        template: urlPrompt ? urlPrompt : API_URL_RAW_PROMPT_TEMPLATE
+    })
+
+    const apiResponsePrompt = new PromptTemplate({
+        inputVariables: ['api_docs', 'question', 'api_url', 'api_response'],
+        template: ansPrompt ? ansPrompt : API_RESPONSE_RAW_PROMPT_TEMPLATE
+    })
+
+    const chain = APIChain.fromLLMAndAPIDocs(llm, documents, {
+        apiUrlPrompt,
+        apiResponsePrompt,
+        verbose: process.env.DEBUG === 'true' ? true : false,
+        headers: typeof headers === 'object' ? headers : headers ? JSON.parse(headers) : {}
+    })
+    return chain
+}
+
+module.exports = { nodeClass: GETApiChain_Chains }

packages/components/nodes/chains/ApiChain/POSTApiChain.ts

@@ -0,0 +1,118 @@
+import { ICommonObject, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { CustomChainHandler, getBaseClasses } from '../../../src/utils'
+import { BaseLanguageModel } from 'langchain/base_language'
+import { PromptTemplate } from 'langchain/prompts'
+import { API_RESPONSE_RAW_PROMPT_TEMPLATE, API_URL_RAW_PROMPT_TEMPLATE, APIChain } from './postCore'
+
+class POSTApiChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'POST API Chain'
+        this.name = 'postApiChain'
+        this.type = 'POSTApiChain'
+        this.icon = 'apichain.svg'
+        this.category = 'Chains'
+        this.description = 'Chain to run queries against POST API'
+        this.baseClasses = [this.type, ...getBaseClasses(APIChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'API Documentation',
+                name: 'apiDocs',
+                type: 'string',
+                description:
+                    'Description of how API works. Please refer to more <a target="_blank" href="https://github.com/hwchase17/langchain/blob/master/langchain/chains/api/open_meteo_docs.py">examples</a>',
+                rows: 4
+            },
+            {
+                label: 'Headers',
+                name: 'headers',
+                type: 'json',
+                additionalParams: true,
+                optional: true
+            },
+            {
+                label: 'URL Prompt',
+                name: 'urlPrompt',
+                type: 'string',
+                description: 'Prompt used to tell LLMs how to construct the URL. Must contains {api_docs} and {question}',
+                default: API_URL_RAW_PROMPT_TEMPLATE,
+                rows: 4,
+                additionalParams: true
+            },
+            {
+                label: 'Answer Prompt',
+                name: 'ansPrompt',
+                type: 'string',
+                description:
+                    'Prompt used to tell LLMs how to return the API response. Must contains {api_response}, {api_url}, and {question}',
+                default: API_RESPONSE_RAW_PROMPT_TEMPLATE,
+                rows: 4,
+                additionalParams: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const apiDocs = nodeData.inputs?.apiDocs as string
+        const headers = nodeData.inputs?.headers as string
+        const urlPrompt = nodeData.inputs?.urlPrompt as string
+        const ansPrompt = nodeData.inputs?.ansPrompt as string
+
+        const chain = await getAPIChain(apiDocs, model, headers, urlPrompt, ansPrompt)
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const apiDocs = nodeData.inputs?.apiDocs as string
+        const headers = nodeData.inputs?.headers as string
+        const urlPrompt = nodeData.inputs?.urlPrompt as string
+        const ansPrompt = nodeData.inputs?.ansPrompt as string
+
+        const chain = await getAPIChain(apiDocs, model, headers, urlPrompt, ansPrompt)
+        if (options.socketIO && options.socketIOClientId) {
+            const handler = new CustomChainHandler(options.socketIO, options.socketIOClientId, 2)
+            const res = await chain.run(input, [handler])
+            return res
+        } else {
+            const res = await chain.run(input)
+            return res
+        }
+    }
+}
+
+const getAPIChain = async (documents: string, llm: BaseLanguageModel, headers: string, urlPrompt: string, ansPrompt: string) => {
+    const apiUrlPrompt = new PromptTemplate({
+        inputVariables: ['api_docs', 'question'],
+        template: urlPrompt ? urlPrompt : API_URL_RAW_PROMPT_TEMPLATE
+    })
+
+    const apiResponsePrompt = new PromptTemplate({
+        inputVariables: ['api_docs', 'question', 'api_url_body', 'api_response'],
+        template: ansPrompt ? ansPrompt : API_RESPONSE_RAW_PROMPT_TEMPLATE
+    })
+
+    const chain = APIChain.fromLLMAndAPIDocs(llm, documents, {
+        apiUrlPrompt,
+        apiResponsePrompt,
+        verbose: process.env.DEBUG === 'true' ? true : false,
+        headers: typeof headers === 'object' ? headers : headers ? JSON.parse(headers) : {}
+    })
+    return chain
+}
+
+module.exports = { nodeClass: POSTApiChain_Chains }

packages/components/nodes/chains/ApiChain/postCore.ts

@@ -0,0 +1,162 @@
+import { BaseLanguageModel } from 'langchain/base_language'
+import { CallbackManagerForChainRun } from 'langchain/callbacks'
+import { BaseChain, ChainInputs, LLMChain, SerializedAPIChain } from 'langchain/chains'
+import { BasePromptTemplate, PromptTemplate } from 'langchain/prompts'
+import { ChainValues } from 'langchain/schema'
+import fetch from 'node-fetch'
+
+export const API_URL_RAW_PROMPT_TEMPLATE = `You are given the below API Documentation:
+{api_docs}
+Using this documentation, generate a json string with two keys: "url" and "data".
+The value of "url" should be a string, which is the API url to call for answering the user question.
+The value of "data" should be a dictionary of key-value pairs you want to POST to the url as a JSON body.
+Be careful to always use double quotes for strings in the json string.
+You should build the json string in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
+
+Question:{question}
+json string:`
+
+export const API_RESPONSE_RAW_PROMPT_TEMPLATE = `${API_URL_RAW_PROMPT_TEMPLATE} {api_url_body}
+
+Here is the response from the API:
+
+{api_response}
+
+Summarize this response to answer the original question.
+
+Summary:`
+
+const defaultApiUrlPrompt = new PromptTemplate({
+    inputVariables: ['api_docs', 'question'],
+    template: API_URL_RAW_PROMPT_TEMPLATE
+})
+
+const defaultApiResponsePrompt = new PromptTemplate({
+    inputVariables: ['api_docs', 'question', 'api_url_body', 'api_response'],
+    template: API_RESPONSE_RAW_PROMPT_TEMPLATE
+})
+
+export interface APIChainInput extends Omit<ChainInputs, 'memory'> {
+    apiAnswerChain: LLMChain
+    apiRequestChain: LLMChain
+    apiDocs: string
+    inputKey?: string
+    headers?: Record<string, string>
+    /** Key to use for output, defaults to `output` */
+    outputKey?: string
+}
+
+export type APIChainOptions = {
+    headers?: Record<string, string>
+    apiUrlPrompt?: BasePromptTemplate
+    apiResponsePrompt?: BasePromptTemplate
+}
+
+export class APIChain extends BaseChain implements APIChainInput {
+    apiAnswerChain: LLMChain
+
+    apiRequestChain: LLMChain
+
+    apiDocs: string
+
+    headers = {}
+
+    inputKey = 'question'
+
+    outputKey = 'output'
+
+    get inputKeys() {
+        return [this.inputKey]
+    }
+
+    get outputKeys() {
+        return [this.outputKey]
+    }
+
+    constructor(fields: APIChainInput) {
+        super(fields)
+        this.apiRequestChain = fields.apiRequestChain
+        this.apiAnswerChain = fields.apiAnswerChain
+        this.apiDocs = fields.apiDocs
+        this.inputKey = fields.inputKey ?? this.inputKey
+        this.outputKey = fields.outputKey ?? this.outputKey
+        this.headers = fields.headers ?? this.headers
+    }
+
+    /** @ignore */
+    async _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues> {
+        try {
+            const question: string = values[this.inputKey]
+
+            const api_url_body = await this.apiRequestChain.predict({ question, api_docs: this.apiDocs }, runManager?.getChild())
+
+            const { url, data } = JSON.parse(api_url_body)
+
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify(data)
+            })
+
+            const api_response = await res.text()
+
+            const answer = await this.apiAnswerChain.predict(
+                { question, api_docs: this.apiDocs, api_url_body, api_response },
+                runManager?.getChild()
+            )
+
+            return { [this.outputKey]: answer }
+        } catch (error) {
+            return { [this.outputKey]: error }
+        }
+    }
+
+    _chainType() {
+        return 'api_chain' as const
+    }
+
+    static async deserialize(data: SerializedAPIChain) {
+        const { api_request_chain, api_answer_chain, api_docs } = data
+
+        if (!api_request_chain) {
+            throw new Error('LLMChain must have api_request_chain')
+        }
+        if (!api_answer_chain) {
+            throw new Error('LLMChain must have api_answer_chain')
+        }
+        if (!api_docs) {
+            throw new Error('LLMChain must have api_docs')
+        }
+
+        return new APIChain({
+            apiAnswerChain: await LLMChain.deserialize(api_answer_chain),
+            apiRequestChain: await LLMChain.deserialize(api_request_chain),
+            apiDocs: api_docs
+        })
+    }
+
+    serialize(): SerializedAPIChain {
+        return {
+            _type: this._chainType(),
+            api_answer_chain: this.apiAnswerChain.serialize(),
+            api_request_chain: this.apiRequestChain.serialize(),
+            api_docs: this.apiDocs
+        }
+    }
+
+    static fromLLMAndAPIDocs(
+        llm: BaseLanguageModel,
+        apiDocs: string,
+        options: APIChainOptions & Omit<APIChainInput, 'apiAnswerChain' | 'apiRequestChain' | 'apiDocs'> = {}
+    ): APIChain {
+        const { apiUrlPrompt = defaultApiUrlPrompt, apiResponsePrompt = defaultApiResponsePrompt } = options
+        const apiRequestChain = new LLMChain({ prompt: apiUrlPrompt, llm })
+        const apiAnswerChain = new LLMChain({ prompt: apiResponsePrompt, llm })
+        return new this({
+            apiAnswerChain,
+            apiRequestChain,
+            apiDocs,
+            ...options
+        })
+    }
+}

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

@@ -0,0 +1,104 @@
+import { ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { ConversationChain } from 'langchain/chains'
+import { CustomChainHandler, 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,
+            verbose: process.env.DEBUG === 'true' ? true : false
+        }
+
+        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
+        }
+
+        if (options.socketIO && options.socketIOClientId) {
+            const handler = new CustomChainHandler(options.socketIO, options.socketIOClientId)
+            const res = await chain.call({ input }, [handler])
+            return res?.response
+        } else {
+            const res = await chain.call({ input })
+            return res?.response
+        }
+    }
+}
+
+module.exports = { nodeClass: ConversationChain_Chains }

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

@@ -0,0 +1,163 @@
+import { BaseLanguageModel } from 'langchain/base_language'
+import { ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { CustomChainHandler, getBaseClasses } from '../../../src/utils'
+import { ConversationalRetrievalQAChain } from 'langchain/chains'
+import { AIChatMessage, BaseRetriever, HumanChatMessage } from 'langchain/schema'
+import { BaseChatMemory, BufferMemory, ChatMessageHistory } from 'langchain/memory'
+import { PromptTemplate } from 'langchain/prompts'
+
+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: 'Return Source Documents',
+                name: 'returnSourceDocuments',
+                type: 'boolean',
+                optional: true
+            },
+            {
+                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.'
+            },
+            {
+                label: 'Chain Option',
+                name: 'chainOption',
+                type: 'options',
+                options: [
+                    {
+                        label: 'MapReduceDocumentsChain',
+                        name: 'map_reduce',
+                        description:
+                            'Suitable for QA tasks over larger documents and can run the preprocessing step in parallel, reducing the running time'
+                    },
+                    {
+                        label: 'RefineDocumentsChain',
+                        name: 'refine',
+                        description: 'Suitable for QA tasks over a large number of documents.'
+                    },
+                    {
+                        label: 'StuffDocumentsChain',
+                        name: 'stuff',
+                        description: 'Suitable for QA tasks over a small number of documents.'
+                    }
+                ],
+                additionalParams: true,
+                optional: true
+            }
+        ]
+    }
+
+    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 returnSourceDocuments = nodeData.inputs?.returnSourceDocuments as boolean
+        const chainOption = nodeData.inputs?.chainOption as string
+
+        const obj: any = {
+            verbose: process.env.DEBUG === 'true' ? true : false,
+            qaChainOptions: {
+                type: 'stuff',
+                prompt: PromptTemplate.fromTemplate(systemMessagePrompt ? `${systemMessagePrompt}\n${qa_template}` : default_qa_template)
+            },
+            memory: new BufferMemory({
+                memoryKey: 'chat_history',
+                inputKey: 'question',
+                outputKey: 'text',
+                returnMessages: true
+            })
+        }
+        if (returnSourceDocuments) obj.returnSourceDocuments = returnSourceDocuments
+        if (chainOption) obj.qaChainOptions = { ...obj.qaChainOptions, type: chainOption }
+
+        const chain = ConversationalRetrievalQAChain.fromLLM(model, vectorStoreRetriever, obj)
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string | ICommonObject> {
+        const chain = nodeData.instance as ConversationalRetrievalQAChain
+        const returnSourceDocuments = nodeData.inputs?.returnSourceDocuments as boolean
+        let model = nodeData.inputs?.model
+
+        // Temporary fix: https://github.com/hwchase17/langchainjs/issues/754
+        model.streaming = false
+        chain.questionGeneratorChain.llm = model
+
+        const obj = { question: input }
+
+        if (chain.memory && options && options.chatHistory) {
+            const chatHistory = []
+            const histories: IMessage[] = options.chatHistory
+            const memory = chain.memory as BaseChatMemory
+
+            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
+        }
+
+        if (options.socketIO && options.socketIOClientId) {
+            const handler = new CustomChainHandler(options.socketIO, options.socketIOClientId, undefined, returnSourceDocuments)
+            const res = await chain.call(obj, [handler])
+            if (res.text && res.sourceDocuments) return res
+            return res?.text
+        } else {
+            const res = await chain.call(obj)
+            if (res.text && res.sourceDocuments) return res
+            return res?.text
+        }
+    }
+}
+
+module.exports = { nodeClass: ConversationalRetrievalQAChain_Chains }

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

@@ -0,0 +1,167 @@
+import { ICommonObject, INode, INodeData, INodeOutputsValue, INodeParams } from '../../../src/Interface'
+import { CustomChainHandler, 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, options: ICommonObject): 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 = options.socketIO
+            ? await runPrediction(inputVariables, chain, input, promptValues, true, options.socketIO, options.socketIOClientId)
+            : 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,
+    isStreaming?: boolean,
+    socketIO?: any,
+    socketIOClientId = ''
+) => {
+    if (inputVariables.length === 1) {
+        if (isStreaming) {
+            const handler = new CustomChainHandler(socketIO, socketIOClientId)
+            const res = await chain.run(input, [handler])
+            return res
+        } else {
+            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
+            }
+            if (isStreaming) {
+                const handler = new CustomChainHandler(socketIO, socketIOClientId)
+                const res = await chain.call(options, [handler])
+                return res?.text
+            } else {
+                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
+            }
+            if (isStreaming) {
+                const handler = new CustomChainHandler(socketIO, socketIOClientId)
+                const res = await chain.call(options, [handler])
+                return res?.text
+            } else {
+                const res = await chain.call(options)
+                return res?.text
+            }
+        } else {
+            throw new Error(`Please provide Prompt Values for: ${seen.join(', ')}`)
+        }
+    } else {
+        if (isStreaming) {
+            const handler = new CustomChainHandler(socketIO, socketIOClientId)
+            const res = await chain.run(input, [handler])
+            return res
+        } else {
+            const res = await chain.run(input)
+            return res
+        }
+    }
+}
+
+module.exports = { nodeClass: LLMChain_Chains }

packages/components/nodes/chains/MultiPromptChain/MultiPromptChain.ts

@@ -0,0 +1,74 @@
+import { BaseLanguageModel } from 'langchain/base_language'
+import { ICommonObject, INode, INodeData, INodeParams, PromptRetriever } from '../../../src/Interface'
+import { CustomChainHandler, getBaseClasses } from '../../../src/utils'
+import { MultiPromptChain } from 'langchain/chains'
+
+class MultiPromptChain_Chains implements INode {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description: string
+    inputs: INodeParams[]
+
+    constructor() {
+        this.label = 'Multi Prompt Chain'
+        this.name = 'multiPromptChain'
+        this.type = 'MultiPromptChain'
+        this.icon = 'chain.svg'
+        this.category = 'Chains'
+        this.description = 'Chain automatically picks an appropriate prompt from multiple prompt templates'
+        this.baseClasses = [this.type, ...getBaseClasses(MultiPromptChain)]
+        this.inputs = [
+            {
+                label: 'Language Model',
+                name: 'model',
+                type: 'BaseLanguageModel'
+            },
+            {
+                label: 'Prompt Retriever',
+                name: 'promptRetriever',
+                type: 'PromptRetriever',
+                list: true
+            }
+        ]
+    }
+
+    async init(nodeData: INodeData): Promise<any> {
+        const model = nodeData.inputs?.model as BaseLanguageModel
+        const promptRetriever = nodeData.inputs?.promptRetriever as PromptRetriever[]
+        const promptNames = []
+        const promptDescriptions = []
+        const promptTemplates = []
+
+        for (const prompt of promptRetriever) {
+            promptNames.push(prompt.name)
+            promptDescriptions.push(prompt.description)
+            promptTemplates.push(prompt.systemMessage)
+        }
+
+        const chain = MultiPromptChain.fromPrompts(model, promptNames, promptDescriptions, promptTemplates, undefined, {
+            verbose: process.env.DEBUG === 'true' ? true : false
+        } as any)
+
+        return chain
+    }
+
+    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
+        const chain = nodeData.instance as MultiPromptChain
+        const obj = { input }
+
+        if (options.socketIO && options.socketIOClientId) {
+            const handler = new CustomChainHandler(options.socketIO, options.socketIOClientId)
+            const res = await chain.call(obj, [handler])
+            return res?.text
+        } else {
+            const res = await chain.call(obj)
+            return res?.text
+        }
+    }
+}
+
+module.exports = { nodeClass: MultiPromptChain_Chains }