Leanpub Header

Skip to main content
Go to Leanpub.com

AI Without Mathematics

A Practical Guide to Understanding LLMs, RAG, AI Agents, and Modern AI Systems Without Starting from Equations

This book is 100% completeLast updated on 2026-07-12
Britto

A practical, systems-first guide to understanding LLMs, RAG, AI agents, GraphRAG, evaluation, fine-tuning, and modern AI applications — without needing to start with equations.

Minimum price

$9.99

$19.98

You pay

Author earns

$

Also available for 1 book credit with a Reader Membership

PDF
About

About

About the Book

AI Without Mathematics is a practical guide to understanding modern AI systems without getting blocked by equations on day one.

A lot of AI learning resources have one of two problems: they either become too abstract too early, throwing readers into notation and theory before they understand what the systems are doing, or they stay too shallow, explaining buzzwords and demos without building a real mental model of how modern AI applications fit together.

This book was written to sit in the middle.

It explains the major building blocks of modern AI in plain language and from a systems-first perspective. Instead of starting with heavy math, it helps you understand what each component is for, what problem it solves, and how it fits into real AI applications.

Inside the book, you’ll learn about:

  • AI, machine learning, deep learning, and neural networks
  • how LLMs generate text and why tokens, context windows, and attention matter
  • embeddings, vector search, and vector databases
  • how RAG systems work end to end
  • when GraphRAG is useful and when it isn’t
  • agents, tools, workflows, and memory in AI systems
  • evaluation, guardrails, and reliability
  • what fine-tuning is actually for, and when it is the wrong solution
  • inference speed, decoding, latency, and optimization tradeoffs
  • how to think about building practical AI projects rather than just learning isolated terms

This book is for students, developers, and builders who want to move beyond AI buzzwords and build a clear mental model of how modern AI systems actually work.

You do not need advanced mathematics to read it.

If you want a practical introduction to LLMs, retrieval, RAG, agents, GraphRAG, evaluation, and AI engineering concepts — without starting from equations — this book is for you.

Share this book

Categories

Artificial IntelligenceComputer Programming/Artificial Intelligence/PythonLarge language models

Feedback

Email the Author

Author

About the Author

Britto

Britto is an AI builder focused on the systems side of modern AI: retrieval-augmented generation (RAG), GraphRAG, AI agents, workflow systems, evaluation, and practical AI products. He is especially interested in the layer between “a model exists” and “a useful AI system actually works” — the engineering decisions that turn models into real applications. AI Without Mathematics was written to help readers build a practical mental model of modern AI systems before getting lost in either hype or heavy theory.

Contents

