DEV Community: New Bing

How to Fix Google Auth Platform Verification Issues (Your home page URL is unresponsive)

New Bing — Thu, 12 Dec 2024 04:48:37 +0000

Struggling with Google Auth Platform’s home page verification? You’re not alone! Here’s a simple guide to solve the issue and pass the checks.

I recently applied for OAuth Consent screen verification! If you’ve been pulling your hair out trying to get your application’s home page verified on Google Auth Platform, you’re in the right place. I recently went through the same frustration. After two days of testing and troubleshooting, I discovered the exact requirements to pass the verification process. Spoiler alert: they’re not as intuitive as you’d hope.

The Two Key Requirements for Verification

Google’s home page verification hinges on two important criteria. Missing either of them will lead to errors and failed checks. Here’s what you need to know:

1. Your Home Page Must Support HTTP (Not Just HTTPS)

Google Auth Platform requires your website’s home page to be accessible via HTTP. If your site only supports HTTPS or automatically redirects HTTP requests to HTTPS, the verification will fail. Instead, you’ll see an error message like this:

"Your home page URL is unresponsive."

This can be incredibly confusing, especially since HTTPS is considered best practice for web security. However, to pass Google’s checks, make sure your home page responds to HTTP requests without redirecting to HTTPS during the verification process.

2. Your Home Page Must Contain the Privacy Policy URL

Your website’s home page also needs to fully include the URL of your privacy policy. Without it, Google will throw an error, even if everything else is configured correctly.

This might mean adding a clear link or reference to your privacy policy directly on your home page—not just buried in a menu or footer. Make sure the URL is complete and points directly to the correct page.

Quick Fix Checklist

Here’s a step-by-step checklist to get your home page verified:

Enable HTTP Support:

Ensure your site is accessible via HTTP, at least temporarily for the verification process.
Disable any automatic redirection from HTTP to HTTPS.

Add Privacy Policy Link:

Place a visible link to your privacy policy on your home page.
Double-check that the URL is complete and points to the right page.

Test Before Submitting:

Visit your home page using HTTP to confirm it’s working.
Check that the privacy policy link is clearly visible and functional.

Final Thoughts

Getting through Google Auth Platform’s home page verification can be frustrating, but following these two key steps will save you time and headaches. Once your site meets the criteria, you’ll be able to move forward without those annoying error messages.

Get TapAI: https://tapai.aicanvas.app/

Get Dot Copilot: https://dotcopilot.ai/

How I Boost My Productivity with TapAI Shortcut: A Game-Changing Tool for Everyday Tasks

New Bing — Wed, 27 Nov 2024 17:12:59 +0000

Get TapAI: https://tapai.aicanvas.app/

Introduction

Productivity in our fast-paced world often hinges on seamless multitasking and minimizing disruptions. As someone who juggles multiple responsibilities, I found TapAI to be an indispensable tool for streamlining my daily tasks. With its AI-powered capabilities, I can handle everything from scheduling events to tracking expenses—without ever leaving the app I’m using.

Here’s how I use TapAI to boost my productivity every single day.

My TapAI Workflow: Simplifying Everyday Tasks

Schedule Events from Conversations

TapAI makes scheduling effortless. It extracts meeting dates and times from my chat conversations and directly adds them to my Apple Calendar. No need to copy-paste or manually input details—it’s all automatic.
Add To-Dos to Reminders

Whether it’s a task from a chat or something noted on an image, TapAI quickly pulls it and adds it to Apple Reminders. This way, I never miss a deadline or an important task.
Track Expenses Effortlessly

TapAI extracts expense details from texts or digital receipts and syncs them to a pre-configured Google Sheet. It’s an easy way to keep track of my spending without manually logging each transaction.
Summarize Web Pages in Seconds

When I’m browsing the web, I use TapAI to summarize lengthy articles or reports directly within my browser. It condenses the content into actionable insights, saving me valuable time.
Translate On-Screen Text and Messages

