DEV Community: marco-bertelli

Exploring the Power of Language Models: Introducing the LLM RAG Chatbot Series

marco-bertelli — Tue, 02 Jan 2024 13:50:20 +0000

In recent years, language models have revolutionized the way we interact with technology. Their ability to understand and generate human-like text has opened doors to countless applications across various industries. One such innovation that has caught the attention of many is the creation of chatbots powered by Large Language Models (LLMs).

If you've been following the advancements in AI, you might have come across the remarkable capabilities of LLMs like GPT-3. These models have sparked a wave of creativity and innovation, particularly in the realm of conversational AI. One fascinating avenue in this domain is the development of Responsive AI Generative (RAG) models for chatbots.

I'm thrilled to announce a new series on Medium dedicated to exploring the potential and intricacies of LLM RAG chatbots. This series aims to delve deep into the technical aspects, practical applications, and the exciting possibilities that these chatbots offer.

Understanding the Foundation: What is an LLM RAG Chatbot?
Before diving into the series, let's grasp the fundamentals. LLM RAG chatbots leverage large language models like GPT-3 and utilize a Retrieve-And-Generate (RAG) approach. This approach combines the strengths of retrieval-based and generative models, allowing the chatbot to retrieve relevant information from a vast knowledge repository and generate human-like responses.

Series Overview:

Unveiling the Architecture:
The initial part of the series will focus on dissecting the architecture of LLM RAG chatbots. We'll explore how these models are built, discussing the intricate network of algorithms and techniques that enable their functioning.
Training and Fine-Tuning:
Understanding how these models are trained and fine-tuned is crucial. In this segment, we'll dive into the methodologies used to train LLMs for chatbot applications, including data preprocessing, model optimization, and fine-tuning strategies.
Real-World Applications:
The series wouldn't be complete without exploring the practical applications of LLM RAG chatbots. From customer support and education to healthcare and more, we'll examine how these chatbots are transforming various industries.
Ethical Considerations:
With great technological advancements come ethical responsibilities. We'll dedicate a segment to discuss the ethical considerations surrounding LLM RAG chatbots, addressing concerns like bias, privacy, and the responsible use of AI.

Conclusion:
The potential of LLM RAG chatbots is vast and continuously evolving. Through this series, my goal is to provide a comprehensive guide for enthusiasts, developers, and curious minds keen on understanding and leveraging the capabilities of these advanced AI-driven chatbots.

Stay tuned for the upcoming articles in this series as we embark on an insightful journey into the realm of LLM RAG chatbots. Join me in exploring the fascinating world where language meets AI, unlocking new frontiers of conversational technology.

I look forward to sharing this exciting exploration with you all!

If you're interested in the series or have insights to share, feel free to connect with me on Medium. Let's dive deep into the world of LLM RAG chatbots together!

Medium: https://medium.com/@marco.bertelli

SmartHome - your home data in real time!

marco-bertelli — Sun, 28 Aug 2022 21:28:00 +0000

Overview of My Submission

hi, today we are going to see a project that collect your home temperature and humidity in real time!

before talking in the detail about the app is important to understand the architecture.

as we can see there are many different parts:

Backend: write using node js and TS, handle the redis integration using redis OM, MongoDb integration, Aws Iot real time MQTT connection and Tensorflow js model utilization. Use redis for reading the real time sensor messagges over the MQTT channel "machines" and try to find a sensor associated with it, if found insert a datalog of the received data in both MongoDb and redis for rapid real time data into the frontend graph. the alarm logic is associated to the datalogs, if when a datalog is created trigger an alarm rule an active alarm is created and will be closed only when an alarm below the trashold arrive, all the alarms are stored and not deleted. Tensorflow is used to read a very simple regression model and use it for the next hour predictions. the most cool features of the backend are:
- Aws Iot integration
- Tensorflow Js integration to parse an existing ML model and use it into JS
- Redis integration to cache data and use redis JSON and redis search to get real time data
- Redis model generator that take an existing Mongoose model and parse it into a redis one with no code logic!
- the alarms rules that are stored into the database!, an example is:

{
    "_id" : ObjectId("6300e639830e983ff546f7af"),
    "sensorId" : ObjectId("62fce2bc830e983ff546f775"),
    "rule" : {
        ">" : [
            {
                "var" : "temp"
            },
            25.0
        ]
    },
    "name" : "Bedroom High Temperature",
    "type" : "rule"
}

as you can see the rule is a sort of logic!, in fact this is possible by the JSON logic module.

