近年 AI 应用技术学习路线：从 LLM、RAG 到 Agent 工程

LLM 基础 ──────→ Prompt Engineering ──────→ Fine-tuning
    │                    │                      │
    │                    ▼                      ▼
    │              Function Calling          RAG
    │                    │                      │
    │                    ▼                      │
    │                   MCP ────────────────────┤
    │                    │                      │
    ▼                    ▼                      ▼
  智能体 ←──────────── Context Engineering
    │
    ▼
  Multi-Agent ──→ Workflow Engineering ──→ Agent Skill
    │
    ▼
  OpenClaw ──→ Harness Engineering
```textmermaid
graph TD
    A[Transformer 原始架构] --> B[Encoder-Only<br/>如 BERT]
    A --> C[Encoder-Decoder<br/>如 T5]
    A --> D[Decoder-Only<br/>当前主流: GPT、Llama]
    style D stroke:#f66,stroke-width:2px
```texttext
输入序列：["我", "喜欢", "AI", "技术"]

自注意力计算（简化）：
每个 Token 都会"关注"所有其他 Token，计算相关性权重：

"我"   → 关注 [我:0.3, 喜欢:0.5, AI:0.1, 技术:0.1]  → 主要是"喜欢"的施事者
"喜欢" → 关注 [我:0.4, 喜欢:0.1, AI:0.3, 技术:0.2]  → "我"喜欢"AI"和"技术"
"AI"   → 关注 [我:0.1, 喜欢:0.3, AI:0.2, 技术:0.4]  → "AI"是一种"技术"
"技术" → 关注 [我:0.1, 喜欢:0.2, AI:0.4, 技术:0.3]  → 与"AI"强关联

→ 每个 Token 的表示 = 所有 Token 的加权求和
→ 权重越大，表示该 Token 对当前 Token 越重要
```textmarkdown
# 示例：翻译任务

# 示例 1
用户：把"早上好"翻译成英文
AI：Good morning

# 示例 2
用户：把"晚安"翻译成英文
AI：Good night

# 正式请求
用户：把"你好"翻译成英文
AI：
```textmarkdown
# 示例：数学问题

用户：计算 245 + 178，请展示计算过程。
AI：让我一步步思考：

第 1 步：245 + 100 = 345
第 2 步：345 + 70 = 415
第 3 步：415 + 8 = 423

答案是 423
```textmarkdown
# 角色
你是一位资深的前端工程师，擅长 React 和 TypeScript。

# 任务
审查以下代码，找出潜在的性能问题。

# 约束
- 只关注性能问题，不关注代码风格
- 每个问题给出具体的修改建议
- 按严重程度排序（高 → 中 → 低）

# 输出格式
| 问题 | 严重程度 | 位置 | 修改建议 |
| ---- | ---- | ---- | ---- |

# 代码
{待审查的代码}
```texttext
原始更新：ΔW (100×100 = 10,000 参数)
LoRA 分解：A (100×2 = 200 参数) × B (2×100 = 200 参数)
实际训练：400 参数 = 10,000 参数的 4%
```textmermaid
graph LR
    subgraph 原始权重 W (d×d)
        W0[冻结的 W₀]
    end
    
    subgraph LoRA 旁路分支
        A[A 矩阵 r×d<br/>可训练] --> B[B 矩阵 d×r<br/>可训练]
    end
    
    Input(输入 x) --> W0
    Input --> A
    B --> Add((+))
    W0 --> Add
    Add --> Output(输出 y)
```textpython
import torch
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 输出示例：trainable params: 6,815,744 || all params: 8,075,097,856 || trainable%: 0.084%
```texttext
┌─────────────────────────────────────────────────────────────┐
│                      RAG 工作流程                              │
└─────────────────────────────────────────────────────────────┘

用户问题 ──→ 编码为向量 ──→ 在向量数据库中检索 ──→ 获取相关文档
                                            │
                                            ▼
                        ┌───────────────────────────────┐
                        │         LLM 生成答案            │
                        │  (基于检索结果 + 自身知识)        │
                        └───────────────────────────────┘
                                            │
                                            ▼
                                        最终回答
```textmermaid
graph TD
    subgraph 离线索引阶段
        Doc[原始文档] --> Split[文本分割]
        Split --> Embed[Embedding 编码]
        Embed --> DB[(向量数据库)]
    end

    subgraph 在线查询阶段
        Q[用户问题] --> QEmbed[Embedding 编码]
        QEmbed --> Search[向量相似度检索]
        DB --> Search
        Search --> TopK[Top-K 候选文档]
        TopK --> ReRank{重排序 Re-Ranker}
        ReRank --> FinalDocs[精选文档]
        FinalDocs --> LLM[LLM 生成]
        Q --> LLM
        LLM --> Ans(最终回答)
    end
