Generative AI and Agentic Systems

Generative AI covers models and systems that create text, images, structured outputs, plans, tool calls, or multimodal responses. This section separates model-training concepts from application architecture: a language model can be pretrained and aligned, but a useful product still needs retrieval, context construction, tools, evaluation, privacy controls, and serving constraints.

Read the early pages for foundation-model mechanics, then follow the branch for the system you are building — RAG for evidence and retrieval, agents for tool-mediated loops, and the safety pages for behavior constraints.

Knowledge map

Foundation-model mechanics feed generation control, retrieval, and multimodal generation; retrieval and generation combine into agents; serving and safety wrap everything that ships.

flowchart TD
  FM[Foundation Models and Training] --> Gen[Generation Control]
  FM --> RAG[Retrieval-Augmented Generation]
  Gen --> Agents[Tool Use and Agents]
  RAG --> Agents
  FM --> MM[Multimodal and Image Generation]
  Gen --> Serving[Serving, Cost, Quantization]
  Agents --> Safety[Guardrails, Injection, Privacy]
  RAG --> Safety

Reading path

Read foundation-model mechanics and generation control first, then retrieval, agents, multimodal generation, serving, and safety.

1. Foundation Models: what a large pretrained model is and is not.
2. Language Model Architecture: the transformer stack behind LLMs.
3. Tokenization: the units an LLM reads and generates.
4. Pretraining: self-supervised learning on large corpora.
5. LLM Training: the full pretraining-to-alignment pipeline.
6. Instruction Tuning: teaching a base model to follow instructions.
7. Alignment: shaping behavior toward helpfulness and safety.
8. In-Context Learning: adapting from examples in the prompt.
9. Prompting: structuring inputs to steer generation.
10. Sampling and Decoding: turning logits into tokens.
11. Top-k and Top-p Sampling: truncated sampling rules.
12. Temperature and Determinism: controlling randomness.
13. Determinism and Reproducibility: making runs repeatable.
14. Structured Output: constraining generations to a schema.
15. RAG: grounding generation in retrieved evidence.
16. Embeddings: vector representations for retrieval.
17. Chunking: splitting documents into retrievable units.
18. Vector Databases: storing and searching embeddings.
19. Retrieval Pipelines: the offline and online retrieval contracts.
20. Hybrid Retrieval: combining lexical and dense signals.
21. Query Rewriting: reshaping the query before retrieval.
22. Reranking: reordering candidates with a stronger model.
23. Context Construction: assembling the final prompt context.
24. Grounding: tying claims to sources.
25. Citations: attributing generated statements to evidence.
26. Hallucination Mitigation: reducing unsupported output.
27. RAG Evaluation: measuring retrieval and answer quality.
28. RAG Architecture Comparison: trade-offs across RAG designs.
29. RAG Benchmark Design: building trustworthy RAG benchmarks.
30. Fine Tuning Versus RAG: when to train versus retrieve.
31. Tool Use and Function Calling: the model’s action layer.
32. Tool Schemas: declaring callable tools.
33. Tool Routing: choosing which tool to call.
34. Agent Loops: the observe-decide-act cycle.
35. Agentic Systems: systems that plan and act over many steps.
36. Planning: decomposing goals into steps.
37. Memory: persisting state across steps and sessions.
38. Reflection and Reviewer Patterns: self-critique against a rubric.
39. Multi-Agent Systems: coordinating multiple roles.
40. Harnesses: the runtime scaffolding around a model.
41. LangChain: a configurable framework for models, tools, middleware, retrieval, and agent loops.
42. LangGraph: graph orchestration for durable, stateful, long-running agents.
43. Agent Evaluation: measuring multi-step task success.
44. LLM-as-Judge: using models to score outputs.
45. Multimodal Models: models over text, image, and more.
46. Vision-Language Models: joint image-text models.
47. Stable Diffusion: latent-diffusion image generation.
48. Local Versus Hosted Models: where the model runs.
49. Model Serving: the runtime layer for reliable calls.
50. Quantization: lower-precision weights for cheaper serving.
51. Cost and Latency Optimization: making systems affordable and fast.
52. Guardrails: runtime behavior constraints.
53. Prompt Injection: the core adversarial-input risk.
54. Data Privacy: protecting user and training data.
55. PII Protection: detecting and redacting personal information.

Connections

• Deep Learning and Natural Language Processing supply the architectures and language tasks underneath.
• Information Retrieval provides the retrieval half of RAG, and Responsible AI governs deployed behavior.

Nav

Learning path — Generative AI systems

Foundation Models →