Communicating with overseas friends is seamless with TapAI. It translates on-screen text or chat messages instantly, so I can reply without leaving the conversation.
Create Notes from Summarized Web Content

When I find useful content online, TapAI not only summarizes it but also sends the summary directly to my notes app. This makes organizing and referencing information a breeze.

Why TapAI Works for Me

Uninterrupted Workflow: TapAI operates seamlessly within the app I’m using, eliminating the need to switch between multiple tools.
AI Efficiency: The advanced AI, powered by ChatGPT, ensures accuracy and context in every task.
Versatile Functionality: From scheduling to translating, TapAI tackles various productivity challenges effortlessly.

How TapAI Boosts My Productivity

By integrating TapAI into my daily routine, I’ve reclaimed countless hours that would otherwise be lost to manual tasks. Its ability to extract, summarize, and organize information in real time allows me to focus on what truly matters.

Conclusion

TapAI is more than a tool; it’s a productivity booster that streamlines tasks and keeps me organized without interruptions. If you’re looking for a way to manage schedules, track expenses, translate messages, and more—all while staying in the flow—TapAI is the solution you need.

Discover how TapAI can transform your productivity here!

iOS 18 - Using ChatGPT powered TapAI shortcut with Apple Notes, Reminders & Calendar for automation

New Bing — Sun, 29 Sep 2024 11:37:33 +0000

TOC:

Create a calendar event with TapAI
Create a reminder with TapAI
Create a note with TapAI
Reply or comment a tweet with TapAI ________________________________________

Get TapAI: https://tapai.aicanvas.app
Tutorial: https://tapai.aicanvas.app/tapai-tutorial

TapAI is an intelligent assistant that simplifies task management by extracting text from your screen with a double-tap. It seamlessly integrates with Apple apps like Calendar, Reminders, and Notes, while also supporting automatic bill parsing into Google Sheets. With advanced ChatGPT processing and secure data handling, TapAI boosts productivity while ensuring privacy.

Thanks for watching and God Bless 😊

How to install the Weaviate vector database on Debian 12

New Bing — Thu, 03 Aug 2023 08:59:06 +0000

I've researched a variety of vector databases. Like Pinecone, Redis, Qdrant, Milvus, Weaviate, Chroma, pgvector. After comparing them, I chose Weaviate as my vector database.

How to install Weaviate on Debian 12

First, Download Weaviate

Go to github.com/weaviate/weaviate, then find the version that is suitable for your operating system.
I chose to download weaviate-v1.20.3-linux-amd64.tar.gz

mkdir vectordb
cd vectordb
wget https://github.com/weaviate/weaviate/releases/download/v1.20.3/weaviate-v1.20.3-linux-amd64.tar.gz

Then install Weaviate

First unzip the file, then add the configuration file.

tar -zxvf weaviate-v1.20.3-linux-amd64.tar.gz

You need to configure the authentication and data persistence environment as below. We use API authentication for test.

export AUTHENTICATION_APIKEY_ENABLED=true
export AUTHENTICATION_APIKEY_ALLOWED_KEYS=q8Z5HN4U2w8jUDRGeGxyKkqvwjPg7w4P
export AUTHENTICATION_APIKEY_USERS=newbing@example.com
export PERSISTENCE_DATA_PATH=/home/newbing/vectordb/data

Launch Weaviate

After unzip file and set the environment, you can launch a instance of weaviate.

./weaviate --host=127.0.0.1 --port=8181 --scheme=http

Launch with supervisor

If you don't want to start or stop by hand, you can use Supervisor to manage the Weaviate instance.
The supervisor config file:

