LLM language models: what they are and how they work

Los large language models, or LLMThey've crept into our conversations just like smartphones did in their day: almost without us noticing, completely changing the way we work, search for information, and communicate with technology. They're the foundation of tools like ChatGPT, Gemini, Claude, and Copilot, and they're behind almost every modern smart assistant.

If ever you wondered What exactly is an LLM, and how does it work internally?How does it differ from classic AI models, or why there is so much talk about parameters, tokens, context window, or quantization? Here you will find an in-depth explanation, but in a clear and approachable language, without losing technical rigor.

What is an LLM language model?

Un LLM (Large Language Model) It is an artificial intelligence model based on deep learning that is trained on enormous amounts of text to be able to to understand, generate and transform human language with a fluency that closely resembles that of a person.

Essentially, an LLM is a system that, given an input text, Predict what the next text fragment should be. (token) based on patterns it has learned by reading billions of examples: books, articles, websites, technical documentation, conversations, code, and other textual resources.

The word “large” (grande) It refers both to the volume of training data and to number of parameters that the model has: it can be hundreds of millions, billions, or even hundreds of billions of parameters that define how the model responds to each input.

Unlike classic rule-based or simple statistical systems, LLMs are capable of to capture deep relationships in languageThey understand nuances, context, irony to a certain degree, complex instructions, and much richer reasoning structures.

From GPT and Transformers to modern LLMs

When we talk about models like GPT-4Claude or Llama, we're actually referring to LLMs based on the Transformer architecture, presented in 2017 in the famous paper “Attention Is All You Need”. This architecture marked a turning point in natural language processing.

Abbreviations GPT They stand for “Generative Pre-trained Transformer”: that is, a model generative (produces new content), pre-trained (it is first trained massively with large text corpora) and based on a transform, the neural network architecture that makes modern LLMs possible.

What differentiates Transformers from older models, such as recurrent neural networks (RNNs), is that they can process entire text sequences in parallel Thanks to its attention-focused approach, instead of proceeding step by step in a strictly sequential manner, this makes training much more efficient and scalable.

Modern LLMs have taken this idea to the extreme: models with billions of parameterstrained with enormous amounts of text, capable of approaching human performance in many language tasks and of surpassing classic systems in translation, summarization, code generation or analysis of large volumes of text.

Tokens: the smallest unit that an LLM “sees”

For an LLM, text is not handled as individual letters nor necessarily as complete words, but as token usage, which are small units of text that can be a short word, part of a word, a punctuation mark, or even a space.

For example, the word “strawberry” can be divided into tokens “straw” y “berry”The model doesn't see the individual letters or count how many "r"s there are: it only sees those two blocks. That's why if you ask it how many "r"s are in "strawberry," it might get it wrong; it's not that it "can't count," it's that It doesn't operate at the letter level, but at the token level..

During preprocessing, the entire training text is chopped into tokens, and each token is represented by a numeric identifierThe model works on sequences of these identifiers, not on raw text, which allows it to deal with any language or mixture of languages ​​in a systematic way.

Embeddings and vector representations

Once the text has been divided into tokens, each token is converted into a numeric vector called embeddingwhich is a mathematical representation of its meaning and its use in different contexts.

These embeddings are high-dimensional vectors where each component captures some semantic or syntactic aspect: tokens that appear in similar contexts They end up having close representations in that vector space. Thus, concepts like "dog" and "bark" will be much closer to each other than "bark" and "tree" when the context refers to pets.

In addition to representing meaning, the models add positional encodingswhich indicate the position in the sequence where each token appears. In this way, the model not only knows which token is present, but also where appears and how it relates to the others in the sentence.

The internal engine: Transformer architecture and self-care

The heart of a modern LLM is the transformer network, which is built with multiple layers of artificial neuronsAt each layer, the input embeddings are transformed, generating increasingly rich and contextual representations of the text.

The key piece is the mechanism of self-attentionThis allows the model to "decide" which parts of the text to pay more attention to when processing each token. This is done by projecting each embedding onto three vectors: query, key, and value, obtained using weight matrices learned during training.

The query represents what a token "searches for," the key captures the information that each token "offers," and the value contains the representation that will be combined in a weighted manner. The model calculates similarity scores between queries and keys to determine which tokens are relevant for each position.

