Forem: Beaudry Jean Sauvenel

Introducing the Stream GPT Data Extraction NPM Package!

Beaudry Jean Sauvenel — Wed, 09 Aug 2023 02:04:17 +0000

I am excited to announce the release of the Stream GPT Data Extraction NPM package, a powerful tool that brings a new level of interactivity and dynamism to your applications powered by OpenAI’s GPT-4 language model. With this package, developers can now interact with GPT-4 in real-time, stream partial prompts, receive intermediate responses, and even extract objects from the generated text before the full response is received. This opens up a world of possibilities for building dynamic and intelligent applications that leverage the capabilities of GPT-4.

Why Stream GPT Data Extraction?
Traditionally, when using language models, developers had to wait for the complete response after sending a prompt. However, this process can be limiting for certain use cases where real-time interaction and extraction of relevant information are crucial. The Stream GPT Data Extraction NPM package addresses this limitation by offering a more flexible and efficient way to work with GPT-4, allowing users to tailor their responses and extract valuable objects from the generated text on-the-fly.

Getting Started
To get started with the Stream GPT Data Extraction NPM package, you’ll need to install it first. Open your terminal or command prompt and run one of the following commands:

npm install stream-gpt-data-extraction sse.js
OR
yarn add stream-gpt-data-extraction sse.js

Usage

Import methods first

import {
  StreamTextResponse,
  StreamObjectResponse,
} from "stream-gpt-data-extraction";

Initializing GPT-4 Text Streaming To begin using GPT-4 Text Streaming, you will need your OpenAI API key and the prompt. If you don’t have an API key yet, head over to the OpenAI website and sign up to obtain one.

StreamTextResponse(
    OPENAI_KEY,
    "Hello",
    (response) => console.log("RESPONSE", response),
    (status)   => console.log("STATUS", status)
);

Initializing GPT-4 Objects Streaming For GPT-4 Object Streaming, the process is similar. You’ll need your OpenAI API key and the prompt.

StreamObjectResponse(
    OPENAI_KEY,
    "Two Chuck Norris Jokes to make you laugh",
    (response) => console.log("RESPONSE", response),
    (status)   => console.log("STATUS", status)
);

How it Works
The Stream GPT Data Extraction NPM package utilizes Server-Sent Events (SSE) to establish a continuous connection with the GPT-4 language model. This enables a seamless stream of partial responses that are received and processed in real-time. Additionally, the ability to extract objects from the generated text as it is being generated allows developers to fine-tune their applications and obtain relevant information without waiting for the entire response.

Conclusion
The Stream GPT Data Extraction NPM package brings a new era of interactivity and dynamism to applications powered by OpenAI’s GPT-4 language model. With the ability to stream partial prompts, receive intermediate responses, and extract objects from the generated text, developers can create more interactive and intelligent applications than ever before. We can’t wait to see the innovative applications and experiences you will build with this powerful tool.

Get started with Stream GPT Data Extraction today and unleash the full potential of GPT-4 in your projects! Happy coding!

👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽👇🏽
https://www.npmjs.com/package/stream-gpt-data-extraction

🇭🇹🇭🇹🇭🇹 Made with love by jsbeaudry from Haiti 🇭🇹 🇭🇹 🇭🇹

How create a USD Bank on Ethereum, BSC and Polygon blockchain?

Beaudry Jean Sauvenel — Mon, 20 Dec 2021 03:00:27 +0000

The digital currency revolution is now spreading to the banking industry, as cryptocurrency begins to reshape the way people borrow and save.

Decentralized finance, or DeFi, describes an alternative financial ecosystem where consumers transfer, exchange, borrow, and lend cryptocurrency, independent of the traditional financial institutions and regulatory structures that have been built around banking services and the central bank.

In this article, I will show you how to start your own bank without the approval of your country's central bank. I have always been fascinated by how to change the banking system in my country (Haiti) where almost all banking services are reserved and concentrated to a group of people and the majority of the population does not have a bank account and does not even access to basic credit.

Let's started:

We're going to use the ERC20 standard from Ethereum.

ERC20?
Ethereum request for comment

An ERC20 token is a standard used for creating and issuing smart contracts on the Ethereum (BSC, Polygon, Avalanche, etc..) blockchain. Smart contracts can then be used to create smart property or tokenized assets that people can invest in. ERC stands for "Ethereum request for comment," and the ERC20 standard was implemented in 2015.

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;

interface IERC20 {

    function totalSupply() external view returns (uint);

    function balanceOf(address account) external view returns (uint);

    function transfer(address recipient, uint amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint value);

    event Approval(address indexed owner, address indexed spender, uint value);

}

The first part content the minimum you need as parent functions to create your bank smart contract.

Understand these functions above: https://ethereum.org/en/developers/tutorials/understand-the-erc-20-token-smart-contract/

Now it's time to code our smart contract:


contract DefiBank {

    // call it DefiBank
    string public name = "DefiBank";

    //Owner of the bank
    address public owner;

    // create 2 state variables
    address public usdc;      // The token you will accept
    address public bankToken; // The token that represents your bank that will be used to pay interest

    // create 1 array to add all your clients
    address[] public stakers;

    // create a 3 maps 
    mapping(address => uint) public stakingBalance; //Clients balance
    mapping(address => bool) public hasStaked; // Find out if this customer has created an account
    mapping(address => bool) public isStaking; // Find out if this customer is using their account

    ......
}

New we will create the functions to interact with these variables.

