从零开始构建智能体 (陈思州等) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A hands-on, open-source guide that takes you from LLM user to agent builder—covering theory, classic paradigms, framework development, and real-world multi-agent projects. Ideal for developers, students, and self-learners with basic Python skills who want to design and implement AI-native agents, not just use low-code tools. 【Book Arc】 - **Opening (~0%–10%)**: Introduces the Hello-Agents project and its mission—bridging the gap between theory and practice in the "Agent era." It outlines the five-part structure (basics, building, advanced, case studies, capstone) and sets expectations for a hands-on learning journey. - **Early (~10%–23%)**: Lays the conceptual foundation—defines agents via the classic sense-act loop, contrasts traditional agent types (reflex, model-based, goal-based, utility-based, learning) with LLM-driven agents, and explains the PEAS framework for task environments. It also covers the history of AI paradigms (symbolic, sub-symbolic, neuro-symbolic) to contextualize modern agents. - **Early (~23%–32%)**: Dives into the core operating mechanism—the Agent Loop (perception, thought, action, observation) and the Thought-Action-Observation interaction protocol. A practical section walks through building a simple travel assistant with weather and attraction tools, using an OpenAI-compatible client. - **Middle (~39%–48%)**: Explores collaboration modes—agents as developer tools (e.g., GitHub Copilot, Cursor) versus autonomous collaborators (e.g., AutoGen, LangGraph). It clarifies the crucial difference between deterministic Workflows and goal-driven, self-directed Agents, using the travel assistant as a recurring example. - **Late (~48%–52%+)**: Begins the historical retrospective—tracing agent evolution from symbolic AI and the Physical Symbol System Hypothesis to expert systems, showing how each paradigm solved prior limitations while introducing new ones. This sets up the transition to learning-based and modern LLM agents. 【Key Takeaways】 - **Agents are defined by the sense-act-autonomy loop** (Early): An agent perceives its environment via sensors, acts via actuators, and makes autonomous decisions to achieve goals—a framework that applies from thermostats to LLM-powered assistants. - **LLM agents differ fundamentally from traditional ones** (Early): Unlike rule-based or utility-based agents, LLM agents use implicit world knowledge from pretraining to handle vague, high-level instructions through planning, tool use, and dynamic correction—shifting from "writing code" to "guiding a brain." - **The Agent Loop is the universal operating rhythm** (Early): Every agent runs a cycle of perception → thought (planning + tool selection) → action → observation. Structuring outputs as Thought/Action/Observation fields enables a parser to bridge LLM reasoning with external tool execution. - **PEAS helps you design task environments** (Early): Performance, Environment, Actuators, Sensors—this framework forces clarity on goals and constraints. Real LLM environments are partially observable, stochastic, multi-agent, and sequential, which directly shapes memory and exploration needs. - **Workflow ≠ Agent** (Middle): A workflow is a predefined, static flowchart (e.g., expense approval rules), while an agent is a goal-directed system that plans, reasons, and adapts dynamically—no hardcoded "if weather = sunny then recommend X" logic. - **Autonomous collaboration comes in distinct architectural patterns** (Middle): From single-agent loops (AgentGPT) to role-play dialogues (CAMEL), organizational workflows (MetaGPT, CrewAI), and state-graph control flows (LangGraph)—each pattern trades off flexibility, reliability, and complexity. - **Agent history is problem-driven evolution** (Late): Symbolic AI (PSSH, expert systems) offered transparency but hit the "knowledge acquisition bottleneck"; sub-symbolic AI learned from data but was a black box. Neuro-symbolic approaches, exemplified by LLM agents, aim to fuse both strengths. 【Reading Tips】 - **Skim the historical chapters (Ch. 2) if you're in a hurry**: The key insight is the "problem-driven" progression—each paradigm solves the last one's flaw. Focus on the final synthesis (neuro-symbolic) to understand why LLM agents look the way they do. - **Deep-read the practical sections (Ch. 1.3 and later hands-on chapters)**: The travel assistant example is the backbone of the book. Run the code, modify the tools, and trace the Thought-Action-Observation loop yourself—this is where the concepts click. - **Pay extra attention to the Workflow vs. Agent distinction**: It's a common point of confusion. Use the travel assistant example (dynamic planning) versus the expense-approval flowchart (fixed rules) as your mental model. - **Don't skip the PEAS analysis**: It may feel abstract, but it's the design template you'll reuse for every agent project. Practice applying it to your own use case before moving to advanced chapters. - **Expect code-heavy sections with API keys**: The excerpts show real code (e.g., Tavily, OpenAI client). Prepare your own API credentials and be ready to debug—the book explicitly encourages modifying code to learn. 【Coverage Limits】 This guide synthesizes content from the opening through the early-middle sections (~0–52%), covering fundamentals, the first practical agent, collaboration modes, and the start of agent history. Later chapters on advanced topics (memory, context engineering, protocols, RL training, evaluation) and comprehensive case studies (travel assistant, deep research, cyber town) are not covered here.