In the previous section, we established that Large Language Models are powerful tools for processing and generating human-like text. But how exactly does a computer model, which fundamentally works with numbers, handle something as nuanced as language? It doesn't read words or sentences like we do. Instead, it operates on units called tokens.

What Are Tokens?

Think of tokens as the basic building blocks of text for an LLM. Instead of processing text character by character (which would be very inefficient) or word by word (which struggles with variations like "run", "running", "ran" or punctuation), LLMs break text down into carefully chosen pieces. A token is often a whole word, but it can also be a part of a word (a subword), a single character, or punctuation.

For example, the sentence "Hello world!" might be broken down into tokens like this: ["Hello", " world", "!"]

Notice the space before "world" is included in the token. A more complex word like "unbelievably" might be split differently depending on the model: ["un", "believe", "ably"] or perhaps ["unbeliev", "ably"]

This subword approach allows the model to handle variations and new words more effectively. It learns relationships between common word parts (un-, -ly, -ing) rather than having to learn every single word form from scratch.

The Tokenizer: Translator Between Text and Numbers

The component responsible for converting raw text into tokens and back again is called a tokenizer. Every LLM is trained with a specific tokenizer. This tokenizer has a defined vocabulary, the set of all possible tokens it knows.

Here's the process:

Tokenization: The tokenizer takes your input text (like a prompt) and breaks it down into a sequence of tokens based on its rules and vocabulary.
ID Conversion: Each token in the vocabulary corresponds to a unique numerical ID. The tokenizer converts the sequence of tokens into a sequence of these IDs. These numbers are what the LLM actually processes.
Detokenization: When the LLM generates a sequence of output IDs, the tokenizer translates these numbers back into tokens and then joins them together to form readable text.

It's important that the same tokenizer used to train the model is also used when you interact with it. Using a different tokenizer would be like trying to communicate using a mismatched dictionary, leading to nonsensical results.

A simplified view of how text flows through the tokenization and generation process with an LLM.

Text Generation: Predicting the Next Token

Now that we understand tokens, how does the LLM actually generate text? At its core, text generation is a step-by-step prediction process.

Your input prompt is tokenized into a sequence of IDs.
The LLM analyzes this sequence and predicts the most likely next token ID that should follow. This prediction is based on the vast amount of text data it was trained on, allowing it to learn patterns, grammar, facts, and even writing styles.
This newly predicted token ID is added to the end of the sequence.
The LLM looks at the new, slightly longer sequence and predicts the next token ID.
This process repeats, adding one token at a time, until the model predicts a special "end-of-sequence" token, reaches a length limit, or is otherwise instructed to stop.

Imagine completing the sentence: "The weather today is...". You might predict "sunny", "cloudy", or "rainy" based on context. An LLM does something similar, but on a massive scale and based purely on statistical patterns learned from its training data. It calculates probabilities for all possible tokens in its vocabulary and typically chooses the one with the highest probability (though techniques like adjusting the "temperature," discussed later, can add randomness).

For example, if the input tokens represent "Once upon a time, there", the model might predict the token for " was" as the most likely next token. The sequence becomes "Once upon a time, there was". Then, looking at this new sequence, it might predict " a". The sequence grows token by token: "Once upon a time, there was a...".

This iterative, token-by-token prediction is the fundamental mechanism behind how LLMs generate coherent and often complex text based on your input. The model's ability to make good predictions relies on the knowledge encoded within its parameters, which is why larger models with more parameters can often capture more intricate language patterns.