These scores are normalized to obtain attention pesosThese indicate how much information from each token (through its value) contributes to the final representation of the actual token. Thus, the model can focus on relevant keywords and "ignore" or give less weight to less important terms such as determiners or neutral connectives.

This mechanism creates a network of weighted relationships between all tokens of the sequence, and it does so in parallel, which makes the architecture very efficient compared to traditional recurrent networks.

Model parameters, weights, and capacity

LLMs are made up of a huge number of weights or parametersThese are internal variables that are adjusted during training and that determine how information is transformed in each layer.

A model with 7 billion parameters (7.000B) is considered relatively small within the world of LLMs, while one with 70 billion (70.000B) already falls into the large category, and models above 400.000 billion parameters are true behemoths that require data center hardware infrastructure.

In practice, the number of parameters is a rough measure of the “intellectual capacity” of the modelThe more parameters, the more complex the language patterns it can learn and the more sophisticated its reasoning can become. However, bigger isn't always better for all use cases: data quality, architecture, and fine-tuning also play a role.

The smaller models, the so-called small LLMThey are ideal for running on devices with limited resources or in local environments, sacrificing some reasoning ability in favor of lightness and privacy.

How to train an LLM

LLM training involves reading immense amounts of text and learning to predict the next token from a sequence based on the previous ones. During this process, the model is faced with millions or billions of examples extracted from its training corpus.

At each step, the model generates a prediction for the next token; then that prediction is compared to the actual token and a loss function which quantifies the error. The model weights are then updated using backpropagation and gradient descent, slightly correcting each parameter to reduce that error.

This loop of predict, measure the error and adjust It is repeated massively until the model converges towards a set of weights that allow it to generate coherent text, with good grammar, some reasoning ability, and factual knowledge learned from the data.

In models like GPT-4 and later, a phase is then added to this massive training. Reinforcement learning with human feedback, in which people (and sometimes other models) evaluate responses and help adjust behavior to better align with human preferences, avoiding toxic, incorrect, or inappropriate responses as much as possible.

Generation process: how an LLM writes

When you interact with an LLM (for example, by typing a prompt into a chatbot), the internal process is a kind of supercharged autofillThe text you write is tokenized, converted into embeddings, and passed through the transformer layers.

Layer by layer, the model adjusts these embeddings, taking into account the context and relationships between tokens thanks to self-attention. In the end, it produces a probability distribution about all the possible tokens that could come next.

Based on that distribution, the system selects the next token following a sampling strategy which can be more or less deterministic. If the temperature If it is set to 0.0, the model will almost always opt for the most probable token, giving very stable and uncreative answers, ideal for code or numerical tasks.

With higher temperatures (0,8 – 1,0), the choice becomes riskier: the model Explore less likely but more varied tokensThis generates more creative responses, useful for brainstorming, narrative writing, or advertising. If the temperature is pushed too far (above ~1,5), the output may become incoherent, with "babbling" or nonsensical phrases.

This process is repeated token by token: each new token is added to the input sequence and the model recalculates the output, until a maximum length or a special completion token is reached.

Context window: the short-term memory of the model

A key aspect of the LLM experience is its context windowwhich is the maximum number of tokens it can take into account at a single "glance". It is, in practice, its short-term memory.

Early models worked with context windows of about 4.000 tokens, roughly equivalent to 3.000 words of text. With that capacity, the model could handle relatively short conversations or moderately long documents, but it lost track of lengthy analyses.

Recent high-end models already handle hundreds of thousands or even millions of tokensThis allows uploading entire books, extensive technical documentation, and large knowledge bases, enabling the LLM to work as a analyst on your own documents without leaving the same context.

The context window is not permanent memory: when it is exceeded, parts of the text must be summarized or cut. But within that margin, the ability to maintain coherence and remember what was said previously is one of the factors that most determines the quality of the interaction.

Types of models: closed, open, and niche

The LLM ecosystem has fragmented into several types of models with very different philosophies. On one hand, there are the closed or proprietary models, such as GPT, Gemini or Claude, developed by large companies and offered as cloud services.

These models are usually the most powerful in terms of reasoning ability, size, and context window, and they run on supercomputers with specialized GPUsIn return, they function as "black boxes": their exact architecture is unknown, the details of their training data are unknown, and there is no total control over the use of the data you send.

