大模型开发核心概念解析

发表于2026-05-26|更新于2026-05-30|大模型基础知识

|浏览量:

大模型开发核心概念解析 —— Harness、Prompt、LLM、Agent、Context 到底是什么？

前言

刚开始接触大模型开发时，各种术语扑面而来：LLM、Prompt、Agent、RAG、Fine-tuning、Context、Harness……

这些概念分别是什么意思？它们各自解决什么问题？它们之间的关系是什么？从零搭建一个大模型应用时，哪些是必须的？

这篇文章帮你一次性理清楚。

1. 大模型应用的整体架构

在深入每个概念前，先用一张图建立整体认识：

┌─────────────────────────────────────────────────────┐
│                   用户输入                           │
└─────────────────┬───────────────────────────────────┘
                  ▼
┌─────────────────────────────────────────────────────┐
│  Harness（框架层）                                    │
│  ┌─────────────┐  ┌──────────┐  ┌───────────────┐  │
│  │ Prompt 管理  │  │ 工具调用  │  │ 上下文管理     │  │
│  │ (模板/组装)  │  │ (函数调用)│  │ (窗口/摘要)   │  │
│  └──────┬──────┘  └────┬─────┘  └───────┬───────┘  │
│         │              │                │           │
│  ┌──────┴──────────────┴────────────────┴───────┐  │
│  │              Agent（代理层）                    │  │
│  │  思考 → 行动 → 观察 → 循环                    │  │
│  └──────────────────────┬───────────────────────┘  │
│                         │                           │
│  ┌──────────────────────┴───────────────────────┐  │
│  │      Context（上下文窗口）                     │  │
│  │  ┌──────┐┌───────┐┌──────┐┌───────┐        │  │
│  │  │系统指令││用户消息││工具结果││历史对话│        │  │
│  │  └──────┘└───────┘└──────┘└───────┘        │  │
│  └──────────────────────┬───────────────────────┘  │
│                         │                           │
│  ┌──────────────────────┴───────────────────────┐  │
│  │          LLM（推理核心）                       │  │
│  │     ┌──────────────────────────┐             │  │
│  │     │    GPT / Claude /       │             │  │
│  │     │    LLaMA / Qwen ...     │             │  │
│  │     └──────────────────────────┘             │  │
│  └──────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘
                  ▼
              输出结果

核心观点：LLM 是大脑，Prompt 是指挥棒，Context 是短期记忆，Agent 是自主行动的手脚，Harness 是整合一切的框架。

2. LLM —— 大脑

2.1 是什么

LLM = Large Language Model，大型语言模型。

它是整个大模型应用的核心引擎。你可以把它理解为一个超级强大的文本生成器——它接受了海量文本的训练（整个互联网级别的数据），学会了语言模式、知识、推理能力。

2.2 常见的 LLM

模型	厂商	特点
GPT-4 / GPT-4o	OpenAI	综合能力强，生态成熟
Claude 3.5 / 4	Anthropic	长上下文、安全对齐好
LLaMA 3 / 3.1	Meta	开源，可本地部署
Qwen 2.5	阿里	中文能力强，开源
DeepSeek V3/R1	深度求索	推理能力强，性价比高
Gemini	Google	多模态能力强
Mistral	Mistral AI	开源，效率高

2.3 LLM 能做什么

文本生成：写文章、写代码、写邮件
理解与推理：回答问题、分析文档、逻辑推理
翻译与总结：跨语言翻译、长文本提炼
代码生成：根据描述生成代码、Debug
对话：多轮交互、角色扮演

2.4 LLM 的局限性（为什么不能只用 LLM？）

局限	说明	解决方案
知识截止	训练数据有截止日期，不知道最新信息	RAG（检索增强生成）
幻觉	会”自信地”编造不存在的知识	外挂知识库验证
无记忆	每次调用是独立的，记不住之前说过什么	Context 管理
无行动能力	只能”说”不能”做”，没法操作数据库/发邮件	Agent + 工具调用
上下文有限	一次能处理的 token 数量有限（4K~200K）	Context 策略（摘要、滑动窗口）
成本	每次调用都花钱，尤其长文本	Prompt 优化、缓存

2.5 一句话理解

LLM 是一个极其聪明的”大脑”，但它没有手脚、没有记忆、不知道今天几号。你需要围绕它搭一套系统才能让它真正干活。

