DEV Community: Ajay Krupal K

GitHub like Contribution HeatMap in JS

Ajay Krupal K — Thu, 08 Aug 2024 18:22:56 +0000

Have you ever wondered how you could replicate the GitHub contribution chart? Most of us have, so here is how you also could do it.

We will be using a library called cal-heatmap

You can install the library with npm install cal-heatmap and then import the library into your application:



import CalHeatmap from 'cal-heatmap';

// Optionally import the CSS
import 'cal-heatmap/cal-heatmap.css';

Insert <div id="cal-heatmap"></div> to render the heatmap and instantiate the paint function:



const cal = new CalHeatmap();
cal.paint({
   itemSelector: '#cal-heatmap',
});

Define the domain and sub-domain, where the domain is main time unit and the sub-domain is the sub-time unit. In this case we will have domain as month and sub-domain as ghDay so that there are no gaps in the charts



cal.paint({
   itemSelector: '#cal-heatmap',
   domain: {
      type: 'month',
      gutter: 4,
      label: { text: 'MMM', textAlign: 'start', position: 'top' },
    },
    subDomain: { type: 'ghDay', radius: 2, width: 11, height: 11, gutter: 4 },
});

The gutter defines the space between each domain or sub-domain i.e. each month or day in our case.

The date option defines the start date of the calendar and the range option defines the number of domains to show which is 12 in our case for the number of months.



cal.paint({
   itemSelector: '#cal-heatmap',
   domain: {
      type: 'month',
      gutter: 4,
      label: { text: 'MMM', textAlign: 'start', position: 'top' },
    },
    subDomain: { type: 'ghDay', radius: 2, width: 11, height: 11, gutter: 4 },
    date: { start: new Date('2012-01-01') },
    range: 12,
});

Now let's add the data from GitHub using GraphQL where the userName is your GitHub's username



query($userName:String!) { 
  user(login: $userName){
    contributionsCollection {
      contributionCalendar {
        totalContributions
        weeks {
          contributionDays {
            contributionCount
            date
          }
        }
      }
    }
  }
}

The response from the GraphQL query will be used as the source of the data



cal.paint({
   itemSelector: '#cal-heatmap',
   domain: {
      type: 'month',
      gutter: 4,
      label: { text: 'MMM', textAlign: 'start', position: 'top' },
    },
    subDomain: { type: 'ghDay', radius: 2, width: 11, height: 11, gutter: 4 },
    date: { start: new Date('2012-01-01') },
    range: 12,
    data: {
       source: response,
       x: 'date',
       y: 'contributionCount',
       defaultValue: 0
    },
});

We will finally define how the heatmap looks with the scale property and add a tooltip and calendar label plugin.



cal.paint({
   itemSelector: '#cal-heatmap',
   domain: {
      type: 'month',
      gutter: 4,
      label: { text: 'MMM', textAlign: 'start', position: 'top' },
    },
    subDomain: { type: 'ghDay', radius: 2, width: 11, height: 11, gutter: 4 },
    date: { start: new Date('2012-01-01') },
    range: 12,
    data: {
       source: response,
       x: 'date',
       y: 'contributionCount',
       defaultValue: 0
    },
    scale: {
      color: {
        type: 'threshold',
        range: ['#14432a', '#166b34', '#37a446', '#4dd05a'],
        domain: [10, 20, 30],
      },
    },
    [
    [
      Tooltip,
      {
        text: function (date, value, dayjsDate) {
          return (
            (value ? value : 'No') +
            ' contributions on ' +
            dayjsDate.format('dddd, MMMM D, YYYY')
          );
        },
      },
    ],
    [
      CalendarLabel,
      {
        width: 30,
        textAlign: 'start',
        text: () => dayjs.weekdaysShort().map((d, i) => (i % 2 == 0 ? '' : d)),
        padding: [25, 0, 0, 0],
      },
    ],
]
});

With this now, you should be able to see a beautiful heatmap of your GitHub contributions.

Follow me on X(formerly Twitter) for more tech stuff

RabbitMQ: Open Source Message Broker Service