Frontend: retrieve the data from the backend API to make a graph based on a custom range time, in the graph you can choose the sensor who data you want to see, there is also the average temperature and humidity cards in the bottom of the dashboard that show you the Average in the selected range. the alrams are real time and retrived with only 1 minute cache to don't lose the new alarms, as explained before the alrams are created only when a value trigger an alarm trashold. there is also a home map to see the sensors disposition and have an idea of the space, the "SUN" card show you the actual values and not the average. the last card show you the prediction fo the next hour. All the components support the multi theme feature to personalize the user experience.

frontend also have mobile support but only Horizontal not vertical!

Sensors: send real time temperature and humidity data every 5 minutes, integrated with Aws-Iot. this sensor are made using Mongoose Os, a really cool it framework that help to increase speed using simil JS code. for the code see the Firmware repo

Redis: used to store the cache and the partial datalogs data to speed up the responses time and keep retrive graphic data simple.
MongoDb: used to store all other data like sensor and alarms

Previews

Live Preview: Site
after enter into the site select a range and enjoy it!

now that we know the base of the app is time to talk about the redis integration, it help a lot for the graph real time data, because as we say before the data are partial stored into redis to take i for graphs, before redis with only mongo the response time was 300 ms, after 120 ms what a great thing!. i also use redis cache to store the most important and slow enpoint (like the tensorflow one) and it was very helpfull, here we go too see a list of endpoints and used cache:

datalogs/:
- /predict: predict the next hour data, using redis cache to keep it for 15 minutes
- /ambient/now: actual data
- /:sensorId/:interval: get datalogs of a sensor use redis JSON and redis Search!
- /ambient/humidity/:interval: Average humidity
- /ambient/temperature/:interval: Average temp
alarms/:
- /active: get active alrams, use redis cache to store it for 1 minutes
- /finished: get finished alarms: use redis cache to keep it for 3 minutes
sensors/: get the sensor list, use redis cache to keep it for 30 minutes.

so a full list of frontend feature you can try in the live demo!

real time graph data from my house sensors on 1 or more sensor in an interval
2D map to take an idea of sensor position
active alarms up to now!
average temp and humidity in the selected range
card with actuals info
next hours prevision using ML!

futures feature

the only thing that i don't have time to make was a complete ML model, in fact this simple one use a regression but a complete one is a timeseries prevision model!

Submission Category: MEAN/MERN Mavericks

video overview of the project Video

Language Used

Node js / TS for the backend
Angular for the frontend
Mongoose Os for the firmware code

Link to Code

Live Preview: Site
after enter into the site select a range and enjoy it!
BackeEnd repo:

marco-bertelli / iotSensorBackend

Backend with node js and TS for redis hackathon

SmartHome

this is a project that get real time temperature and humidity data from esp32 with DHT22 AM2302 temperature sensor. after this the data is stored in both redis and MongoDb and processed from the frontend (see the other repo for more frontend info)

Overview video

Here's a short video that explains the project and how it uses Redis:

How it works

before start is important to understand the app architecture:

as we can see there are many different parts:

Backend: write using node js and TS, handle the redis integration using redis OM, MongoDb integration, Aws Iot real time MQTT connection and Tensorflow js model utilization. Use redis for reading the real time sensor messagges over the MQTT channel "machines" and try to find a sensor associated with it if found insert a datalog of the received data in both MongoDb and redis for rapid real time data into…

View on GitHub

FrontEnd repo:

marco-bertelli / iotSensorFrontend

Angular ngx-admin frontend for redis challenge

SmartHome

Overview video

Here's a short video that explains the project and how it uses Redis:

How it works

before start is important to understand the app architecture:

as we can see there are many different parts:

Backend: write using node js and TS, handle the redis integration using redis OM, MongoDb integration, Aws Iot real time MQTT connection and Tensorflow js model utilization. Use redis for reading the real time sensor messagges over the MQTT channel "machines" and try to find a sensor associated with it if found insert a datalog of the received data in both MongoDb and redis for rapid real time data into…

View on GitHub

Firmware repo:

marco-bertelli / iotSensorFirmware

the firmware code for the esp32 sensors

SmartHome

Overview video

Here's a short video that explains the project and how it uses Redis:

How it works

before start is important to understand the app architecture:

as we can see there are many different parts:

Backend: write using node js and TS, handle the redis integration using redis OM, MongoDb integration, Aws Iot real time MQTT connection and Tensorflow js model utilization. Use redis for reading the real time sensor messagges over the MQTT channel "machines" and try to find a sensor associated with it if found insert a datalog of the received data in both MongoDb and redis for rapid real time data into…

View on GitHub

