DEV Community: Raja Osama

GPT Models Can Do More Than Just Talk: How to Make Them Brew You Coffee ☕

Raja Osama — Thu, 15 Jun 2023 08:43:54 +0000

Intent Classification 🎯

Intent classification is the task of figuring out what the user wants to achieve or do from their natural language input. For example, if the user says "Can you make me a coffee?", the intent could be "Make a coffee". This way, we can map the user's input to a specific action or function that we want our GPT model to perform.

To do this, I used Ada Models, which I wrote about in a previous article. Ada Models are models that return the embedding of the text, which is a numerical representation of its meaning. The embedding captures the semantic and syntactic features of the text, such as the words, phrases, and context.

By using a simple formula, we can find the most relatable of the embedding among a set of predefined categories, which indicates the most likely intent. The formula is based on the Euclidean distance, which measures how close two vectors are in a multidimensional space. The smaller the distance, the more similar the vectors are.

For example, if we have three categories: "Make a coffee", "Make a tea", and "Make a sandwich", and we have an embedding for each category, we can compare the embedding of the user's input with each category embedding and find the one with the smallest distance. If the user says "Can you brew me a coffee?", the embedding of their input will be closer to the embedding of "Make a coffee" than to the other two categories, so we can infer that their intent is "Make a coffee".

A sample of how we can find the intent can be found by categorizing the intents into actions. So for example, if you have an action like Make a coffee, you can define it as a category with a user-provided prompt and a function to execute:

Make a coffee => (User Provided Prompt = "Can you make me a coffee?") => MakeACoffee()

However, to increase the accuracy and flexibility of the system, we don't just define one category for each action, but more different ways of expressing the same intent. For example:

Make me a coffee => (User Provided Prompt = "Can you make me a coffee?") => MakeACoffee()\
Bring me a coffee => (User Provided Prompt = "Can you bring me a coffee?") => MakeACoffee()\
Buy me a coffee => (User Provided Prompt = "Can you buy me a coffee?") => MakeACoffee()

As you can see, all these categories will trigger the same function: MakeACoffee().

Rule-Based System 📜

The rule-based system is like any other chatbot system, but ours will be very dynamic and powerful and use AI from start to end. The concept is to make a list of categories as keys and objects as values:

const intents = {
  categories: {
    "Make a coffee": MakeACoffee,
    "Make me a coffee": MakeACoffee,
    "Bring me a coffee": MakeACoffee,
    "Buy me a coffee": MakeACoffee,
  },
};

Each object has an action, which can be either an API call or something else, a URL to call if it's an API call and a response function to handle the result of the call. For example:

const MakeACoffee = {
 action: "LOCAL_ACTION",
 response : (response) => 'Your coffee is here!'
};

A function would make a fetch request and return the response. You can customize the response as much as you like.

Now whenever you ask for, Make me a coffee Your result would be your coffee is here.

But what if you have follow-up questions or options? How would you handle that?

For example, when you ask the system to makeACoffee, you might want to handle what kind of coffee use case. To do that, we will have a recursive approach.

Each object can also have an ask function to generate a follow-up question and a categories object to define the possible options for the user. For example:

const MakeACoffee = {
  action: "API_CALL",
  url: "http://localhost:3000/coffees",
  ask: [
    (coffees) => {
      return `What kind of coffee would you like ${coffees.map(
        (coffee) => coffee
      )}?`;
    },
  ],
  categories: () => ({
    Mocha: MochaCoffee,
    Karak: KarakCoffee,
    Espresso: EspressoCoffee,
  }),
};

Now with this approach, we will have a list of coffees in the response with a follow-up question and another object to handle the user's choice.

const MochaCoffee = {
  action: "LOCAL_ACTION",
  response: (response) => "Your mocha coffee is here!",
};

And that's it! You have successfully integrated your GPT model with your own data sources and actions. You can now enjoy your coffee while chatting with your AI friend. ☕

Behind the Scenes 🕵️‍♂️