Ajay Krupal K — Fri, 12 Jul 2024 14:46:19 +0000

RabbitMQ is an Open Source message broker service aiding systems with microservice architecture. For example, let's say you want to upload a video to YouTube, behind the scenes, there might be one service to upload the video, one to notify people who are subscribed to the author, and so on. The upload service appends “New video” events to a RabbitMQ stream. Multiple backend applications can subscribe to that stream and read new events independently of each other.

With the same example of a video streaming service, the producer is when the video is uploaded to the platform which can happen through an API. The API then produces a message with the required data which publishes it to an exchange. The exchange then routes it to one or more queues which are linked to the exchange with a routing and binding key. The message then waits in the queue until it is consumed by the consumer which in this case is the uploads service.

The Exchange can behave in one of these three ways:

Sending the message directly to a specific queue or
Multiple queues with a shared pattern using topics or
To all the available queues

A basic example of sending a message to RabbitMQ locally. The below code is to send a message to the queue. Pre-requisites for this is to install RabbitMQ server and amqplib locally.

//library that implements messaging protocol
import { connect} from 'amqplib'

// connect to rabbitmq locally
const connection = await connect('amqp://localhost');
const channel = await connection.createChannel();

const queue = 'test';
const message = 'hello world'

// queue can be durable either stored in RAM or memory
await channel.assertQueue(queue, {durable: false});

// message is produced
channel.sendToQueue(queue, Buffer.from(message));

Now that the message is sent to the queue, we need another file to receive the message, which can also be a server subscribed to the same queue and RabbitMQ client.

//library that implements messaging protocol
import { connect} from 'amqplib'

// connect to rabbitmq
const connection = await connect('amqp://localhost');
const channel = await connection.createChannel();
const queue = 'test';
await channel.assertQueue(queue, {durable: false});

//consume the message
channel.consume(queue, (message) => {
    const msg = {...message}
    console.log("Received message: " + msg.content)
})

When both files are run simultaneously, the message should be received in the terminal of the second file as "hello world".

Alternatively, you can use CloudAMQP to create a RabbitMQ instance on the cloud and replace the localhost connection string with the one on the cloud. If you need a more detailed RabbitMQ blog do let me know in the comments.

Until then, follow me on twitter😅 for more

Conversational Queries with ElasticSearch

Ajay Krupal K — Wed, 03 Apr 2024 18:31:35 +0000

Elasticsearch is a search and analytics engine designed to handle your data needs with speed and relevance. Whether you're dealing with structured or unstructured, numerical or geospatial data, Elasticsearch will be able to handle it efficiently. It is most commonly used for ingesting and analyzing log data in near-real time.

Each analytics or search engine has its own unique querying methods. Elasticsearch follows the DSL (Domain Specific Language) method for querying data which is based on a key-value format called JSON (JavaScript Object Notation). But imagine not having to learn these rigid syntaxes, this is where conversational queries come into play. So what are conversational queries? It simplifies the way users interact with data. Users just have to type a query in plain language without having to follow any specific syntax, and with the help of AI chat models such as GPT, Gemini, and Claude, it will respond back to you in natural language. It's like talking to your data - easy, intuitive, and efficient.

The process for the conversational queries with Elasticsearch is as follows:

The logs of your application are directed to flow to Elasticsearch
These logs have to be converted to embeddings which are collections of vectors where similar data points will be mapped to vectors that are close together in the vector space, while dissimilar data points will be mapped to vectors that are far apart. This improves efficient data retrieval.
Elasticsearch will act as a vector database storing the collection of all log embeddings.
An LLM of your choice can then be integrated with your Elasticsearch to respond to users' conversational queries
When a user asks the LLM a conversational query, the LLM retrieves all embedded documents similar to the query from Elasticsearch.
Compiling all the retrieved documents, the LLM will output a response in natural language

This is just one example of how you could use a common storage application like Elasticsearch to respond to users' queries in natural language by leveraging the power of vector embeddings and large language models. The combination of vector databases and conversational AI offers exciting possibilities for making data more accessible and user-friendly across various domains and use cases.