......

    // In constructor pass in the address for USDC token,  set your custom bank token and the owner will be who will deploy the contract
    constructor() public {
        usdc = INPUT-USDC-TOKEN-ADDRESS-RELATE-TO-THE-BLOACKCHAIN;
        bankToken = INPUT-YOUR-TOKEN-ADDRESS-HERE;
        owner = msg.sender;
    }

......

......

    // Change the ownership 
     function changeOwner(address newOwner) public {
    // require the permission of the current owner
        require(owner == msg.sender, “Y”our are not the current owner);
        owner = newOwner;
    }

......

.......

 // allow user to deposit usdc tokens in your contract

    function deposit(uint _amount) public {

        // Transfer usdc tokens to contract
        IERC20(usdc).transferFrom(msg.sender, address(this), _amount);

        // Update the account balance in map
        stakingBalance[msg.sender] = stakingBalance[msg.sender] + _amount;

        // Add user to stakers array if they haven't staked already
        if(!hasStaked[msg.sender]) {
            stakers.push(msg.sender);
        }

        // Update staking status to track
        isStaking[msg.sender] = true;
        hasStaked[msg.sender] = true;
    }

......

......

    // allow user to withdraw total balance and withdraw USDC from the contract

     function withdrawTokens() public {

        // get the users staking balance in usdc
        uint balance = stakingBalance[msg.sender];

        // require the amount staked needs to be greater then 0
        require(balance > 0, "staking balance can not be 0");

        // transfer usdc tokens out of this contract to the msg.sender (client)
        IERC20(usdc).transfer(msg.sender, balance);

        // reset staking balance map to 0
        stakingBalance[msg.sender] = 0;

        // update the staking status
        isStaking[msg.sender] = false;

} 

......

......

    // Send bank tokens as a reward for staking. You can change the way you need to give interest if you want

    function sendInterestToken() public {
    // require the permission of the current owner
        require(owner == msg.sender, "Your are not the current owner");

        for (uint i=0; i<stakers.length; i++) {
            address recipient = stakers[i];
            uint balance = stakingBalance[recipient];

    // if there is a balance transfer the same amount of bank tokens to the account that is staking as interest

            if(balance >0 ) {
                IERC20(bankToken).transfer(recipient, balance);

            }

        }

    }
......


}

That's all you need to disrupt your country's banking system.

Remember to create the bank token separately before deploying the smart contract.

Thanks, hope this minimal smart contract will help a lot of you.

Complete code: https://gist.github.com/jsbeaudry/d61de7c738cc31018e210f3a96ba1508

Build and publish an api quickly with express.

Beaudry Jean Sauvenel — Mon, 14 Oct 2019 03:20:00 +0000

Today when you plan to build an api many things come in your head like you say why not use a serverless platform like Firebase, AWS, Stich etc. Because build an api can take some time to:

1- Identify the entities
2- Manage the relationship between them
3- Plan the routes
4- Authentification
5- Security
6- Etc.

In this article i am going to show you how you can build an Api easily. To start we will use node.js with express as the main tools.

The first thing you need to do is identify our entities by example we will do a api for a blog.

As entities we have : users, articles, comments

Now let's start:

1 - Download and install node if not yet done.
link: https://nodejs.org/en/

2 - Install Yoeman,
Yeoman helps you to kickstart new projects, prescribing best
practices and tools to help you stay productive.

  $ npm install -g yo

3 - Install generator-api
Generator for creating RESTful NodeJS APIs, using ES6,
Mongoose and Express. The fastest way to get your project up and
running using an awesome stack.

  $ npm install -g generator-api

4 - Ok, once done type yo api and answer the questions

  $ yo api
  ? Server name: blog-api
  ? Server description: Api to manage my blog
  ? Server version: 1.0.0
  ? Author name: Jean Sauvenel Beaudry
  ? Author email: sauvene2013@gmail.com
  ? Models: (singular and comma separated) users,articles,comments
  ? what should the database be named? mongo_string_db
  ? would you like to have Docker included in the app? No
  create package.json
  create config.js
  create index.js
  create routes.js
  create .gitignore
  create .eslintrc.json
  create .eslintignore
  create lib/controller.js
  create lib/facade.js
  create model/users/controller.js
  create model/users/facade.js
  create model/users/router.js
  create model/users/schema.js
  create model/articles/controller.js
  create model/articles/facade.js
  create model/articles/router.js
  create model/articles/schema.js
  create model/comments/controller.js
  create model/comments/facade.js
  create model/comments/router.js
  create model/comments/schema.js
  create README.md

5 - Alright our blog is created. To test it we need to connect the api with a database. To do that we are going to use MongoDB

MongoDB is a cross-platform document-oriented database program. Classified as a NoSQL database program, MongoDB uses JSON-like documents with schema. It's a super database platform to start. Go on the link to create a mongo database instance like that:

mongodb+srv://user:passwordx@cluster.mongodb.net/database_name?retryWrites=true&w=majority

Link: https://www.mongodb.com

6 - Go to config.js replace mongodb://localhost/mongo_string_db with your new mongodb string or use a .env file to affect MONGO_DB_URI (recommend for more secure).

   const config = {
   environment: process.env.NODE_ENV || 'dev',
   server: {
   port: process.env.PORT || 8080
   },
   mongo: {
   url: process.env.MONGO_DB_URI || 
   'mongodb://localhost/mongo_string_db'
   }
  }

7 - Now we are ready to go. Just type

  $ npm start  or yarn start

You can use postman test your CRUD.

Next articles:
1 - Secure this Api.
2 - Authenticate your users
3 - Grow it by adding new model
6 - Deploy with a single command line using Zeit (Now)

Thank you for reading. My current project : https://www.snipplabs.com/