At the other extreme are the models open weightsas the llama 3Mistral or Qwen are examples where developers publish the model weights so anyone can download and run them on their own hardware. They don't usually include the training code or the original data, but they allow for a local and private use very flexible.

There are also really projects open source, such as OLMo, which share not only weights but also code and, where possible, data details. These models are especially valuable for scientific research, transparency, and auditing.

Finally, there are the niche modelsThey are trained or fine-tuned for specific domains such as medicine, law, programming, or finance. Although they may be much smaller than generalist giants, in their specific field they can outperform much larger models in accuracy and usefulness.

How to interpret the “name” of a model

If you browse repositories like Hugging Face, you'll see model names that look like nuclear keys, for example: Llama-3-70b-Instruct-v1-GGUF-q4_k_mEach part of that name provides useful information about the model.

The first part, Llama-3, indicates the family and base architecture, in this case the Llama 3 model from Meta. The number 70b It indicates the size: 70.000 billion parameters, which gives you an idea of ​​the hardware required (very high-end graphics cards or servers with a lot of memory).

The label Instruction indicates that the model has been fine-tuned to follow instructions and converse naturally. If you want to use an LLM as an assistant, it is essential that the name includes "Instruct" or equivalent; otherwise, the model may behave like a generic text filler and not answer your questions well.

The fragment GGUF This is the file format, especially common for running models on CPUs or Apple devices. Other formats like EXL2, GPTQ, or AWQ are typically designed for NVIDIA GPUs and offer different performance optimizations.

Lastly, q4_k_m It describes the quantization level (4 bits in this case) and the specific method (K-Quants), which affects the disk size, the memory required, and the small loss of precision that is accepted in order to run the model on more modest hardware.

Quantization: Compressing Giant Brains

State-of-the-art models in their original format can occupy tens or hundreds of gigabytes and require amounts of video memory (VRAM) that are beyond the capabilities of a home PC. That's where the quantization.

In its complete form, an LLM typically stores its weights in 16-bit precision (FP16), with many decimal places that allow for very fine calculations. Quantization reduces this number of bits, for example from 16 to 4, rounding the values ​​so that take up much less space and require less memory to run.

What's surprising is that, for many chat, writing, or summarizing tasks, going from 16 to 4 bits barely affects perceived quality: recent studies show that a model in Q4 can maintain around 98% of their practical reasoning ability for general use, with a weight reduction of up to 70%.

More aggressive quantizations like Q2 or IQ2 allow you to fit huge models into very limited equipment, but the price is high: noticeable loss of coherence, loops, repetitions or failures in more demanding logical tasks, especially in mathematics and complex programming.

If your goal is to perform delicate technical tasks, it's advisable to use the highest quantization your hardware supports (Q6, Q8, or even unquantized), while for lighter tasks like writing or brainstorming, Q4 is usually the sweet spot for most users.

Hardware and VRAM: how far does your computer go?

To find out if you can run a model on your own PC, rather than just looking at the system RAM, you need to look at the VRAM of your graphics cardA quick rule of thumb is to multiply the billions of parameters by about 0,7 GB of VRAM in moderate quantization.

For example, a model like Call 3 8B in Q4 It will have around 5,6 GB of VRAM, manageable by many current gaming GPUs. However, a model of 70B parameters It may require around 49 GB of VRAM, something reserved for professional cards or multi-GPU configurations.

In the current ecosystem, we coexist with two major hardware approaches for local AI. On the one hand, the NVIDIAwhere RTX GPUs of the 3000, 4000 or 5000 series, using CUDA, offer very high text generation speeds, but with the limitation that VRAM is expensive and does not usually exceed 24 GB in home consumption.

On the other hand, there is the Apple's pathWith its M2, M3 or M4 chips and unified memory, a Mac with 96 or 192 GB of shared memory can load gigantic (quantized) models that would be impossible to house on a single home GPU, although the generation speed is usually lower.

In both scenarios, tools such as LM Studio u Don't They facilitate the download, configuration, and execution of local models, allowing you to adjust parameters such as temperature, CPU/GPU usage, or memory without having to struggle with complex command lines, unless you are looking for very fine integration with other programs.

LLM versus other types of generative AI

When you interact with an image generator, for example, your prompt text is first processed with a language model It understands your request, classifies the intention, and extracts the key elements (artistic style, objects, context, etc.). This information is then translated into representations that consume specific image models.

