book

Mastering NLP From Foundations to Agents - Second Edition

Name: Mastering NLP From Foundations to Agents - Second Edition
ISBN: 9781806106134

by Lior Gazit, Meysam Ghaffari

February 2026

Intermediate to advanced

694 pages

18h 17m

English

Packt Publishing

Read now

Unlock full access

Contributors
Subscribe for a free eBook
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesGet the code bundleGet in touchFree benefits with your bookHow to unlock
An Introduction to the NLP Landscape
Your purchase includes a free PDF copy + exclusive extrasThe evolution of NLPFoundational strategies for processing natural languageThe synergy of NLP and MLIntroduction to math and statistics in NLPUnderstanding language models – from BERT to GPT-5.X and beyondSummaryQuestionsReferencesJoin our Discord and Reddit Space
Mathematical Foundations for Machine Learning in NLP
Introduction to linear algebraBasic operations on matrices and vectorsMatrix definitionsDeterminantsEigenvalues and eigenvectorsComputational approaches to eigenvalues and eigenvectorsEigenvalue decompositionSingular value decompositionBasic probability for machine learningStatistically independentDiscrete random variables and their distributionsProbability density functionMaximum likelihood estimationLog-likelihood and parameter estimationFrom MLE to word predictionN-gram counts and probability estimationInterpreting the resultBayesian estimationOptimizationSummaryQuestionsFurther readingReferencesGet this book’s PDF copy, code bundle, and more
Unleashing Machine Learning Potential in NLP
Technical requirementsData explorationData visualizationData cleaningHandling missing valuesRemoving duplicatesStandardizing and transforming dataHandling outliersFeature engineeringFeature scalingPolynomial expansionLogarithmic transformationSelf-supervised representations as featuresFeature selectionFilter methodsWrapper methodsEmbedded methodsDimensionality reduction techniquesCommon machine learning modelsLinear regressionLogistic regressionDecision treesSupport vector machines (SVMs)Ensemble modelsBaggingBoostingStackingRandom forest – a common ensemble modelGradient boostingNeural networks and transformersNeural networksTransformersPositional encodingsWhy the Transformer matters for NLPSplitting dataHyperparameter tuningModel underfitting and overfittingHandling imbalanced dataSMOTEThe NearMiss algorithmCost-sensitive learningDealing with correlated data and featuresTemporal correlationCorrelated text featuresSummaryQuestionsReferencesJoin our Discord and Reddit Space
Streamlining Text Preprocessing Techniques for NLP
Technical requirementsRemove and decode encoding artifactsLowercasing in NLPConverting digits to wordsSpelling correctionRemoving special characters and punctuationStop word removalSpell checking and correctionLemmatizationStemmingNERPOS taggingRule-based methodsStatistical methodsDeep learning-based methodsRegular expressionValidating inputText manipulationText cleaningParsingTokenizationExplaining the preprocessing pipelineCode for NER and POSCode for tokenizersSummaryQuestionsReferencesGet this book’s PDF copy, code bundle, and more
Text Classification Using Traditional ML Techniques
Technical requirementsTypes of text classificationSupervised learningNaive BayesLogistic regressionSVMUnsupervised learningSemi-supervised learningLabel propagationCo-trainingSentence classification using a one-hot-encoding vector representationText preprocessingVocabulary constructionOne-hot encodingN-gramsModel trainingText classification using TF-IDFText classification using Word2VecWord2VecPractical optimization note: making Word2Vec trainable at scaleGloVe and FastText: advancements in static word embeddingsGloVe: Global Vectors for Word RepresentationFastText: subword-aware word embeddingsWhere they fit in traditional ML pipelinesText classification using Word2VecFeature selection for text classificationModel evaluationBeyond F1: metrics that shine on imbalanced datasetsConfusion matrixOverfitting and underfitting in text classificationCross-validation and experiment reproducibilityEvaluation pitfalls in text classificationHyperparameter tuning in text classificationApplied considerations in text classificationTopic modeling: a particular use case of unsupervised text classificationLatent Dirichlet allocation (LDA)BERTopic – a modern embedding-based topic modeling techniqueBERTopic in practicePractical considerationsReal-world ML system design for NLP text classificationThe business objectiveThe technical objectiveTentative high-level system designChoosing a metricExplorationImplementing an ML solutionInstrumenting every runEvaluating the resultsDone and deliveredReviewing our use case – ML system design for NLP classification in a Jupyter notebookThe business objectiveThe technical objectiveThe pipelineCode settingsGathering the dataProcessing the dataPreprocessingPreliminary data explorationFeature engineeringSplitting into train/test setsPreliminary statistical analysis and feasibility studyFeature selectionIterating over ML modelsGenerating the chosen modelSummaryQuestionsReferencesJoin our Discord and Reddit Space
Text Classification Part 2 – Using Deep Learning Language Models
Technical requirementsUnderstanding deep learning basicsWhat is a neural network?The motivation for using neural networksThe basic design of a neural networkNeural network common termsNeuron (or node)Activation functionEpochBatch sizeThe architecture of different neural networksThe challenges of training neural networksLanguage modelsUsing self-supervised learning to train language modelsMasked language modeling (MLM)Autoregressive language modelingTransfer learningFeature extractionFine-tuningUnderstanding TransformersArchitecture of TransformersLearning more about large language modelsThe challenges of training language modelsSpecific designs of language modelsBERTGPT-style generative models for text classificationQLoRA fine-tuningQLoRA for LLMsReviewing our use case – ML/DL system design for NLP classification in a Jupyter notebookThe business objectiveThe technical objectiveThe pipelineDeep learningFormatting the dataEvaluation metricTrainer objectSummaryQuestionsReferencesGet this book’s PDF copy, code bundle, and more
Demystifying LLM Theory, Design, and Implementation
Technical requirementsWhat are LLMs and how are they different from LMs?Why LLMs stand outTransformer modelsMotivations for developing and using LLMsImproved performanceBroad generalizationFew-shot learningUnderstanding complex contextsMultilingual capabilitiesHuman-like text generationRisks and considerationsChallenges in developing LLMsAmounts of dataComputational resourcesRisk of biasModel robustnessInterpretability and debuggingSafety and security considerationsEnvironmental impactExample designs of state-of-the-art LLMsGPT models and their use in ChatGPTWhat GPT models areTraining pipeline: pretraining and alignmentEfficiency and rumors of mixture‑of‑expertsGPT‑5 seriesLLaMAClaudeGeminiDeepSeekPaLMEvaluationPerplexity and language modeling performanceReasoning evaluationFactuality evaluationSafety evaluationRobustness evaluationFluency, coherence, and diversityLLM-as-a-judgeSummaryQuestionsReferencesJoin our Discord and Reddit Space
Parameter-Efficient Fine-Tuning and Reasoning in LLMs
Technical requirementsFine-tuning LLMs with LoRA and QLoRAProblem setup and notationLow-Rank Adaptation (LoRA)Benefits and complexityGradients in LoRAWhere to apply LoRAMerging for inferenceQuantized LoRA (QLoRA)Quantization preliminariesForward computation with QLoRAMemory and compute requirementsTraining objective with QLoRAPractical training flow for LoRA and QLoRAData and objectiveTargeted modulesInitialization and stabilityOptimization strategyMemory management and long contextsHyperparameter choicesLoRA vs QLoRAUse case: query projectionGradient flowParameter efficiencyAvoiding forgettingTraining flowEvaluation and merging for deploymentReinforcement learning with human feedbackAdvanced RLHF techniques for LLMsDirect Preference Optimization (DPO)Group Relative Policy Optimization (GRPO)Reasoning in LLMsInputs, reasoning, and outputsUse case: reasoning as an explicit latent processProbabilistic modelingLatent-step factorizationTraining regimesRegime 1: Supervised reasoning with ground-truth stepsRegime 2: Supervised reasoning with answers only (latent steps)Regime 3: Preference-based reasoning objectivesSummaryReferencesGet this book’s PDF copy, code bundle, and more