[program:weaviate]
directory=/home/newbing/vectordb/
command=/home/newbing/vectordb/weaviate --host=127.0.0.1 --port=8181 --scheme=http
autostart=true
autorestart=true
user=www
environment=HOME="/home/www",AUTHENTICATION_APIKEY_ENABLED="true",AUTHENTICATION_APIKEY_ALLOWED_KEYS="q8Z5HN4U2w7jUDRGeGxyKkqvwjPg7w4P",AUTHENTICATION_APIKEY_USERS="newbing@example.com",PERSISTENCE_DATA_PATH="/home/newbing/vectordb/data"
numprocs=1
redirect_stderr=true
stdout_logfile=/var/log/supervisor/weaviate.log

Finally, I'd like to introduce my new project: the GPT2API.

What is GPT2API?

Website: https://aicanvas.app/gpt
GPT2API is a platform to help you build API to make ChatGPT easier to use. You can build API and share it with the community, or you can call API from API.Hub, which is other API shared by the community.

Features:

Build API with ChatGPT commands.
Test API on the website.
Share it with the community.
Have the community extend the API.
Sample code for your project.
Cheap price for calling ChatGPT, $1 with 600K tokens.

If you have any questions about GPT2API or programming, you can contact me on the twitter. You are very welcome to experience GPT2API. I hope to get your comments.

How to use Weaviate to store OpenAI embedding vectors in a Golang program

New Bing — Tue, 01 Aug 2023 11:13:30 +0000

Recently, I wanted to use the Vector Database to store OpenAI embedding vectors.
I've researched a variety of vector databases. Like Pinecone, Redis, Qdrant, Milvus, Weaviate, Chroma, pgvector. After comparing them, I chose Weaviate as my vector database. weaviate is developed in Golang, which makes it easier for me to install and test.

How to install Weaviate on Debian 12

First, Download Weaviate

Go to github.com/weaviate/weaviate, then find the version that is suitable for your operating system.
I chose to download weaviate-v1.20.3-linux-amd64.tar.gz

mkdir vectordb
cd vectordb
wget https://github.com/weaviate/weaviate/releases/download/v1.20.3/weaviate-v1.20.3-linux-amd64.tar.gz

Then install Weaviate

First unzip the file, then add the configuration file.

tar -zxvf weaviate-v1.20.3-linux-amd64.tar.gz

You need to configure the authentication and data persistence environment as below. We use API authentication for test.

export AUTHENTICATION_APIKEY_ENABLED=true
export AUTHENTICATION_APIKEY_ALLOWED_KEYS=q8Z5HN4U2w8jUDRGeGxyKkqvwjPg7w4P
export AUTHENTICATION_APIKEY_USERS=newbing@example.com
export PERSISTENCE_DATA_PATH=/home/newbing/vectordb/data

Launch Weaviate

After unzip file and set the environment, you can launch a instance of weaviate.

./weaviate --host=127.0.0.1 --port=8181 --scheme=http

Launch with supervisor

If you don't want to start or stop by hand, you can use Supervisor to manage the Weaviate instance.
The supervisor config file:

[program:weaviate]
directory=/home/newbing/vectordb/
command=/home/newbing/vectordb/weaviate --host=127.0.0.1 --port=8181 --scheme=http
autostart=true
autorestart=true
user=www
environment=HOME="/home/www",AUTHENTICATION_APIKEY_ENABLED="true",AUTHENTICATION_APIKEY_ALLOWED_KEYS="q8Z5HN4U2w7jUDRGeGxyKkqvwjPg7w4P",AUTHENTICATION_APIKEY_USERS="newbing@example.com",PERSISTENCE_DATA_PATH="/home/newbing/vectordb/data"
numprocs=1
redirect_stderr=true
stdout_logfile=/var/log/supervisor/weaviate.log

Use Weaviate in Golang

Create weaviate client

package vector

import (
    "github.com/rs/zerolog/log"
    "github.com/spf13/viper"
    "github.com/weaviate/weaviate-go-client/v4/weaviate"
    "github.com/weaviate/weaviate-go-client/v4/weaviate/auth"
    "net/url"
)