Tensorflow Model: if you want more info of tensorflow visit the model here: colab

closure

if you like the project or have any questions leave a like and a comment!
all the shares will be appreciated!

Check out Redis OM, client libraries for working with Redis as a multi-model database.
Use RedisInsight to visualize your data in Redis.
Sign up for a free Redis database.

Azure Trial Hackathon - EmotionalSound - perfect spotify song for your emotions

marco-bertelli — Tue, 08 Mar 2022 00:47:24 +0000

Project Links
Demo
Frontend
BackEnd

Overview of our project
This project goal is to suggest real Spotify songs by understanding face emotions.
This project help you to find perfect sound for your actual mood!
You only have to enter in the demo, take a photo of your face and see which new Spotify song EmotionalSound suggest for you.
If you click the button you can real time listen the song on Spotify!.
Every 5 minutes the back-end search for new real time released and add it to song list.

Preview

Mobile
This project have full mobile support (also Safari), and if you click the Spotify Button you can open the Song in your mobile application

Submission Category:
The category for this project is: AI Aces.
I am using Azure Face API for detecting the face emotions and a custom classification neural network made with Tensorflow and compiled to be used by TensorFlowJs.

In addition, to publish the frontend i am using an Azure Static Webapp (great Angular support) and for the backend an Azure App Service with custom Docker images.

For docker images i use Azure Container Registry.

For frontend i have implemented CI/CD with GitHub Actions.
Instead for back-end i prefer to use Bitbucket with Custom Pipelines for build And Deploy the Docker images.

Neural Network Model:
the neural network model is a quite simple classification model that use the normalized data from Spotify API to understand the mood of a song Based on Song Background Frequency and other values.
To better Understand this part i suggest you to visit and try the Google Collab project here!: Collab Url

Tech Stack
The frontend is written in Angular 11.
From the homepage of the application,you can take picture from your webcam and the image is send as a base64 string directly to the Backend, through an API.

YOUR DATA ARE NOT STORED IN ANY WAY

The backend is written in Node js 16 and Express.
For the database to store the song retrived by Spotify Api i use MongoDb 4.4.
an example of Database doc is:

{ 
    "_id" : ObjectId("6224cff6eff1e8fefdf67e45"), 
    "name" : "Don’t Forget My Love", 
    "__v" : NumberInt(0), 
    "image" : "https://i.scdn.co/image/ab67616d0000b2732cfa4b40e2d7b56fb171dd53", 
    "mood" : "2", 
    "spotifyUrl" : "https://open.spotify.com/track/5L7ddKqhj6xZFeb8ZOoI4r"
}

For interact with Mongodb i use mongoose, an npm library for easy wrap all.
The API receives the base64 string image from the Frontend and sends it to the Azure Face API directly using a simple axios call.
The Back-end get the response from azure and understand the max mood (es happiness) and send it to the client with the saved songs generated from The Neural Network and Spotify Api.
Every 5 minutes the back-end get new spotify releases from the API and Neural Network analise the data for understand the mood of the new song, and save it to Mongo.
On the results page, we display a “dynamic” mood label with the founded songs and a button to real-time listen it.

Azure resources
This is the list of our services deployed on Azure:

CI/CD
I have automated the Frontend builds through CI/CD thanks to two GitHub Actions generated from Azure.

For the back-end i need a more complicated one that make a docker image and release it on the Azure Container Registry

image: atlassian/default-image:2
clone:
  depth: full
pipelines:
  branches:

    master:
      - step:
          name: Deploy to Azure
          caches:
            - docker
          services:
            - docker
          script:
            - docker login emotionalsound.azurecr.io -u $AZURE_USER -p $AZURE_PASS
            - docker build -t emotionalsound.azurecr.io/prod:latest .
            - docker push emotionalsound.azurecr.io/prod:latest
definitions:
  services:
    docker:
      memory: 3072  # increase docker memory for unit testing into the pipe

RoadMap
the project is official on Beta stage, my roadMap is to improve before the end of Hackathon the import system to get more song to suggest, and random shuffle it for get more result variety.

If anyone encounters any kind of bug, please report it in the comments

About Me
My name is Marco Bertelli, i am a 21 years old back-end developer that work in Runelab.
This is my first Hackathon, if you have suggestions or comments are Welcome.
If you like the project Comment and Share this article on Linkedin or with your friend!

If anyone has any questions or suggestions, don't hesitate to leave a comment!

mongoose recommended plugin

marco-bertelli — Sun, 28 Nov 2021 16:52:18 +0000

