hello-agents

Structured 16-chapter tutorial organized into 5 progressive parts (Foundations → Single Agents → Advanced Capabilities → Real-World Case Studies → Capstone) that teaches agent architecture from first principles through implementation. Each chapter includes executable Python code examples demonstrating concepts like ReAct paradigm, Plan-and-Solve patterns, and reflection mechanisms, with bilingual documentation (Chinese/English) supporting learners at different experience levels.

Lightweight Python framework providing base agent classes, unified LLM client integration (supporting OpenAI, Anthropic, Ollama, and other providers), and a tool registry system for function calling. The framework abstracts provider-specific API differences through a common interface, enabling agents to switch LLM backends without code changes while managing message history, configuration, and extension patterns through inheritance and composition.

Framework for training agents through reinforcement learning feedback, where agent outputs are evaluated against success criteria and used to optimize behavior. The pipeline includes reward signal generation, trajectory collection from agent runs, and training loops that improve agent decision-making based on outcomes, enabling agents to learn from experience rather than relying solely on pre-trained LLM weights.

Systematic approach to measuring agent performance across multiple dimensions (accuracy, latency, cost, tool usage efficiency) with standardized evaluation metrics and benchmarking datasets. The framework provides methods for comparing agent implementations, tracking performance over time, and identifying bottlenecks, enabling data-driven optimization of agent systems.

Complete working examples of production-grade agent systems demonstrating how to apply framework concepts to real problems: an Intelligent Travel Assistant coordinating flight/hotel bookings, an Automated Deep Research Agent conducting multi-step research and synthesis, and a Cyber Town Simulation with multiple interacting agents. Each case study includes full source code, architectural decisions, and lessons learned, serving as templates for building similar systems.

Framework for community members to contribute specialized agents and extensions (ColumnWriter for multi-agent article generation, MindEchoAgent for emotion-driven music recommendation, DeepCastAgent for research-to-podcast pipeline). The project structure enables contributors to build agents addressing specific use cases while maintaining compatibility with the core framework, creating a growing ecosystem of reusable agent implementations.

Centralized registry that maps tool names to Python functions, automatically generates function calling schemas compatible with OpenAI and Anthropic APIs, and handles tool invocation with argument validation. The system uses Python type hints and docstrings to generate schemas, enabling agents to discover available tools and invoke them with proper error handling and result formatting.

Concrete implementation of the Reasoning-Acting paradigm where agents alternate between thinking steps (reasoning about the problem and planning actions) and execution steps (calling tools and observing results). The framework provides structured prompting patterns that guide LLMs to produce explicit reasoning traces before tool invocation, enabling interpretability and error recovery through reflection on failed actions.

Agent pattern where the LLM first generates a detailed plan breaking down a complex task into subtasks, then executes each subtask sequentially with tool invocations. The framework provides structured prompting to elicit explicit plans before execution, enabling agents to handle multi-step workflows where later steps depend on earlier results, with built-in error handling for failed subtasks.

Agent capability where the LLM examines its own outputs, tool results, or intermediate steps and decides whether to continue, retry with different parameters, or take an alternative approach. The framework provides structured prompting patterns that ask agents to evaluate their progress against the original goal, identify failures or suboptimal results, and generate corrective actions without external intervention.

End-to-end retrieval-augmented generation system that ingests documents, chunks them into retrievable segments, embeds them into vector space, and retrieves relevant context to augment agent prompts. The framework integrates document loading, chunking strategies, embedding generation, and similarity-based retrieval, enabling agents to ground responses in specific documents and cite sources.

Framework patterns for coordinating multiple specialized agents that communicate through defined message protocols, enabling complex tasks to be solved through agent collaboration. The system provides abstractions for agent-to-agent messaging, result aggregation, and orchestration patterns (sequential, parallel, hierarchical) that allow agents to delegate subtasks to each other and combine results.

Systematic approach to crafting agent prompts that guide LLM behavior through system messages, role definitions, task specifications, and output format constraints. The framework provides patterns for structuring prompts to elicit specific agent behaviors (reasoning, planning, tool usage) and includes techniques for managing context length, prioritizing important information, and handling edge cases through prompt engineering rather than code changes.

Built-in tool implementations enabling agents to persist information across steps (NoteTool for writing and reading notes) and execute system commands (TerminalTool for running shell commands and capturing output). These tools extend agent capabilities beyond LLM-only reasoning by providing persistent state management and direct system interaction, enabling agents to maintain context across long conversations and execute real-world tasks.