Table of Contents

  • Preface
  • Who This Book Is For
    • Who this book is not for
    • What you should expect from this book
    • The mindset I recommend while reading
    • A final note before we begin
  • How to Use This Book
    • If you are a complete beginner, read in order
    • If you already know the basics, you can skip strategically
    • How to read the technical chapters
    • How to use the case studies
    • How to use the glossary and tools chapter
    • What to do if a chapter feels dense
    • A practical reading strategy
    • The best way to get value from this book
    • The mindset I want you to keep
  • What “Without Mathematics” Means
    • What it does mean
    • It means the book is focused on understanding systems, not deriving their internals
    • What it does not mean
    • Why this book takes this approach
    • What you will still learn in this book
    • What you will not be asked to do
    • A useful way to think about this book
    • The promise of this book
  • Roadmap of the Book
    • The big picture
    • Part I — Foundations
    • Part II — Large Language Models
    • Part III — Retrieval, RAG, and GraphRAG
    • Part IV — AI systems beyond the model
    • Part V — Case studies
    • Part VI — Reference and next steps
    • How the chapters build on one another
    • What I want this roadmap to do for you
    • The path ahead
  • Part I — Foundations
  • What Is AI?
    • A practical definition of AI
    • AI is a broad umbrella, not one single technique
    • The shift from explicit rules to learned behavior
    • AI is about tasks, not magic
    • Different kinds of AI tasks
    • AI is usually narrow, not general
    • Why modern AI feels different from older software
    • AI is not the same as automation
    • AI is not one model sitting alone
    • A simple mental model of AI
    • What AI is not
    • Why this definition matters for the rest of the book
    • Chapter summary
  • How Machine Learning Actually Works
    • The key shift: from hand-written rules to learned patterns
    • Machine learning: instead of writing all the rules, let the system learn from examples
    • A practical definition of machine learning
    • The core workflow of machine learning
    • A simple example: learning to classify spam
    • What does the model actually “learn”?
    • Why training is not memorization alone
    • Inputs, outputs, and patterns
    • Supervised, unsupervised, and other learning styles
    • What “improving” actually means
    • Machine learning is about compression of patterns
    • Why machine learning became so powerful
    • Machine learning is powerful, but not magical
    • A concrete example of the machine learning mindset
    • Chapter summary
  • How Deep Learning Differs from Machine Learning
    • First: deep learning is inside machine learning, not separate from it
    • A simple analogy: machine learning is the category, deep learning is one powerful family inside it
    • So what actually changes when we move from traditional machine learning to deep learning?
    • Traditional machine learning often depends heavily on human-designed features
    • Deep learning learns representations automatically from raw or less-processed data
    • The word “deep” refers to multiple layers of representation
    • Traditional machine learning vs deep learning: the clean conceptual difference
    • A simple example: spam detection vs image understanding
    • Deep learning is especially powerful for unstructured data
    • Why deep learning exploded in importance
    • So is deep learning always better than “regular” machine learning?
    • A side-by-side comparison
    • Deep learning does not mean “the model understands like a human”
    • Deep learning is the foundation of modern generative AI
    • Where deep learning fits in the rest of this book
    • Chapter summary
  • Neural Networks Without Equations
    • A neural network is not a digital brain
    • The simplest mental model: a neural network is a layered transformation system
    • Inputs, layers, outputs
    • Why layers matter
    • A simple image example
    • A simple language example
    • So what is inside a layer?
    • Neural networks learn useful representations, not just final answers
    • A network starts out bad at the task
    • What training changes inside the network
    • A neural network is not one rule — it is a large web of weighted influences
    • Why neural networks are good at complicated pattern recognition
    • The same neural network idea appears in many forms
    • Neural networks are the building blocks of modern AI systems
    • A useful analogy: a hierarchy of filters and detectors
    • Why neural networks can be both powerful and brittle
    • What neural networks are not doing
    • Chapter summary
  • Training, Data, Loss, and Learning
    • The big picture of training
    • Why data comes first
    • A simple example: teaching a spam detector
    • What is loss?
    • Why the model needs a loss signal
    • A practical way to think about loss
    • Training is not “memorize the answer”; it is “reduce loss across many examples”
    • The full learning loop in plain English
    • What exactly is being adjusted?
    • Training is a search for better parameters
    • Why one example is never enough
    • Why more data can help — and why bad data can hurt
    • What does it mean for the model to “learn a pattern”?
    • Loss is local feedback, not a philosophical judgment
    • Training loss vs real-world usefulness
    • Batches, repetition, and epochs — the rhythm of training
    • Overfitting: when the model learns the training data too narrowly
    • Generalization: the real goal of learning
    • A language model version of the same training story
    • A practical analogy: learning like repeated correction
    • The four core ideas to keep in your head
    • What training is not
    • Chapter summary
  • Part II — Large Language Models
  • What Is an LLM?
    • Start with the smaller phrase: what is a language model?
    • Given some text, predict what text should come next.
    • Why “predict the next text” is more powerful than it sounds
    • So what makes an LLM “large”?
    • The most important mental model: an LLM is a text prediction engine trained at scale
    • LLMs are built on deep learning
    • What an LLM actually receives as input
    • Why an LLM can answer questions even though it was trained to predict text
    • LLMs do not only memorize text — they learn patterns across text
    • Why LLMs can feel intelligent
    • What an LLM is good at
    • What an LLM is not
    • LLMs are not the same as chatbots
    • LLMs can be general-purpose, but they are still limited by context and training
    • The LLM as a component in a larger system
    • Chapter summary
  • How LLMs Predict Text
    • The core idea: generation happens one step at a time
    • A simple toy example
    • The generation loop in plain English
    • What does “predict the next token” actually mean?
    • The model is not choosing from all language equally
    • Why token-by-token generation can still produce long coherent answers
    • A longer example: generating an explanation
    • The role of probability
    • Most likely token vs sampled token
    • Why the model can go wrong
    • Why next-token prediction can produce reasoning-like behavior
    • The context keeps growing during generation
    • Why stopping matters
    • The hidden complexity behind a “simple” next-token loop
    • An analogy: writing one move at a time in chess vs seeing the whole board
    • LLM text generation is usually autoregressive
    • Chapter summary
  • Tokenization, Context Windows, and Attention
    • Part 1: Tokenization
    • What is tokenization?
    • What exactly is a token?
    • Why not just use full words?
    • A simple way to think about tokenization
    • Example: one sentence, many tokens
    • Tokens are also how output is generated
    • Token count matters more than word count for LLMs
    • Part 2: Context windows
    • What is a context window?
    • The model can only reason over what fits inside its current context window.
    • Why context windows matter so much
    • A simple example of context
    • Context is not only the user’s prompt
    • What happens when the context is too long?
    • Why the context window affects quality
    • Part 3: Attention
    • What is attention?
    • A plain-English intuition for attention
    • Attention is about relevance within context
    • A simple conceptual example
    • Why attention matters so much in language
    • Attention does not mean the model “understands” in a human sense
    • How tokenization, context windows, and attention fit together
    • A practical example: answering a question from a document
    • Why these ideas matter for real AI engineering
    • Common misunderstandings to avoid
    • Chapter summary
  • How Transformers Work: From Tokens to the Next Prediction
    • The complete transformer flow
    • Position: preserving sequence order
    • Attention: mixing information across tokens
    • Self-attention, cross-attention, and masking
    • Feed-forward networks: transforming each position
    • Residual connections and normalization
    • Encoder, decoder, and encoder-decoder models
    • From hidden states to a token
    • Chapter summary
  • Part III — Retrieval, RAG, and GraphRAG
  • Embeddings in Plain English
    • Start with the problem embeddings are trying to solve
    • A practical definition of an embedding
    • A simple intuition: embeddings place meaning into a space
    • An embedding maps a piece of data to a point in a high-dimensional space
    • What does the embedding actually look like?
    • Why not just use keywords?
    • Embeddings are a way of doing semantic comparison
    • A concrete example: matching similar questions
    • Embeddings are not only for text
    • Word embeddings vs sentence embeddings vs document embeddings
    • How are embeddings created?
    • The geometry matters more than the individual numbers
    • What does “similar” mean in embedding space?
    • Embeddings are compressions, not full understanding
    • The core use case: semantic search
    • A tiny example of semantic retrieval
    • Embeddings and nearest-neighbor retrieval
    • Embeddings also help with clustering and grouping
    • Embeddings in recommendation systems
    • Embeddings are a bridge between raw content and retrieval logic
    • Common misunderstandings about embeddings
    • Chapter summary
  • Vector Databases and Search
    • Start with the problem: embeddings are only useful if you can search them
    • What is a vector database?
    • A simple mental model
    • Why not just store embeddings in a normal database?
    • What does vector search actually mean?
    • A tiny example of the retrieval flow
    • The concept of nearest neighbors
    • Similarity is geometric, not symbolic
    • What gets stored in a vector database?
    • Why metadata matters
    • How vector search differs from keyword search
    • Keyword search asks:
    • Vector search asks:
    • The important practical truth: both can be useful
    • Similarity metrics: how does the system decide what is “close”?
    • Why naive brute-force search does not scale well
    • Approximate nearest neighbor search
    • The basic workflow of a vector database in practice
    • Vector databases are a retrieval layer, not the final answering layer
    • Vector databases are useful beyond RAG
    • What vector databases do not solve by themselves
    • Common misunderstandings about vector databases
    • Chapter summary
  • What RAG Is and Why It Matters
    • Start with the core problem RAG is trying to solve
    • A simple definition of RAG
    • A plain-English version
    • The difference between a plain LLM answer and a RAG answer
    • Case 1: plain LLM without retrieval
    • Case 2: RAG-based system
    • Why RAG exists at all: LLMs are not ideal as sole knowledge stores
    • A good one-sentence intuition for RAG
    • The three components of a basic RAG system
    • The basic RAG workflow from end to end
    • A tiny example of RAG in action
    • Why RAG is so powerful in practice
    • RAG is really a way of giving the model temporary working knowledge
    • RAG is not only for “chat with PDFs”
    • RAG is not just retrieval plus dumping text into a prompt
    • Why RAG is often better than fine-tuning for knowledge injection
    • What RAG does not automatically solve
    • A useful way to compare RAG with plain prompting
    • Plain prompting without RAG
    • Prompting with RAG
    • RAG is a bridge between retrieval systems and language models
    • Chapter summary
  • How RAG Systems Work End to End
    • The big picture: RAG has two phases
    • Phase 1: indexing / preparation
    • Why chunking matters so much
    • Common chunking strategies
    • At this point, indexing is done
    • Phase 2: query-time retrieval and generation
    • Prompt design matters a lot in RAG
    • The full RAG pipeline in one compact view
    • Indexing phase
    • Query phase
    • Why RAG quality depends on multiple layers
    • A concrete example: one user question through the full system
    • RAG is often better understood as a system, not a single model feature
    • Common failure modes in RAG systems
    • A practical mental model: RAG is “search plus synthesis”
    • Chapter summary
  • What GraphRAG Is and When to Use It
    • Why standard RAG is not always enough
    • The core idea of GraphRAG
    • A simple mental picture
    • GraphRAG is not “RAG but more advanced” by default
    • What a graph actually stores
    • Where the graph comes from
    • Entity extraction
    • Relationship extraction
    • Graph storage
    • What retrieval looks like in GraphRAG
    • Vector RAG vs GraphRAG vs Hybrid RAG
    • Vector RAG
    • GraphRAG
    • Hybrid RAG
    • When GraphRAG is worth using
    • When GraphRAG is probably unnecessary
    • GraphRAG does not replace the need for source text
    • GraphRAG is really about retrieval design
    • A realistic way to think about GraphRAG
  • Part IV — AI Systems Beyond the Model
  • Agents, Tools, and Workflows
    • Why “just ask the model” is sometimes not enough
    • The core distinction: model vs system
    • What a tool is in an AI system
    • Why tools matter
    • Common categories of tools
    • What an agent is
    • Not every tool-using system is a full agent
    • What a workflow is
    • Fixed workflows vs agentic workflows
    • Why workflows are often better than “fully autonomous agents”
    • Where planning fits in
    • Where memory or state fits in
    • A simple example: support triage assistant
    • Another example: SEO analysis workflow
    • Tool use does not remove the need for retrieval design
    • Tool use also does not remove the need for evaluation
    • When an agent is worth it
    • When an agent is probably unnecessary
    • A practical way to think about system complexity
    • The real point of agents, tools, and workflows
  • Memory in AI Systems
    • How does the system remember anything?
    • Start with the simplest distinction: context is not the same as memory
    • Why memory matters
    • Memory makes systems feel less stateless
    • The two big categories: short-term memory and long-term memory
    • Another useful distinction: ephemeral memory vs persistent memory
    • The most common memory pattern: save information, then retrieve it later
    • What kinds of things are worth remembering?
    • What should probably not be remembered automatically?
    • Short-term memory in chat systems
    • The context-window problem
    • Conversation summarization as memory
    • Retrieval-based memory
    • How retrieval-based memory works at a high level
    • Structured memory vs unstructured memory
    • Structured memory
    • Unstructured memory
    • Memory in agents and workflows
    • Memory in business AI systems
    • Personalization and memory
    • Memory is useful, but it also introduces risks
    • Stale memory is a real engineering problem
    • One useful principle: memory should help the current task, not merely preserve history
    • Memory does not eliminate the need for retrieval
    • A useful way to think about memory layers
    • A practical example: AI project assistant
    • Another practical example: business onboarding assistant
    • What memory is not
    • When should you add memory to an AI system?
    • Chapter summary
  • How to Evaluate AI Systems
    • Why evaluation matters
    • Evaluation is not one thing
    • What exactly are you evaluating?
    • Level 1: Evaluating the final answer
    • Level 2: Evaluating intermediate system components
    • Level 3: Evaluating the overall system tradeoff
    • Start by defining the task clearly
    • Build an evaluation set
    • A good evaluation set should reflect real usage
    • Human evaluation vs automated evaluation
    • Human evaluation
    • Automated evaluation
    • Evaluating answer quality
    • Correctness
    • Completeness
    • Relevance
    • Grounding and faithfulness
    • Citation quality
    • Evaluating retrieval quality
    • Retrieval hit rate
    • Ranking quality
    • Noise in retrieved context
    • Evaluating tool use and workflows
    • Evaluating latency
    • Evaluating cost
    • Evaluating robustness
    • LLM-as-judge evaluation
    • A practical evaluation loop
    • Evaluation is not about chasing one perfect score
  • Guardrails and Reliability
    • What stops the system from doing the wrong thing?
    • Start with the core idea
    • Why AI systems need guardrails
    • Guardrails are different from evaluation
    • Reliability is broader than guardrails
    • A simple way to think about guardrails
    • Guardrails exist at multiple layers
    • Input guardrails
    • Output guardrails
    • Retrieval guardrails
    • Prompt guardrails
    • Tool-use guardrails
    • Human confirmation as a guardrail
    • Format guardrails and schema validation
    • Scope guardrails
    • Refusal as a guardrail
    • Reliability is often about handling uncertainty well
    • Prompt injection and instruction hijacking
    • What if the model sees instructions you did not intend it to follow?
    • Guardrails for agents are stricter than guardrails for chatbots
    • Reliability is not only about blocking bad behavior
    • Guardrails in a RAG system: a concrete example
    • Guardrails in an agent workflow: another example
    • Soft guardrails vs hard guardrails
    • Why hard guardrails matter in production systems
    • Reliability also depends on fallback behavior
    • Common guardrail mistakes
    • How to think about reliability in one sentence
    • A practical checklist for designing guardrails
    • Chapter summary
  • When Fine-Tuning Helps—and When It Does Not
    • What fine-tuning is
    • What fine-tuning is not
    • The most important distinction in this chapter
    • Prompting changes the instruction
    • RAG changes the context
    • Fine-tuning changes the model’s behavior
    • A simple example of when prompting is enough
    • A simple example of when RAG is the better answer
    • A simple example of when fine-tuning may be worth it
    • Fine-tuning is strongest when the task pattern repeats
    • When fine-tuning is actually worth considering
    • When fine-tuning is the wrong solution
    • Fine-tuning does not remove the need for good system design
    • How fine-tuning and RAG can work together
    • A practical way to diagnose whether fine-tuning is needed
    • Why evaluation burden matters so much
    • Fine-tuning is a product decision, not just a modeling decision
    • A realistic example: support assistant for a software company
    • Fine-tuning is not “advanced” just because it sounds technical
  • How to Build AI Projects
    • Start with the right question: what problem is the project solving?
    • Good AI projects usually have one of three shapes
    • A strong project usually has a clear user, a clear task, and a clear output
    • A useful project-building sequence
    • Baselines matter more than people think
    • Every good AI project needs evaluation
    • Keep the project explainable
    • Build the project like a system, not like a notebook accident
    • Useful components many AI projects end up needing
    • Decide early what the “finished artifact” is
    • Example 1: building a RAG project
    • Example 2: building a benchmark project
    • Example 3: building an agentic workflow project
    • Learn to separate “core logic” from “nice extras”
    • What makes an AI project portfolio-worthy?
    • A good README is part of the project
    • A practical checklist before calling a project “done”
    • Common mistakes when building AI projects
    • Chapter summary
  • Why LLM Generation Is Slow—and How to Speed It Up
    • What “inference” means
    • Why speed matters in AI systems
    • Where latency comes from
    • Two important latency ideas: total latency and time to first token
    • Total latency
    • Time to first token
    • Why large language models are naturally slow
    • The autoregressive bottleneck
    • Latency is often tied to output length
    • Why bigger models are usually slower
    • Inference optimization is often about reducing wasted work
    • Simple system-level optimizations come first
    • Prompt size affects speed too
    • Batching and parallel work
    • Why decoding strategy matters
    • The core optimization question
    • Speculative decoding: the big intuition
    • Why speculative decoding is attractive
    • Multi-token prediction: another speed idea
    • Speed and quality usually trade off against each other
    • Why evaluation matters during optimization
    • What to measure when you optimize
    • A realistic optimization mindset
    • The broader lesson of this chapter
  • Part V — Engineering Walkthroughs
  • Case Study: Building an SEO Agent
    • What problem the system is trying to solve
    • Why this is a good AI systems problem
    • The high-level architecture
    • A possible component breakdown
    • Why decomposition matters
    • Where the “agent” part actually appears
    • What the architecture teaches us about agents
    • Where evaluation becomes essential
    • What “good” evaluation might look like here
    • Where guardrails matter
    • Why this project is portfolio-worthy
    • The deeper lesson of the case study
    • Lessons from this case study
  • Case Study: Benchmarking GraphRAG Against Vector RAG and Hybrid RAG
    • Why this is a strong case study
    • The central question of the benchmark
    • The three systems being compared
    • Vector RAG
    • GraphRAG
    • Hybrid RAG
    • Why the same domain matters
    • Choosing a domain that makes GraphRAG meaningful
    • Building the benchmark question set
    • A useful way to categorize questions
    • Why GraphRAG needs a fair test
    • What the evaluation should measure
    • Correctness
    • Faithfulness and evidence use
    • Retrieval quality itself
    • Latency and cost
    • The benchmark is really about tradeoffs
    • A realistic benchmark workflow
    • What makes this project hard in a good way
    • What the benchmark teaches about GraphRAG
    • Why this case study matters beyond GraphRAG
    • Lessons from this case study
  • Research Walkthrough: Exploring Multi-Token Decoding and the Speed–Quality Tradeoff
    • The core problem: autoregressive generation is sequential
    • The project question
    • Why this idea is difficult
    • The high-level idea of the project
    • A useful baseline: standard autoregressive decoding
    • One way to frame the experiment
    • Why a masked-language-style approach is attractive
    • Why the architecture choice matters
    • What makes this a real research problem
    • What should be measured
    • Output quality
    • Block accuracy
    • Latency or effective decoding efficiency
    • Tradeoff curves matter more than one number
    • A concrete failure mode to watch for: uncoordinated blocks
    • Another useful comparison: semi-autoregressive coordination
    • Why this project is strong for a portfolio
    • What the project teaches about optimization
    • The deeper lesson of the case study
    • Lessons from this case study
  • Part VI — Reference and Next Steps
  • What to Learn Next
    • The big idea of this chapter
    • There are three strong directions after this book
    • What to learn next if you choose applied AI engineering
    • What to learn next if you choose systems and production AI
    • What to learn next if you choose theory and research
    • You do not have to pick only one path forever
    • A practical “what should I do next month?” roadmap
    • If you want a stronger six-month direction
    • What not to do next
    • A simple self-diagnosis: which path sounds most like you?
    • The deeper truth: your path will probably alternate between building and studying
    • Chapter summary
  • Glossary
    • Core AI and learning concepts
    • Language models and generation
    • Retrieval and search
    • Agents, evaluation, and reliability
    • Adaptation, interfaces, and performance
    • Graphs and multimodal systems
  • Common AI Terms and Abbreviations
    • Core AI abbreviations
    • Language and model architectures
    • Application and data formats
    • Training and adaptation
    • Hardware, serving, and search
    • Product and operations terms
    • Evaluation and retrieval metrics
  • Tools, Libraries, and Platforms
    • The big idea: stop thinking in brand names, start thinking in system layers
    • A practical stack for AI systems
    • Layer 1: core programming and data tools
    • Python
    • NumPy
    • Pandas
    • Jupyter Notebook
    • Why this first layer matters
    • Layer 2: model and training libraries
    • PyTorch
    • TensorFlow
    • Hugging Face Transformers
    • Tokenizers and model processors
    • Layer 3: model access and inference platforms
    • Hosted model APIs
    • OpenAI
    • Anthropic
    • Ollama
    • vLLM
    • Layer 4: embeddings, retrieval, and vector storage tools
    • Sentence-transformers and embedding models
    • FAISS
    • Chroma
    • Pinecone
    • Retrieval frameworks and reranking
    • Layer 5: graph and structured knowledge tools
    • Neo4j
    • GraphRAG-related pipelines
    • Layer 6: LLM application frameworks and orchestration tools
    • LangChain
    • LCEL and composability
    • LangGraph
    • When frameworks help and when they do not
    • Layer 7: evaluation, observability, and experiment tracking tools
    • LangSmith
    • Weights & Biases
    • Layer 8: deployment and serving tools
    • Web frameworks and APIs
    • Cloud and infrastructure tools
    • How to decide what to learn first
    • If you want to build RAG systems first
    • If you want to experiment with local models
    • If you want to build agentic workflows
    • If you want to work on GraphRAG
    • The real skill is not memorizing tools
  • Further Reading
    • How to use this chapter
    • Section 1: Machine learning and deep learning foundations
    • Section 2: Transformers and language models
    • Section 3: Retrieval, RAG, and search systems
    • Section 4: Agents, tools, and workflow systems
    • Section 5: Evaluation, benchmarking, and reliability
    • Section 6: Local models, inference, and systems performance
    • Section 7: Research papers — how to approach them without drowning
    • Suggested topic-based reading paths
    • If you want to get better at RAG
    • If you want to understand LLM internals better
    • If you want to build agent systems
    • If you want to move toward production AI
    • A practical rule for choosing resources
    • A reading strategy that works well
    • What not to do with further reading
    • Chapter summary
  • References
    • Core References at a Glance
    • Chapter summary
  • About the Author
    • My angle on AI
    • Why this book is written the way it is
    • Who this book was written for
    • What I hope you take away from this book
    • A final note from me to you
  • Thank You and Next Steps
    • What I hope this book gave you
    • What to do after finishing the book
    • A strong next-step menu
    • A very practical 30-day challenge
    • How to keep learning without getting overwhelmed
    • What not to do from here
    • If this book helped you
    • What I’d love this book to become
    • One final reminder
    • Final thank you

Get the free Community Edition

You can get the free Community Edition in PDF or EPUB just by sharing your name and email address with the author, or you can just click this link to read a shorter sample online...

 

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub