🤖 Agent Learning: Learn Agent Development from Scratch

The complete open-source roadmap for learning AI Agents — from LLM basics to production-ready Agent systems.

Agent Learning (agent_learning) is a systematic, practice-oriented AI Agent learning roadmap and hands-on tutorial covering LLM fundamentals, RAG, memory, tool use, function calling, agentic workflows, LangChain, LangGraph, MCP, multi-agent systems, evaluation, deployment, and agentic RL.

If you want to learn how to build AI Agents — not just use ChatGPT, but understand how agents retrieve knowledge, remember context, call tools, plan actions, collaborate, and run safely in production — this project is for you.

Daily auto-tracking of arXiv frontier papers — content stays cutting-edge, always.

License: MIT Stars PRs Welcome mdBook Daily arXiv

   

🐛 Report Issues · 💬 Discussions · 🇨🇳 中文版 README

🚀 Auto-Tracking Frontier: Daily arXiv Paper Updates

🤖 This repository automatically searches arXiv for the latest AI Agent-related papers every day and updates the content accordingly — ensuring you always stay at the cutting edge of research!

  • 📡 Daily Automated Search: A scheduled pipeline scans arXiv daily for new papers on Agent architectures, tool use, memory systems, multi-agent collaboration, reinforcement learning for agents, and more.
  • 📝 Auto-Updated Content: Relevant findings are automatically integrated into the corresponding chapters, keeping the book's frontier sections fresh and up-to-date.
  • 🔔 Never Miss a Breakthrough: No need to manually track dozens of research feeds — this repo does it for you, so you can focus on learning and building.

💡 This means the content you read here is not static — it evolves continuously with the latest advances in the AI Agent field.

👥 Who Is This For?

  • Developers who want to build real AI Agent applications instead of only prompting chatbots
  • Students and beginners who need a structured path from LLM basics to Agent systems
  • LLM application engineers working with RAG, tool calling, memory, LangGraph, MCP, and evaluation
  • Researchers and builders who want to connect frontier Agent papers with engineering practice
  • Product and startup teams exploring production-ready Agent workflows

🧭 Learning Paths

Path Start Here Goal
Beginner Path LLM basics → Prompt Engineering → Function Calling → RAG → Memory → ReAct Understand how an Agent works end to end
Engineering Path Tool Layer → LangGraph → Evaluation → Security → Deployment → Observability Build production-ready Agent systems
Research Path ReAct → Reflexion → MemGPT → PPO / DPO / GRPO → Agentic RL Follow and understand frontier Agent research
Project Path Hello Agent → RAG QA Agent → Memory Agent → Data Analysis Agent → Coding Agent Learn by building complete applications

✨ Key Features

  • 🎯 Step by Step: From LLM fundamentals to multi-Agent systems, each chapter has a clear knowledge progression
  • 💻 Code First: Every core concept comes with runnable Python code examples
  • 🎨 Rich Illustrations: 120+ hand-drawn SVG architecture diagrams / flowcharts / sequence diagrams for intuitive understanding
  • 🎬 Interactive Animations: 5 built-in interactive HTML animations (Perceive-Think-Act cycle, ReAct reasoning, Function Calling, RAG flow, GRPO sampling)
  • 🔬 Paper Reviews: Key chapters include frontier paper deep-dives (ReAct, Reflexion, MemGPT, GRPO, etc.)
  • 🏗️ Complete Projects: 3 comprehensive hands-on projects (AI Coding Assistant, Intelligent Data Analysis Agent, Multimodal Agent)
  • 🛡️ Production Ready: Covers security, evaluation, deployment, and other production essentials
  • 🧪 Cutting Edge: Covers Context Engineering, Agentic-RL (GRPO/DPO/PPO), MCP/A2A/ANP, and other 2025–2026 latest advances
  • 📐 Formula Support: KaTeX-rendered math formulas for clear reading of policy gradient, KL divergence derivations in RL chapters
  • 🔄 Continuously Updated: Tracking the latest changes in LangChain, LangGraph, MCP, and other frameworks