3. Prompt —— 指挥棒

3.1 是什么

Prompt 是你给 LLM 的指令文本。它决定了 LLM 以什么角色、什么方式、什么格式来回答。

Prompt = 你告诉 LLM 的话 + 你希望 LLM 怎么回答的方式

3.2 Prompt 的构成

一个完整 Prompt 通常包含这些部分：

┌─────────────────────────────────────────┐
│  System Prompt（系统指令）               │
│  你是一个专业的Python开发者……           │
├─────────────────────────────────────────┤
│  User Message（用户消息）               │
│  请帮我写一个函数，实现……               │
├─────────────────────────────────────────┤
│  Few-shot Examples（示例）              │
│  例如：输入"xxx"，输出"yyy"            │
├─────────────────────────────────────────┤
│  Constraints（约束条件）                │
│  只用标准库，不要第三方依赖             │
├─────────────────────────────────────────┤
│  Output Format（输出格式）              │
│  以JSON格式返回：{"code": "...", ...}   │
└─────────────────────────────────────────┘

3.3 Prompt 为什么重要

LLM 的能力上限是模型决定的，但能不能发挥出这个上限，100% 取决于 Prompt。

同一个 LLM，不同 Prompt 的效果天差地别：

❌ 差 Prompt：
  "帮我写个爬虫"

✅ 好 Prompt：
  "你是一个有10年经验的Python爬虫工程师。
   请用Python 3.11+编写一个异步爬虫，
   目标网站是xxx，需要处理反爬机制。
   要求：使用aiohttp，错误重试3次，
   结果保存为JSON文件。
   先列出设计思路，再给出完整代码。"

3.4 Prompt Engineering 的核心技巧

技巧	说明	示例
角色设定	给 LLM 一个专业身份	“你是一个资深律师”
具体明确	越具体越好，不要模糊	“用Markdown表格列出” 而非 “列出来”
分步骤	让 LLM 一步步思考	“先分析，再给出结论”
给示例	Few-shot 示例效果极好	“输入A→输出B，输入C→输出D”
约束条件	明确告诉 LLM 不要做什么	“不要使用正则表达式”
输出格式	规定输出结构	“用JSON格式返回”
思维链	引导 LLM 展示推理过程	“让我们一步步思考”

3.5 System Prompt vs User Prompt

	System Prompt	User Prompt
作用	设定行为准则、角色、全局约束	具体任务、问题
可见性	用户通常看不到/不能改	用户输入的内容
优先级	通常在 User Prompt 之前	在 System Prompt 之后
例子	“你是一个乐于助人的助手”	“帮我写一篇文章关于……”

3.6 一句话理解

Prompt 是你指挥 LLM 的”遥控器”。同样的模型，不同的 Prompt 可以是一个”弱智”也可以是一个”专家”。

4. Context —— 短期记忆

4.1 是什么

Context（上下文）是 LLM 在本次对话中”看到”的全部内容。它包括系统指令、历史对话、用户输入、工具调用的结果等。

Context = LLM 在当前请求中能”看到”的所有文本

4.2 Context 的构成

Context = 系统指令 + 历史对话 + 用户当前输入 + 检索到的知识 + 工具调用结果

         ┌─────────────────────────────────────┐
         │  1. System Prompt (固定)            │ ◄── 行为准则
         ├─────────────────────────────────────┤
         │  2. 历史对话 (不断增长)              │ ◄── 多轮记忆
         │     Q: 昨天你提到了什么？            │
         │     A: 我提到了关于Python的事情     │
         ├─────────────────────────────────────┤
         │  3. 检索到的知识 (RAG结果)           │ ◄── 外挂知识
         │     [知识] Python是Guido van Rossum  │
         │     在1989年创造的……               │
         ├─────────────────────────────────────┤
         │  4. 工具调用结果                     │ ◄── 实时数据
         │     当前天气：北京 25°C 晴           │
         ├─────────────────────────────────────┤
         │  5. 用户当前输入                     │ ◄── 本次问题
         │     今天需要穿外套吗？               │
         └─────────────────────────────────────┘

4.3 Context Window（上下文窗口）

Context Window 是 LLM 一次能处理的最大 token 数量。不同模型的范围：