Follow me on twitter for more here

Transformers: The Architecture of AI

Ajay Krupal K — Sun, 04 Feb 2024 14:00:54 +0000

Pre-requisite:
What is neural networks?: https://dev.to/ajaykrupalk/neural-networks-the-artificial-brain-behind-ai-115p

ChatGPT's GPT-3 and GPT-4 and Google Bard's BERT are a few examples of Transformers. But what are transformers and how are they helping the most used chat models?

What are transformers?

Transformers are something that transforms from one sequence into another. Each transformer has two parts: an Encoder and a Decoder. The encoder is associated with the input and the decoder with the output.

How do Transformers work?

Transformers work through sequence-to-sequence learning. That means, they take a sequence of tokens (e.g., words in a sentence) and predict the next token. This is done by iterating through encoder layers.

The encoder generates encodings that define which parts of the input sequence are relevant to each other and passes these encodings to the next encoder layer.

The decoder takes all of the encodings and uses their derived context to generate the output sequence.

Transformers are a form of semi-supervised learning i.e. they are pre-trained in an unsupervised manner with a large, unlabelled data set, whereafter they are fine-tuned through supervised learning to improve performance.

Attention Mechanism

Transformers are different from other architectures in that they do not necessarily process data in order. Transformers use something called an Attention Mechanism which provides context around items in the input sequence. This makes them more efficient, for example, for tasks like translation, where the meaning of text is considered rather than the order of words.

Follow me on twitter for more here

Neural Networks: The Artificial Brain behind AI

Ajay Krupal K — Sat, 03 Feb 2024 05:47:32 +0000

AI accomplishes a myriad of tasks comparable to human capabilities, thanks to its foundation in neural networks, a structure inspired by the working of the human brain. This article aims to provide an overview of the working of neural networks in brief.

Neural networks take in data as input, train themselves to recognize the pattern in the data and then predict the output for a new set of similar data.

How do Neural Networks work?

Neural networks are made of neurons, the basic processing units. Each neural network has 3 layers: an input layer, hidden layer, and output layer. The input layer takes in the input and passes it on to the hidden layer, which processes the input and then passes it on to the output layer which predicts a response.

Let's say a Neural Network is being trained to recognize images. Each image pixel is fed as input to the neuron of the input layer. Neurons are connected to the next layer through channels. Each channel is assigned a numerical value known as weight. Each input is multiplied by the corresponding weight of the connected channel and their sum is sent as input to the hidden layer.

Each of the neurons in the hidden layer is associated with a numerical value called bias which is added to the sum got from the previous layer. The total value is sent to a threshold function called activation function. The result of the activation function will decide if the neuron is activated or not. If a neuron is activated, it will transmit data to the output layer. The transmission of data in this way is called forward propagation.

In the output layer, the neuron with the highest value fires and determines the output. The output might not be correct, but the network will also be fed the correct output and the predicted output will be compared with the actual output to find out the error. The magnitude of the error indicates how wrong the network was and the sign shows how much higher or lower than expected. This information is transferred backwards through the network, known as back propagation.

The training of the network ends like this. Though the training process is time-consuming at times, the benefits of neural networks are large. Google Lens and Facial Recognition are a few of the applications of neural networks.

Follow me on twitter for more here

What is an LLM?

Ajay Krupal K — Tue, 30 Jan 2024 13:59:08 +0000

In the past 2 years, everyone has heard of ChatGPT and most of you might have also used it. The technology that helps you have human-like conversations with a chatbot is called an LLM (Large Language Model).

LLMs can understand as well as generate human language. The LLMs can train on massive amounts of text datasets, which can be about 10 gigabytes of data. To put that into perspective, 1 gigabyte can be about 178 Million words, imagine the number of words the LLM can be trained on. A single LLM can be used for various text-based applications like Chat, Summarization, Code Generation, and more.

When datasets are fed to an LLM, it learns about the language, as well as the patterns of the language. After which, an input can be given to the LLM and it will generate a response. This input is what is commonly known as a prompt, and the way your prompt is structured defines the behaviour of the language model.