📸 Selected Content Preview

Below are selected showcases from the book's 120+ hand-drawn SVG illustrations, all original to this book.

🧠 Agent Core Architecture

Perceive-Think-Act Loop (Chapter 1)

Agent's core mechanism: Perceive environment → LLM reasoning → Execute action → Loop until goal achieved

ReAct Reasoning Framework (Chapter 5)

Thought → Action → Observation alternating loop, enabling Agents to think while acting

🛠️ Tool Calling & RAG

Function Calling Complete Flow (Chapter 3)

6-step complete flow from user input to tool invocation to final response, with message structure illustration

RAG Retrieval-Augmented Generation (Chapter 6)

Offline indexing + Online retrieval dual-phase architecture, making LLM answers evidence-based

💾 Memory System & Context Engineering

Three-Layer Memory Architecture (Chapter 4)

Working memory → Short-term memory → Long-term memory, with important info sinking down and semantic retrieval pulling up

Prompt Engineering vs Context Engineering (Chapter 7)

From "how to say it" to "what the LLM sees" — the paradigm shift of the Agent era

🤝 Multi-Agent & Communication Protocols

Three Multi-Agent Communication Patterns (Chapter 15)

Message Queue (async decoupling) / Shared Blackboard (data sharing) / Direct Call (real-time collaboration)

MCP / A2A / ANP Protocol Comparison (Chapter 16)

Three-layer protocol stack: ANP for discovery → A2A for task collaboration → MCP for tool invocation

🧪 Reinforcement Learning & Frameworks

GRPO Training Architecture (Chapter 10)

No Critic model needed, computes advantage via intra-group normalization, only 1.5× model size in VRAM

LangGraph Three Core Concepts (Chapter 12)

State (shared state) · Node (processing unit) · Edge (execution flow control)

📖 The above is just a selected preview — For the full 120+ architecture diagrams + 5 interactive animations, please read online

🎬 Interactive Animations

This book includes 5 interactive HTML animations to help you intuitively understand the dynamic processes of core concepts:

Animation Chapter Description
🔄 Perceive-Think-Act Cycle Chapter 1 Dynamic demonstration of Agent's core loop
💡 ReAct Reasoning Process Chapter 5 Shows the alternating Thought → Action → Observation process
🔧 Function Calling Chapter 3 Complete tool invocation flow animation
📚 RAG Retrieval Flow Chapter 6 From document chunking to vector retrieval to answer generation
🎯 GRPO Sampling Process Chapter 10 Visualization of intra-group multi-output sampling and reward normalization

💡 Interactive animations are only available in the online e-book. Local builds can also preview them.

🔥 Core Topics at a Glance

🧠 Agent Core Architecture

  • Perceive → Think → Act Loop
  • ReAct Reasoning Framework
  • Task Decomposition & Planning
  • Reflection & Self-Correction

🛠️ Tools & Skills

  • Function Calling Mechanism
  • Custom Tool Design
  • Skill System Construction
  • Tool Description Best Practices

🧪 Reinforcement Learning Training

  • SFT + LoRA Basic Training
  • PPO / DPO / GRPO Algorithm Deep-Dive
  • Complete Training Pipeline Hands-on
  • 2025–2026 Latest Research Advances

💾 Memory, Knowledge & Context

  • Short-term / Long-term / Working Memory
  • Vector Databases (Chroma / FAISS)
  • RAG Retrieval-Augmented Generation
  • Context Engineering & Attention Budget

🤝 Multi-Agent Collaboration & Communication

  • MCP / A2A / ANP Protocol Stack
  • Supervisor vs Decentralized Patterns
  • CrewAI / AutoGen Frameworks
  • LangGraph Stateful Agents

🛡️ Production Full Pipeline

  • Evaluation Benchmarks (GAIA / SWE-bench)
  • Security Defense & Sandbox Isolation
  • Containerized Deployment & Streaming
  • Observability & Cost Optimization