模型	Context Window
GPT-3.5	4K ~ 16K tokens
GPT-4	8K ~ 32K tokens
GPT-4o	128K tokens
Claude 3.5 Sonnet	200K tokens
Claude 4	200K tokens
Gemini 1.5 Pro	1M ~ 2M tokens
LLaMA 3	8K ~ 128K tokens
DeepSeek V3	128K tokens

4.4 Context 管理的挑战

当对话不断变长，Context 迟早会超出窗口限制。常用的策略：

策略一：滑动窗口

对话轮次:  1  2  3  4  5  6  7  8  9 10
            ┌────────────────────────┐
窗口位置:   │  5  6  7  8  9 10     │  ← 只保留最近的 N 轮
            └────────────────────────┘
旧的对话被丢弃

优点：简单、开销低
缺点：丢失了早期的重要信息

策略二：摘要压缩

对话轮次:  1  2  3  4  5  6  7  8  9 10
                ↓
           摘要化: "用户问了Python和JWT相关的问题"
                ↓
   [摘要][7  8  9 10]    ← 摘要 + 最近几轮

优点：保留要点，节省空间
缺点：摘要过程也消耗 token，且可能丢失细节

策略三：结构化记忆

1 2	短期记忆（窗口内）：最后 N 轮对话的完整内容长期记忆（向量库）：重要信息的持久化存储（通过 RAG 检索）

优点：兼顾近期细节和长期知识
缺点：架构复杂

4.5 Context 与 Token 成本

LLM 是按 token 计费的，而且 Context 越长，成本越高（因为 LLM 需要”阅读”所有输入才能生成回答）。

以 GPT-4o 为例（假设价格）：
  Context 1000 tokens → 一次回答成本 ≈ $0.005
  Context 10000 tokens → 一次回答成本 ≈ $0.05
  Context 50000 tokens → 一次回答成本 ≈ $0.25

所以 Context 管理不仅是技术问题，也是成本问题。

4.6 一句话理解

Context 是 LLM 的”工作台面”——台面越大能放的东西越多，但每多放一件东西你都要付钱。你需要聪明地决定放什么、扔掉什么。

5. Agent —— 自主行动的躯干

5.1 是什么

Agent（智能体/代理）是一个能自主思考、规划、执行行动的 AI 系统。它不仅仅是被动地回答你的问题，而是能：

理解目标：你给它一个目标（”帮我订一张去北京的机票”）
制定计划：思考需要做哪些步骤
执行行动：调用工具（查询航班、比价、下单）
观察结果：看工具返回了什么
调整策略：如果失败了，重试或换方案
循环直到完成

5.2 ReAct 模式 —— Agent 的核心工作方式

Agent 最经典的实现模式叫 ReAct（Reasoning + Acting，推理 + 行动）：

循环：
  1. Thought（思考）：下一步需要做什么？
  2. Action（行动）：调用某个工具
  3. Observation（观察）：工具返回了什么结果
  4. 回到 1，直到得到最终答案

举例：

用户: "北京的天气怎么样，适合穿什么衣服？"

Thought: 用户想知道北京的天气，我需要先查天气信息
Action: 调用 get_weather(city="北京")
Observation: 返回 "北京 25°C，晴"

Thought: 25°C是温暖天气，适合穿短袖或薄长袖
Action: 调用 get_clothing_advice(temp=25, condition="晴")
Observation: 返回 "建议穿短袖T恤、薄外套"

Thought: 我现在有完整答案了，可以回复用户
Final Answer: "北京今天25°C，晴，体感舒适。
              建议穿短袖T恤，早晚加一件薄外套。"

这种思考-行动-观察-再思考的循环，就是 Agent 区别于普通 LLM 调用的核心特征。

5.3 Tool Use（工具调用）—— Agent 的手脚

Agent 之所以能”做事”，靠的是工具（Tools / Function Calling）。

常见的工具类型：

工具类型	例子	解决什么问题
搜索引擎	web_search()	LLM 知识截止，无法知道最新信息
代码执行器	run_python()	LLM 只能给出代码，不能运行验证
数据库查询	query_db(sql)	LLM 不能直接访问数据库
文件操作	read_file() / write_file()	LLM 不能读写文件
API 调用	call_api(url, data)	LLM 不能访问外部服务
计算器	calculate(expr)	LLM 做数学题可能出错，用计算器保证正确