An LLM is made of:

Data: It simply refers to the millions of text data that the LLM is fed
Architecture: For GPT, the architecture is known as a transformer, which enables handling sequences of data and understanding the context of each word in a sentence
Training: The architecture is then trained on the large amount of data fed to the LLM. During this process, the language model learns how to predict the next word in a sentence until it can generate a coherent sentence.

In conclusion, LLMs are machine learning models trained on huge amounts of text datasets and can be customised to make big applications to generate or review code, answer questions on a document provided, generate articles and so on.

How Harvard and Khan Academy use AI for education?

Ajay Krupal K — Fri, 26 Jan 2024 07:25:44 +0000

The recent surge in public interest in AI began with the release of DALL-E and ChatGPT from OpenAI. Since their release, there have been several AI powered applications developed. Witnessing these advancements, I wondered how it could transform the traditional form of education. Just a few weeks ago, I stumbled upon videos on YouTube which were about how Harvard's CS50 Course and Khan Academy were starting to use AI as Teaching Assistants for their courseware and here I want to talk about them.

CS50

CS50 is Harvard University's online introductory course on Computer Science. These courses are available on their YouTube channel. Recently one of the instructors showcased how they were using AI model ChatGPT to help students taking the course and that caught my attention. The two things they have introduced for students as well as teachers are:

cs50.ai
This is a Q&A chat model integrated which is trained on the contents of the course and students can ask questions to the chatbot and they will be able to get solutions to their doubts. The doubts is not only limited to theory but can also be used for doubts on code, and error messages. This chatbot has become a personal teaching assistant, replacing the presence of a teacher to answer students doubts outside class hours.

cs50.dev
It is basically Visual Studio customized for CS50 and on the browser. Students could type out their code and select a part of the code and ask the AI model integrated with it to explain the code and the student is able to get an explanation of each line of code.

The AI model can also help students improve their code style and formatting. The students just have to click on a button and can see how the coding style and formatting can be improved and with a click of another button they can have those changes in their code.

Khan Academy

Sal Khan, the founder of Khan Academy in a TED talk spoke about how his company was using AI to help students. They are also using a chat model but with more advanced type of capabilities, called Khanmigo. They call this a student's personal tutor and teaching assistant.

Khanmigo, is a chatbot with the following features:

When there is a problem statement given to a student, the student will not directly receive the answer of the problem but will be tutored by the bot on the steps to solve the problem
For doubts related to coding quizzes on the platform, the student need not copy paste the code, but just ask Khanmigo their doubt and the chatbot will analyze the code on it's own and provide a solution
The same applies to videos too, the chatbot understands the context of the video that the student is watching and is able to answer question about the same
The chatbot can also act as an academic and career coach, and will help the student with questions about academics and their career choices.

These few use cases of AI in education, gets me excited on what the future holds for it. This is just the beginning and I am really curious to know how people will leverage this technology to make education fun.

(Cont.) LangChain.js: Chatting with a PDF

Ajay Krupal K — Mon, 22 Jan 2024 13:13:13 +0000

A few articles that preceded this:
Fundamentals of LangChain
LangChain.js: Chatting with a PDF - Part 1

Now, that we have done with the retriever module, the next steps are:

Step 4: Rephrase the Question

The question has to be reformed to be a standalone question, so that it can be understood independently without any prior knowledge. This ensures that the question is clear and can be answered accurately.

In the below code, we see a RunnableSequence, which takes in the prompt, passes it to the Google Model, and converts the output to a string.

import { RunnableWithMessageHistory } from "@langchain/core/runnables"; 
import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts"; 

