Forem: Benard Mseti

How to work with OpenAI APIs

Benard Mseti — Sun, 20 Aug 2023 14:02:25 +0000

If you are confused about how OpenAI APIs work, this post will give you a high overview and explain to you how you can utilize the Basic Chat Completion API.

Just like any other RESTful APIs you have worked with before, all we do is setup a request from our client and send the payload to OpenAI’s server and we will receive a response back from them based on the query we sent.

But what do you put in the client request?

The client request is composed of the instructions that we want OpenAI to process and then send back a response based off this payload. For OpenAI, the payload will consist of the model we want to use, messages (prompt, assistant and user messages) and temperature.

As seen above, messages will contain three sets of roles, system, assistant, and user. All the messages should be added to this list if you are working with a chatbot that needs to have the memory of previous chats between user and assistant.

For the temperature, the lower the temperature the more predictable and repetitive the responses returned will be. 0.7 is the recommended temperature but tune it to fit your needs.

I hope you have learned something new!

Don’t forget to follow my socials for more of these short tutorials.

Twitter

Set up a Stripe Checkout REST API (+ metadata) using Go and Gin Framework.

Benard Mseti — Wed, 14 Jun 2023 16:30:23 +0000

Implementing payment APIs for a go backend may be a struggle not only for gin framework developers that are just starting out but also the ones that have been using the framework for a while.

This article will show how to simply integrate a stripe checkout REST API that will produce links to a stripe checkout screen for your users to perform payments in your apps.

First install stripe package using this command

go get -u github.com/stripe/stripe-go/v74

Now add this controller

func CreateCheckoutUrl(c *gin.Context) {
    var body struct {
        Amount       int64  `form:"amount"`
        ReceiptEmail string `form:"email"`
                Metadata     string `form:"metadata"`
    }

    if err := c.Bind(&body); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": "Failed to read body",
        })

        return
    }

    apiKey := os.Getenv("STRIPE_SECRET_KEY")
    stripe.Key = apiKey

    domain := "https://your.domain.com/"
    params := &stripe.CheckoutSessionParams{
        LineItems: []*stripe.CheckoutSessionLineItemParams{
            {
                PriceData: &stripe.CheckoutSessionLineItemPriceDataParams{
                    Currency: stripe.String("usd"),
                    ProductData: &stripe.CheckoutSessionLineItemPriceDataProductDataParams{
                        Name: stripe. String("Product Name Here"),
                    },

                    TaxBehavior: stripe.String("exclusive"),
                    UnitAmount:  stripe.Int64(body.Amount * 100),
                },
                Quantity: stripe.Int64(1),
            },
        },
        CustomerEmail: &body.ReceiptEmail,
        Mode:          stripe.String(string(stripe.CheckoutSessionModePayment)),
        SuccessURL:    stripe.String(domain + "/"),
        CancelURL:     stripe.String(domain + "/"),
        AutomaticTax:  &stripe.CheckoutSessionAutomaticTaxParams{Enabled: stripe.Bool(true)},
    }

    params.AddMetadata("id", body.Metadata)

    fmt.Println("params - ", params)

    s, err := session.New(params)

    if err != nil {
        log.Printf("Error creating session: %v", err)
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": err.Error(),
        })
        return
    }

    c.JSON(http.StatusOK, gin.H{
        "checkout_url": s.URL,
    })
}

In your routes add the following endpoint

// stripe api
    r.POST("/create-checkout-url/", controllers.CreateCheckoutUrl)

Done, You can now deploy your gin backend and test the API by making a post request to the endpoint we just created.

Simplest way to deploy a Flutter Web App

Benard Mseti — Mon, 12 Jun 2023 12:57:50 +0000

Flutter is a cross-platform framework which allows us to build and deploy apps for different platforms using a single codebase.

In this tutorial, you'll learn how to deploy your Flutter webapp using Railway.

Let's dive in!

Open your IDE terminal and run



flutter build web --web-renderer html

This will ensure that the webapp uses html rendering on all devices that it is accessed from.

Let the app build run:

Next

In the project folder look for build/web file directory

Right click on the web directory and open the file -> Use Finder(mac)/File Explorer(Windows).

The web directory carries our whole compiled Flutter web app.

Next step is to commit the files to github.

Open github and create a new repository with your desired name.

You can make the repository public/private depending on your requirements.

Click on upload existing files as seen above and then drag and drop the contents from our web directory to the github repository and wait for all files to be uploaded.

Once upload is done, commit changes and wait for the files to be proceed.

Your repository should now look like this 👇🏾

Let's set up railway

Next go to railway and follow below steps.

Click on start a new project
Choose deploy from github repo

Choose repository to deploy, ours was 'myappname'

Select Deploy Now

Wait for build to finish

Select Add a Domain

Voila! You now have successfully deployed your Flutter Webapp, you can access it through the link provided.

Here's the example site

github webapp project

Connect with me on twitter 😊 if you have any questions.

Configure CORS for a Go backend

Benard Mseti — Sun, 11 Jun 2023 08:41:35 +0000

According to mozilla.org, Cross-Origin Resource Sharing (CORS) is an HTTP-header based mechanism that allows a server to indicate any origins (domain, scheme, or port) other than its own from which a browser should permit loading resources.

When writing a backend for your app using golang in the local environment you can perform requests to your APIs without the need to configure CORS, but once you deploy the backend you will require CORS or else you will face errors communicating with the backend.

This tutorial will help you fix this error in a go backend that uses gin framework.

We will first download and install the cors middleware using the following line

go get github.com/gin-contrib/cors

Then now import to your main.go file

import "github.com/gin-contrib/cors"

Now let's add cors middleware

Add the following code in the main.go file

func main() {
    r := gin.Default()
    config := cors.DefaultConfig()
    config.AllowAllOrigins = true
    config.AllowMethods = []string{"POST", "GET", "PUT", "OPTIONS"}
    config.AllowHeaders = []string{"Origin", "Content-Type", "Authorization", "Accept", "User-Agent", "Cache-Control", "Pragma"}
    config.ExposeHeaders = []string{"Content-Length"}
    config.AllowCredentials = true
    config.MaxAge = 12 * time.Hour

    r.Use(cors.New(config))
}

Your main.go file should now look like below now;

package main

import (
    "time"

    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    "github.com/username/appname/controllers"
)

func init() {
    //initialize app
}

func main() {
    r := gin.Default()
    config := cors.DefaultConfig()
    config.AllowAllOrigins = true
    config.AllowMethods = []string{"POST", "GET", "PUT", "OPTIONS"}
    config.AllowHeaders = []string{"Origin", "Content-Type", "Authorization", "Accept", "User-Agent", "Cache-Control", "Pragma"}
    config.ExposeHeaders = []string{"Content-Length"}
    config.AllowCredentials = true
    config.MaxAge = 12 * time.Hour

    r.Use(cors.New(config))

        //Add endpoints here
    r.POST("/ping/", controllers.Pong)

    r.Run()
}

You can now deploy and run your go backend successfully on a serverless platform like railway easily and CORS error should be fixed now.

Have any questions?