```textpython
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", "。", "！", "？", ".", " "]
)

chunks = text_splitter.split_text(your_document_text)

vectorstore = Chroma.from_texts(
    texts=chunks,
    embedding=OpenAIEmbeddings()
)

results = vectorstore.similarity_search("如何配置 LoRA？", k=3)
for doc in results:
    print(doc.page_content)
```textpython
from openai import OpenAI

client = OpenAI()

messages = [
    {"role": "user", "content": "今天北京的天气怎么样？"}
]

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市名称，如'北京'、'上海'"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=messages,
    tools=tools
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)    # → "get_weather"
print(tool_call.function.arguments)  # → '{"location": "北京"}'
```texttext
Agent = LLM（大脑）+ Planning（规划）+ Memory（记忆）+ Tools（工具）
```textmermaid
graph TD
    Start((接收目标)) --> Think[思考 Thought<br/>LLM 分析当前状态]
    Think --> Plan[规划 Plan<br/>分解为可执行步骤]
    Plan --> Act[行动 Action<br/>调用工具执行]
    Act --> Obs[观察 Observation<br/>获取执行结果]
    Obs --> Check{任务完成?}
    Check -- 是 --> End((结束))
    Check -- 否 --> Think
```texttext
┌─────────────────────────────────────────────────────────────┐
│                    ReAct 执行示例                              │
└─────────────────────────────────────────────────────────────┘

用户：北京明天的天气适合户外运动吗？

Thought 1：我需要先查北京明天的天气，再判断是否适合户外运动。
Action 1：调用 get_weather(location="北京", date="明天")
Observation 1：明天北京晴，气温 25°C，湿度 40%，风速 3 级

Thought 2：天气晴朗、温度适宜、湿度低、风速小，非常适合户外运动。
Action 2：无需更多工具调用
Answer：明天北京天气晴朗，气温 25°C，湿度适中，非常适合户外运动！
        推荐活动：跑步、骑行、徒步。
```textmermaid
graph TD
    subgraph 层级模式 Hierarchical
        H_Main[主智能体] --> H_Sub1[子智能体 A]
        H_Main --> H_Sub2[子智能体 B]
    end

    subgraph 协作模式 Collaborative
        C_A[智能体 A] <--> C_B[智能体 B]
        C_A --> C_Sum(汇总结果)
        C_B --> C_Sum
    end

    subgraph 竞争模式 Competitive
        Comp_A[智能体 A] --> Comp_Eval{选择最佳结果}
        Comp_B[智能体 B] --> Comp_Eval
        Comp_C[智能体 C] --> Comp_Eval
    end
```textpython
from crewai import Agent, Task, Crew

researcher = Agent(
    role="研究员",
    goal="收集并分析最准确的信息",
    backstory="你是一位专业的研究员，擅长从多个来源收集信息。"
)

writer = Agent(
    role="技术写手",
    goal="将复杂技术用易懂的语言解释清楚",
    backstory="你是一位资深技术作家，擅长将复杂概念通俗化。"
)

research_task = Task(
    description="研究 LLM 最新发展趋势",
    agent=researcher
)

write_task = Task(
    description="撰写一篇 LLM 科普文章",
    agent=writer
)

crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])
result = crew.kickoff()
```textxml
<task>
  审查以下代码的安全问题
</task>

<context>
  <project>Web API 服务</project>
  <language>Python</language>
  <framework>FastAPI</framework>
</context>

<code>
  {待审查代码}
</code>

<constraints>
  只关注 OWASP Top 10 安全风险
</constraints>
```texttext
my_skill/
├── SKILL.md        # 技能定义文件（必需）
├── tools/          # 工具脚本目录
│   ├── script1.py
│   └── script2.sh
├── knowledge/      # 知识文件目录
│   └── guide.md
└── config.yaml      # 配置文件
```textmarkdown
---
name: code-reviewer
version: 1.0.0
description: 自动代码审查技能
triggers:
  - "审查代码"
  - "code review"
---

# Code Reviewer Skill

## 功能
审查代码的安全性和性能问题。

## 使用方式
1. 提供待审查的代码文件
2. 智能体自动调用审查工具
3. 输出审查报告

## 依赖
- Python 3.10+
- ruff, bandit
```texttext
┌─────────────────────────────────────────────────────────────┐
│                     OpenClaw 系统架构                         │
└─────────────────────────────────────────────────────────────┘

  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
  │   消息平台   │     │   消息平台   │     │   消息平台   │
  │ (Telegram)  │     │  (Discord)  │     │  (WhatsApp) │
  └──────┬──────┘     └──────┬──────┘     └──────┬──────┘
         │                   │                   │
         └───────────────────┼───────────────────┘
                             │
                    ┌────────▼────────┐
                    │    Gateway     │  ← 控制平面（WebSocket）
                    │  (控制中枢)     │
                    └────────┬────────┘
                             │
         ┌───────────────────┼───────────────────┐
         │                   │                   │
  ┌──────▼──────┐     ┌──────▼──────┐     ┌──────▼──────┐
  │   智能体   │     │   Tools     │     │   Memory    │
  │   (大脑)    │     │  (工具集)   │     │  (记忆)     │
  └─────────────┘     └─────────────┘     └─────────────┘
```textbash
# 安装（官方推荐 Node.js 24，兼容 Node.js 22.14+）
npm install -g openclaw@latest