Advanced Setup and Integration with RAG and MCP
Core requirements for building LLM systemsHardware and compute foundationsSoftware ecosystemSecurity, privacy, and complianceSetting up an LLM application – API-based closed source modelsArchitecture of the API paradigmAdvantages and trade-offsAPI integration and resilience designSystem-level optimization patternsReliability, rate-limiting, and governanceExample use case – asynchronous document summarization agentSetting up an LLM application – local open source modelsSelecting the right open source modelEnvironment and inference setupParameter-Efficient Fine-Tuning (PEFT)Model serving and deploymentExample use case – domain-specific instruction tuning for clinical summarizationAdvanced system design – retrieval-augmented generationRAG pipelineChunking: The forgotten critical stageEmbedding models and vector representationsRetrieval layer and query pipelineOptimization techniquesEvaluation and diagnosticsUse case: Enterprise policy RAGLangChain as an orchestration layerArchitectural foundationsExecution graphDeclarative configuration via LCELPrompt management and context controlMemory and state persistenceLCEL and advanced compositionDebugging, testing, and observabilityCommon design patternsLlamaIndex (GPT Index)Architectural overviewIndex structuresQuery enginesEmbedding and service contextLlamaIndex and LangChain interoperabilityAdvanced capabilitiesObservability and performance tuningUse case: Multi-index legal RAG systemAdvanced RAG optimizationsSemantic cachingIncremental embeddingsCache-augmented generationAdditional optimizationsMCP: Seamless integration between LLM applications and external toolsMotivation and design goalsProtocol semanticsIntegration patternsSecurity and access controlPerformance and scalability considerationsMCP in multi-model ecosystemsEnd-to-end architectures for LLMsHealthcare RAG systemLegal multi-agent summarization and verification pipelineFinancial analytics assistant (cross-model MCP integration)Query routing and fusionAdaptive context managementStreaming and cachingEngineering patterns and optimization techniquesEmerging architectures: Multi-modal RAG and self-optimizing agent graphsMM-RAGSOAGsImplementation strategiesSummaryQuestionsReferencesJoin our Discord and Reddit Space
Advanced LLM Practices Using RAG and LangChain
Technical requirementsEnhancing LLM performance: choosing between local, free and remote, paid LLMsApplication-level model selectionRequest-level model routingReviewing an LLM routing pipelineSetting up the environment and installing dependenciesDefining a catalog of candidate modelsImplementing lightweight heuristics for prompt analysisCapturing a resource snapshot for local awarenessScoring candidate models according to routing goalsInitializing and calling models via a unified interfaceRouting and dispatching the requestRunning the router on a sample promptUnderstanding the trade-offs we make and their consequencesCase study 1: LangChain in healthcareSet up the environment and install dependenciesLoad the mock physician notes into memoryChunk the documents and build a vector indexQuery the vector store for relevant notesAdd a language model layer to interpret retrieved evidenceImplement a simple LLM routerApplying conversation memoryCase study 2: LangChain design for legal document analysisInstall dependencies and set up the environmentLoad and prepare the contracts datasetSplit contracts into chunks and embed themFormat retrieval results for grounding and citationImplement a legal-aware LLM routerTest the retrieval and router with an example queryEnable conversation memory for follow-up questionsSummaryQuestionsReferencesGet this book’s PDF copy, code bundle, and more
Multi-Agent Solutions and Advanced Agent Frameworks
Technical requirementsWhat is an agent?Understanding the core concepts of single-agent and multi-agent systemsAnatomy of a single agentPolicy: planner/controllerMemory: short and long termToolsObservation loop (act → observe → revise)Termination criteriaFailure modes and guardrailsMulti-agent patternsTopologiesInteraction protocolsTask decomposition strategiesBuilding an executive brief assistant from end to endInitialize your modelBuild helper classes for metering and loggingDefine prompt templatesIngest and index documentsDefine quality control toolsImplement a single-agent baselineBuild a multi-agent hub-and-spoke systemOrchestrate the agentsCompare single-agent vs. multi-agent runsDeep dive into MAF and advanced orchestration frameworksOrchestration loop: plan → act → observe → reviseObservability hooks and policiesAdvanced featuresTool schemas and constraintsMulti-step planning and sub-goal trackingEventing and callbacks for tracing and auditComparing two different frameworksImplementing a simple agent using MAF and OllamaStart an Ollama model via LLMPopExpose a simple OpenAI-compatible clientDefine a read-only tool with a tight JSON schemaAdd lightweight middleware for safety and telemetryImplement the one-hop agent loopNext stepsBuilding coordinated multi-agent workflows with MAFFormalize the business task and acceptance criteriaChoose a model provider and initialize the chat clientSet up observability with OpenTelemetryIngest the document corpus and build a vector indexExpose read-only tools for agentsDefine role prompts for the agentsImplement the workflow and the coordinator logicExecute the workflow and inspect tracesEvaluate and iterateGoldens, spot checks, and performance signalsStrategies for agent collaboration, negotiation, and competitionCollaboration mechanicsShared scratchpads vs. mediated summariesRole handoffs with explicit contractsConsensus protocols: majority vote, weighted expertise, debate, then decideNegotiation patternsProposer-critic loopsBidding and task auctionConflict resolutionCompetitive setups for quality and safetyRed team agent versus builder agentDuel of explanationsBudget-aware contestsSafety and governance hooksPolicy agents, allow and deny lists, tool sandboxes, and data-scope constraintsHITL checkpoints for high-risk tasksImplementing collaboration and competition strategies in multi-agent systemsSetup: providers, model, telemetry, and indexRead-only tools and verifiersDataset: defining tasksPrompt helpers and scoring functionsStrategy implementationsRunning strategies and evaluating resultsInterpretationSummaryQuestionsReferencesJoin our Discord and Reddit Space
Technical Guardrails of AI Safety and Responsible Implementation
Why must responsibility be built into systems?The pillars of responsible AI implementationEthical alignment – building a moral compass into the machineLegal compliance – the rulebook of accountabilityBusiness compliance – operationalizing values through policyReliability and resilience – engineering for trustRegulatory frameworks – a global convergence of responsibilityTranslating ethics into systemsThe responsible AI architecture stackMapping governance to technical componentsDesign patterns for responsible AI systemsTechnical guardrail typologiesArchitectural blueprints for guardrailed LLM systemsAt training time – data governance and bias detectionAt inference time – policy-aware mediationAt the output stage – moderation, grounding, and response gatingAt audit time – traceability and continuous learningCase study 1 – Amazon Bedrock GuardrailsWhere context fits inCase study 2 – OpenAI gpt-oss safeguardUse case – The chatbot that sold a car for $1Designing policy enforcement pipelinesInput control – shape and screen what comes inIntermediate governance – route by role and intentOutput moderation – check tone, content, and fitHuman in the loop – escalate, decide, and learnObservability and telemetry – make compliance traceableRisk taxonomy and mitigation techniquesThe governance interface – connecting people and systemsThe Office of Responsible AI (ORA)Policy ownership and change managementAudit readiness and incident reportingOperational safety measurement and continuous assuranceEmerging frontiers in AI safety architectureSummaryQuestionsReferencesGet this book’s PDF copy, code bundle, and more
Designing and Managing AI-Native Products
How products evolve to accommodate AI systemsStructural redesign for LLM consumptionChunking as a design decisionMetadata and content normalizationVersioning strategies and lineage trackingData flow patterns built for LLMsVector storage as a first-class componentHybrid retrieval and rerankingReal-time indexing and refresh strategiesLocal versus cloud inference in the data pathProduction performance for AI productsLatency and throughput matter for product adoptionCore maturity metrics for LLM inferenceTime to first tokenTime per output tokenToken generation timeEnd-to-end latencyRequests per second and tokens per secondGoodputMedian performance versus tail performanceMonitoring product experience with P50, P95, and P99Designing product requirements around performance targetsExample 1 – chatbots for customer supportExample 2 – code assistantsExample 3 – document processing toolsPerformance enhancements in modern AI systemsSemantic caching for repeated or structured workloadsWhere semantic caching helps mostDesign challenges: staleness, personalization, and safetyToken prefill and KV cachingHow KV caching works in practiceToken prefill and shared prefixesReducing TTFT with LMCache – a dedicated cache orchestration layerWhat LMCache doesHow LMCache interacts with product architectureWhere LMCache fits in our performance toolboxInternal enterprise tools as AI-first systemsMigration from legacy dashboards to conversational toolsSafety, correctness, and trustModernizing enterprise searchMeasuring and improving relevanceDesigning approval flows for AI-generated workWorkflow checkpoints and risk tiersHuman review layers in regulated environmentsRollout planning across large organizationsStakeholder alignment and sponsorshipChange management and user adoptionCommon blockers and how to address themCustomer-facing products built around LLMsNew user experience patterns that emerged from AIStreaming text as a first-class featureConversational UI as the primary surfaceContext management and memorySafety, traceability, and user trustGrounding and citations as user experience elementsHallucination mitigation as product behaviorTransparent prompts and data useProduct tiering and pricing for AI servicesModel selection and feature setsContext windows, latency, and quotasAligning pricing with valueThe role of the product manager in AI-native developmentIdentifying opportunities with measurable valueScoping for capabilities, data readiness, and latency expectationsCapabilitiesData readinessLatency and reliabilityCross-functional ownershipMetrics and experiments for AI-enhanced journeysHow the build process itself adapts to AIAI-driven code generation and refactoringSpecification drafting with LLMsTest creation and automation with LLMsImpact on development velocity, staffing, and costQuality considerations in AI-assisted developmentRunning LLMs on smaller and edge devicesWhy on-device and edge LLMs?Compressing models for edge deploymentQuantization and low-bit inferenceSLMs and edge-oriented architecturesDistillation and specializationRuntimes and platforms for local LLMsGeneral-purpose local inference runtimesPlatform-specific ecosystemsHybrid edge-cloud patternsDesign trade-offs and implications for AI-native productsPractical architecture patternsWhen to use cloud inferenceWhen to use local inferenceWhen to combine bothRouting by complexity and confidenceRouting by privacy and policyRouting by resource and experienceExample blueprint for an AI-native productSummaryQuestionsReferencesJoin our Discord and Reddit space
Appendix A
Mathematical formulation of the feasibility testIndependence and conditional probabilityApplying the formulation to binary text features
Appendix B
Unlock Access to the Code Bundle and the PDF VersionUnlock this book’s free benefits in three easy stepsStep 1Step 2Step 3Need help?
Appendix C
AnswersChapter 1 - An Introduction to the NLP LandscapeChapter 2 - Mathematical Foundations for Machine Learning in NLPChapter 3 - Unleashing Machine Learning Potential in NLPChapter 4 - Streamlining Text Preprocessing Techniques for NLPChapter 5 - Text Classification Using Traditional ML TechniquesChapter 6 - Text Classification Using Deep Learning Language ModelsChapter 7 - Demystifying LLM Theory, Design, and ImplementationChapter 8 - Parameter-Efficient Fine-Tuning and Reasoning in LLMsChapter 9 - Advanced Setup and Integration with RAG and MCPChapter 10 - Advanced LLM Practices Using RAG and LangChainChapter 11 - Multi-Agent Solutions and Advanced Agent FrameworksChapter 12 - Technical Guardrails of AI Safety and Responsible ImplementationChapter 13 - Designing and Managing AI-Native Products
Index
Other Books You May Enjoy

Content preview from Mastering NLP From Foundations to Agents - Second Edition

7 Demystifying LLM Theory, Design, and Implementation

In this chapter, we delve deep into the intricate world of LLMs and the underpinning mathematical concepts that fuel their performance. The advent of these models has revolutionized the field of natural language processing (NLP), offering unparalleled proficiency in understanding, generating, and interacting with human language.

As we explore the operations of LLMs, we will introduce the key metric of perplexity, a measurement of uncertainty that is pivotal in determining the performance of these models. A lower perplexity indicates the confidence that a language model (LM) has in predicting the next word in a sequence, thus showcasing its proficiency. Adding to that, while perplexity remains ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781806106134

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Mastering NLP From Foundations to Agents - Second Edition

by Lior Gazit, Meysam Ghaffari

7

Demystifying LLM Theory, Design, and Implementation

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.