The same applies to the generation of audio or musicAn LLM can understand the textual description (“create a quiet piece with piano and strings”) and turn it into a structure that a specialized audio model then transforms into sound.

In code generation, LLMs are directly involved: they are trained with large source code repositoriestechnical documentation and usage examples, allowing them to write functions, explain errors, translate between programming languages, or even design small games like tic-tac-toe in C# from a simple natural language description.

Practical uses of LLMs in everyday life

LLMs can be fine-tuned for specific tasks that maximize their ability to understand and generate text, leading to an ever-increasing range of applications in personal and business environments.

Among the most common uses we find the conversational chatbots such as ChatGPT, Gemini or Copilot, which act as general assistants capable of answering questions, explaining concepts, helping with homework, writing emails or drafting reports.

Another very powerful category is that of content generationProduct descriptions for ecommerce, advertising copy, blog articles, video scripts, newsletters or social media posts, all generated from relatively simple instructions.

In companies, LLMs are used to answer frequently asked questionsAutomating part of the customer service, classifying and labeling large volumes of feedback (reviews, surveys, social media comments) and extracting insights on brand perception, recurring problems or opportunities for improvement.

They also excel at tasks of translation and localizationDocument classification, extraction of relevant information, generation of executive summaries and support for decision-making by reinforcing the human team with rapid analyses on large sets of text.

Limitations and risks of LLMs

Despite their power, LLMs have significant limitations that should be kept in mind in order to use them wisely and without unrealistic expectations.

The best known is the phenomenon of the hallucinationsThe model can generate information that sounds very convincing but is false or inaccurate. This occurs because the LLM Predicts text, not factsAnd if there is not enough context or the prompt is ambiguous, fill in the gaps with plausible, albeit invented, content.

We also need to consider the biasesModels learn from data generated by people, with all that this implies: biases, stereotypes, inequalities, and a partial view of the world. Without control and alignment mechanisms, an LLM can reproduce or even amplify these biases.

Another key limitation is its prompt dependencyThe quality of the response depends largely on how you phrase the request: vague instructions generate mediocre results, while well-designed prompts lead to much more useful, accurate, and actionable responses.

Finally, LLMs do not have a real understanding of the world: they lack direct perception, they do not have integrated long-term memory unless external systems are added, and unless the provider enables it, They do not have access to real-time informationTheir “knowledge” is limited to what was present in their training data and what fits within their current context window.

Relationship with the business world and work

In the corporate environment, LLMs are becoming integrated into CRM, sales tools, services, and e-commerce platforms to increase productivity and improve the customer experience.

These models allow you to automate repetitive tasks such as responding to similar emails, generating initial contract proposals, summarizing calls or meetings, and guide human agents with real-time response suggestions, without necessarily replacing your judgment but significantly reducing the mechanical load.

In marketing and sales, they are used to better segment customersAnalyze large amounts of textual data (reviews, queries, social media), personalize messages, and discover opportunities that would otherwise go unnoticed among thousands of interactions.

This impact on the work environment is reminiscent of that of industrial robots in manufacturing: some monotonous work is reduced, job profiles are transformed, and new functions focused on [the following] emerge. design, monitor and integrate AI systems in existing processes.

Future of LLMs: Multimodality and greater capabilities

The evolution of LLMs points towards increasingly more models multimodalcapable of processing not only text, but also images, audio, and even video in an integrated way. In this way, a single system could understand a conversation, analyze a scanned document, interpret a graph, and reason about all of it simultaneously.

Some models are already being trained with combinations of text, audio, and video, opening the door to advanced applications in fields such as autonomous vehiclesrobotics or enhanced personal assistants, which “see” and “hear” as well as read.

As training techniques are refined, LLMs are expected to improve in accuracy, bias reduction, and handling of up-to-date informationincorporating external verification mechanisms and controlled access to real-time data sources.

We will also see a consolidation of hybrid models: combinations of high-performance closed models to specialized open models and local tools that allow maintaining privacy and control over the most sensitive data.

In short, LLMs are transitioning from a flashy novelty to becoming a basic productivity infrastructureThis applies to both individuals and businesses. Understanding what they can do, how they work, and what their limitations are is key to leveraging them effectively without delegating more than they can realistically handle.