5.4 Agent 的类型

类型	说明	适用场景
单 Agent	一个 LLM 负责所有思考和行动	简单任务
多 Agent	多个 Agent 协作（主管分配任务给专员）	复杂任务
Orchestrator Agent	一个调度 Agent + 多个子 Agent	企业内部流程自动化
ReAct Agent	思考-行动-观察循环	通用场景
Plan-and-Execute Agent	先规划再执行	需要长周期规划的任务

5.5 Agent 的挑战

挑战	说明	应对
循环失控	Agent 可能无限循环	设置最大迭代次数
幻觉传播	错误的工具调用结果被当作事实	结果的验证和交叉检查
成本不可控	多次 LLM 调用导致高费用	设置预算上限
安全风险	Agent 可能执行危险操作	权限隔离、人工审核
鲁棒性	一个中间步骤失败可能让整个任务失败	重试机制、异常处理

5.6 一句话理解

Agent 让 LLM 从”只会说”变成”既能说又能做”。它自己思考、自己调用工具、自己根据结果调整下一步，像一个有大脑的机器人。

6. Harness —— 缰绳与缰绳架

6.1 是什么

Harness 直译是”马具/缰绳”，在大模型开发中，它指的是架子/框架/编排层——把所有组件（LLM、Prompt、Context、Agent、工具）整合起来的东西。

如果你用过以下框架，你已经接触过 Harness 了：

LangChain — 最流行的大模型开发框架
LlamaIndex — 专注数据索引和 RAG
Dify — 可视化大模型应用平台
AutoGen — 微软的多 Agent 框架
CrewAI — 多 Agent 协作框架
Semantic Kernel — 微软的大模型编排框架
Haystack — 搜索和 RAG 框架
Vercel AI SDK — 前端友好的 AI 开发工具包

6.2 Harness 解决什么问题

如果不使用 Harness，你需要自己处理大量繁琐工作：

非 Harness 方式（手写）	Harness 方式
手动拼接 URL 调用 LLM API	一行代码 `llm.invoke(prompt)`
自己写 Context 窗口管理	内置上下文管理策略
手动解析 JSON 格式的工具调用	自动解析和执行工具调用
自己实现 Agent 的 ReAct 循环	内置 Agent 执行器
自己写 Prompt 模板	模板引擎 + 变量注入
自己管理对话历史	内置 Memory 模块
自己写 RAG 流程	内置向量库 + 检索链

6.3 Harness 的核心职责

┌────────────────────────────────────────┐
│            Harness (框架层)             │
├────────────────────────────────────────┤
│ 1. LLM 管理                            │
│    - 多模型切换                        │
│    - 重试/降级策略                     │
│    - API 密钥管理                       │
├────────────────────────────────────────┤
│ 2. Prompt 管理                          │
│    - 模板引擎                          │
│    - 变量注入                          │
│    - 版本管理                          │
├────────────────────────────────────────┤
│ 3. Context 管理                         │
│    - 滑动窗口                          │
│    - 摘要压缩                          │
│    - Token 计数                        │
├────────────────────────────────────────┤
│ 4. Agent 编排                           │
│    - ReAct 循环                        │
│    - 工具注册与调度                    │
│    - 任务队列                          │
├────────────────────────────────────────┤
│ 5. 工具系统                             │
│    - 函数定义转换                      │
│    - 结果解析                          │
│    - 错误处理                          │
├────────────────────────────────────────┤
│ 6. 持久化                               │
│    - 会话存储                          │
│    - 向量数据库集成                    │
│    - 缓存                              │
├────────────────────────────────────────┤
│ 7. 可观测性                             │
│    - Token 统计                        │
│    - 调用链追踪                       │
│    - 性能监控                          │
└────────────────────────────────────────┘

6.4 LangChain 示例 —— 最流行的 Harness

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationBufferMemory

# 1. 初始化 LLM
llm = ChatOpenAI(model="gpt-4o")

# 2. 定义工具
@tool
def get_weather(city: str) -> str:
    """查询一个城市的当前天气"""
    # 调用天气 API...
    return f"{city} 25°C，晴"

# 3. 配置 Prompt 模板
prompt = PromptTemplate.from_template(
    "你是一个专业的天气助手。\n"
    "{chat_history}\n"
    "用户问题: {input}\n"
    "工具: {tools}\n"
    "请用 {agent_scratchpad} 来思考"
)

