Computers cannot understand natural language (the way people speak or write) or context (the situation or background that gives meaning to language) the way humans do. Generally speaking, computers require structured inputs (organized data in a set format), fixed rules, predefined patterns, and explicit instructions. LLMs (Large Language Models) exist because traditional software and rule-based systems fail when tasks involve unstructured language (free-form text), ambiguity (unclear meaning), and massive variation (many different ways of saying things).

Real-World Use Case: The Customer Support Email That Breaks Traditional Software

Imagine you run an online store. One morning, your customer-support system receives this email:

“Hey, I ordered that blue wireless keyboard last week, and it still hasn’t shown up. I checked the tracking link, but it’s stuck on ‘processed.’ Can you see what’s going on? Also, if it’s going to take too long, I might just switch to the black one instead — whichever ships faster. Thanks!”

To a human, this message is effortless to understand.
You instantly grasp:

• The customer is frustrated but polite.

• They want to know why the order is delayed.

• They bought the blue wireless keyboard.

• They’re open to switching to the black model if it arrives sooner.

• They don’t want a refund or cancellation — just the fastest path to getting a keyboard.

But to a traditional computer system?
This message might as well be random noise.

Rule-based software chokes on everything that makes the email human:

• The language is unstructured — no fixed fields, no predictable sentence shape.

• The intent is embedded in conversational phrasing (“can you see what’s going on?”).

• The alternative product is mentioned indirectly (“switch to the black one”).

• Key details are scattered across multiple sentences and pronouns (“that one”).

• The emotional tone (mild frustration, patience) is invisible to rigid systems.

To make a conventional program handle this email, you’d need to force users into rigid form fields or build an ever-expanding list of rules — rules that explode combinatorially as soon as real people write like real people.

This is exactly why LLMs exist.
They step into the gap created by unstructured language, ambiguity, implied meaning, and the infinite creativity of human expression. LLMs can interpret the intent, extract the key entities, recognize the conditional request (“if it takes too long, switch colors”), and even detect the customer’s tone — all without demanding that humans talk like structured databases.

What are Large Language Models?

LLMs, or Large Language Models, are deep learning models trained on vast datasets. They are based on the transformer neural network architecture, which is highly effective at understanding, generating, and modeling natural language and related content for a variety of tasks.

Why shift to Transformers?

It is a type of neural network architecture that excels at processing sequential data. It is an evolution of the RNN (recurrent neural network) designed to cover the gap in long-range dependencies. RNNs process sequences step-by-step, which makes it difficult to capture relationships between words, leading to the vanishing gradient problem. It is a challenge in deep learning where the gradients, used to update a neural network’s weights, become extremely small as they are propagated backward through the layers. Transformers utilize a self-attention mechanism to simultaneously weigh the importance of all words in a sequence, thereby overcoming these limitations.

Transformer arch

Pretraining LLMs

Training starts with a massive amount of data- billions or trillions of words from various sources. It involves cleaning, pre-processing to remove errors, duplicates, and undesirable content.
The process of tokenization converts the text into smaller, machine-readable units called “tokens.” These tokens can be as short as individual characters or as long as entire words. Tokenization enables the model to process complex language by breaking it down into components that a machine can evaluate. Initially, training uses self-supervised learning (with unlabelled data) and supervised learning. The model passes tokens through a transformer network using a self-attention mechanism, which enables it to calculate relationships between tokens, even if they are far apart. This helps establish dependencies in language understanding.

Tokenization & meaning derivation

How to use LLMs

Once trained, it works by responding to prompts by tokenizing the prompt, converting it into embeddings, and using its transformer to generate text one token at a time, calculating the probabilities for all potential next tokens, and outputting the next. The model does not know the final answer in advance; it uses the statistical relationship it learned in training to predict.

The easiest and fastest way to get domain-specific knowledge from a general-purpose LLM is through prompt engineering, which does not require additional training. Users can modify prompts in all sorts of ways. LLMs have strategies to control their outputs, such as LLM temperature, which controls the randomness of text that is generated by LLMs during inference, or top-k/top-p sampling, which limits the set of tokens considered to the most likely ones, balancing creativity and coherence.

Types of LLM Parameters

Parameters

There are three primary categories: Weights, Biases, and Hyperparameters.

1. Weights: Numerical values that represent the importance that the LLM assigns to a specific input. The input weight is proportional to the relevance of the model’s output. Within neural networks, weights are multipliers that determine the signal strength from one neural network layer to the next. It affects how a network propagates data forward through its layers.

2. Biases: Constant values added to a signal’s value from the previous layers. The model uses biases to allow neurons to activate under conditions where the weight alone might not be sufficient to pass through the activation function. Like weights, biases are adjusted with backpropagation during training to optimize model performance and minimize errors.

3. Hyperparameters: External settings that determine a model’s behavior, shape, size, resource use, and other characteristics. It is a significant pillar of LLM customization that includes:

• Number of Layers: Neural networks are made of layers of neurons or nodes. The more layers between the initial input layer and the final output layer, the more complex the model. It also has its downsides; if the model has too many layers for a task that does not require it can lead to wasteful computational resources and overfitting.

• Context Window: The maximum number of tokens the model can field while maintaining coherence across the entire input sequence. It also determines the length of the conversation that a model can maintain without losing track of previous content. Larger context windows lead to greater accuracy, fewer hallucinations, and the ability to process larger documents or have longer conversations.

• Temperature: Randomness or creativity deal. Raising the temperature increases the probability distribution for the next words that appear in the model’s output during text generation, i.e., proportional to randomness. In the case of a chatbot, which needs to be creative, it needs a higher temperature to create human-like text. But for high regulatory fields such as law or finance, it must adhere to strict requirements.

• Top-p: Like temperature, top-p sampling also affects word diversity in generated text outputs. Top-p works by setting a probability threshold p for the next token in an output sequence. The model is allowed to generate responses by using tokens within the probability limit.

• Top-k: The k value sets the limit for the number of terms that can be considered as the next in the sequence. Terms are ordered based on probability, and the top k terms are chosen as candidates.

• Token number: The token number or max tokens hyperparameter sets an upper limit for output token length. Smaller token number values are ideal for quick tasks such as chatbot conversations and summarization — tasks that can be handled by small language models as well as LLMs.

• Learning Rate: Critical hyperparameter that affects the speed at which the model adjusts its weights and biases during training and fine-tuning. These processes often use a learning algorithm known as gradient descent.

• Frequency penalty: Helps prevent models from overusing terms within the same outputs. Once a term appears in the output, the frequency penalty dissuades the model from reusing it again later.

• Presence penalty: Related hyperparameter that works similarly to the frequency penalty, except it only applies once. The presence penalty lowers a term’s logit value by the same amount regardless of how often that term is present in the output, so long as it appears at least once.

• Stop Sequence: Preset string of tokens that, when it appears, causes the model to end the output sequence. For example, if a model is designed to output a single sentence at a time, the stop sequence might be a period.

Deterministic LLM Pipeline (Temperature = 0)

import json
import openai

# --------------------------------------------------------------
# Model configuration
# --------------------------------------------------------------
# Using a deterministic LLM response for classification/extraction.
# temperature = 0 ensures:
#   - reproducibility
#   - no creativity/randomness
#   - consistent behavior for pipelines
#
# "gpt-4.1" is fast + capable enough for structured outputs.
MODEL_NAME = "gpt-4.1"
TEMPERATURE = 0.0

# --------------------------------------------------------------
# Function: call_llm
# --------------------------------------------------------------
# This is the *core* wrapper that all downstream logic uses.
# It creates a single, standardized interface for:
#   - sending messages to the LLM
#   - controlling temperature, tokens, safety
#   - parsing JSON outputs
#   - error handling (minimal version for clarity)
#
def call_llm(prompt: str) -> dict:
    """
    Execute an LLM call and return a JSON-decoded response.
    ALL tasks (categorization/extraction/summarization/etc.) reuse this.
    """

    response = openai.ChatCompletion.create(
        model=MODEL_NAME,

        # messages is a LIST because you can include system / assistant / user roles.
        # Here we use only user content for simplicity.
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],

        # temperature controls randomness (0 = deterministic)
        temperature=TEMPERATURE,

        # max_tokens controls how long the model can respond.
        # Keeping it high enough to ensure JSON fits.
        max_tokens=500,

        # top_p is another randomness controller (we keep default 1)
        # top_p lower = more conservative sampling.
        top_p=1.0,

        # frequency_penalty discourages repeated tokens (kept 0 here)
        frequency_penalty=0.0,

        # presence_penalty encourages introducing new topics (kept 0)
        presence_penalty=0.0,
    )

    # Extract the raw string JSON content
    raw_output = response["choices"][0]["message"]["content"]

    # Convert JSON string → Python dict
    return json.loads(raw_output)

# --------------------------------------------------------------
# Function: analyze_customer_email
# --------------------------------------------------------------
# This is our CASE-STUDY example:
# We take a customer support email and extract structured attributes.
#
# The LLM is instructed to behave as an "AI support triage system."
# All instructions are baked into one clear prompt.
#
def analyze_customer_email(email_text: str) -> dict:
    """
    Use LLM to analyze a customer’s email and extract:
        - issue_category
        - urgency_level
        - sentiment
        - summary
        - recommended_action

    Returns fully structured JSON.
    """

    prompt = f"""
    You are an AI system that analyzes customer support emails and produces
    STRICTLY structured JSON. You MUST follow the output schema exactly.

    Extract and infer the following fields:
      - "issue_category": one of ["billing", "technical", "account", "refund", "other"]
      - "urgency_level": one of ["low", "medium", "high"]
      - "sentiment": one of ["positive", "neutral", "negative"]
      - "summary": short 1-2 line summary of the email
      - "recommended_action": action a support agent should take

    RULES:
      - Respond ONLY in JSON.
      - No explanation outside JSON.
      - Be deterministic and consistent.

    Email:
    \"\"\"
    {email_text}
    \"\"\"
    """

    return call_llm(prompt)

# --------------------------------------------------------------
# Main Pipeline Entrypoint
# --------------------------------------------------------------
# This demonstrates the simplest real workflow:
#   Input → LLM → structured output → returned upstream
#
def run_pipeline(email_text: str) -> dict:
    """
    Complete pipeline for processing a single customer email.
    Easy to integrate in APIs, batch jobs, or downstream scoring.
    """
    result = analyze_customer_email(email_text)
    return result

# --------------------------------------------------------------
# Example Usage (only runs if this file is executed manually)
# --------------------------------------------------------------
if __name__ == "__main__":
    sample_email = """
    Hi, my account was suddenly locked today and I can’t access my
    subscription. I need this fixed ASAP because my work depends on it.
    """

    print("Input Email:\n", sample_email)
    print("\nLLM Output:")
    print(run_pipeline(sample_email))

Final Thoughts

Together, these parameters — weights, biases, and hyperparameters — define the behavior, capacity, and personality of an LLM. They control everything from how much context the model can remember to how creative its responses are, to how quickly it learns during training. Understanding these knobs is essential because they form the foundation of every customization technique we use today.

And this is where the bridge to the next stage begins.

In real-world systems, we rarely retrain a model from scratch. Instead, we use these parameters — especially the inference-time hyperparameters — to shape the model’s behavior through prompt engineering, guided reasoning, structured outputs, and safety mechanisms.

This is the layer where organizations transform a general-purpose LLM into a domain-aligned, predictable, and governable system.

In the next post, we’ll explore how these concepts come together: how prompts are designed, refined, evaluated, governed, and deployed inside modern AI pipelines. This is where the model stops being just a mathematical object — and becomes a reliable component in a production workflow.

Stay tuned for more insights! 🚀