var (
    _cli *weaviate.Client
)

func GetClient() (*weaviate.Client, error) {
    if _cli != nil {
        return _cli, nil
    }
    uri, err := url.Parse(viper.GetString("weaviate.api"))
    if err != nil {
        log.Error().Err(err).
            Str("func", "init").
            Str("package", "vector").
            Msg("parse api addr failed")
        return nil, err
    }
    cfg := weaviate.Config{
        Host:       uri.Host,
        Scheme:     uri.Scheme,
        AuthConfig: auth.ApiKey{Value: viper.GetString("weaviate.key")},
    }
    client, err := weaviate.NewClient(cfg)
    if err != nil {
        log.Error().Err(err).
            Str("func", "init").
            Str("package", "vector").
            Msg("create client failed")
        client = nil
    }
    _cli = client
    return client, err
}

Store vector to Weaviate


// Create store vector to weaviate.
// class is schema or table name,
// props are the attributes of the data,
// vector is the embeddings from openai
func Create(ctx context.Context, class string, props map[string]string, vector []float32) (*models.Object, error) {
    cli, err := GetClient()
    if err != nil {
        return nil, err
    }
    created, err := cli.Data().Creator().
        WithClassName(class).
        WithProperties(props).
        WithVector(vector).
        Do(ctx)

    if err != nil {
        return nil, err
    }
    return created.Object, nil
}

Search vector with similarity

// Near search vectors with similarity
// class is schema or table name,
// fields are the attributes of the data will be return,
// vector is the embeddings from openai of source compare data,
// maxDistance the max distance of searched data, between 0 from 1, small is better
// limit how many data rows to return
func Near(ctx context.Context, class string, fields []string, vector []float32, maxDistance float32, limit int) ([]any, error) {
    if limit == 0 {
        limit = 10
    }
    cli, err := GetClient()
    if err != nil {
        return nil, err
    }
    gqlField := make([]graphql.Field, len(fields)+1)
    for _, field := range fields {
        gqlField = append(gqlField, graphql.Field{Name: field})
    }
    _additional := graphql.Field{
        Name: "_additional", Fields: []graphql.Field{
            {Name: "certainty"}, // only supported if distance==cosine
            {Name: "distance"},  // always supported
        },
    }
    gqlField = append(gqlField, _additional)

    nearVector := cli.GraphQL().NearVectorArgBuilder().
        WithVector(vector).       // Replace with a compatible vector
        WithDistance(maxDistance) // set the max distance

    res, err := cli.GraphQL().Get().
        WithClassName(class).
        WithFields(gqlField...).
        WithNearVector(nearVector).
        WithLimit(limit).
        Do(ctx)
    if err != nil {
        return nil, err
    }
    retList := make([]any, 0)
    if getRes, ok := res.Data["Get"]; ok {
        getMap, ok := getRes.(map[string]any)
        if ok {
            list, ok := getMap[class]
            if ok {
                retList, ok := list.([]any)
                if ok {
                    return retList, nil
                } else {
                    return nil, errors.New("data not array list")
                }
            } else {
                return nil, errors.New("data not found")
            }
        } else {
            return nil, errors.New("no get data found")
        }
    }
    return retList, nil
}

Find vector by attribute