# 初始化配置
openclaw onboard --install-daemon

# 启动 Gateway
openclaw gateway --port 18789 --verbose

# 打开本地控制台
openclaw dashboard
```textjson
[
  {
    "id": "eval_001",
    "input": "帮我查一下北京明天的天气",
    "expected_tool": "get_weather",
    "expected_params": {"location": "北京"},
    "difficulty": "easy"
  },
  {
    "id": "eval_002",
    "input": "帮我规划一个北京三日游，预算 5000 元",
    "expected_tools": ["search_attractions", "search_hotels", "calculate_budget"],
    "difficulty": "hard"
  }
]
```texttext
┌─────────────────────────────────────────────────────────────┐
│                   评估驱动的开发循环                            │
└─────────────────────────────────────────────────────────────┘

  ┌──────────────┐
  │ 1. 定义评估集  │ ← 包含多样化用例、边界案例、期望输出
  └──────┬───────┘
         │
         ▼
  ┌──────────────┐
  │ 2. 运行评估   │ ← 执行所有用例，收集结果
  └──────┬───────┘
         │
         ▼
  ┌──────────────┐
  │ 3. 分析失败   │ ← 定位失败用例，分析根因
  └──────┬───────┘
         │
         ▼
  ┌──────────────┐
  │ 4. 修改配置   │ ← 调整提示词/智能体配置/工具定义
  └──────┬───────┘
         │
         ▼
    ┌─────────┐
    │ 成功率？ │
    └────┬────┘
    ╱         ╲
  达标       未达标
   │           │
   ▼           └──→ 返回步骤 2
 发布
```texttext
┌─────────────────────────────────────────────────────────────┐
│              企业知识库问答智能体架构                            │
└─────────────────────────────────────────────────────────────┘

用户提问 ──→ 智能体（LLM）
                │
                ├──→ 工具 1：知识库检索（RAG）
                │       └── 向量数据库 → 返回相关文档
                │
                ├──→ 工具 2：数据库查询（Function Calling）
                │       └── SQL 数据库 → 返回结构化数据
                │
                └──→ 工具 3：网络搜索（Function Calling）
                        └── 搜索 API → 返回最新信息
```textpython
import json
from openai import OpenAI
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

client = OpenAI()

vectorstore = Chroma(
    collection_name="company_docs",
    embedding_function=OpenAIEmbeddings()
)

def execute_sql_safely(sql: str) -> str:
    normalized_sql = sql.strip().lower()
    if not normalized_sql.startswith("select"):
        return "安全策略拒绝：只允许 SELECT 查询。"

    # 真实项目中应在这里接入只读数据库连接，并加入参数化查询、超时和审计。
    return "这里返回只读 SQL 查询结果。"

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_knowledge_base",
            "description": "在企业知识库中检索相关文档",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "检索关键词"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "query_database",
            "description": "查询企业数据库获取结构化数据，如订单、客户信息等",
            "parameters": {
                "type": "object",
                "properties": {
                    "sql": {
                        "type": "string",
                        "description": "SQL 查询语句"
                    }
                },
                "required": ["sql"]
            }
        }
    }
]

def execute_tool(tool_name: str, arguments: dict) -> str:
    if tool_name == "search_knowledge_base":
        results = vectorstore.similarity_search(arguments["query"], k=3)
        return "\n\n".join([doc.page_content for doc in results])
    elif tool_name == "query_database":
        return execute_sql_safely(arguments["sql"])
    return "未知工具"

def run_agent(user_message: str, max_iterations: int = 5) -> str:
    messages = [{"role": "user", "content": user_message}]

    for _ in range(max_iterations):
        response = client.chat.completions.create(
            model="gpt-4.1",
            messages=messages,
            tools=tools
        )

        msg = response.choices[0].message

        if not msg.tool_calls:
            return msg.content

        messages.append(msg.model_dump(exclude_none=True))

        for tool_call in msg.tool_calls:
            result = execute_tool(
                tool_call.function.name,
                json.loads(tool_call.function.arguments)
            )
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "达到最大迭代次数，请尝试更具体的问题。"
```textjson
[
  {
    "id": "e2e_001",
    "input": "公司的年假政策是什么？",
    "expected_tool": "search_knowledge_base",
    "difficulty": "easy"
  },
  {
    "id": "e2e_002",
    "input": "上个月销售额最高的产品是什么？",
    "expected_tool": "query_database",
    "difficulty": "medium"
  },
  {
    "id": "e2e_003",
    "input": "对比我们产品和竞品的市场表现，给出分析报告",
    "expected_tools": ["search_knowledge_base", "query_database"],
    "difficulty": "hard"
  }
]