export function createRephraseQuestionChain() {
    const REPHRASE_QUESTION_SYSTEM_TEMPLATE = `
    Given the following conversation and a follow up question,
    rephrase the follow up question to be a standalone question.
    `;

    // Rephrase the question to be a standalone question
    // along with passing the chat history
    const rephraseQuestionChainPrompt = ChatPromptTemplate.fromMessages([
        ["system", REPHRASE_QUESTION_SYSTEM_TEMPLATE],
        new MessagesPlaceholder("history"),
        ["human", "Rephrase the following question as a standalone question:\n{question}"],
    ]);

    // Runnable to rephrase the question
    const rephraseQuestionChain = RunnableSequence.from([
        rephraseQuestionChainPrompt,
        new ChatGoogleGenerativeAI({
            modelName: "gemini-pro",
            maxOutputTokens: 2048,
            apiKey: process.env.google_api_key
        }),
        new StringOutputParser(),
    ]);
    return rephraseQuestionChain;
}

const rephraseQuestionChain = createRephraseQuestionChain();

Technical Terms:

StringOutputParser: Converts the incoming input to a String.

Step 5: Create a prompt template for the response and initialize the chain to retrieve the response

We make a prompt template for the response, so that the LLM answers according to our use case. Using all our prompts we initialize a RunnableSequence to run all our prompts in sequence.

// make a prompt template for the response
const ANSWER_CHAIN_SYSTEM_TEMPLATE = `You are an experienced researcher,
expert at interpreting and answering questions based on provided sources.
Using the below provided context and chat history, 
answer the user's question to the best of your ability
using only the resources provided. Be verbose!

<context>
{context}
</context>`;

// Creat a prompt template from Messages
const answerGenerationChainPrompt = ChatPromptTemplate.fromMessages([
    ["system", ANSWER_CHAIN_SYSTEM_TEMPLATE],
    new MessagesPlaceholder("history"),
    [
        "human",
        `Now, answer this question using the previous context and chat history:

    {standalone_question}`
    ]
]);

// initialize the chain to retrieve the answer for the question
const conversationalRetrievalChain = RunnableSequence.from([
    RunnablePassthrough.assign({
        standalone_question: rephraseQuestionChain,
    }),
    RunnablePassthrough.assign({
        context: documentRetrievalChain,
    }),
    answerGenerationChainPrompt,
    new ChatGoogleGenerativeAI({
        modelName: "gemini-pro",
        maxOutputTokens: 2048,
        apiKey: process.env.google_api_key
    }),
]);

Technical Terms:

RunnablePassthrough: It is a component or function in the Langchain framework that allows the passage of data or information without any modification or processing. It acts as a placeholder or a pass-through mechanism in a chain of operations or transformations.

Step 6: Initialize the chat history and run the final chain.

The final part is we should get the chat history and pass all the initialized runnables to the final chain.

import { ChatMessageHistory } from "langchain/stores/message/in_memory";

// we should create a new history object per session
const messageHistories = {};
const getMessageHistoryForSession = (sessionId) => {
    if (messageHistories[sessionId] !== undefined) {
        return messageHistories[sessionId];
    }
    const newChatSessionHistory = new ChatMessageHistory();
    messageHistories[sessionId] = newChatSessionHistory;
    return newChatSessionHistory;
};
const finalRetrievalChain = new RunnableWithMessageHistory({
    runnable: conversationalRetrievalChain,
    getMessageHistory: getMessageHistoryForSession,
    inputMessagesKey: "question",
    historyMessagesKey: "history",
}).pipe(new StringOutputParser())

const result = await finalRetrievalChain.invoke({
  question: "What are the pre-requisites of this course?",
}, {
  configurable: { sessionId: "test" }
});

console.log(result)

//Input: Our loaded PDF has details about a Machine Learning Course by Andrew NG
//Output:
/* 
To enroll in this class, you must meet the following prerequisites:

* Basic probability and statistics. A course like Statistics 116 would be more than enough.

* Basic linear algebra. Courses like Math 51, 103, 113, or CS205 at Stanford are recommended. Matrix and vector multiplication, matrix inverse, and eigenvectors are concepts you should be familiar with.

* Programming skills. You should be able to write a simple computer program.

* Understanding of big O notation and data structures such as queues, stacks, and binary trees.

If you have taken these courses or have equivalent knowledge, you should be prepared for this class. However, it is important to note that while programming will not be a major focus of the course, some programming in MATLAB or Octave will be required.
*/