// FindByAttribute find vector data by attribute.
// class is schema or table name,
// fields are the attributes of the data will be return,
// key the attribute to compare
// value the compare value
func FindByAttribute(ctx context.Context, class string, fields []string, key, value string) ([]any, error) {
    retList := make([]any, 0)
    cli, err := GetClient()
    if err != nil {
        return retList, err
    }
    gqlField := make([]graphql.Field, len(fields)+1)
    for _, field := range fields {
        gqlField = append(gqlField, graphql.Field{Name: field})
    }
    _additional := graphql.Field{
        Name: "_additional", Fields: []graphql.Field{
            {Name: "vector"}, // always supported
        },
    }
    gqlField = append(gqlField, _additional)

    res, err := cli.GraphQL().Get().
        WithClassName(class).
        WithFields(gqlField...).
        WithWhere(filters.Where().WithPath([]string{key}).WithOperator(filters.Equal).WithValueString(value)).
        Do(ctx)
    if err != nil {
        return nil, err
    }
    if getRes, ok := res.Data["Get"]; ok {
        getMap, ok := getRes.(map[string]any)
        if ok {
            list, ok := getMap[class]
            if ok {
                retList, ok := list.([]any)
                if ok {
                    return retList, nil
                } else {
                    return nil, errors.New("data not array list")
                }
            } else {
                return nil, errors.New("data not found")
            }
        } else {
            return nil, errors.New("no get data found")
        }
    }
    return retList, nil
}

The whole weaviate store,search,find code

package vector

import (
    "context"
    "errors"
    "github.com/weaviate/weaviate-go-client/v4/weaviate/filters"
    "github.com/weaviate/weaviate-go-client/v4/weaviate/graphql"
    "github.com/weaviate/weaviate/entities/models"
)

// Create store vector to weaviate.
// class is schema or table name,
// props are the attributes of the data,
// vector is the embeddings from openai
func Create(ctx context.Context, class string, props map[string]string, vector []float32) (*models.Object, error) {
    cli, err := GetClient()
    if err != nil {
        return nil, err
    }
    created, err := cli.Data().Creator().
        WithClassName(class).
        WithProperties(props).
        WithVector(vector).
        Do(ctx)

    if err != nil {
        return nil, err
    }
    return created.Object, nil
}

// Near search vectors with similarity
// class is schema or table name,
// fields are the attributes of the data will be return,
// vector is the embeddings from openai of source compare data,
// maxDistance the max distance of searched data, between 0 from 1, small is better
// limit how many data rows to return
func Near(ctx context.Context, class string, fields []string, vector []float32, maxDistance float32, limit int) ([]any, error) {
    if limit == 0 {
        limit = 10
    }
    cli, err := GetClient()
    if err != nil {
        return nil, err
    }
    gqlField := make([]graphql.Field, len(fields)+1)
    for _, field := range fields {
        gqlField = append(gqlField, graphql.Field{Name: field})
    }
    _additional := graphql.Field{
        Name: "_additional", Fields: []graphql.Field{
            {Name: "certainty"}, // only supported if distance==cosine
            {Name: "distance"},  // always supported
        },
    }
    gqlField = append(gqlField, _additional)

    nearVector := cli.GraphQL().NearVectorArgBuilder().
        WithVector(vector).       // Replace with a compatible vector
        WithDistance(maxDistance) // set the max distance

    res, err := cli.GraphQL().Get().
        WithClassName(class).
        WithFields(gqlField...).
        WithNearVector(nearVector).
        WithLimit(limit).
        Do(ctx)
    if err != nil {
        return nil, err
    }
    retList := make([]any, 0)
    if getRes, ok := res.Data["Get"]; ok {
        getMap, ok := getRes.(map[string]any)
        if ok {
            list, ok := getMap[class]
            if ok {
                retList, ok := list.([]any)
                if ok {
                    return retList, nil
                } else {
                    return nil, errors.New("data not array list")
                }
            } else {
                return nil, errors.New("data not found")
            }
        } else {
            return nil, errors.New("no get data found")
        }
    }
    return retList, nil
}

