UBOS Community: Vika

Working with Large Files in AI Chat Bot

Vika — Fri, 29 Mar 2024 13:30:46 +0000

To begin, if you haven't already installed our "AI-Powered Chatbot" template, you need to do so in our Marketplace.

In order to enable the "AI-Powered Chatbot" to handle larger volumes of files, certain changes need to be made. Specifically, the OpenAI model used for embedding should be changed from text-embedding-ada-2 to text-embedding-3-large (to accommodate working with larger vectors), and the function responsible for writing data to the Chroma database needs to be modified.
Let's take the endpoint "/createVector" as an example. Initially, it will look like this:

And here's how it will look after our modifications for working with large files:

Before the "create vector" function node, we need to add another function to check the length of the received text from array-loop msg.array. The maximum number of tokens per embedding request is 8191.
(Here's where you can familiarize yourself with "Language model tokenization").
Therefore, we need to perform the following check:

If each text is longer than, for example, 5500 characters, we split it into chunks of 5500 characters and push them into an array for passing into the next array-loop.
If the text is shorter than the specified length, send it for vector creation. This function, named "check text," will have the following code:

msg.tobase = msg.payload
msg.ids = Date.now().toString()

function splitText(text, chunkSize) {
    const chunks = [];
    for (let i = 0; i < text.length; i += chunkSize) {
        chunks.push(text.slice(i, i + chunkSize));
    }
    return chunks;
}

const chunkSize = 5500;

msg.payload = msg.payload

if(msg.payload.length > 5500) {
    const textChunks = splitText(msg.payload, chunkSize);
    msg.textChunks = textChunks
    return [null, msg]
} else {    
    return [msg, null]
}

The "splitText" function takes the text that needs to be divided into chunks and the required length of each chunk. The result will be an array of text chunks that we can pass into an array-loop further.

If the text either matches the specified length or we've split it into necessary chunks and passed them into an array-loop, we proceed to the function responsible for sending the embedding request ("new create vector").

In these functions, we specify headers with our OpenAI API_KEY, a settings object where we specify that we want to use the text-embedding-3-large model, pass the text for embedding, and check the type of the database. Thanks to these changes, we can work with vectors of greater length, namely 3072 instead of 1536 (Here's where you can familiarize yourself with “Embeddings”).
The code will look as follows:

msg.OPENAI_API_KEY = global.get("openai").OPENAI_API;
msg.input = msg.payload
msg.ids = Date.now().toString()
msg.url = 'https://api.openai.com/v1/embeddings';
msg.tobase = msg.payload;

msg.headers = {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${msg.OPENAI_API_KEY}`,
};


const settings = {
    model: "text-embedding-3-large",
    input: msg.input
};

msg.payload = settings;
msg.settings = settings;



if (msg.typeBase === "chroma") {

    return [null, msg]
}
else {
    return [msg, null]
}

Next, replace the node "OpenAi Ubos" with "http request."
Additionally, we need to modify the following function used for writing the vector to the Chroma database and add the nodes "chroma collection" and select the "add" operation in it.

Now, following the same analogy, these actions need to be performed in other Endpoints where we send requests for embedding, write data to vector databases, or retrieve them (in which case the operation in "chroma collection" will be "query").
Here's an example of how the endpoint "/updateVector" looked and how it should look to handle larger volumes of information:

Also, to increase the amount of information you're passing to ChatGPT, you need to navigate to the "Bot" flow and increase the number of results returned from the Chroma database in the "add vector to chroma collection" function:

But keep in mind that your request to ChatGPT should not exceed the token limit for the chosen model, and also that the response from the models is limited to 4096 tokens (you can find a list and description of all ChatGPT models here).

Instructions for Integrating Google Sheets with Node-RED

Vika — Mon, 11 Mar 2024 12:17:18 +0000

To set up the integration of Google Sheets with Node-RED, follow these steps:
1.Go to the Google Cloud Console at https://console.cloud.google.com

2.Create a new project or use an existing one. The project name is not significant

3.After creating the project, navigate to its settings.

4.In the "IAM & Admin" -> "Service Account" section, create a new service account for the project.

Create new

5.When creating the service account, grant it the appropriate permissions and roles.

Generate and save the access keys in JSON format.

6.In the "APIs & Services" -> "Library" section, enable access to the Google Sheets API for your project.

7.Obtain the identifier (ID) of the Google Sheets spreadsheet you plan to work with. This ID can be found in the URL of the open spreadsheet.

8.In Node-RED, install the required node-red-contrib-google-sheets module.

node-red-contrib-google-sheets

9.In the module settings, paste the access keys from the JSON file

10.Select the desired method (e.g., read or write data), specify the spreadsheet ID, and the range of cells.
11.Test the settings by sending a request to read data from the spreadsheet through the API.
After completing all the steps, you will have successfully set up the integration of Google Sheets with Node-RED and will be able to work with spreadsheet data through Node-RED flows.

Note that these instructions provide general steps, and additional configuration or adjustments may be required depending on the specific requirements of your project.

ChatGPT Prompt Configuration

Vika — Wed, 08 Nov 2023 11:49:08 +0000

Configuring ChatGPT prompts effectively is crucial for harnessing the full potential of this powerful language model. In this article, we will explore the intricacies of ChatGPT prompt configuration, diving into various techniques and best practices to optimize interactions with the AI. Understanding how to craft prompts tailored to specific tasks and contexts can significantly enhance the quality of responses generated by ChatGPT.

"All fields are mandatory and together form a unified prompt (instruction) for ChatGPT. Let's examine each of the points:

1) Answer length: You specify how detailed the response will be.

2) Answer as: You have the choice of the role your bot will assume in the response.

3) Tone: The desired tone of the response.

4) Language: There are three available languages for your bot.

5) Knowledge base: By default, the default knowledge base is selected, but you can also choose your own if available. This knowledge base forms the foundation of your bot's knowledge.

6) Custom prompt: Here, you can provide a more detailed and individualized instruction for your bot. However, we advise against overly restricting your bot's actions. Writing the prompt is a crucial and challenging stage that requires careful consideration, as the result significantly impacts the overall performance of artificial intelligence.
The general structure of the prompt includes:

Context: Provide the relevant context for the task or conversation.

Task Objective: State the goal of the task or query clearly.

**Expected Output Description: **Describe the expected result in terms of content, quantity, and format (text, unordered list, JSON, CSV, table, etc.).

Conditions and Limitations: Outline any conditions or limitations applicable to the task.

If you want to assign a complex task to ChatGPT containing many details and references, write an instruction on how the communication will proceed. To correctly 'feed' the model all the necessary input, instruct the chat that you will provide examples in the following messages and it should wait until you upload all the information. You can request ChatGPT to avoid explanations, respond with specific phrases, and ask clarifying questions to better understand the task. Complex tasks should be broken down into sub-tasks to obtain more accurate responses.

!!!The command 'Do not write your own opinion' is extremely important as an instruction.ʼ

Examples of requests that include role, task, and follow-up instructions:

Act as a cybersecurity specialist. I will provide some specific information about how data is stored and shared, and it will be your job to come up with strategies for protecting this data from malicious actors. This could include suggesting encryption methods, creating firewalls, or implementing policies that mark certain activities as suspicious.

By adhering to these guidelines and instructions, users can harness ChatGPT's capabilities to their fullest, ensuring productive and tailored conversations with this powerful language model.

How to create Telegram bot.

Vika — Wed, 08 Nov 2023 10:06:58 +0000

Follow the steps shown below to make bot for your bussiness.

Creating Telegram bot

Open the Telegram app on your mobile device or desktop computer.Search @BotFather bot in Telegram and open a chat with it.
Send the command "/newbot" to BotFather and follow the prompts to create a new bot.

You will need to provide a name for your bot. And after pasted it and token in the form on "Bot Setup" page.

After filling in the data, you need to save this data by clicking on the "Save" button.

How to training bot by different types of source.

Vika — Wed, 08 Nov 2023 09:37:46 +0000

Using a template, you can customize your bot to fit your personal and business needs. You have the ability to populate your knowledge base using files, website links, or manually. Below, we will explore each type in detail.

To begin, you should already have all the necessary keys set up and gain access on the Training page.

WEBSITE:
If you have a website with the desired information that is well-programmed, you can retrieve all the textual content from it. This can be done in the "WEBSITE" tab by simply filling in the inputs following the example shown in the screenshot.

This method will be useful to you if the website from which you need to gather information has a clean HTML source code. If the website is built using website builders, a lot of information may be unreadable.

FILE:
You have the ability to upload three types of files: .txt, .pdf, .xlsx. Regarding .txt files, they can have any structure, but for better results, you can create a FAQ structure.
Here is an example of a text file where there is a division into FAQ and concise information.

FAQ:
Using FAQs, you have the ability to manually populate content with the structure: question-answer pairs.

INSERT TEXT:
With this tab, you can insert or type any text, which will be divided into fragments of 500 characters each and saved in the system.

UBOS offers user-friendly tools and templates, enabling to customize bots for personalized and business needs. By following the provided steps, you can efficiently improve their content accessibility, ensuring a better experience for your audience.

An AI-Powered Chatbot with ChatGPT (previous version)

Vika — Mon, 25 Sep 2023 17:36:41 +0000

Installing a Template on a New Workspace

Go to https://platform.ubos.tech/ and log in to your account.
Click on that link to access the page displaying all workspaces.

Click the "+" button if you need to create a new workspace.

Enter a name for the new workspace and then click on the "Create" button. Once completed, proceed to open the newly created workspace.

Select the option "Start from a template."

Then click on the "Install" button next to your desired template.

Select the workspace where you want to install the template, and then click on the "Fork template" option.

Wait until a green light appears next to all services.

Copy the UI link and paste it into a new browser window.

Click the "Setup application!" button.

You can see this message, you need to wait a bit and click on the button again.

Save or remember the password and login.

Enter your password and login into the fields of the login form to access your admin panel.

Now, let's take a closer look at what our template consists of, how to customize it, and create a knowledge base.

The admin panel consists of several modules, the main ones being "App settings" and "Base".Let's start with "App settings".

General settings are required to create a knowledge base and serve as the foundation. Here, there is integration with two third-party services: Pinecone, which is a vector database, and OpenAI. You can find information on how to obtain all the necessary keys and settings in the following link. Click here to know how to get the OpenAI keys. Be exercised caution and devote particular attention to the completion of the PROMPT section. This section serves as the guiding light for your AI assistant, shaping the manner and style in which the bot will engage with users.

The following tabs correspond to the type of messenger where your AI assistant will directly interact. Currently, this can include Telegram, Instagram, Messenger, and WhatsApp. You can choose one or multiple options.

After completing all the essential configurations, you can proceed to create and populate your knowledge base.

After creating the database, it should be populated by clicking the "Edit" button. Currently, there are several ways to achieve this:

If you have a website with the desired information that is well-programmed, you can retrieve all the textual content from it. This can be done in the "Links" tab by simply filling in the inputs following the example shown in the screenshot.

In the "Files" tab, you can upload existing information in .txt format. It is preferable that these files are free from grammatical errors, contain proper punctuation, and are divided into paragraphs for preliminary editing. Google Docs is an ideal tool for this purpose. The higher the quality of your file, the less subsequent editing of vectors (knowledge chunks for the bot) will be required.

Here is an example of a text file where there is a division into paragraphs and concise information.

In the 'FAQ' tab, you can upload a .txt file consisting of questions and answers. A mandatory requirement is to use a '?' after each question and a '.' after each answer.

Here is an example of a text file where there is a division into FAQ and concise information.

Additionally, you can upload a file in PDF format.

If you need to manually add short information, such as a single question and answer or multiple ones, you can do so in the "Additional" tab.

Once all the necessary information is uploaded, you can begin dividing the data into smaller data chunks (create vectors). This can be achieved through several methods. ----> push the button Divide file

After this, you will see a modal window where you can choose the file dividing type:

Divide by sentences.
Divide by paragraphs.
An additional option is to divide by paragraphs or sentences using an increment. In this method, artificial intelligence generates several questions for each small piece of your information, aiding the bot in better understanding the user's context and providing accurate responses.

Division may take some time. Once the data is divided, you can view the vectors and make edits by navigating to the editing page and pressing the button “Edit vectors”. To activate it after starting the division, press the “Refresh” button.

In the vector editing page, you will find vectors and their statuses. By clicking the 'Refresh' button, you can view new vectors and monitor status updates as the division progresses. Once the division is completed, you can go through the vectors for any necessary edits.

When you are satisfied with the results, you can make this database accessible to your BOT by clicking the 'Save in Pinecone' button.
Please note that saving may take some time, and you can monitor the status updates by clicking the 'Refresh' button.

If you wish to test how the BOT responds and you haven't yet connected with managers, you can do so on the Demo page.

If you already have your BOT on messaging platforms and wish to observe its responses to users for finer AI analysis and data adjustments, you can do so by visiting the 'Users' page.

On the Management page, you can create new users for your application and, depending on their roles, hide or add accessible pages. For instance, users with an 'Admin' *role can view all pages and create new users, while *'Analyst' role users may only access chat with a bot, and so on. It all depends on your preferences.

Important Addition: If you delete the knowledge base, individual files, or vectors, all data will be removed from the bot's knowledge base. Please exercise caution.Our team is always ready to assist and address any issues that may arise.
With respect, UBOS.

Create a document in the PDF format.

Vika — Thu, 22 Jun 2023 09:31:40 +0000

PDF формат дуже зручний формат обміну даними люди найчастіше використовують документи PDF, коли хочуть обмінюватися інформацією без дозволу редагувати вихідний файл Exchange файл з тим, у кого немає необхідного програмного забезпечення для перегляду вихідного файлу.

Нижче буде розглянуто найпростіший варіант створення документу такого типу на платформі UBOS.

Для цього нам знадобиться:

Крок перший:

На боці UI створюємо інтерфейс та налаштовуємо функції.

UI WIDGETS SETTINGS

Звичайний Input для ввода текстової інформації, налаштування по замовчуванню

Кнопка в налаштуваннях якої на подію OnClick запускаємо функцію створення DPF документу.** Важливо** : PDF документ повинен відкриватися на новій сторінці,тому використовуємо функцію navigateTo де URL це посилання на бекенд де знаходиться flow, в query передаємо інформацію з Input та вказуємо Target - New window

UI WIDGETS	SETTINGS
	Звичайний `Input` для ввода текстової інформації, налаштування по замовчуванню
	Кнопка в налаштуваннях якої на подію `OnClick` запускаємо функцію створення DPF документу. Важливо : PDF документ повинен відкриватися на новій сторінці,тому використовуємо функцію `navigateTo` де `URL` це посилання на бекенд де знаходиться `flow`, в `query` передаємо інформацію з `Input` та вказуємо `Target - New window`

тіло функції ->

{{navigateTo('https://companybd-632484b419f0331000000199.ubos.tech/getPDF',{"title": Input_title.text,"text":Input_text.text},'NEW_WINDOW')}}

Крок другий:

Потрібно на `Flow Builder UBOS` зробити наступне:

Cтворюємо flow використовуючи такіNODEs:

NODE	INSTALL
	Basic NODE `node-red 3.0.2`
	Basic NODE `node-red 3.0.2`
	Need to install `node-red-contrib-pdfmake 1.1.0`
	Basic NODE `node-red 3.0.2`
	Basic NODE `node-red 3.0.2`

Налаштовуємо NODEs:

Http in:
function "createContent":
в msg.payload передаємо дані з input в структуру передбачену для створення Pdf документа. Content:[]- обов'язкова умова, в styles- описуються стилі для документа за бажанням.

msg.payload =  {
    content: [
        { text: `${msg.payload.title}`, style:'header' },
        { text: `${msg.payload.text}`, style: 'anotherStyle' }
    ],
    styles: {
        header: {
            fontSize: 28,
            bold: true,
            alignment: 'center'
        },
        anotherStyle: {
            fontSize: 18,
            italics: true,
            alignment: 'center'
        }
    }
        }
return msg;

pdfmake:

function "createHeaders":

налаштовуємо headers:

msg.headers = {
    "Content-Disposition": "inline",
    'Content-Type': 'application/pdf'
}
return msg;

Загальний вигляд flow

В результаті введені дані конвертуються в PDF документ.

Using Templates on UBOS: Instructions and Examples, Powered by OpenAI

Vika — Mon, 10 Apr 2023 12:52:13 +0000

1. Introduction
2. Template Overview
3. Using a Template on UBOS: Step-by-Step Guide
4. Examples of Using a Template on UBOS

1.Introduction

In this article, we will talk about what a template is and how to use it on UBOS. We will provide a detailed instruction on using the template and give examples of how it can be used to create a website. With this article, you will be able to quickly and effectively start your project and add the necessary functionality by using the template.

2.Template Overview

To get started, you will need a UBOS account where you can deploy any template you choose. Each template consists of both a user interface and a backend.

UI part

Backend part

3.Using a Template on UBOS

UI
The UI includes an input field to enter prompts, a submit button to send requests, and another input field to display the OpenAI's response. The "settings" tab allows you to view the specific configurations used for sending requests.

In this input you have to insert your api key OpenAI, the instruction is at the link ⇥

We send the data from this input to Http in in Node-red, and receive them in msg.payload
On the Onclick event, send a POST request to the backend.

In this input, we see the result of the query.

This button open the modal window "settings"
Settings data is also the result of the query.

Backend
IMPORTANT!!!
To run the flow on the backend, you need to add
OpenAI key

1.`_HTTP In node_`

This node is the starting point of the flow and waits for an incoming HTTP POST request on the "/createSQLtranslate" URL. When it receives a request, it passes the payload to the next node.

`_Function node "OpenAI API properties"_`

This node is responsible for setting up the necessary properties and headers for making a request to the OpenAI API. It takes the incoming text payload and creates an object with the OpenAI API properties and headers required for making a request. It then returns the modified message object to the next node.

`_HTTP Request node "OpenAI API"_`

This node sends a POST request to the OpenAI API using the properties and headers that were set up in the previous node. It waits for the response from the API and passes it to the next node.

`_Function node "Response"_`

This node is responsible for processing the response from the OpenAI API. It converts the payload from the API response to an object format, extracts the translated text, and returns a modified message object that contains the text and the translation settings or response the error info.

`_HTTP Response node_`

This node sends a response back to the client who made the initial request, with the translated text as the payload. It sends the HTTP response back to the client with the translated text.

4.Examples of Using a Template on UBOS

Template "SQL translate." The product designed to provide a translation service for SQL queries, allowing users to convert SQL queries from one dialect to another.

How to get the OpenAI keys

Vika — Wed, 29 Mar 2023 08:12:22 +0000

Where to get required keys?

Getting OpenAI API key

Sign up here. You can use your Google or Microsoft account to sign up if you don't want to create using an email/password combination. You may need a valid mobile number to verify your account.
Now, visit your OpenAI key page or click "Create new secret key".

3.Note that the key must be copied immediately.

Paste the generated key in the form on "AI Setup" page and choose model.

After filling in the data, you need to save this data by clicking on the "Save" button.

CRUD operations on the UBOS platform for beginners (part 2)"GET".

Vika — Wed, 01 Mar 2023 08:47:54 +0000

Introduction

The UBOS platform allows you to develop web applications using various operations, such as CREATE, READ, UPDATE, and DELETE. In this article, we will focus on the GET operation, which is one of the basic operations used to retrieve data from a database. We will explore how to use the GET operation in web applications on the UBOS platform and how to implement it.

What is the GET operation?

GET is one of the HTTP methods used to retrieve data from a server. With a GET request, you can retrieve information stored on the server and transfer it to the client browser. In web applications, GET requests are used to obtain static information, such as page content, images, audio and video files.

Example of using GET in web applications on the UBOS platform

In the previous article, we used Create to create a new "Phonebook" collection. Now we will retrieve data from it. To do this, we need:

API and Table widget on UI
Flow on the backend.

Step 1:
The first step is to gather the data that you want to add to the database.

Widget we need:

The Table widget is a graphical user interface (GUI) component used to display tabular data in a structured format. It allows you to display data from a database or API in a grid-like format with rows and columns.

Step 2:

Сonfigure the display of data on page load.

Сonfigure the display of data on the Table.

Display data from the API.
Hide unnecessary data in the table.

Step 3:
Flow Builder UBOS is a visual tool for creating and managing APIs and integrations. You can use Flow Builder UBOS to create a backend for your application that can perform CRUD operations on a database. Each node is discussed in more detail in the previous article,however, there are some peculiarities.

Configure:

Please note that this is the name we use in the API on the UI.

_IMPORTANT!!! When making a request to the database, use

msg.payload = {
deleted:false
}
return msg;

This way, we will always receive up-to-date data because when an item is deleted, we will change its value to deleted:true_

The last Node: we can see the response on the debug.

Summary
Now, every time the page is loaded, the table will display up-to-date data from the database.

CRUD operations on the UBOS platform for beginners (part 1)"CREATE".

Vika — Tue, 14 Feb 2023 09:50:26 +0000

CRUD operations are the foundation of most web applications, and they allow you to create, read, update, and delete records in a database. In this series of articles, we'll take a look at how to perform the first operation Create on UBOS, the popular low-code platform for building web applications.

Creating records the UI on UI editor and backend on Node-RED.
Let’s look at each method separately and create the phonebook.

Create- operation is one of the four basic CRUD (Create, Read, Update, Delete) operations used in database management. The "Create" operation is used to add new records to a database.
Advise you to read before starting work :

Step 1:
The first step is to gather the data that you want to add to the database.

Widgets we need:

|An FORM widget would be used to gather the data: name,email,phone number. Widget FORM already has widgets TEXT (use for title) and BUTTON(use for submit).

INPUT is used to input information and can have different types of data such as text,email,number. Depends on the needs.

Step 2:

Create API
In UBOS UI, you can create an API (Application Programming Interface) to allow your application to interact with a database and perform CRUD operations. Here's a simple explanation of how to create an API in UBOS:
To create the API you'll use the visual interface to build the API using a series of actions and triggers.

Add new API

It is important to call it as the endpoint on the backend is named.

The selected method must also match the method on the backend, in this case it is POST. In the body we pass the information collected from the form. Note that the content type - is json so it's good practice to use the JSON.stringify() method in the body.

We call this API on the onclick event of the button in the FORM.

Step 3:
Flow Builder UBOS is a visual tool for creating and managing APIs and integrations. You can use Flow Builder UBOS to create a backend for your application that can perform CRUD operations on a database. Here's a simple explanation of how to create a backend using Flow Builder UBOS.

*Now a little more about each node *

"http in" is a built-in node in Node-RED that allows you to receive incoming HTTP requests. The "http in" node acts as a server that listens for incoming requests and passes them to other nodes in the flow for processing. The "http in" node is commonly used in Node-RED to create APIs and webhooks that can be consumed by other applications.
Here are some of the key features of the "http in" node in Node-RED:
HTTP methods: The "http in" node supports all of the standard HTTP methods, including GET, POST, PUT, DELETE, and others. You can use this node to handle different types of requests, such as retrieving data from the server, submitting data to the server, or deleting data from the server.
URL patterns: The "http in" node allows you to define URL patterns that determine which incoming requests are handled by the node. For example, you can use the node to handle all requests to a specific endpoint, or to handle requests that match a particular pattern.
Request and response handling: The "http in" node provides access to the incoming request and the outgoing response, allowing you to process the request and generate a response. You can use other nodes in the flow to perform operations such as data validation, database queries, and data manipulation.
Middleware: The "http in" node allows you to add middleware functions that can be used to perform operations such as authentication, data validation, or data transformation. You can use middleware to implement custom logic that is executed before the request is passed on to other nodes in the flow.

In our case we use the method POST for creating new collection.

The "function" node in Node-RED is a core node that allows you to perform custom processing on incoming data in your flows. The "function" node provides a simple way to add custom logic to your flows, and it's a very flexible node that can be used for a wide range of tasks.

Here are some of the key features of the "function" node in Node-RED:

JavaScript code: The "function" node allows you to write JavaScript code that can be executed when a message arrives at the node. The code can be used to perform operations such as data manipulation, data validation, or database queries.
Input and output: The "function" node can receive input in the form of a message, and it can send output in the form of a message. The input and output messages can contain data in a wide range of formats, including JSON, XML, and plain text.
Context: The "function" node provides access to a context object that can be used to store data that is specific to the current flow. You can use the context object to store data such as configuration settings, user-defined variables, or intermediate results from processing.
Debugging: The "function" node provides built-in debugging support that allows you to view the input and output messages and to step through the code line by line to understand how it works.For example node.warn(msg.payload)
Reusable logic: The "function" node allows you to create reusable logic that can be used across multiple flows in your Node-RED application. This makes it easy to implement common functionality, such as data validation, data transformation, or database queries, that can be used by multiple flows.

We can also use npm modules such as objectid() in more detail in the next article.

In our case we use it for creating new collection "phonebook"and build a data storage structure.

In the message we receive data from the UI, but pay attention to two things:

We don’t need to generate _id this automatically makes mongodb.
We add deleted:false for items. We will use it for a "soft delete" in the "DELETE" part.

The "node-red-node-mongodb" node is a MongoDB node for Node-RED, which allows you to interact with a MongoDB database from within your Node-RED flows. The "node-red-node-mongodb" node provides a simple and easy-to-use interface for performing common database operations, such as inserting, updating, retrieving, and deleting data.

Here are some of the key features of the "node-red-node-mongodb" node:

Connection configuration: The "node-red-node-mongodb" node allows you to define a connection to a MongoDB database, which can be used to perform database operations. The connection configuration includes details such as the hostname, port, database name, and credentials.
CRUD operations: The "node-red-node-mongodb" node provides built-in support for common database operations, including inserting, updating, retrieving, and deleting data. You can use the node to perform these operations with just a few clicks, and the node automatically handles the details of connecting to the database and executing the appropriate commands.
Query support: The "node-red-node-mongodb" node provides support for querying data from the database, allowing you to retrieve data based on specific criteria. The node provides a simple interface for defining queries, and it supports a wide range of query options, including sorting, limiting, and skipping.
Data manipulation: The "node-red-node-mongodb" node allows you to manipulate the data in the database, including updating and transforming data as it is retrieved from the database. You can use the node to perform operations such as data validation, data transformation, or data enrichment.
Error handling: The "node-red-node-mongodb" node provides built-in error handling that allows you to respond to errors that occur during the processing of database operations. For example, you can use the node to return an error response if the database is unavailable, or if the query fails to return any data.

In our case we use :

 Server -  Companies (name depends on how you named your server when you built the server)
Collection - phonebook (name of the collection you create)
 Operation - insert
  select Only store msg.payload object

The "debug" node in Node-RED is a built-in node that allows you to see the messages that are passing through your flows in real-time. The "debug" node provides a simple and convenient way to debug your flows and to view the data that is being processed by your nodes.

Here are some of the key features of the "debug" node in Node-RED:

Message inspection: The "debug" node allows you to inspect the messages that are passing through your flows, including the payload and the topic of each message. This makes it easy to see what data is being processed by your nodes, and to understand how your flows are working.
Real-time updates: The "debug" node updates in real-time, so you can see the messages as they are processed by your nodes. This makes it easy to catch any issues or errors in your flows as they occur, and to make any necessary adjustments.
Output format: The "debug" node provides several options for the output format, including plain text, JSON, and HTML. This makes it easy to format the debug output to suit your needs and to make it easy to read.
Debugging options: The "debug" node provides several options for debugging your flows, including the ability to show the complete message object, to limit the number of messages displayed, and to choose the output format.
Node-RED dashboard: The "debug" node can also be used in conjunction with the Node-RED dashboard to display debug messages on a dashboard. This makes it easy to monitor your flows and to see the status of your nodes in real-time.

Useful tips: to view the whole object of the message, select: complete msg object and and let’s name ,so it will be easier to navigate the console

Summary

When we create an element on the UI and send it to the backend

we write this item into the collection, in order to see this item you need to create the GET request it will be the second part of our article.

Sending SMS with NODE RED

Vika — Fri, 27 Jan 2023 22:04:34 +0000

One of the most popular uses of Node-RED is to send and receive SMS messages using the Twilio API.

In this article, we will show you how to create a flow in Node-RED that sends an SMS message to a specified phone number.

Before starting work:

Step 1: Create a Twilio Account

The first step in sending SMS messages with Node-RED and Twilio is to create a Twilio account.

Link: https://www.twilio.com/console.

You need to sign up and create a project on twilio then you will able to find your Account SID under the "Project Info" section.
Also, you can find your Auth token under the "Project Info" section.

Please keep in mind that you should keep your Account SID and Auth token secure, as they allow access to your Twilio account.

Step 2: Install the Twilio Node

Next, you will need to install the node-red-contrib-twilio package in Node-RED. This package provides a set of nodes that allow you to interact with the Twilio API. You can install it directly from the Palette Manager in the Node-RED interface:

Open the Node-RED editor in your web browser.
Go to the menu on the top right corner and select "Manage palette"
Select the "install" tab.
Search for "node-red-contrib-twilio" in the search bar.
Click on the "install" button next to the package.
Once the installation is complete, the Twilio node should be available in the palette and can be used in flows.

Step 3: Create a new flowFor.

Then you should use Flow Builder UBOS.

NODE	INSTALL
	Basic NODE `node-red 3.0.2`.
	Basic NODE `node-red 3.0.2`
	Basic NODE `node-red 3.0.2`
	Need to install `node-red-node-twilio 0.1.0`

Add the Twilio node

To send an SMS message with Node-RED and Twilio, you will need to add the Twilio node to your flow. To do this, go to the "function" section of the palette and drag the Twilio node onto the workspace. Double-click on the node to open its configuration options and enter your Twilio Account SID and Auth Token.

Add a trigger node

Next, you will need to add a trigger node to your flow. A trigger node is used to initiate the flow. In this case, we will use an HTTP request node as our trigger. Drag an HTTP request node onto the workspace and connect it to the Twilio node. In the HTTP request node configuration, you can specify the HTTP method and endpoint that will trigger the flow.

Add a function node

Finally, you will need to add a function node to your flow. This node will be used to specify the phone number to send the SMS to and the message to be sent. Connect the function node to the Twilio node and enter the following code:

msg.phoneNumber = msg.payload.phoneNumber;
msg.payload = msg.payload.text;
msg.topic = `"+380" ${msg.phoneNumber}`;

return msg;

Deploy the flow

Step 4: You need to create a UI part.

For that you should use UI Editor UBOS

UI WIDGETS	SETTINGS
	An input widget would be used to allow users to enter the phone number or text they want to send an SMS message to. This input could be a text field or a number field, depending on the desired format of the phone number and destination
	A button widget would be used to trigger the function that sends the SMS message. The button could have a label such as "To send" or "Text Message" and when clicked, it would execute the code that sends the SMS message using the phone number entered in the input field.

Step 5: Create the API to send data on backend and call it to the event onClick button To send:

Where the URL consists of the backend address and the Flow name:

https://companybd-632484b419f0331000000199.ubos.tech/sentSms

Body consists of input data:

{
"text:{{JSON.stringify(Input_text.text)}},
"phoneNumber":{{JSON.stringify(PhoneInput.text)}}
}

Figure - Result of the program.