This book is a deep dive into how modern AI systems truly work, moving far beyond surface-level tool usage to uncover the underlying mechanics of large language models (LLMs). It begins at first principles, tracing the full journey of a prompt from raw text input to tokenization, meaning extraction, and next-token prediction. Readers gain an intuitive understanding of concepts like embeddings, context windows, neural networks, and self-attention, building a mental model of how transformers process language. Rather than treating AI as a black box, the book equips readers with clarity on why models behave the way they do, making every later concept easier to grasp and apply.

From this foundation, the book shifts into building practical knowledge systems using Retrieval-Augmented Generation (RAG). It covers semantic search, chunking strategies, vector databases, and the complete RAG pipeline, followed by advanced techniques such as hybrid search, re-ranking, query transformation, and contextual retrieval. Readers then move into creating real-world applications: mastering prompt engineering, enabling tool use through function calling, managing memory, and leveraging frameworks like LangChain. The later sections introduce agentic AI, where systems reason, act, and iterate. Topics include the ReAct pattern, LangGraph workflows, multi-tool and multi-agent systems, human-in-the-loop safety, and reflection-based self-improvement, all supported by working code and practical examples.

By the end of this book, readers will not just know how to use AI tools, they will understand how to design, build, and deploy intelligent systems from the ground up. They will be able to create robust agents, evaluate performance, optimize cost and latency, and secure their systems against real-world risks. More importantly, they will possess a clear mental model of how everything fits together, enabling them to adapt as the field evolves and confidently build production-grade AI applications.

What will you learn?

• Inner workings of LLMs (tokens, embeddings, transformers, attention)
• Building production-ready RAG systems end-to-end
• Designing and scaling autonomous AI agents
• Using LangChain and LangGraph for structured workflows
• Deploying, monitoring, optimizing, and securing AI systems
  Who is it for?

This book is for software engineers, data engineers, data scientists, AI engineers, and technical leaders who want to build real-world AI systems. It is also ideal for career changers with basic Python knowledge who want to deeply understand how AI works. No prior ML or AI framework experience is required.

Explains underlying mechanisms, not just tools and recipes Production-first design embeds reliability, safety, and scalability throughout Starts from zero; no prior AI knowledge required

Autorentext

Sameer Shukla is a technology enthusiast with over 18 years of experience in software design and development, specializing in AI, data engineering, and scalable cloud architectures. I actively contribute to the tech community through writing, research, and speaking engagements, with a strong focus on building practical, real-world solutions. I have written many articles and a book on freeCodeCamp / DZone and other online learning platforms.

Inhalt

PART 1: How LLMs Work: The Foundation.- Chapter 1: What Happens When You Type a Prompt.- Chapter 2: Tokens.- Chapter 3: Embeddings.- Chapter 4: The Context Window.- Chapter 5: Neural Networks.- Chapter 6: The Transformer Architecture.- Chapter 7: Self-Attention.- PART 2: RAG and Knowledge Systems.- Chapter 8: Why LLMs Need External Knowledge.- Chapter 9: Semantic Search.- Chapter 10: Chunking Strategies.- Chapter 11: Vector Databases.- Chapter 12: The RAG Pipeline.- Chapter 13: Hallucination and Grounding.- PART 3: Advanced RAG.- Chapter 14: Hybrid Search.- Chapter 15: Re-Ranking.- Chapter 16: Query Transformation.- Chapter 17: Contextual Retrieval.- Chapter 18: RAG Evaluation.- Chapter 19: Agentic RAG.- PART 4: Building LLM Applications.- Chapter 20: LLM API Interaction.- Chapter 21: Prompt Engineering.- Chapter 22: Function Calling and Tool Use.- Chapter 23: Memory.- Chapter 24: LangChain.- Chapter 25: Building a RAG Pipeline in LangChain.- PART 5: Agentic AI.- Chapter 26: What is an Agent.-Chapter 27: The ReAct Pattern.- Chapter 28: LangGraph.- Chapter 29: Building Your First Agent from Scratch.- Chapter 30: Multi-Tool Agents.- Chapter 31: Human-in-the-Loop.- Chapter 32: Multi-Agent Systems.- Chapter 33: The Reflection Pattern.- Chapter 34: RAG Agents.- PART 6: Production and Real Systems.- Chapter 35: LLMOps.- Chapter 36: Observability.- Chapter 37: Evaluating Agents.- Chapter 38: Cost and Latency Optimization.- Chapter 39: Agent Security.