Language model
A language model is a computational model that represents patterns in linguistic tokens to estimate sequence probabilities and predict or generate language from context.
Software Testing with Generative AI
A large language model is a machine-learning model trained on extensive text data to generate and transform language from an input prompt.
- How it is used
- Supports focused testing and development tasks by generating, transforming, or enhancing information through prompts or APIs.
- How deep it goes
- Explains prompts, probabilistic prediction, training data, risks, and prompt tactics, but stops short of deep model internals.
- Examples
- Uses phone keyboard predictions, file-upload test design, code transformation, synthetic data, and Java booking-API code generation.
- What you can do after
- Apply it via prompt engineering to accelerate focused testing work while verifying outputs and retaining human direction.
Read how Software Testing with Generative AI explains language model →
LLMs in Production
A large language model is an artificial intelligence model trained on large text collections to predict and generate human language.
- How it is used
- Supports language-centered tasks such as drafting communication, chatbots, programming assistance, and interactive games.
- How deep it goes
- Explains transformer-based scaling, prompting, training stages, evaluation, and production trade-offs through comparisons and practical examples.
- Examples
- Uses paperwork and lesson planning, an OpenAI API prototype, and a Python example generating text with BLOOM.
- What you can do after
- Apply it via OpenAI’s API or Hugging Face Transformers to prototype or run text generation.
How Large Language Models Work
A machine-learning model trained on very large text collections to understand and generate human language or other sequential content such as source code.
- How it is used
- Explains how generative language systems work and helps users, developers, and decision makers judge suitable applications.
- How deep it goes
- Traces tokenization, embeddings, attention, autoregressive generation, and training objectives, but stops short of building a model from scratch.
- Examples
- Uses haiku generation, summarization, word games, drug names, pi code, and Modula-3 translation to illustrate capabilities and failures.
- What you can do after
- Evaluate/understand LLM outputs, constrain practical use cases, verify results, and recognize when novelty or risk makes deployment unsuitable.
Read how How Large Language Models Work explains language model →
Natural Language Processing in Action, Second Edition
A large language model is a neural language model trained on very large text corpora to model and generate language.
- How it is used
- Uses next-word prediction to generate text for prompts and chatbot responses.
- How deep it goes
- Defines conditional next-word probabilities and demonstrates token preparation and generation, while treating the probability diagram as a simplified view.
- Examples
- Demonstrates WikiText2 word sequences, a generated GRU continuation, and a Llama 2 answer with contradictory arithmetic.
- What you can do after
- Apply it via PyTorch and Transformers to generate text, then inspect outputs for errors before relying on them.
Read how Natural Language Processing in Action, Second Edition explains language model →
Introduction to Generative AI, Second Edition
A large language model is a language model trained on very large amounts of data with many parameters to understand and generate natural language across tasks.
- How it is used
- Introduces the general-purpose systems behind chat, text generation, question answering, and other natural language tasks.
- How deep it goes
- Explains prediction, tokens, and training at an intuitive level, without implementation details.
- Examples
- Uses sentence completion, translation, chatbots, and coding assistants to illustrate capabilities.
- What you can do after
- Evaluate/understand what an LLM response may be useful for and why fluent output still needs checking.
Read how Introduction to Generative AI, Second Edition explains language model →
Deep Learning with R, Third Edition
A large language model is a machine-learning model trained on large text corpora to understand and generate natural-language text.
- How it is used
- Frames text generation as repeated next-token prediction instead of classification over complete output sequences.
- How deep it goes
- Defines the next-token probability distribution and explains the scale problem; introduces a character-level build without detailing its implementation here.
- Examples
- Uses a 20,000-word vocabulary calculation and a next-character model for Shakespeare-like text.
- What you can do after
- Build it from scratch as a small next-character model for generating Shakespeare-like text.
Read how Deep Learning with R, Third Edition explains language model →
Grokking AI Algorithms, Second Edition
A large language model is a neural language model trained on large text corpora to process and generate human language.
- How it is used
- Uses language models to explain text generation, question answering, translation, and code writing through a progression from keyboard autocomplete to LLMs.
- How deep it goes
- Explains the autocomplete intuition, Transformer-block components, and architecture tradeoffs, without demonstrating a complete LLM implementation in the supplied excerpts.
- Examples
- Contrasts a phone keyboard completing “Hey, what are” with an LLM and compares toy and real-world Transformer configurations.
- What you can do after
- Evaluate/understand it by relating LLM capabilities to training data, parameters, Transformer components, and memory, compute, and latency tradeoffs.
Read how Grokking AI Algorithms, Second Edition explains language model →
The Art of AI Product Development
A machine-learning model trained on large text corpora to understand and generate natural language.
- How it is used
- Supports content creation and other language tasks within applications whose user interactions and downstream uses determine the risks.
- How deep it goes
- Explains training data, usage patterns, selection, customization, and evaluation at a product-decision level, leaving fine-tuning’s technical challenges to engineers.
- Examples
- Uses a content-generation app, brand-specific copy edits, model benchmarks, and direct user interaction to make trade-offs concrete.
- What you can do after
- Evaluate/understand it by shortlisting models against product constraints, testing task-specific quality, and planning safeguards and iteration.
Read how The Art of AI Product Development explains language model →
Deep Learning with Python, Third Edition
A language model trained on large text corpora that can generate human-sounding responses, mentioned here as an example of a system that may be modular but still lacks recombination ability.
- How it is used
- Uses next-token prediction to make text generation feasible without classifying every possible output sequence.
- How deep it goes
- Defines the next-token distribution and works through an inference loop, then distinguishes masked and sequence-to-sequence variants.
- Examples
- Builds Shakespeare-like character generation from a prompt and tests a large language model on a letter-counting word problem.
- What you can do after
- Build it from scratch using a Keras token-by-token generation loop that feeds each predicted character back into the model.
Read how Deep Learning with Python, Third Edition explains language model →
Grokking AI Applications
A large language model is a machine-learning model trained on large text collections to predict and generate sequences of natural-language tokens.
- How it is used
- Serves as the probabilistic text-in, text-out core that GenAI applications orchestrate with prompts and supporting components.
- How deep it goes
- Explains training stages, embeddings, context, and next-token generation, while allowing readers to skip detailed modern architecture internals.
- Examples
- Uses ChatGPT conversation memory, an ice-cream shop’s opening hours, live weather, email sending, and calculator-assisted arithmetic.
- What you can do after
- Build from scratch applications that manage LLM randomness and extend models with memory, retrieval, tools, and agents.
Generative AI in Action
A large language model is a neural model trained on large text corpora to understand and generate natural language, including source code in code-focused variants.
- How it is used
- Supports enterprise language workflows ranging from extraction and summarization to chatbots and code generation.
- How deep it goes
- Explains training and iterative token generation conceptually, then develops API settings and integration choices without mathematical derivation.
- Examples
- Uses contact-detail extraction and a two-call OpenAI text-generation and translation script.
- What you can do after
- Apply it via the OpenAI API for basic text tasks and evaluate configuration, grounding, and enterprise risks.
Investing for Programmers
A large language model is an artificial-intelligence model trained on extensive text data to understand and generate human language.
- How it is used
- Deploys language generation for company research, document summarization, risk assessment, code generation, and structured investment workflows.
- How deep it goes
- Explains generative use, attention, prompting, APIs, parameters, and limitations, but defers detailed transformer internals.
- Examples
- Demonstrates stock-strategy comparisons, company-risk scoring, document summaries, Python API calls, and LangChain agents using financial news.
- What you can do after
- Apply LLMs through OpenAI, Gemini, Anthropic, Mistral, Hugging Face, or LangChain APIs while reviewing outputs for reliability.
Read how Investing for Programmers explains language model →
Effective Conversational AI
A large language model is a machine learning model trained on very large text datasets to model and generate sequences of language.
- How it is used
- Supports chatbot answers and assists builders with dialogue, training data, and other conversational AI tasks.
- How deep it goes
- Defines next-word prediction and works through API routing, prompts, model selection, and guardrails without detailing model internals.
- Examples
- Uses a generated pie recipe, password-related utterances, and an insurance-claim dialogue flow.
- What you can do after
- Apply it via a chatbot API for selected requests, while testing outputs and retaining controls over user-facing answers.
Read how Effective Conversational AI explains language model →
Knowledge Graphs and LLMs in Action
A large language model is a neural language model trained on very large text corpora to understand and generate natural-language content.
- How it is used
- Supports knowledge extraction, natural-language querying, summarization, conversational interfaces, and interpretation of structured analytical results.
- How deep it goes
- Explains scaling, transfer learning, prompting, fine-tuning, grounding, and several implementation pipelines, while deferring full model-training internals.
- Examples
- Uses drug discovery, customer support, pathway interpretation, clinical decision support, and ontology-grounded biomedical entity disambiguation.
- What you can do after
- Build domain-specific extraction and question-answering systems using prompts, fine-tuning, knowledge graphs, and validation workflows.
Read how Knowledge Graphs and LLMs in Action explains language model →
Sutskever's List
A language model assigns probabilities to sequences of linguistic tokens and can generate or evaluate text.
- How it is used
- Defines the probability model underlying generative language models and next-token training.
- How deep it goes
- Explains sentence probabilities and next-token training, including shifted labels and causal masking.
- Examples
- Contrasts grammatical and plausible text with broken grammar and grammatically correct but semantically odd text.
- What you can do after
- Evaluate how syntax and meaning affect text probabilities and understand how autoregressive models generate text.
The Complete Obsolete Guide to Generative AI
A machine-learning model trained on large text corpora to process and generate natural-language text.
- How it is used
- Accelerates language-driven work through prompts, data querying, automation, and productivity-tool integrations.
- How deep it goes
- Defines prediction-based language generation and response controls, while deferring deeper model theory to separate definitions and later model work.
- Examples
- Uses hotel chat responses, PDF sales totals, Python help, spreadsheet formulas, sentiment labels, and banking-data queries.
- What you can do after
- Apply it via chat tools and APIs to generate, analyze, automate, and verify language-based work.
Read how The Complete Obsolete Guide to Generative AI explains language model →
Deep Learning with PyTorch, Second Edition
A language model with enough scale to generate and answer with fluent text from prompts.
- How it is used
- Illustrates how deep learning can answer queries and generate text from prompts.
- How deep it goes
- Demonstrates prompting and notes probabilistic output, but does not explain language-model architecture or generation mechanics.
- Examples
- Uses a request for a self-introduction poem and ChatGPT’s generated verse.
- What you can do after
- Evaluate/understand prompt-driven text generation without treating fluent output as evidence of human-like thought.
Read how Deep Learning with PyTorch, Second Edition explains language model →
Inside AI
A large language model is a machine-learning model trained on large text corpora to process and generate human-language text.
- How it is used
- Uses language models to explain conversational AI and practical text-generation tasks.
- How deep it goes
- Explains pretraining, fine-tuning, tokens, and next-token prediction through a prompt example without descending into implementation.
- Examples
- Illustrates generation with an electric-vehicle prompt and applications including summarization, translation, coding assistance, and customer support.
- What you can do after
- Evaluate/understand it: identify useful LLM tasks while checking plausible output for errors, bias, and misleading claims.
Starting Data Analytics with Generative AI and Python
A machine-learning model trained on large text collections to understand and generate natural language.
- How it is used
- Supports analytics planning, code generation, result interpretation, and text mining rather than replacing checks on data and outputs.
- How deep it goes
- Defines an LLM and demonstrates access workflows, while leaving model architecture and technical internals aside.
- Examples
- Uses customer-review idioms, a Python chat API call, and a locally invoked Llama model as concrete cases.
- What you can do after
- Apply it via a chat API or local model to assist analytics, then check generated code and interpretations against the task.
Read how Starting Data Analytics with Generative AI and Python explains language model →
AI-Powered Search
A large language model is a neural language model trained on large text corpora to predict and generate language and perform related language-understanding tasks.
- How it is used
- Uses LLMs to interpret queries, embed content, personalize retrieval, and produce answers or summaries from search results.
- How deep it goes
- Defines language models and outlines Transformer representations, then develops embedding and fine-tuning workflows without requiring model training from scratch.
- Examples
- Works through product embeddings for personalization, short answers from an outdoors question-answering dataset, and sourced web-result summarization.
- What you can do after
- Apply it via SentenceTransformer to embed products, or fine-tune a Transformer-based model to return short answers from documents.
Learn Generative AI with PyTorch
A large language model trained beforehand on broad textual data and reused for downstream tasks.
- How it is used
- Uses pretrained language models for generation and question answering, then connects them to tools when answers require current information.
- How deep it goes
- Explains a small GPT-style model’s token-to-logit path and demonstrates pretrained-model use, without training a pretrained LLM at scale.
- Examples
- Uses a small PyTorch GPT model and a GPT-4 question about the 2024 Academy Awards.
- What you can do after
- Apply it via LangChain to combine an LLM with Wikipedia and Wolfram Alpha for factual or real-time queries.
Read how Learn Generative AI with PyTorch explains language model →
Machine Learning Platform Engineering
A large language model is a neural language model trained on extensive text data to generate or transform natural-language content.
- How it is used
- Uses an LLM to generate answers in a retrieval-augmented documentation assistant.
- How deep it goes
- Explains integration, model choice, observability, and cost; stops short of language-model training internals.
- Examples
- Uses a company-documentation chatbot, a manual-versus-LangChain retrieval pipeline, and token-cost comparisons across model options.
- What you can do after
- Apply it via LangChain in a retrieval-augmented assistant, then monitor responses and spending.
Read how Machine Learning Platform Engineering explains language model →
Data Analysis with LLMs
A language model with a very large number of learned parameters, trained on broad text data for general-purpose language tasks.
- How it is used
- Connects natural-language instructions to direct data analysis or to queries executed by specialized tools.
- How deep it goes
- Explains prompting, reusable templates, query generation, and cost choices through workflows; does not develop neural-network internals.
- Examples
- Uses laptop-review classification, survey questions translated to SQL, and questions about graph data translated to Cypher.
- What you can do after
- Apply it via a Python model library to classify reviews or generate queries, then evaluate model choices on sample data.
Build AI-Enhanced Web Apps
A large language model is a machine-learning model trained on large amounts of text to understand and generate natural-language content.
- How it is used
- Powers natural-language features in web apps, including chat, summarization, document-grounded answers, and interview practice.
- How deep it goes
- Defines generation through next-word prediction and works through API-backed application flows; leaves training and hosting an LLM outside the implementation.
- Examples
- Uses a conversational chat interface, a document-question-answering chain, and an interview assistant with generated feedback.
- What you can do after
- Apply it via OpenAI or Gemini APIs to build and evaluate natural-language features without hosting a model.
Read how Build AI-Enhanced Web Apps explains language model →
Effective Data Analysis
A large language model is a machine-learning model trained on extensive text data to process and generate human language.
- How it is used
- Positions LLMs as prompt-driven assistants for drafting and analytics workflows, while retaining the analyst’s judgment.
- How deep it goes
- Defines broad text training and prompt-based output, then illustrates prompting; does not explain model architecture or training internals.
- Examples
- Uses customer-login summary prompts and an exercise comparing chatbot-generated rat-sighting predictions with an existing model.
- What you can do after
- Evaluate/understand LLM output by refining analytics prompts and checking generated analyses, code, metrics, and recommendations against existing work.
Build Python Web Apps with Streamlit
An LLM is a large language model that generates or transforms text from input sequences.
- How it is used
- Powers trivia question generation, free-text answer evaluation, and chat responses in Python applications.
- How deep it goes
- Defines text processing and generation, then works through API calls and application patterns without explaining model-training internals.
- Examples
- Uses a trivia game, a short Streamlit chatbot, and a one-node LangGraph chatbot.
- What you can do after
- Build it from scratch as a Python app feature that calls an LLM, handles its response, and can add retrieved context.
Read how Build Python Web Apps with Streamlit explains language model →
AI Agents and Applications
A large language model is a neural language model trained on extensive text data to understand and generate language and perform text-based reasoning.
- How it is used
- Powers bounded text tasks, conversational chatbots, and agents that choose actions in multi-step workflows.
- How deep it goes
- Demonstrates a model call and explains its place in application workflows, without detailing neural-model internals.
- Examples
- Uses a phishing reminder request, a research summarization engine, and a retrieved-document Q&A workflow.
- What you can do after
- Apply it via OpenAI and LangChain to generate task-specific responses, while selecting models and supplying relevant context.
Read how AI Agents and Applications explains language model →
Causal AI
A large language model is a deep neural language model with billions of parameters trained on vast amounts of text and other data.
- How it is used
- Uses LLMs as resources for sourcing and checking causal information needed to formulate assumptions about a data-generating process.
- How deep it goes
- Defines their scale, generative role, and foundation-model status, then offers a high-level causal primer rather than detailed language-model internals.
- Examples
- Uses GPT-4 through ChatGPT for causal-information queries and names GPT, Gemini, Llama, and Microsoft 365 Copilot as model or product examples.
- What you can do after
- Apply it via ChatGPT to seek causal information while assessing proposed assumptions and allowing for variable responses.
Coding with AI
A large language model is a neural language model trained on extensive data to understand and generate language, including programming-language text.
- How it is used
- Powers developer tools that draft code, analyze code, and assist documentation across software workflows.
- How deep it goes
- Defines LLMs and traces Transformer processing through representations, positions, self-attention, and scalable parallel sequence processing.
- Examples
- Uses an active-status CSV filtering and averaging task to contrast traditional Python work with an AI-generated draft.
- What you can do after
- Apply it via AI tools by prompting for drafts, revising generated code, and verifying outputs before use.
Time Series Forecasting Using Foundation Models
A large language model is a neural-network model trained on large text corpora to perform language understanding and generation tasks.
- How it is used
- Extends natural-language generation capabilities to time-series forecasting by converting numerical prediction into a prompted language task.
- How deep it goes
- Defines language-model capabilities and details prompt construction and output parsing, but stops short of making LLMs forecasting-specific.
- Examples
- Uses Flan-T5, Llama-3.2-3b-instruct, natural-language prompts, generated strings, and extracted forecast values.
- What you can do after
- Apply it via prompting to forecast time series, while evaluating whether preprocessing, computation, and accuracy trade-offs justify its use.
Read how Time Series Forecasting Using Foundation Models explains language model →
The AI Pocket Book
A neural language model trained on large text corpora to predict and generate natural language.
- How it is used
- Explains how conversational and generative AI turns prompts into outputs one token at a time.
- How deep it goes
- Traces tokenization, embeddings, contextualization, probabilities, and wrapper-driven generation, but defers exact internal calculations.
- Examples
- Uses Eiffel Tower completion, arithmetic, translation, token probability tables, and system-prompt date responses.
- What you can do after
- Evaluate how prompts, token probabilities, wrappers, and injected context shape an LLM’s response.
Deep Learning with JAX
A large neural language model used for language-modeling tasks such as generation, training, fine-tuning, and serving.
- How it is used
- Deploys pretrained language models or supports their training, fine-tuning, evaluation, and serving.
- How deep it goes
- Surveys model families and JAX tooling but stops short of explaining transformer internals or language-model training algorithms.
- Examples
- Uses Llama, Gemma, GPT-J, GPT-Neo, BLOOM, GPT-2, T5, BERT, EasyLM, Pax, and MaxText as concrete examples.
- What you can do after
- Operate pretrained models and evaluate JAX-based options for training, fine-tuning, scaling, or serving LLMs.
Build a Reasoning Model (From Scratch)
A neural language model trained on large text corpora to predict and generate text.
- How it is used
- Uses next-token prediction to generate fluent text and support later reasoning-training or preference-tuning stages.
- How deep it goes
- Explains pretraining, prompt continuation, reasoning simulation, scaling, and failure modes, but stops short of neural architecture or optimization details.
- Examples
- Demonstrates Germany’s capital, penguin contradictions, GPT-4o responses, and staged LLM training workflows.
- What you can do after
- Evaluate whether an LLM response reflects learned statistical association or explicit rule-based reasoning.
Read how Build a Reasoning Model (From Scratch) explains language model →
Learn AI-Assisted Python Programming, Second Edition
A large language model is a machine-learning model that represents statistical relationships among language elements and predicts sequences of text from context.
- How it is used
- Deploys natural-language prompts as an interface for generating Python programs with Copilot.
- How deep it goes
- Explains contextual next-word prediction, nondeterminism, and limited understanding, but does not descend into model implementation.
- Examples
- Uses next-word completion, Copilot-generated Python, classroom-seat prompts, and doctests to illustrate prediction and verification.
- What you can do after
- Evaluate generated responses by refining prompts, comparing alternatives, testing code, and checking correctness and security.
Read how Learn AI-Assisted Python Programming, Second Edition explains language model →
Data Without Labels
A large language model is a machine-learning model trained on very large text collections to understand and generate language.
- How it is used
- Uses language models to connect word-sequence prediction with text analysis and LLM applications.
- How deep it goes
- Works through n-gram probabilities and context lengths, but does not explain LLM internals or implement an LLM.
- Examples
- Compares unigrams, bigrams, and trigrams using “It is raining heavily,” then names document summarization and customer support.
- What you can do after
- Evaluate/understand it by distinguishing an n-gram’s limited preceding-word context from the LLM applications described here.
Essential GraphRAG
A large language model is a neural language model trained on extensive text data to generate human-like text by predicting token sequences.
- How it is used
- Supports language generation, instruction following, retrieval-augmented answering, structured extraction, and natural-language query generation.
- How deep it goes
- Explains transformer-based prediction, capabilities, limitations, and application patterns, but defers detailed neural-network internals and training procedures.
- Examples
- Uses next-word completion, haiku generation, outdated ownership information, fabricated legal citations, and incorrect WikiData identifiers.
- What you can do after
- Evaluate/understand generated language and apply LLMs through RAG, structured extraction, or text-to-Cypher workflows.
Outlier Detection in Python
A large language model is a neural model trained on very large text corpora to process and generate natural language.
- How it is used
- Uses models to identify records that depart from learned patterns, without establishing a role for language models.
- How deep it goes
- Explains fitting and predictive failure in outlier detectors, but does not define language-model training or operation.
- Examples
- Uses breast-cancer records and a decision tree distinguishing real from synthetic data, rather than a language-model example.
- What you can do after
- Evaluate/understand model fit for outlier detection, but not build or operate a language model.
Read how Outlier Detection in Python explains language model →
Machine Learning System Design
A large language model is a machine learning model trained on large text corpora to generate or transform language and perform related language tasks.
- How it is used
- Uses conversational generation to illustrate the difficulty of monitoring outputs that can vary for the same input.
- How deep it goes
- Illustrates response variability and the effects of model updates, but does not explain language-model architecture or training internals.
- Examples
- Shows four different ChatGPT replies to the same input.
- What you can do after
- Evaluate/understand it by judging whether varying dialogue responses are acceptable rather than expecting identical replies.
Read how Machine Learning System Design explains language model →
Build an AI Agent (From Scratch)
A large language model is a neural language model trained on extensive text data that generates and interprets language.
- How it is used
- Serves as an agent’s decision-making core, interpreting requests and choosing tools within an iterative loop.
- How deep it goes
- Defines next-token prediction and reasoning tokens, then examines model choice and tool-free limits without detailing model-training internals.
- Examples
- Uses a summer-vacation word prediction, research requests involving PDFs, and tool-free GAIA problems.
- What you can do after
- Apply it via LiteLLM APIs to prototype an agent, then evaluate when its answers require external tools.
Read how Build an AI Agent (From Scratch) explains language model →
Build a Large Language Model (From Scratch)
A large neural language model trained on text to understand and generate language, typically using transformer self-attention.
- How it is used
- Frames language generation as a pipeline from text preparation through transformer prediction, pretraining, evaluation, and task-specific fine-tuning.
- How deep it goes
- Explains parameters, next-token prediction, tokenization, transformer modules, and training stages, while deferring detailed self-attention implementation.
- Examples
- Uses translation completion, ChatGPT-style assistants, GPT-3 datasets, token sampling, and zero-shot or few-shot task prompts.
- What you can do after
- Build it from scratch by preparing text, implementing attention and a GPT-like model, pretraining it educationally, and fine-tuning task behavior.
Read how Build a Large Language Model (From Scratch) explains language model →
Digital Twins in Action
A large language model is a machine-learning model trained on large text corpora to process and generate natural language, optionally incorporating visual inputs.
- How it is used
- Provides natural-language access to digital-twin state and supports contextual analysis, scenario generation, and agent decisions.
- How deep it goes
- Explains grounding and agent-level safety, but does not detail language-model architecture or training.
- Examples
- Uses a pump-pressure question, turbine diagnostic report, and home HVAC setpoint decision.
- What you can do after
- Evaluate/understand when contextual LLM assistance merits its safety controls and recurring inference cost.
Hugging Face in Action
A large language model is a high-capacity neural model trained on large text corpora to process and generate language.
- How it is used
- Connects pretrained or hosted language models to application workflows, prompts, private data, retrieval systems, and tools.
- How deep it goes
- Defines training, parameters, and tokens, then demonstrates API-based use; it stops short of neural-network mathematics and model construction.
- Examples
- Demonstrates question answering, translation, invoice and receipt queries, private-document retrieval, and tabular-data analysis.
- What you can do after
- Build it from scratch with LangChain or LlamaIndex, then operate local or hosted models in question-answering and private-data workflows.
A Pythonic Adventure: From Python basics to a working web app
A language model is a computational model trained on text or other language data to represent patterns and relationships in language.
- How it is used
- Uses language models as assistants for generating answers and improving Python code.
- How deep it goes
- Explains training on text, word relationships, and text similarity, but stops short of detailed model internals.
- Examples
- Uses Python list indexing, error explanations, code review, comments, and the Paris–France/Madrid–Spain analogy.
- What you can do after
- Apply it via ChatGPT to explain errors, review code, suggest fixes, and generate programming answers, while reviewing and testing the results.
Read how A Pythonic Adventure: From Python basics to a working web app explains language model →
Snowflake Data Engineering
A large language model is a model trained to process, generate, and transform human language.
- How it is used
- Augments Snowflake pipelines by classifying reviews and extracting structured order data from unstructured text.
- How deep it goes
- Defines LLMs and details prompting, stored-procedure calls, data-frame conversion, persistence, and output evaluation without model internals.
- Examples
- Uses bakery reviews and order emails, including CSV extraction into COLLECTED_ORDERS_FROM_EMAIL and ambiguous French-bread requests.
- What you can do after
- Apply it via Snowflake Cortex functions and stored procedures to convert email content into reviewable Snowflake table rows.
Read how Snowflake Data Engineering explains language model →
AI-Powered Developer: Build software with ChatGPT and Copilot
A large language model is a deep learning model trained to process and generate human language and other text-like sequences.
- How it is used
- Accelerates software tasks through natural-language generation, debugging suggestions, refactoring, documentation, and exploratory examples.
- How deep it goes
- Defines LLMs and sketches training, parameters, Transformers, and self-attention while deferring deeper neural-network theory.
- Examples
- Uses Flask scaffolding, Python session management, memory-leak analysis, code refactoring, and a Dash stock-price dashboard.
- What you can do after
- Apply it via AI tools to draft, inspect, refine, and verify code while protecting sensitive data.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains language model →
Data-Driven Cybersecurity
A neural model trained on extensive text data to predict and generate language.
- How it is used
- Uses language models to generate synthetic cybersecurity data, analyze incidents, and support security reporting.
- How deep it goes
- Works through model-selection criteria and an analysis pipeline rather than language-model internals.
- Examples
- Shows a synthetic-data pipeline and an incident exercise with a frequency chart and generated response table.
- What you can do after
- Apply it via LM Studio or a cloud API to analyze cybersecurity data, then verify outputs before acting.
Read how Data-Driven Cybersecurity explains language model →
Microsoft Azure in Action
A large language model is a machine-learning model trained on large text corpora to generate or transform natural-language content.
- How it is used
- Powers book recommendations, summaries, content creation, and conversational applications through Azure OpenAI Service.
- How deep it goes
- Explains selection trade-offs and input limits, then shows deployment and invocation rather than model internals.
- Examples
- Uses customer-review recommendations, technical-book summaries, an AI Foundry model comparison, and an Azure CLI completions request.
- What you can do after
- Apply it via Azure AI Foundry and Azure CLI to select, deploy, test, and invoke a model for text tasks.
Read how Microsoft Azure in Action explains language model →
Domain-Specific Small Language Models
A very large neural language model trained on broad text corpora to predict or generate language, used here for code generation and assistance.
- How it is used
- Frames LLM selection and deployment around generation quality, operational cost, hardware, data governance, and domain fit.
- How deep it goes
- Explains transformer roles, training approaches, model tradeoffs, and inference constraints without deriving attention or training algorithms.
- Examples
- Uses GPT-Neo large, code generation, structured data, and Hugging Face inference workflows as concrete examples.
- What you can do after
- Apply LLMs through Hugging Face libraries while evaluating accuracy, execution speed, computational cost, and domain suitability.
Read how Domain-Specific Small Language Models explains language model →
Writing for Developers: Blogs that get read
A machine-learning model trained on large text corpora to predict and generate natural-language sequences.
- How it is used
- Uses generative AI to uncover omissions and logical gaps in engineering blog drafts before focused peer review.
- How deep it goes
- Defines association-based behavior and demonstrates prompting, but stops short of explaining model internals or generation mechanics.
- Examples
- Uses ChatGPT feedback on an engineering blog post and prompts about logical gaps, problems, and paragraphs needing detail.
- What you can do after
- Apply it via a generative-AI tool to identify possible draft omissions, then judge which suggestions deserve revision.
Read how Writing for Developers: Blogs that get read explains language model →
AI Agents in Action, Second Edition
A large language model is a machine-learning model that generates and interprets language using patterns learned from extensive text data.
- How it is used
- Serves as the text-generating and reasoning component in direct chat, assistants, and agents.
- How deep it goes
- Explains tokenization, next-token probabilities, sampling, training feedback, and alignment without detailing model architecture.
- Examples
- Uses direct chat, image generation, a constrained time-travel story, and a source-selecting search workflow.
- What you can do after
- Operate/configure it with token measurements, generation settings, prompts, and typed schemas in an OpenAI Agents SDK workflow.
Read how AI Agents in Action, Second Edition explains language model →
Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
A large language model is a machine-learning model trained on large text corpora to understand and generate language sequences.
- How it is used
- Supports text-processing and tabular-data workflows as an assistant for feature engineering, coding, analysis, visualization, and reporting.
- How deep it goes
- Explains major task categories and practical analytics uses, but does not detail training procedures or model internals.
- Examples
- Uses textual dataset fields, Python functions, regular expressions, CSV files, charts, tables, and generated analytical reports as concrete applications.
- What you can do after
- Apply it via ChatGPT's Advanced Data Analytics API to preprocess, analyze, visualize, and summarize CSV data.
Read how Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI explains language model →
Spring AI in Action
A large language model is a machine-learning model trained on extensive text data to understand and generate natural-language content.
- How it is used
- Uses LLMs to add natural-language generation, question answering, classification, summarization, moderation, and conversational capabilities to Spring applications.
- How deep it goes
- Explains prompt submission, client abstraction, statelessness, memory, and tool interactions, but does not descend into model-training internals.
- Examples
- Demonstrates question answering, sentiment analysis, summarization, moderation, classification, image descriptions, conversation history, and tool results.
- What you can do after
- Apply it via Spring AI by building a REST-backed ChatClient service that submits prompts and returns generated content.
Data Pipelines with Apache Airflow, Second Edition
A large language model is a machine learning model trained on extensive text data to understand and generate natural-language text.
- How it is used
- Generates recipe answers from retrieved documents after an Airflow-supported data-preparation workflow makes family recipes searchable.
- How deep it goes
- Explains text corpora, compares fine-tuning with retrieval, and shows an application call; does not detail model architecture or training algorithms.
- Examples
- Uses a family-recipe chat, a chocolate-cookie question, translation, ingredient-based suggestions, and a Python retrieval-chain listing.
- What you can do after
- Apply it via AzureChatOpenAI and a retrieval chain to answer questions using recipes stored in a vector database.
Read how Data Pipelines with Apache Airflow, Second Edition explains language model →
Transformers in Action
A large language model is a neural language model trained on large text corpora to predict and generate natural-language sequences.
- How it is used
- Supports language tasks such as translation, text completion, and conversational AI, while serving as a target for adaptation and evaluation.
- How deep it goes
- Explains the transformer foundation and model-variant trade-offs, then gives a concrete inference workflow rather than a from-scratch LLM implementation.
- Examples
- Uses translation and conversational AI as task contrasts, plus a tokenized question passed through generation and decoding.
- What you can do after
- Apply it via a model tokenizer and `model.generate` to produce a response, while considering adaptation and deployment costs.
Data Storytelling with Altair and AI
A large language model is a neural language model with many learned parameters that generates or transforms text based on input context.
- How it is used
- Uses LLMs to generate textual context, especially commentaries and annotations for audience-calibrated data stories.
- How deep it goes
- Defines prediction and transformer foundations, then stops short of explaining how LLMs work technically.
- Examples
- Demonstrates ChatGPT-generated commentaries and annotations, domain-tailored models, vector-database retrieval, and a fabricated political scandal.
- What you can do after
- Apply ChatGPT for data-story context, extend it with fine-tuning or RAG, and validate generated content before publication.
Read how Data Storytelling with Altair and AI explains language model →
AI Agents in Action
A large language model is a neural language model trained on extensive text data to generate and transform natural-language content.
- How it is used
- Powers chatbots, assistants, agents, content generation, and application integrations.
- How deep it goes
- Defines generative behavior, architecture, data, fine-tuning, access, prompting, and selection without detailing transformer internals.
- Examples
- Uses ChatGPT, GPT-4, the OpenAI API, LM Studio, and prompt flow connection exercises as concrete examples.
- What you can do after
- Operate/configure LLM integrations through the OpenAI API SDK, LM Studio, or prompt flow.
Automating API Delivery
A large language model is a machine-learning model trained on extensive text data to generate and transform natural-language or code-based content.
- How it is used
- Supports coding assistance and automated API linting when conventional rules are difficult or costly to write.
- How deep it goes
- Explains training, transformers, language capabilities, and linting workflows, but defers model internals and requires output validation.
- Examples
- Uses coding assistants, Claude prompts, monetary OpenAPI properties, pagination checks, and Optic LintGPT configuration.
- What you can do after
- Apply it via Anthropic Claude or Optic’s LintGPT to generate code suggestions or lint OpenAPI documents with natural-language rules.
MongoDB 8.0 in Action, Third Edition
A large language model is a machine learning model with many parameters trained to process and generate natural language.
- How it is used
- Supports chatbots, customer support, and technical assistance by generating natural-language responses from learned patterns.
- How deep it goes
- Explains pattern-based generation, hallucinations, and the eight-step RAG workflow without detailing model internals.
- Examples
- Uses chatbot, customer-support, and technical-assistance scenarios grounded in retrieved documents.
- What you can do after
- Apply RAG to generate responses informed by retrieved, verified information and reduce hallucinations.
Read how MongoDB 8.0 in Action, Third Edition explains language model →
Just Use Postgres!
An LLM is a large language model trained to understand and generate natural-language text.
- How it is used
- Powers question answering, chatbots, task automation, and RAG-based movie recommendations.
- How deep it goes
- Explains capabilities, tool use, prompt context, and statelessness, but stops short of model internals or mathematical treatment.
- Examples
- Uses a DreamWorks movie question, a Postgres movie catalog, and a TinyLlama RAG notebook prototype.
- What you can do after
- Builds a prompt-based application that invokes an LLM with user questions and retrieved context.
Build a Text-to-Image Generator (from Scratch)
A language model is a model that processes or generates human language, typically as sequences of text.
- How it is used
- Uses autoregressive sequence generation to turn encoded text prompts into image-token sequences for image synthesis.
- How deep it goes
- Traces tokenization, BART encoding, autoregressive decoding of 256 image tokens, and VQGAN reconstruction without detailing language-model internals.
- Examples
- Follows a text prompt through BART to 256 image tokens, then decodes them into a high-resolution image.
- What you can do after
- Understand how autoregressive language-model-style decoding can generate image tokens from a text prompt.
Read how Build a Text-to-Image Generator (from Scratch) explains language model →
Everyday Data Visualization
A large language model is a machine-learning model trained on extensive text data to process and generate human language.
- How it is used
- Uses large-language models to generate realistic test data for visualization prototypes when real data is unavailable.
- How deep it goes
- Defines the model through a practical use case but stops short of explaining training, architecture, or language-generation internals.
- Examples
- Uses a ChatGPT-generated survey containing two respondents, three questions, and numerical rating responses.
- What you can do after
- Apply via ChatGPT to generate structured, realistic test data for prototypes before production data becomes available.
Read how Everyday Data Visualization explains language model →
Build a Website with ChatGPT
A large language model is a machine-learning model trained on extensive text data to generate and transform natural-language content.
- How it is used
- Uses language generation and transformation to support conversational requests for web-page content and code.
- How deep it goes
- Explains the name GPT, pretraining, next-word prediction, and transformers without descending into model implementation details.
- Examples
- Uses essays, stories, poems, web-page code, and next-word prediction as concrete examples.
- What you can do after
- Apply it via conversational interfaces to request natural-language content or web-page code.
Read how Build a Website with ChatGPT explains language model →
Authorization in Action
A large language model is a machine-learning model trained on extensive text data to process and generate language.
- How it is used
- Supports policy creation, analysis, explanation, and incident triage without becoming the final authorization decision point.
- How deep it goes
- Explains advisory uses and authority boundaries, but stops short of model internals or generative-model implementation.
- Examples
- Uses policy explanation, hypothetical access exploration, flagged-event grouping, tenant identification, and incident-narrative drafting.
- What you can do after
- Diagnose access patterns with language-model summaries while preserving authoritative findings in deterministic checks and human review.
Kafka for Architects
Inference is the generation of model predictions from input data using a trained machine-learning model.
- How it is used
- Uses trained models to generate predictions from fresh event data in real-time applications.
- How deep it goes
- Explains data preparation, train/test evaluation, and serving predictions, but stops short of algorithm internals.
- Examples
- Uses ad-click prediction and fraud detection to illustrate model targets and real-time inference.
- What you can do after
- Apply it via a deployed model server to produce predictions from incoming event data.
Statistics Every Programmer Needs
A mathematical model represents relationships in a system using mathematical structures to analyze or predict its behavior.
- How it is used
- Uses mathematical models to support decisions by optimizing outcomes, forecasting behavior, or simulating possible scenarios.
- How deep it goes
- Defines models as decision tools and sketches objectives and constraints through linear programming.
- Examples
- Uses supply chains, transportation, manufacturing, and portfolio construction as optimization applications.
- What you can do after
- Understand how objectives and constraints turn resource-limited decisions into an optimization problem.
Read how Statistics Every Programmer Needs explains language model →
Building Reliable AI Systems
A model that represents patterns in language to predict or generate sequences of text.
- How it is used
- Provides language understanding and generation as the passive core that agents extend with tools and actions.
- How deep it goes
- Defines its practical role and production limits, but does not explain model internals or training.
- Examples
- Uses flight search and booking, plus a customer request combining image understanding, product search, and return-policy lookup.
- What you can do after
- Evaluate standalone language models by distinguishing text understanding and generation from external action.
Read how Building Reliable AI Systems explains language model →
Building LLM Applications with DSPy
A language model is a machine-learning model that generates or evaluates language based on textual context.
- How it is used
- Configures the language model used by subsequent DSPy calls.
- How deep it goes
- Defines the LM object and explains model selection and configuration, without detailing model internals.
- Examples
- Configures gpt-4o-mini and describes trial-and-error prompt testing for article summaries.
- What you can do after
- Apply it via DSPy by creating an LM object and configuring it for subsequent calls.
Read how Building LLM Applications with DSPy explains language model →
Related concepts
- retrieval-augmented generationused by · Retrieval-augmented generation is a technique that retrieves relevant information from external sources and supplies it as context to a generative model when producing an output.
- promptused by · An input, typically containing instructions or context, supplied to an artificial-intelligence model to guide or elicit its output.
- AI agentused by · An AI agent is a computational system that uses artificial intelligence to interpret information, select actions, and pursue goals through interaction with an environment.
- generationproduces · Generation is the computational production of outputs from supplied inputs or context, often by applying a model to produce predictions or new content.
- ChatGPTincludes · ChatGPT is OpenAI’s conversational AI service, which lets users interact with generative AI models and related tools through natural-language prompts.
- machine learningkind of · Machine learning is a field of computational methods in which systems learn patterns or relationships from data to make predictions, decisions, or other outputs.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.