# 4. 创建 Agent
agent = create_react_agent(
    llm=llm,
    tools=[get_weather],
    prompt=prompt
)

# 5. 创建执行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=[get_weather],
    memory=ConversationBufferMemory(),
    max_iterations=5,      # 防止无限循环
    verbose=True           # 显示思考过程
)

# 6. 执行
result = agent_executor.invoke({"input": "北京的天气怎么样？"})

看到没？ 使用 Harness，只需要几十行代码就能搭建一个完整的 Agent 系统。

6.5 一句话理解

Harness 是大模型应用的”脚手架”——它把 LLM、Prompt、Context、Agent、工具全部串联起来，让你不用从零造轮子。

7. 其他重要概念

7.1 RAG（Retrieval-Augmented Generation）

是什么：检索增强生成。让 LLM 在回答前先去知识库检索相关文档。

1	用户提问 → 检索知识库 → 找到相关文档 → 文档 + 问题一起放入 Context → LLM 回答

解决什么问题：LLM 不知道私有数据、不知道最新信息、会胡编乱造。

核心流程：

1
2
3

1. 文档 → 切分 → 向量化 → 存入向量数据库
2. 用户提问 → 向量化 → 向量数据库中搜索相似内容
3. 找到的内容 + 用户问题 → 放入 Context → LLM 生成回答

7.2 Fine-tuning（微调）

是什么：在预训练好的 LLM 基础上，用你自己的数据继续训练，让模型”学会”特定领域的知识或风格。

对比 Prompt vs RAG vs Fine-tuning：

	Prompt 工程	RAG	Fine-tuning
需要训练	❌ 不需要	❌ 不需要	✅ 需要
数据要求	写几个例子	准备文档库	大量标注数据
更新时效	改 Prompt 即可	更新知识库即可	重新训练
改变模型行为	❌ 有限	❌ 不改变	✅ 深度改变
适用场景	大多数情况	知识密集型任务	特定风格/格式
成本	低	中	高

7.3 Token

是什么：LLM 处理文本的最小单位。它不是字母也不是单词，而是一个”词块”。

1 2	"Hello, world!" → ["Hello", ",", " world", "!"] → 4个 tokens "你好，世界！" → ["你好", "，", "世界", "！"] → 4个 tokens

为什么重要：

LLM 按 token 计费（输入 + 输出）
Context Window 限制也是按 token 算
中文约 1.5~2 个字符 ≈ 1 token
英文约 0.75 个单词 ≈ 1 token

7.4 Temperature

是什么：控制 LLM 输出的随机性/创造性的参数。

Temperature	效果	适用场景
0.0 ~ 0.2	确定性强，每次都选最可能的词	代码生成、数学计算、事实问答
0.3 ~ 0.7	适度多样性	一般对话、翻译
0.8 ~ 1.0	高创造性，每次回答不同	创意写作、头脑风暴
> 1.0	极高随机性，可能胡言乱语	极少使用

7.5 Embedding（向量嵌入）

是什么：将文本转换为一串数字（向量），让计算机能计算文本之间的”相似度”。

1
2
3

"猫"     → [0.23, -0.45, 0.67, 0.12, ...]  (768维向量)
"狗"     → [0.21, -0.42, 0.65, 0.15, ...]  (与"猫"的向量相似度高)
"汽车"   → [-0.12, 0.33, -0.56, 0.78, ...] (与"猫"的向量相似度低)

用在哪儿：RAG 中的”相似搜索”全靠 Embedding。

8. 它们如何协同工作

用一个真实场景来展示所有概念如何配合：

场景：企业智能客服

1	用户发来消息："我的订单 #12345 还没到货，帮我查一下"

Step 1: Harness 接收请求

1	# LangChain (Harness) 接收到用户消息

Step 2: Context 组装

Context = {
    System:  "你是某电商的客服助手，专业、有礼貌"
    History: [用户之前的对话...]
    Input:   "我的订单 #12345 还没到货，帮我查一下"
}

Step 3: Prompt 放入 Context

1
2
3

问：用户关于订单的问题
要求：先查订单信息，再做回答
输出格式：结构清晰，有订单状态和预计到达时间

Step 4: Agent 开始工作

Thought: 用户想知道订单状态，我需要查订单系统
Action:  调用 query_order(order_id="12345")
Observation: {"status": "运输中", "预计到达": "2026-05-27"}

Thought: 订单在运输中，明天到达。还需要查物流详情吗？
Action:  调用 get_logistics(order_id="12345")
Observation: "包裹已到达北京分拣中心"

Thought: 信息够了，可以给用户回复了
Final Answer: "您的订单 #12345 目前运输中，
              已到达北京分拣中心，预计明天(5月27日)到达。
              请您留意查收。"

Step 5: LLM 生成最终回答

1 2	LLM 接收完整的 Context（含 Prompt、历史、工具结果） → 生成最终的自然语言回答

Step 6: Harness 管理输出

1
2
3

- 统计本次调用的 token 消耗
- 将本次对话存入历史
- 返回结果给用户

协同关系总结

               ┌──────────┐
               │  用户输入 │
               └────┬─────┘
                    ▼
          ┌─────────────────┐
          │   Harness       │ ←── 总管全局
          │   (LangChain)   │
          └────┬────────────┘
               │
     ┌─────────┼─────────┐
     ▼         ▼         ▼
┌────────┐┌────────┐┌────────┐
│Prompt  ││Context ││Agent   │
│管理    ││管理    ││编排    │
└───┬────┘└───┬────┘└───┬────┘
    │         │         │
    └─────────┼─────────┘
              ▼
         ┌────────┐
         │  LLM   │ ←── 核心引擎
         └───┬────┘
              ▼
         ┌────────┐
         │  输出  │
         └────────┘

9. 总结与脑图

一条完整的大模型开发链路

从一个想法开始 →

① 选一个 LLM（大脑）
  ↳ GPT-4o / Claude / 开源模型

② 写 Prompt（指挥棒）
  ↳ 角色设定 + 任务描述 + 约束条件

③ 设计 Context 策略（短期记忆）
  ↳ 窗口大小？摘要策略？Memory 组件？

④ 如果需要实时/外部信息，加 RAG
  ↳ 向量数据库 + 检索逻辑

⑤ 如果需要执行操作，加 Agent（手脚）
  ↳ Tool 定义 + ReAct 循环

⑥ 选一个 Harness 框架（脚手架）
  ↳ LangChain / LlamaIndex / 自建

⑦ 调试、优化、迭代
  ↳ Token 追踪、Prompt 调优、异常处理

核心概念一句话记忆

概念	一句话
LLM	超级聪明的大脑，但没有手脚和记忆
Prompt	指挥 LLM 的遥控器，决定 LLM 怎么回答
Context	LLM 的短期工作台，里面放着它当前能看到的所有信息
Agent	让 LLM 从”只会说”变成”会做”，自主思考→行动→观察循环
Harness	把上面所有东西串起来的脚手架，不用从零造轮子
RAG	给 LLM 配一个知识库，让它能查资料再回答
Fine-tuning	训练 LLM 变成某个领域的专家
Token	LLM 世界的”字数”，也是计费单位
Temperature	控制 LLM 脑洞大小的旋钮
Embedding	把文字翻译成数字，让计算机理解语义相似度

如何继续深入学习

上手实操：用 LangChain 搭一个简单的 RAG 应用
深入框架：读 LangChain / LlamaIndex 的源码
Agent 模式：研究 ReAct、Plan-and-Execute、Multi-Agent 等模式
Prompt 工程：学习 Chain-of-Thought、Tree-of-Thought 等高级技巧
生产化：学习监控、缓存、降级、A/B 测试等生产级最佳实践

写在最后：大模型开发本质上是一种”新编程范式”——你不再用代码精确控制每一步逻辑，而是用 Prompt 和框架来”引导”一个聪明的模型完成任务。理解每个组件的作用和配合方式，是构建可靠 AI 应用的第一步。希望这篇文章帮你织起了一张完整的概念网。

文章作者: 望

文章链接: https://m42-orion.github.io/2026/05/26/%E5%A4%A7%E6%A8%A1%E5%9E%8B%E5%BC%80%E5%8F%91%E6%A0%B8%E5%BF%83%E6%A6%82%E5%BF%B5%E8%A7%A3%E6%9E%90-Harness-Prompt-LLM-Agent-Context/

LLM 大模型 Agent Prompt AI开发