the scope of this library is allow mongoose users to implement in a simple way a content-based recommended system with mongoose schema,
is pretty simple and in future i want to introduce a collaborative-filter method.

how work?:
calculate similarities between mongoose entities on a single text field using tfidf and vector distance, for more search content-based systems descriptions

how to use this library
after install in your project add the plugin in entity schema in wich you want similar entities:

import { RecommendedPlugin } from 'mongoose-recommended-plugin';

const mongooseSchema = {

    YOUR SCHEMA DEFINITION

    };


    // before generating the model 
    mongooseSchema.plugin(RecommendedPlugin);

after add the plugin to schema you can put in schema types two new field:

similar = indicate the text field to calculate similarity like name or description
minSimilarity = indicate the min percentage to mark another entity similar (es 0.1 is 10%)

an example:

{
        offerCode: {
            type: String,
            odinQFilter: true
        },
        discountCode: {
            type: String,
        },
        // make sure place similar on a String field!
        discountDescription: {
            type: String,
            odinQFilter: true,
            similar: true,
            minSimilarity: 0.1
        },
        originalPrice: {
            type: Number
        },
        discountedPrice: {
            type: Number
        },
        discountPercentage: {
            type: Number
        },
        startDate: {
            type: Date
        },
        endDate: {
            type: Date
        },
        neverExpire: {
            type: Boolean,
            default: false
        },
        offerLink: {
            type: String
        },
}

after this on the basic schema you have 2 new methods that allow you to calculate similars and get it:

calculateSimilars
getSimilar

important
before calling getSimilar you have to call calculateSimilars to calculate and save in the db the similars.
we will see it now

now we have to call calculateSimilars to get and save into db the results (plugin will save results in a collection name: BASIC_COLLECTION_NAME+similarresults).

for using it i suggest using a schedulr like it:

import schedule from 'node-schedule';
import Offers from '../../api/offers/model';

const log = logger.child({ section: '\x1B[0;35mScheduler:\x1B[0m' });

export const start = function () {
    log.info('Starting...');

    schedule.scheduleJob('*/10 * * * * *',calculateSimilarsResult);

    log.info('Starting...', 'DONE');
};

async function calculateSimilarsResult(){
    await Offers.calculateSimilars();
}

this is an example of how calculate similars every 10 seconds, ut you can call it when you want and how you want.

after this we can call seconds method passing the _id of entity for wich we want similars:


await Offers.getSimilar('619d2d91eac832002d2f36de')

and thats all!

db format of plugin save


{ 
    "_id" : ObjectId("61a25cae646804e510d84f92"), 
    "relatedScore" : [
        {
            "id" : ObjectId("619d2d91eac832002d2f36de"), 
            "score" : 0.45293266622972733
        }
    ], 
    "entityId" : "619ac77c39dd6b002d1bd3bb", 
    "__v" : NumberInt(0)
}

for questions or contribute write at marco.bertelli@runelab.it

i hope this library will be helpfull, if you like the project like and share this article!

Terraform Trello integration

marco-bertelli — Wed, 11 Aug 2021 09:12:43 +0000

Hi everyone, today we are going to watch my first open-source terraform custom provider in collaboration with Runelab (an italian custom software and project agency).

but first what do this provider?

allow you to create a workspace,board and custom list when you create a normal project on terraform!

this automate the process of creating a trello workspace, board and lists when you create a normal project.

see an example:

#other resources creations like server and cloudfront

  required_providers {
    trello = {
      source = "marco-bertelli/trello"
      version = "0.2.3"
    }
  }
}


resource "trello_board" "my-board-name" {
    key = "your-key"
  token = "your-token"
  workspace_name = "terraform-trello"
  board_name = "test"
  cards = ["new","todo","custom"]
}

you must put this code into main.tf

how you can see you need a trello api key and a trello token of the account in who you want to create the workspace and board (you can find key and token here link)

and later chose a name for workspace the board name and the lists names and is all!
run:

terraform init
terraform apply and you will see all online

here the result:

if you like this like and share to the community!

A LOT OF ANGULAR TUTORIALS!

marco-bertelli — Sat, 17 Oct 2020 15:17:10 +0000

how i wrote in my last post in the next two weeks it we will up my new project (a new site called angularDevCommunity in which i will post a lot of angular tutorial since lazy loading up to develop a full headless cms angular responsive project), stay tunned !

A BIG ANGULAR IDEA...

marco-bertelli — Tue, 13 Oct 2020 07:58:58 +0000

hi guys, i am new but i have a big idea, what do you think if i do a sites called AngularForDeveloper in which i post angular tutorial and my real project??