How ChatGPT Understands Your Questions?

Akshay Kant — Wed, 01 Jul 2026 17:42:40 +0000

When you ask ChatGPT a question, it may seem like it's thinking like a human. In reality, it uses a powerful AI model trained to understand patterns in language and predict the most likely next token (a word or part of a word). To understand how this works, let's first look at three important terms: ChatGPT, GPT, and LLM.

What is ChatGPT?

ChatGPT is the chat application you are using. It uses a GPT model underneath and adds conversation features.

What is GPT?

GPT (Generative Pre-trained Transformer) is a Transformer-based Large Language Model (LLM) that generates text by predicting the next token based on the previous context.

Let's break down:

Generative - It generates new content such as text, code, or summaries.
Pre-trained - It is first trained on a massive collection of text before being used for specific tasks.
Transformer - It uses the Transformer neural network architecture, which helps it understand relationships between words and context efficiently.

What is LLM?

An LLM (Large Language Model) is a very large AI model trained on huge amounts of data that understands and generates human language by predicting the next token based on the context.

What does LLM stand for?

LLM (Large Language Model

Large - Trained on massive dataset.
Language - Designed to understand and generate human language.
Model - A trained neural network that has learned patterns from data.

What problems LLMs solve?

It automate or assist with tasks that involve language and reasoning, such as:

Answering questions
Writing emails, reports, and articles

There are some Popular LLM's we use in our daily life examples include GPT, Llama, Gemini, Claude, and DeepSeek. LLMs are widely used in chatbots, writing assistants, coding tools, education, customer support, and search assistants.

What Happens When You Send a Message to ChatGPT?

Typing a prompt - You type a question or request in the chatGPT UI and hit enter.
Processing your message - Your message is sent to the server processed by the GPT model. It analyzes the text, understand the context, and prepare to generate a response.
Generating a response - The model predicts the next token based on the context. This happens one token at a time until a complete response is formed.
Response Delivered - The final response is sent back to chatGPT and displayed in the UI.

ChatGPT does not copy and paste answer from the internet(by default). It generates response based on patterns learned training on enormous amount of text data (no live internet browsing)

Why Computers Don't Understand Human Language

Computers don't understand human language because they only process mathematical probabilities and binary code, not actual meaning. While humans use shared context, emotion, and life experience to easily grasp nuance, machines rely on statistical pattern matching to predict which words should come next.

Computers translate human-readable text and numbers into binary (strings of 0s and 1s) so electrical circuits can process them. Because computer hardware only understands "on" (1) and "off" (0), all data is stored as combinations of these digits

What is token?

A token is the basic unit of text that an LLM processes. Before generating a response, the model breaks your input into tokens, converts those tokens into numerical representations.

Before a sentence can be understood by the model, it must first be broken into smaller pieces called tokens.
So, for LLM we uses tokens. tokens are actually numbers as LLM can not understand the text.

What is Tokenization?

Tokenization is nothing but conversation of Natural language(human language) to numbers or token.

Why tokenization is needed?

Machine learning models (like LLMs, text classifiers, and translators) cannot directly process raw letters or words. Tokenization bridges this gap through two main functions:

Structuring - it divides a continuous stream of text into manageable pieces.
Numerical Mapping - It translates those pieces into a vocabulary of numerical IDs, allowing models to process language using linear algebra and probability.

Type of Tokenization

Word Tokenization - Splits text by word boundaries (e.g., "Machine learning is fun" becomes ["Machine", "learning", "is", "fun"]).
Sub-Word Tokenization - Breaks down complex words into smaller, frequently occurring units (e.g., "unhappiness" into ["un", "happi", "ness"]).
Character Tokenization - Splits text into individual letters/symbols. It is useful for heavily misspelled data or character-level language modeling.

What is Transformers

Transformers: The Technology Behind Modern LLMs

By now, we've seen how your text is broken into tokens and converted into numbers that a computer can process. But a new question arises:

How does the model understand the relationship between these tokens and generate meaningful responses?

A Transformer is a deep learning architecture introduced by researchers at Google in 2017 in the paper "Attention Is All You Need."
It understands the relationships between tokens using a mechanism called self-attention, allowing it to process language efficiently and generate context-aware responses.

How Does a Transformer Understand Language?

The secret behind the Transformer is a mechanism called Self-Attention.

Self-attention allows every token to determine which other tokens are important for understanding the current context.

Consider the sentence:

"The animal didn't cross the street because it was tired."

When processing the word "it", the Transformer learns that "it" refers to "the animal", not "the street."

Why Almost Every Modern LLM Uses Transformers?

Today's leading language models all rely on the Transformer architecture because it offers several major advantages over older approaches.
one of them is:

Better Context Understanding

Transformers can learn relationships between words that are far apart in a sentence.

For example:

"The book that I bought last week was surprisingly interesting."

Even though "book" and ** "interesting"** are separated by several words, the Transformer can still understand their relationship.

Conclusion

Understanding how ChatGPT works doesn't require a deep background in Artificial Intelligence. At a high level, the process is surprisingly systematic. When you send a prompt, your text is broken into tokens, converted into numerical representations, processed by a Transformer-based Large Language Model (LLM), and used to predict the next token repeatedly until a complete response is generated.

Throughout this article, we explored the building blocks behind this process—from understanding what LLMs are and the problems they solve, to why computers need text converted into numbers, how tokenization works, and why the Transformer architecture became the foundation of modern AI systems.

While we've covered the high-level workflow, there's still much more happening behind the scenes. Concepts like embeddings, self-attention, positional encoding, and next-token prediction are what enable these models to understand context and generate remarkably human-like responses.

I hope this article gave you a solid foundation for understanding how ChatGPT works. The next time you ask ChatGPT a question, you'll know that behind every answer is a fascinating pipeline of tokens, mathematical computations, and Transformer layers working together to generate a response—one token at a time.

How Can Primitive Values Use Methods in JavaScript?

Akshay Kant — Tue, 23 Jan 2024 18:52:35 +0000

There are two types of data types in Javascript
1) Primitive types
2) Non-primitive types (object references)

Primitive types: Primitives are known as being immutable data types because there is no way to change a primitive value once it gets created.

Non-primitive types: Non-primitive values are mutable data types. Objects can store data, and collections of their properties are mutable.

Let's first understand what a method is.

Methods: Methods are functions stored as properties of objects. Primitive values don't directly contain methods, but JavaScript temporarily wraps most primitives in corresponding object wrappers when property access occurs.

Did you notice something...
Primitives are immutable, while methods are typically associated with objects.
But even then we have built-in methods in javascript for primitive data types.
So how does it work? Let's find out..

All primitive types, except null and undefined, have their corresponding object wrapper types, which provide useful methods for working with the primitive values.

When a property or method is accessed on a primitive value, JavaScript automatically wraps the value into the corresponding wrapper object and accesses the property on the object instead.

Here's how JavaScript handles methods for primitive values using object wrapper types:

1. Primitive Value Handling:

When you try to call a method on a primitive value directly, JavaScript recognizes the attempt to use a method on a value that doesn't inherently have methods.
To provide the necessary functionality, it performs a temporary conversion of the primitive value into its corresponding object wrapper type.
This conversion happens behind the scenes, without you explicitly creating the wrapper object yourself.

2. Wrapper Object Creation:

JavaScript creates a wrapper object that encapsulates the primitive value.
This wrapper object has the same value as the primitive but belongs to the object wrapper type (e.g., Number, String, Boolean, BigInt, Symbol). null and undefined are the only primitive values that do not have object wrappers.
The wrapper object has the methods associated with its type, allowing you to perform operations on the primitive value.

3. Method Execution:

The method you called is then executed on the wrapper object. The method can read the primitive value and return a derived result. Since primitives are immutable, the original value is never modified.
Once the method finishes execution, the wrapper object is discarded.
The original primitive value remains unchanged, as it was never directly modified.

let name = "akshay";
let myName = name.toUpperCase(); // Calls toUpperCase() on the primitive string "akshay"

console.log(myName); // Output: "AKSHAY"
console.log(name); // Output: "akshay"
console.log(typeof name);  // Output: "string" (still a primitive)

DEV Community: Akshay Kant

How ChatGPT Understands Your Questions?

How Can Primitive Values Use Methods in JavaScript?