Follow me on twitter for more here

LangChain.js: Chatting with a PDF

Ajay Krupal K — Sun, 21 Jan 2024 06:56:01 +0000

To understand this article, please visit first, the fundamentals of LangChain here. A pre-requisite to understand the below code.

LangChain has a library for JavaScript, which helps you build applications powered by LLMs in the same way as in Python. Below, let us go through the steps in creating an LLM powered app with LangChain.js, JavaScript, and Gemini-Pro.

Pre-requisites:

Install LangChain npm install -S langchain
Google API Key
LangChain Module npm install @langchain/community
LangChain Google Module npm install @langchain/google-genai

Step 1: Loading and Splitting the Data

The initial step is to load the source document, in our case a PDF and splitting the document's data into smaller chunks, so that our LLM can easily process it.

import { PDFLoader } from "langchain/document_loaders/fs/pdf";
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";

export async function loadAndSplitChunks({
    chunkSize,
    chunkOverlap
}) {
    //Initialize the PDF Loader
    const loader = new PDFLoader("./files/drylab.pdf");

    // Load the PDF file as text
    const rawCS229Docs = await loader.load();

    // Split the text by different characters
    // until it finds a character
    const splitter = new RecursiveCharacterTextSplitter({
        chunkSize,
        chunkOverlap,
    });

    // Splits the text into chunks
    const splitDocs = await splitter.splitDocuments(rawCS229Docs);
    return splitDocs;
}

// Calling the function
// to load the pdf file and split the document
const splitDocs = await loadAndSplitChunks({
    chunkSize: 1536,
    chunkOverlap: 128,
});

Technical Terms:

Chunk Size: It refers to the size or length of each individual chunk.
Chunk Overlap: It refers to the amount of overlap between consecutive chunks of text. The purpose of chunk overlap is to ensure that important context is not lost when splitting long texts into smaller chunks.

Step 2: Initialize and Load the Vector Store

Now, that we have split the document into chunks, convert them into embeddings and store them into an in-memory vector store.

import { GoogleGenerativeAIEmbeddings } from "@langchain/google-genai";
import { MemoryVectorStore } from "langchain/vectorstores/memory";
import dotenv from "dotenv";
dotenv.config();

export async function initializeVectorstoreWithDocuments({
    documents
}) {
    // Initialize your integrtion's embeddings
    const embeddings = new GoogleGenerativeAIEmbeddings({
        modelName: "embedding-001", // 768 dimensions
        taskType: TaskType.RETRIEVAL_DOCUMENT,
        title: "Retrieval Document",
        apiKey: process.env.google_api_key
    });;

    // initialize your vector store
    const vectorstore = new MemoryVectorStore(embeddings);
    // add the chunks to the vector store
    await vectorstore.addDocuments(documents);
    return vectorstore;
}

//pass the chunks of data to the vector store
const vectorstore = await initializeVectorstoreWithDocuments({
    documents: splitDocs,
});

Technical Terms:

Embeddings: Numerical representation of words, sentences or documents that capture it's semantic meaning.
Memory Vector Store: It is an in-memory vectorstore that stores embeddings in-memory and does an exact, linear search for the most similar embeddings.

Step 3: Retrieving the document

The retrieval part has 3 main steps which are executed in sequence:

input: The value of input is got in our case from a field called question
retriever: This is used for document retrieval
convertDocsToString: The retrieved documents are then converted into strings

import { RunnableSequence } from "@langchain/core/runnables";


export function createDocumentRetrievalChain() {
    // convert the documents and adds <doc> tags 
    // and concatenates them as strings.
    const convertDocsToString = (documents) => {
        return documents.map((document) => `<doc>\n${document.pageContent}\n</doc>`).join("\n");
    };

    // Each of the runnables mentioned will be executed in sequence
    const documentRetrievalChain = RunnableSequence.from([
        (input) => input.standalone_question,
        retriever,
        convertDocsToString,
    ]);

    return documentRetrievalChain;
}

