Prerequisites for Understanding the AI Agent Book: A Complete Technical Guide

To understand the AI Agent book by bojieli, you need basic Python programming skills, fundamental LLM concepts, prompt engineering knowledge, command-line familiarity, and an active LLM API key.

The open-source repository bojieli/ai-agent-book implements the core formula Agent = LLM + Context + Tools across 92+ hands-on experiments. Before diving into the codebase and reproducing the chapter exercises, ensure you meet the foundational requirements outlined in the repository's learning guide and documentation.

Technical Prerequisites

Python Programming Proficiency

All practical implementations in the repository are written in Python. The coding-agent examples in Chapter 5, such as chapter5/coding-agent/example_with_system_hints.py, assume you can read and modify object-oriented Python code.

You should understand:

• Class instantiation and method calls
• Environment variable management for API keys
• Package installation via pip and requirements.txt

The central Agent class in chapter5/coding-agent/agent.py requires you to initialize objects and invoke the run_task() method, making Python syntax familiarity non-negotiable.

Machine Learning and LLM Fundamentals

The book adopts an LLM-centric view of agency. Chapter 1 introduces reinforcement learning (RL) based definitions and discusses model behaviors including fine-tuning, RLHF (Reinforcement Learning from Human Feedback), and retrieval-augmented generation (RAG).

You need to understand:

• What a large language model (LLM) is and how it generates text
• Basic concepts of model context windows and token limits
• The difference between base models and instruction-tuned models

Without this foundation, the architectural discussions in README.md regarding the three-component agent structure will lack necessary context.

Prompt Engineering Basics

From Chapter 2 onward, the material emphasizes context engineering, including system prompts, KV-Cache optimization, and prompt compression techniques. The learning guide in docs/zh-CN/LEARNING.md explicitly lists "系统提示、KV Cache、上下文压缩、提示工程" (system prompts, KV Cache, context compression, prompt engineering) as core topics.

Familiarity with:

• System vs. user prompts
• Token counting and context window management
• Structured output formatting

These skills enable you to modify the agent configurations and optimize the Agent class behavior defined in the source code.

Infrastructure and Environment Setup

Command-Line and Docker Familiarity

Many experiments, particularly the evaluation benchmarks in Chapter 6, require executing shell scripts and containerized environments. The repository provides "一键克隆脚本" (one-click clone scripts) and various bash utilities that presume terminal proficiency.

You should be comfortable:

• Executing shell commands to run Python scripts
• Navigating directory structures via command line
• Basic Docker operations (if running containerized benchmarks)

LLM API Access

The practical agents call external LLM services including Kimi, DeepSeek, and OpenRouter. The README.md contains an API-key table listing recommended providers, and the code samples require valid credentials in environment variables to instantiate the Agent class.

Ensure you have:

• An active API key from at least one supported provider
• Understanding of rate limits and token pricing
• Ability to securely store keys in environment variables

Hands-On Learning Mindset

Beyond technical skills, the book requires a willingness to run experiments. The learning philosophy emphasizes "动手实践" (hands-on practice), with each chapter shipping independent projects in docs/zh-CN/LEARNING.md that you must execute and modify to master the concepts.

This is not a theoretical text—you are expected to break, debug, and extend the 92+ experiments to build intuition about agent behavior.

Verifying Your Setup: First Agent Example

Once you meet the prerequisites, test your environment with this minimal implementation from the Chapter 5 coding agent framework:

# hello_world_demo.py

from chapter5.coding_agent.agent import Agent

# Initialise the agent (uses the default system prompt & tool registry)

agent = Agent()

# Send a short instruction to the LLM

response = agent.run_task("Write a one‑sentence summary of what an AI Agent is.")

print("Agent reply:", response)

To run this:

1. Install dependencies from chapter5/coding-agent/requirements.txt
2. Export your LLM API key as an environment variable
3. Execute python hello_world_demo.py

Successful execution confirms your Python environment, API access, and basic understanding of the agent instantiation pattern used throughout the book.

Summary

• Python programming is essential for modifying and running the chapter5/coding-agent/agent.py implementations.
• LLM fundamentals including RLHF, RAG, and context windows provide necessary context for Chapter 1's theoretical framework.
• Prompt engineering skills enable you to optimize system prompts and manage KV-Cache effectively.
• Command-line proficiency and Docker familiarity support the evaluation benchmarks and utility scripts.
• Active LLM API keys from providers like Kimi or DeepSeek are required for all practical experiments.
• Hands-on experimentation mindset aligns with the book's philosophy of learning by running the 92+ provided exercises.

Frequently Asked Questions

Do I need a GPU to run the AI Agent book experiments?

No, most experiments rely on API calls to external LLM services rather than local model inference. As implemented in bojieli/ai-agent-book, the Agent class sends requests to cloud providers (OpenRouter, DeepSeek, etc.), so a standard laptop with internet access and Python installed is sufficient for the majority of Chapter 5 and 6 exercises.

Can I follow the book without knowing Chinese?

While the primary documentation and docs/zh-CN/LEARNING.md are written in Chinese, the code itself—including chapter5/coding-agent/agent.py and example scripts—uses English variable names and comments. If you are comfortable reading Python code and use translation tools for the conceptual sections in README.md, you can technically follow the implementations, though you may miss nuances in the learning path descriptions.

What if I don't have an LLM API key yet?

The repository requires an API key to instantiate the Agent class and execute run_task() methods. The README.md provides a table of recommended providers offering free tiers or low-cost entry points. Without API access, you can read the source code and theoretical sections, but you cannot reproduce the 92+ hands-on experiments that form the core learning methodology.

Is prior experience with reinforcement learning necessary?

Basic RL knowledge helps for understanding Chapter 1's formal definition of agency, but it is not strictly required for the practical implementation. The coding examples abstract away the RL mechanics behind the Agent class interface. However, understanding concepts like reward signals and policy optimization will deepen your comprehension of why the Agent = LLM + Context + Tools formula is structured as documented in the repository.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}