// FindByAttribute find vector data by attribute.
// class is schema or table name,
// fields are the attributes of the data will be return,
// key the attribute to compare
// value the compare value
func FindByAttribute(ctx context.Context, class string, fields []string, key, value string) ([]any, error) {
    retList := make([]any, 0)
    cli, err := GetClient()
    if err != nil {
        return retList, err
    }
    gqlField := make([]graphql.Field, len(fields)+1)
    for _, field := range fields {
        gqlField = append(gqlField, graphql.Field{Name: field})
    }
    _additional := graphql.Field{
        Name: "_additional", Fields: []graphql.Field{
            {Name: "vector"}, // always supported
        },
    }
    gqlField = append(gqlField, _additional)

    res, err := cli.GraphQL().Get().
        WithClassName(class).
        WithFields(gqlField...).
        WithWhere(filters.Where().WithPath([]string{key}).WithOperator(filters.Equal).WithValueString(value)).
        Do(ctx)
    if err != nil {
        return nil, err
    }
    if getRes, ok := res.Data["Get"]; ok {
        getMap, ok := getRes.(map[string]any)
        if ok {
            list, ok := getMap[class]
            if ok {
                retList, ok := list.([]any)
                if ok {
                    return retList, nil
                } else {
                    return nil, errors.New("data not array list")
                }
            } else {
                return nil, errors.New("data not found")
            }
        } else {
            return nil, errors.New("no get data found")
        }
    }
    return retList, nil
}

Finally, I'd like to introduce my new project: the GPT2API.

What is GPT2API?

Features:

Build API with ChatGPT commands.
Test API on the website.
Share it with the community.
Have the community extend the API.
Sample code for your project.
Cheap price for calling ChatGPT, $1 with 600K tokens.

If you have any questions about GPT2API or programming, you can contact me on the twitter. You are very welcome to experience GPT2API. I hope to get your comments.

How to use Lemon Squeezy as a payment in next.js

New Bing — Sat, 29 Jul 2023 03:43:52 +0000

Really like the UX design of lemon squeezy and yesterday I supported lemon squeezy payments in the product GPT2API.

The front end of GPT2API uses the Next.js framework and is Next.js version 13 using the app model.

First, I create the lemon.js loader to make GPT2API support overlay mode.

import Script from "next/script"

export default function LemonPay({handler}) {
    function lemonLoaded() {
        window.createLemonSqueezy()
        LemonSqueezy.Setup({
            eventHandler: (event) => {
                if (handler) {
                    handler(event)
                }
            }
        })
    }
    return (
        <Script src="https://app.lemonsqueezy.com/js/lemon.js" onLoad={lemonLoaded}></Script>
    )
}

The use the lemon.js loader and open the overlay to create order to pay.

'use client'

import { WalletCards } from "lucide-react"

const lemonStore = process.env.NEXT_PUBLIC_LEMONSQUEEZY_STORE
const lemonProduct = process.env.NEXT_PUBLIC_LEMONSQUEEZY_VARIANT_ID

export default function Profile({ }) {
    function buy() {
        const params = new URLSearchParams()
        params.set('checkout[email]', 'user@example.com')
        params.set('checkout[custom][type]', 'gpt2api')
        params.set('checkout[custom][value]', '600000')
        params.set('checkout[custom][email]', 'user@example.com')
        const checkoutUrl = `https://${lemonStore}.lemonsqueezy.com/checkout/buy/${lemonProduct}?` + params.toString()
        LemonSqueezy.Url.Open(checkoutUrl)
    }
    function lemonHanlder(evt) {
        console.info('lemon event', evt)
        if (evt.event === 'Checkout.Success') {
            // do something after checkout success.
        }
    }
    return (
        <>
            <div className="flex flex-col gap-4">
                <div className="w-full" onClick={buy}>
                    <WalletCards className="mr-1 w-4 h-4" /><span>Checkout</span>
                </div>
                <LemonPay handler={lemonHanlder} />
            </div>
        </>
    )
}

Remember, the Lemon Squeezy checkout link is in this format.

https://${lemonStore}.lemonsqueezy.com/checkout/buy/${lemonProduct}

You can find this from the Lemon Squeezy Dashboard on the Products page.
First, go to Products and share it.

You can get the checkout link as below.

What is GPT2API?

Features:

Build API with ChatGPT commands.
Test API on the website.
Share it with the community.
Have the community extend the API.
Sample code for your project.
Cheap price for calling ChatGPT, $1 with 600K tokens.

If you have any questions about GPT2API or programming, you can contact me on the twitter. You are very welcome to experience GPT2API. I hope to get your comments.

Use the grammar correction API provided by GPT2API to fix English grammar errors.

New Bing — Wed, 26 Jul 2023 13:32:54 +0000

Using GPT2API is easy to create API. So I create a grammar correction API and make it public to the community.

Prompts

You're a native English speaker, and you're good at correcting the grammar inside your statements. Please correct the wrong grammar in the statements provided by the user, and output it in the following JSON format:  {"result":"<right sentence>"}

Visit this link to get more details
https://aicanvas.app/gpt/run?id=100011

Call the API in your project

Get the token

Go to page https://aicanvas.app/gpt/account/api to get the token.

Copy code

Javascript code for demo use, you should replace the in the code.
Javascript

var md5 = require('js-md5');
var myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
var timestamp = parseInt(Date.now()/1000)
var token = "<token>"
var sign = md5(token + timestamp)

var raw = JSON.stringify({
  "timestamp": timestamp,
  "app_id": "1",
  "sign": sign,
  "api": 100011,
  "model": "gpt-3.5-turbo",
  "max_tokens": 2048,
  "query": "$QUERY"
});

var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};

fetch("https://aicanvas.app/api/gpt/call", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));

Here is the Golang code, replace the before you run it.

package main

import (
  "fmt"
  "strings"
  "time"
  "net/http"
  "io/ioutil"
  "crypto/md5"
  "encoding/hex"
)

func Md5(text string) string {
    hasher := md5.New()
    hasher.Write([]byte(text))
    return hex.EncodeToString(hasher.Sum(nil))
}

func main() {

  url := "https://aicanvas.app/api/gpt/call"
  method := "POST"
  token := "<token>"
  ts := time.Now().Unix()
  sign := Md5(fmt.Sprintf("%s%d", token, ts))

  payload := strings.NewReader(fmt.Sprintf(`{"timestamp":%d,"app_id":"3","sign":"%s","api":5,"model":"gpt-3.5-turbo","max_tokens":2048,"query":"abc"}`, ts, sign))

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Try it

Go to page https://aicanvas.app/gpt/run?id=100011, then login and copy code to test the API.

ChatGPT wrapper aka GPT2API released

New Bing — Wed, 26 Jul 2023 07:00:47 +0000

I used to be a Laravel developer. But my team members are not good in PHP. Because PHP is a weak type language. They always write some code in strange style. Over time, the code becomes difficult to maintain. When we develop with Laravel, we use Vue as our frontend framework.

When I start this new project, I want to fix these problems by switching to a new stack. I've been learning Golang for a long time, but I've never written a project using React.

After digging deeper into React, I found two frameworks very interesting and I believe they will help me build my project faster. They are Next.js and shadcn/ui. If you are new to React, I highly recommend trying next.js and shadcn/ui.

Share some screenshots of GPT2API

Design API page

Run API page

Technical details about my project

Project name: GPT2API
Website: https://aicanvas.app/gpt
Frontend Framework: React and Next.js
UI Framework: shadcn/ui and tailwindcss
Backend Framework: Gin with Golang
Database: Mysql 8
Server: Linode
Payment: Paddle

What is GPT2API?

GPT2API is a platform to help you build API to make ChatGPT easier to use. You can build API and share it with the community, or you can call API from API.Hub, which is other API shared by the community.

Features:

Build API with ChatGPT commands.
Test API on the website.
Share it with the community.
Have the community extend the API.
Sample code for your project.
Cheap price for calling ChatGPT, $1 with 600K tokens.

If you have any questions about GPT2API or programming, you can contact me on the twitter. You are very welcome to experience GPT2API. I hope to get your comments.