// retrieve the document from the vectorstore
const retriever = vectorstore.asRetriever();

// calling the retriever module
const documentRetrievalChain = createDocumentRetrievalChain();

Technical Terms:

RunnableSequence: It represents a sequence of runnables, where the output of each runnable becomes the input of the next one.

More of this coming in the next article. 📚✨

Follow me on twitter for more here
Part 2 is out here

LangChain: Framework for LLMs

Ajay Krupal K — Fri, 19 Jan 2024 14:51:53 +0000

What is LangChain?

It is a framework which helps build LLM driven applications. One of the problems LangChain tries to solve is RAG or Retrieval Augmented Generation.

RAG or Retrieval Augmented Generation

RAG is a model architecture utilized in certain LLMs. Once a user sends a query to the LLM, a retriever module selects all the related information to the query. The retrieved information is used as context for a generator module which augments the relevant response.

Ingestion

Ingestion is the process of transforming the documents into numbers that computers can understand called vectors. The whole process includes:

Loading the source document: This is done with the help of loaders. The source documents can be PDF, CSV, JSON files or any other web source too.
Splitting the data of the document into chunks: This is done with the help of splitters. They split the data into smaller chunks.
Converting each of those chunks into vectors: The chunks are converted to vectors which are known as embeddings, which are then stored to the vector store.

What happens when you query the LLM?

Once the data is loaded and is stored into the vector store, when a user sends a query, behind the scenes the query gets converted into embeddings. The vector store is checked for similar vectors and are returned. The vectors are then converted into text as a response to the user.

Architecture of a chatbot in LangChain

In Langchain, one of the architectures of a chatbot that is followed is shown below. It is structured in such a way that it is able to handle follow-up questions.

Initially, the chat history and the new question is passed to the LLM. Then, the question is passed to the LLM and is asked to create a standalone question of the same. The relevant documents are also retrieved from the vector store. Now, both the relevant documents and standalone question, will be used by the LLM to generate a response to the user.

Technical Terms

A few technical terms associated with LangChain:

Embedding: Vector representations of text, that capture the semantic meaning of the text.
Runnable: Allows you to run a set of runnables like model, prompt, parser, etc. in a pre-defined order.
Streaming: Allows you to get the output chunk by chunk.
Batch: Allows you to process multiple inputs efficiently in a batch or parallelized manner.

Sources

LangChain Documentation: https://js.langchain.com/docs/get_started
LangChain YouTube Channel: https://youtu.be/AKsfHK_4tf4?si=ZEIlHWBp4Qfco3O-

For more:
Chatting with a PDF using LangChain - 1
Chatting with a PDF using LangChain - 2

API? What?

Ajay Krupal K — Mon, 10 Oct 2022 03:52:10 +0000

Most of us might have heard of the word API a lot in the tech world, such as Twitter API, Notion API, Google API and so on. So it’s time to debunk what an API is.

API stands for Application Programming Interface. It usually refers to REST API where REST stands for Representational State Transfer. API works just like a website where a call from the client (user) is sent to the web server and data is received back over the HTTP Protocol. While a website returns back a Graphical Output, an API usually responds back in a specific format such as JSON data.

Picture depicting GitHub Website vs GitHub API

You can always access an API, take it’s data and pass it into another API and build some thing great. In a way that we can read data from API, we can similarly send data to an API. Before that we need to know what HTTP Request Methods are. There are two main HTTP Request Methods, GET and POST. GET method allows you to send a request to the API and receive back a response in a format such as JSON. POST method allows you to write data to the API and can be best done by mentioning the data in the body of the request. This cannot be accomplished within a browser instead we can use a software known as POSTMAN [https://www.postman.com/]. But to write data to a public API, the API owners usually require Authentication, and the most commonly used authentication is OAuth. An OAuth basically takes credentials in the form of username and password in exchange for an access token which needs to be passed to the API which lets you securely access the API and write to it. Suppose you want to send out a tweet using the Twitter API, you can get the access token of the Twitter API, and then use this access token to send out a tweet from Postman.

If you find this article useful, please feel free to like and comment.