🚀 Quick Start

Local Build

# Install mdBook (choose one)
cargo install mdbook
# Or macOS: brew install mdbook

# Install mdbook-katex plugin (for math formula rendering)
cargo install mdbook-katex

# Clone the repository
git clone https://github.com/Haozhe-Xing/agent_learning.git
cd agent_learning

# Build both Chinese and English versions and start unified server (default port 3000)
./serve.sh

After starting, visit:

  • 🌐 Language Selection Home: http://localhost:3000
  • 🇨🇳 Chinese Version: http://localhost:3000/zh/
  • 🇺🇸 English Version: http://localhost:3000/en/

Environment Setup (For Code Practice)

# Python 3.11+
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Install core dependencies
pip install langchain langchain-openai langgraph openai anthropic

# Configure API Key
export OPENAI_API_KEY="your-key-here"

📊 Technology Stack

Python LangChain LangGraph OpenAI Anthropic FastAPI Docker Chroma FAISS mdBook KaTeX

🤝 Contributing

All forms of contribution are welcome!

  • 🐛 Found a bug: Submit an Issue
  • 💡 Content suggestions: Start a Discussion
  • 📝 Improve content: Fork → Edit → Submit PR
  • ⭐ Support the project: Give this repo a Star!

Contributing Guide

# Fork and clone
git clone https://github.com/YOUR_USERNAME/agent_learning.git

# Create a feature branch
git checkout -b feature/improve-chapter-3

# Local preview
./serve.sh

# Commit and push
git commit -m "feat: improve Chapter 3 tool calling code examples"
git push origin feature/improve-chapter-3

Content Organization Conventions

  • Each chapter is placed in a separate directory src/zh/chapter_xxx/ (Chinese) or src/en/chapter_xxx/ (English)
  • Chapter overview goes in README.md, sections are numbered as 01_xxx.md, 02_xxx.md
  • Chinese SVG illustrations go in src/zh/svg/, English versions in src/en/svg/, naming format: chapter_xxx_description.svg
  • Chinese interactive animations go in src/zh/animations/, English versions in src/en/animations/

Paper Reading Template

All paper reading and frontier research sections should follow a consistent structure so that readers can quickly understand why a paper matters, what it contributed at the time, and how it connects to real Agent engineering.

Use the following template for each representative paper:

### Paper Title: one-sentence explanation of the problem it solves

- **Paper link**:
- **Code / project link**:
- **Year / organization**:
- **Problem addressed at the time**:
- **Core contribution**:
- **Method breakdown**:
- **Engineering insight for Agent systems**:
- **Limitations**:

Quality requirements:

  • Link to the original source: include the arXiv, conference, official blog, GitHub, or project page whenever available.
  • Explain historical contribution: describe what problem the work solved when it appeared, not only what it does.
  • Connect to engineering practice: explain how the idea affects Agent memory, tools, planning, evaluation, safety, training, or deployment.
  • State limitations: clarify what the paper does not solve, where assumptions are strong, or whether the result is mainly benchmark-driven.
  • Avoid paper lists without synthesis: after several papers, add a short comparison table or narrative summary explaining how the works relate to each other.

📄 License

This project is open-sourced under the MIT License.

🗺️ Project Roadmap

  • Chinese / English online book powered by mdBook
  • 120+ original SVG architecture diagrams and flowcharts
  • Interactive animations for core Agent concepts
  • Paper reading sections for key Agent research
  • Agentic RL chapters covering PPO / DPO / GRPO
  • Runnable Agent example projects and templates
  • Agent glossary and keyword cheat sheet
  • Agent architecture diagram gallery
  • Interview questions and self-check exercises
  • Production-ready Agent template with evaluation and observability

⭐ Star History

If this project helps you, please give it a Star ⭐ — it's the greatest encouragement for the author!

Star History Chart

Built with ❤️, so that every developer can master AI Agent development

⬆ Back to Top