Now let's look at the behind the scene working of this application. I showed you the configuration, but let's look at the internals.

The second part of this article is here : GPT Models Can Do More Than Just Talk: How to Make Them Brew You Coffee ☕

Blazing Fast Search with text-embedding-ada-002 in Node.js 🚀

Raja Osama — Wed, 14 Jun 2023 10:57:30 +0000

Do you want to create amazing applications that can search, cluster, recommend, and classify text and code? Do you want to use a powerful and cost-effective embedding model that can handle long documents and diverse tasks? Do you want to learn how to use text-embedding-ada-002 in Node.js with ease and simplicity? If you answered yes to any of these questions, then this article is for you! 😍

In this article, we will show you how to use text-embedding-ada-002, a new and improved embedding model from OpenAI, in Node.js. We will explain what embeddings are, why they are useful, and how text-embedding-ada-002 outperforms previous models. We will also show you how to install the OpenAI library, and make requests to the /createEmbedding endpoint. Finally, we will give you one examples of how to use text-embedding-ada-002 for different use cases, such as search.

Complete Article can be found here https://rajaosama.me/blogs/blazing-fast-search-with-embedding-model-ada

What are embeddings? 🤔

Embeddings are numerical representations of concepts converted to number sequences, which make it easy for computers to understand the relationships between those concepts. For example, the word "cat" can be represented by a vector of numbers, such as [0.2, -0.5, 0.7 ...]. The distance between two vectors measures their relatedness. Small distances suggest high relatedness and large distances suggest low relatedness.

Embeddings are commonly used for:

Search (where results are ranked by relevance to a query string)
Clustering (where text strings are grouped by similarity)
Recommendations (where items with related text strings are recommended)
Anomaly detection (where outliers with little relatedness are identified)
Diversity measurement (where similarity distributions are analyzed)
Classification (where text strings are classified by their most similar label)

Why text-embedding-ada-002? 🙌

text-embedding-ada-002 is a new embedding model from OpenAI that replaces five separate models for text search, text similarity, and code search. It outperforms the previous most capable model, Davinci, at most tasks, while being priced 99.8% lower¹. Here are some of the advantages of text-embedding-ada-002:

Stronger performance. text-embedding-ada-002 outperforms all the old embedding models on text search, code search, and sentence similarity tasks and gets comparable performance on text classification¹.
Unification of capabilities. text-embedding-ada-002 simplifies the interface of the /createEmbedding endpoint by merging the five separate models into a single new model. This single representation performs better than the previous embedding models across a diverse set of text search, sentence similarity, and code search benchmarks¹.
Longer context. The context length of text-embedding-ada-002 is increased by a factor of four, from 2048 to 8192 tokens¹, making it more convenient to work with long documents.
Smaller embedding size. The new embeddings have only 1536 dimensions¹, one-eighth the size of davinci embeddings², making them more cost effective in working with vector databases.
Reduced price. The price of text-embedding-ada-002 is reduced by 90% compared to old models of the same size². The new model achieves better or similar performance as Davinci at a 99.8% lower price¹.

Overall, text-embedding-ada-002 is a much more powerful tool for natural language processing and code tasks. It can help you create even more capable applications in your respective fields.

How to set up Node.js? 💻

Node.js is an open-source and cross-platform JavaScript runtime environment⁵ that allows you to run JavaScript code outside the browser. To use text-embedding-ada-002 in Node.js, you need to set up your Node.js environment first.

To install Node.js on your machine, follow these steps:

Go to the official Node.js website⁶ and download the installer for your operating system.
Run the installer and follow the instructions on the screen.
To verify that Node.js is installed correctly, open a terminal or command prompt window and type node -v. You should see something like v18.16.0 printed on the screen.

How to install OpenAI API library? 📚

The OpenAI library is a wrapper around the OpenAI API that makes it easy to use in different programming languages. To use text-embedding-ada-002 in Node.js, you need to install the OpenAI API library for Node.js.

To install the OpenAI API library for Node.js using npm (Node Package Manager), follow these steps:

Open a terminal or command prompt window and navigate to your project directory.
Type npm install openai and press enter.

How to make requests to /createEmbedding endpoint? 📨

To get an embedding from text-embedding-ada-002 in Node.js using the OpenAI API library,
follow these steps:

Import the OpenAI API library by typing const openai = require('openai'); at the top of your JavaScript file.
Create an instance of the OpenAI class by typing const OPENAI_API_KEY = 'sk-your-api-key'; and const OPENAI_API_KEY = process.env.OPENAI_API_KEY; const configuration = new Configuration({ apiKey: OPENAI_API_KEY, }); const openai = new OpenAIApi(configuration); where you replace your-api-key with your actual API key that you can get from your account page⁷.
Create an input object that contains your input string and the model ID by typing const input = {input: 'Your input string goes here', model: 'text-embedding-ada-002'};.
Call the createEmbedding method of the OpenAI class by typing openai.createEmbedding(input).then(response => { // do something with response });. The response object will contain an embedding array that you can extract, save, and use.

How to use text-embedding-ada-002 for different use cases? 🚀

Now that you know how to get an embedding from text-
embedding-
ada-
002 in Node.js,
let's see some examples of how to use it for different use cases.

Complete Article can be found here https://rajaosama.me/blogs/blazing-fast-search-with-embedding-model-ada

Search 🔎

One common use case for embeddings is search,
where you want to rank results by relevance to a query string.
For example,
suppose you have a collection of documents about animals,
and you want to find the most relevant ones for a given query.

To do this,
you can follow these steps:

Get embeddings for all your documents using text- embedding- ada- 002 and store them in a vector database, such as Elasticsearch⁸.
Get an embedding for your query string using text- embedding- ada- 002 and send it to your vector database.
Retrieve the documents with the smallest distances (or highest similarities) to your query embedding and display them as your search results.

Here is some pseudocode that illustrates this process:

// Import libraries
const { Configuration, OpenAIApi } = require("openai");
const { Client } = require("@elastic/elasticsearch");
const client = new Client({
  node: "http://localhost:9200",
  auth: {
    username: "elastic",
    password: process.env.ELASTIC_SEARCH,
  },
});

// Test the connection
client.ping((err, res) => {
  if (err) {
    console.error("Connection failed:", err);
  } else {
    console.log("Connection successful:", res);
  }
});

// Create instances
const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const configuration = new Configuration({
  apiKey: OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

const createIndices = async () => {
  await client.indices.create({
    index: "pets",
    body: {
      mappings: {
        properties: {
          // The document field stores the text of the animal
          document: {
            type: "text",
          },
          // The embedding field stores the vector representation of the animal
          embedding: {
            type: "dense_vector",
            dims: 1536,
            index: true,
            similarity: "cosine",
          },
        },
      },
    },
  });
};

const createIndexs = () => {
  // // Get embeddings for documents
  const documents = [
    "A cat is a domesticated animal that likes to sleep.",
    "A dog is a loyal companion that likes to play.",
    "A bird is a feathered creature that likes to fly.",
    "A fish is an aquatic animal that likes to swim.",
    "A lion is a wild animal that likes to hunt.",
  ]; // sample documents
  documents.forEach((document, index) => {
    const input = { input: document, model: "text-embedding-ada-002" };
    openai
      .createEmbedding(input)
      .then((response) => {
        const embedding = response.data.data[0].embedding; // extract embedding array
        client.index({
          // store document and embedding in Elasticsearch
          index: "pets",
          //   type: 'document',
          //   id: index,
          body: {
            document: document,
            embedding: embedding,
          },
        });
      })
      .catch((e) => {
        throw new Error("Failed once, dont try again");
        console.log(e.message);
      });
  });
};

const query = () => {
  // Get embedding for query
  const query = "What animal likes water?"; // sample query
  const input = { input: query, model: "text-embedding-ada-002" };
  openai.createEmbedding(input).then((response) => {
    const query_embedding = response.data.data[0].embedding; // extract query embedding array

    // Search documents by query embedding
    client
      .search({
        index: "pets",
        body: {
          knn: {
            field: "embedding",
            query_vector: query_embedding,
            k: 5, // Return the top 3 nearest neighbors
            "num_candidates": 10
          },
        },
      })
      .then((result) => {
        const hits = result.hits.hits; // get the matched documents
        hits.forEach((hit) => {
          console.log(hit._source.document); // print the document text
          console.log(hit._score); // print the similarity score
        });
      });
  });
};

const main = () => {
  createIndices();
  createIndexs()
  query()
};

main();

The output of this code might look something like this:

A fish is an aquatic animal that likes to swim.
1.9999999
A bird is a feathered creature that likes to fly.
1.0000001
A dog is a loyal companion that likes to play.
0.99999994
A cat is a domesticated animal that likes to sleep.
0.9999999
A lion is a wild animal that likes to hunt.
0.9999998

As you can see, the fish document is the most relevant one for the query, followed by the bird document. The other documents have lower similarity scores and are less relevant.

More Examples and usecases of using text-embedding-ada-002 can be found here https://rajaosama.me/blogs/blazing-fast-search-with-embedding-model-ada

Thank you.

Interview Topics for a JS Full Stack Engineer in 2022 💻

Raja Osama — Fri, 04 Mar 2022 20:18:58 +0000

Hello 👋 Rockstars 🎸, so lately i have been job hunting 👨🏻‍🎓 and i am mostly these days preparing for the job interviews and therefore i created a list of interview subjects that are mostly likely to be in an interview for the role of Full Stack developer (JS). These questions are what i have came across mostly in my interviews so therefore i decided to write about it.

When I talk about Full-Stack engineer (JS), I am most likely to be talking about the stack that includes: ✅

Javascript
React
Node Js
CI/CD
Software engineering concepts

So Let's get into it.

Micro Services
Monolithic
Server-less
Event-Driven architecture
Message Driven architecture
Procedural Programming
Functional Programming
Object-Oriented Programing
OOPS
Inheritance
Polymorphism
Abstraction
Encapsulation

Node JS

What type of frameworks are commonly used
What is Rest API
What is GraphQL
How is GraphQL and Rest API is different
What is Node Js
How is Node Js different from the javascript that is being used in browsers.
Can we make node Js multi-threaded
How do you scale a node Js application
What is clustering in Node Js
What is HTTPS servers
What is express
What are the middlewares in the express application
A Use case for middleware in the express application
response Status codes we commonly used group 100, group 200, group 300, group 400, group 500
Testing with Jest
Unit Testing
What are containers
What is Docker
what is K8S
How do you handle authentication
How you handle OAuth2
What is JWT
How do you validate JWT
Where do you usually validate JWT

React Js

What is React
What is Hooks
Name commonly-used Hooks
What is State
What is Props
Difference Between States and props
Can we change states directly
What is server-side rendering
What is client-side rendering
How is client-side and server-side rendering different
What are HOC
What is Redux
What is a store in redux
What are actions in redux
What are reducers in redux
What are the effects in SAGA
What are generator function
How is a generator function different then the normal function
Commonly used reserved keyword of a generator function

Javascript

Define Event Loop
What is javascript
How does Javascript handle concurrency
What are callbacks
What are Closures
What is debouncing and throttling
What is Babel
What is Webpack
What is Integration Testing
What is acceptance testing
What is system testing
What is MongoDB
What is Redis
What is micro front-end
Pros and cons of micro front-end
What is CI
What is CD
What is a pipeline

Above are some of the topics that i feel like are very likely to be in an interview question. I will keep on updating the list. If you want to show some support or stay upto date with what i am doing you can follow me on my linkedIn.

Anyways thank you for being here. hope you have a wonderful day.

(Raja Osama)