想象你经营着一座大型游乐场,有海盗船、过山车、旋转木马几十个项目。每天游客换了一拨又一拨,谁玩了什么、排队多久、哪个项目最受欢迎、哪个设备总出故障——如果只靠口口相传,你两眼一摸黑。于是你建了一间“智能监控室”:每个项目都装上了记录仪,游客一进一出、玩了多长时间、花了多少代币、体验如何,全都被清清楚楚写进台账。 PromptLayer 就是大模型应用里的这间“智能监控室”。你写的每一个提示词(Prompt)就像一位游客,它去大模型那儿“玩一圈”,输入了什么、输出了什么、用了多久、花了多少钱,PromptLayer 都帮你记下来。有了这本台账,你不再是蒙眼运营者,而是可以对着数据说话,把提示词一版一版地调优,让 AI 应用越来越聪明。

岗位关联

对 AI 从业者来说,PromptLayer 是把“玄学调参”变成“数据驱动”的关键工具。掌握它,你就能在提示词迭代、成本控制、故障排查中拥有全局视野,成为团队里最靠谱的 AI 应用工程师。

目录
  1. 可视化演示
  2. 初识监控室
  3. 核心功能
  4. 工作流程
  5. LangChain集成
  6. 版本管理
  7. 数据驱动优化
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

动态演示PromptLayer提示词的核心机制,通过基础/核心/应用/扩展四种模式展示关键概念与交互流程。

本节配有交互动效(进入视口后自动加载,约 3KB)。

PromptLayer提示词:Prom Prompt工程管理与版本控制 PromptLayer平台架构 核心机制可视化 PromptLayer提示词整体架构与关键组件

初识监控室

游乐场如果没有监控室,游客投诉“刚才海盗船等了四十分钟”时,你只能凭感觉辩解;有了监控记录,你能精确指出“那天下雨设备检修,确实延误了二十分钟”。大模型应用面临的困境一模一样:提示词是悄悄写给模型的“指令”,模型怎么理解、返回了什么、中间调了几次工具,传统打印日志里只有零散的一行行字,像撕碎的便签纸。

PromptLayer 就是那本整齐的“游客台账”。它把每一次大模型调用包装成一个可检索的事件,记录下“游客”从进门(输入提示词)到出门(拿到输出)的全过程。你可以按时间回放,按用户筛选,按模型对比——这是普通 print 日志做不到的。

调用链的追踪价值在于“串联”。一个复杂的 AI Agent 可能先让大模型决定下一步,再调用搜索工具,最后把结果汇总成回答。这中间每一步都通过 PromptLayer 串联成一条完整的“游玩路线”(调用链路)。当最终回答驴唇不对马嘴时,你能沿着路线找出是哪一步误导了模型。

回到游乐场的比喻:完整度越高,你越像一位盯着监控大屏的总指挥,任何角落的异常都逃不过你的眼睛。反之,如果一半调用没记录,出了问题就只能“拆监控找真相”了。

调用链完整度=已记录步骤数实际执行步骤数\text{调用链完整度} = \frac{\text{已记录步骤数}}{\text{实际执行步骤数}}
调用链完整度衡量你的监控覆盖了多少真实步骤。如果等于 1,说明监控无死角;小于 1,则有些调用像“黑户”一样消失了。
  1. 识别实际步骤统计一次完整 AI 任务中,模型推理、工具调用、外部 API 请求等确实发生了几步。
    实际执行步骤数=Nexec\text{实际执行步骤数} = N_{\text{exec}}
  2. 统计记录步骤查 PromptLayer 台账里,被你显式打点或自动捕获的调用数。
    已记录步骤数=Nlog\text{已记录步骤数} = N_{\text{log}}
  3. 计算比值用记录数除以实际数,得到覆盖比例。
    调用链完整度=NlogNexec\text{调用链完整度} = \frac{N_{\text{log}}}{N_{\text{exec}}}

核心功能

监控室的核心设备有哪几样?在 PromptLayer 里,“游客”的每一次游玩记录都被拆成几个关键字段:输入了什么(提示词全文)、输出了什么(模型回复全文)、排队多久(延迟)、花了几个代币(成本)、以及这个游客是从哪个入口进来的(请求来源与链路)。这就像游乐场的电子手环,记录着你几点入园、玩了几个项目、在哪个商店消费了。

输入输出记录是最基础但最有用的一层。有了它,你可以复现任何一次历史对话,而不需要用户重新操作一遍。当用户说“上次那个回答挺好的,帮我再生成一次”,你可以直接从台账里捞出发给模型的原文。

延迟与成本是运维者最关心的仪表盘。每次调用的耗时(以秒为单位)和消耗的 Token 数量、乘以单价,就是一次调用的费用。PromptLayer 还会帮你按月汇总,告诉你“这个月光是让模型聊天就烧了三千块”,这对控制预算至关重要。

这就像游乐场里每个项目单独收费:进门花 10 代币,玩项目再花 20 代币。看不见的 Token 费用因为有了监控,变成了明明白白的账单,你自然知道应该去砍哪个项目的成本。

单次调用成本=(Ninput×Pinput)+(Noutput×Poutput)\text{单次调用成本} = (N_{\text{input}} \times P_{\text{input}}) + (N_{\text{output}} \times P_{\text{output}})
一次调用的花费 = 输入 Token 数 × 输入单价 + 输出 Token 数 × 输出单价。输出通常比输入贵,因为它需要模型逐字生成。
  1. 统计输入 Token把提示词按模型的分词器切分成小块,数出总的输入 Token 数。
    Ninput=提示词的 Token 数N_{\text{input}} = \text{提示词的 Token 数}
  2. 统计输出 Token生成的回复同样切分,得到输出 Token 数。
    Noutput=回复的 Token 数N_{\text{output}} = \text{回复的 Token 数}
  3. 乘单价并求和两个 Token 数分别乘其单价,再相加。
    Cost=Ninput×Pinput+Noutput×Poutput\text{Cost} = N_{\text{input}} \times P_{\text{input}} + N_{\text{output}} \times P_{\text{output}}

工作流程

在游乐场搭监控室,第一步是装摄像头,第二步是布线,第三步才是坐进监控室看屏幕。PromptLayer 的使用也分三步走:注册账号拿钥匙(API Key)、把 SDK 装进代码、然后去网页控制台看报表。

注册并获取 API Key 就像去物业领门禁卡。你在 PromptLayer 官网建一个项目,系统会发给你一串专属密钥。这串密钥是你的“设备编号”,让 PromptLayer 知道日志该归到哪个账本下。注意:API Key 必须放在服务端环境变量里,绝不能写进前端代码,否则等于把监控室钥匙挂在门口。

SDK 日志上报是“布线”环节。在你的 Python 服务里安装 promptlayer 包,然后像普通 OpenAI 调用一样使用它。PromptLayer 会自动抓取请求和响应,打包成一条结构化日志,悄悄传到云端。你这边代码不用大改,只是把 import openai 换成 import promptlayer.openai。

最后是坐进控制台。网页面板上有时间线、表格、图表,按天/小时维度展示调用量、平均延迟、错误率。你可以输入一个关键词搜索某次对话,也可以按成本排序找出最贵的几条调用。就像监控室的几十块屏幕,一切尽收眼底。

布线质量决定监控可靠性。如果上报成功率只有 60%,那你的监控室一半屏幕是雪花点。所以接入后第一件事,不是看报表,而是先确认“摄像头全亮了”。

上报成功率=成功到达 PromptLayer 的日志数本应记录的调用总数×100%\text{上报成功率} = \frac{\text{成功到达 PromptLayer 的日志数}}{\text{本应记录的调用总数}} \times 100\%
上报成功率衡量日志传输的可靠性。网络抖动、SDK 配置错误都可能让日志丢包,所以这个指标要尽量逼近 100%。
  1. 统计应记录总数代码中所有经过 PromptLayer 包装的调用次数。
    Ntotal=所有被包装的调用N_{\text{total}} = \text{所有被包装的调用}
  2. 统计成功上报数PromptLayer 服务端实际收到的日志条数。
    Nsuccess=服务端收到的日志N_{\text{success}} = \text{服务端收到的日志}
  3. 计算百分比两者相除再乘 100%,得到可靠度。
    成功率=NsuccessNtotal×100%\text{成功率} = \frac{N_{\text{success}}}{N_{\text{total}}} \times 100\%

LangChain集成

现在很多 AI 应用不是直接调大模型,而是用 LangChain 这样的框架组装“流水线”:先检索文档,再让大模型思考,接着调工具,最后生成答案。这就像游乐场里的“综合项目”,游客要连着玩好几个设备。如果监控室只为单个设备布线,综合项目的完整过程就看不全了。

LangChain 的解决方案是“回调机制”(Callback)。你可以把 PromptLayer 注册成一个全局监听器,当 LangChain 内部发生“开始调用模型”“调用成功”“调用失败”等事件时,PromptLayer 会自动记录。这好比你在所有设备门口装上了感应器,游客走到哪一步都会“滴”一声,上传到监控中心。

配置步骤非常简单:先安装 langchain 和 promptlayer,然后设置环境变量,再把 PromptLayer 的 callback 对象传给 LangChain 的 callbacks 参数。两行代码,就能让 LangChain 的每一次模型调用、工具调用都自动上报。不需要手动在每个环节打点,监控室自己会“监听”。

集成收益在于“全链路透明”。你可以看到一条 Agent 任务从用户提问到最终回答,中间调用了哪几个模型、哪个工具、各自的耗时和成本。这就像监控室的“多画面回放”,把完整的游玩路线一帧帧展示。

有了 LangChain 的集成,你不必再猜“是不是工具调用太慢”这类问题。监控室会把慢动作回放给你看:原来卡在文档检索那一步,接下来就去优化检索策略——这就是集成带来的“办案效率”。

Ttotal=Tretrieval+Treasoning+Ttool+TgenerationT_{\text{total}} = T_{\text{retrieval}} + T_{\text{reasoning}} + T_{\text{tool}} + T_{\text{generation}}
总耗时是检索、推理、工具调用、生成四段耗时的总和。哪一段变慢,一眼就能从链路里揪出来。
  1. 分解各阶段耗时从调用链中提取每个环节的耗时值。
    Tretrieval,Treasoning,Ttool,TgenerationT_{\text{retrieval}}, T_{\text{reasoning}}, T_{\text{tool}}, T_{\text{generation}}
  2. 逐项求和把四个耗时相加,得到整体延迟。
    Ttotal=∑k=14TkT_{\text{total}} = \sum_{k=1}^{4} T_k

版本管理

提示词的迭代就像配方改良。今天觉得措辞不够专业,明天加一句“请用初中生能听懂的话解释”,后天又删掉一个形容词。如果没有记录,你根本不知道哪一版效果最好,甚至忘了“上一版是怎么写的”。PromptLayer 的版本管理就是配方的“留档本”,每次调用都会自动记录当时的 Prompt 内容,你还可以手动给某个版本打标签,比如 “v1.0 上线版”、“v1.1 修复幻觉版”。

版本记录让你可以回滚。当新版本效果变差,比如回答开始答非所问,你只需在控制台找到历史版本的 Prompt 内容,复制回来重新部署即可。这比在 git 里翻找 Prompt 文件更快,因为 Prompt 往往藏在代码深层,而 PromptLayer 直接给你看“当时发出去的那份原文”。

对比功能则像美食评论家的盲测。你把两个版本的 Prompt 放在一起,用同一批测试问题分别跑一遍,看哪一版的回答更符合标准。PromptLayer 支持对同一请求做多版本对比,输出逐条对照,帮你找出措辞差异导致的输出偏差。

版本管理的终极价值是“回归测试”。就像改良配方后要请老顾客回来试吃,确认没有砸招牌。你可以沉淀一批标准测试问题,每次改 Prompt 后自动批量跑一遍,用 PromptLayer 记录结果,对比是否变差。这样提示词优化就不再是“赌运气”,而是有据可循的工程实践。

J(A,B)=∣A∩B∣∣A∪B∣J(A, B) = \frac{|A \cap B|}{|A \cup B|}
Jaccard 相似度衡量两个 Prompt 版本的重合程度。如果值接近 1,说明改动很小;接近 0,说明几乎重写了。
  1. 把 Prompt 拆成集合将两版 Prompt 按词(Token)切分,各自转成集合。
    A={a1,a2,… },B={b1,b2,… }A = \{a_1, a_2, \dots\}, \quad B = \{b_1, b_2, \dots\}
  2. 求交集大小统计两版本共有多少相同词。
    ∣A∩B∣=相同词数量|A \cap B| = \text{相同词数量}
  3. 求并集大小统计两版本总共涉及的词数。
    ∣A∪B∣=全部去重词数量|A \cup B| = \text{全部去重词数量}
  4. 算比值交集除以并集,得到 0~1 的相似度。
    J(A,B)=∣A∩B∣∣A∪B∣J(A,B) = \frac{|A \cap B|}{|A \cup B|}

数据驱动优化

监控室最终不是为了摆着好看,而是指导运营。PromptLayer 汇集的调用数据,能帮你回答三个问题:我的提示词质量到底如何?怎么改才能更好?改完之后有没有真的变好?

质量指标是第一步。PromptLayer 支持给每次调用打标签,比如“用户是否点了赞”、“回答是否被采纳”。把这些反馈汇总,就能算出一个“好评率”。结合延迟和成本,你就有了一个多维度的质量画像。

有了评分,就可以做迭代实验:对同一问题,分别用 Prompt v1.1 和 v1.2 跑一批测试用例,对比两组的质量评分。哪版分数高就用哪版。这就像游乐场试运行两种排队方案,测一测哪种方案游客等待时间更短、满意度更高。

持续监控让优化闭环永动。上线新 Prompt 后,PromptLayer 继续收集真实用户的调用数据。如果质量评分忽然下滑,说明新版本可能有坑,立刻回滚。数据驱动优化的本质是“让每一次改动都留下证据”,而 PromptLayer 就是那个永不疲惫的取证员。

质量评分=w1×好评率−w2×平均延迟−w3×平均成本\text{质量评分} = w_1 \times \text{好评率} - w_2 \times \text{平均延迟} - w_3 \times \text{平均成本}
质量评分把积极反馈、延迟、成本加权组合成一个可比较的数值。权重 w 根据你的业务优先级自己定。
  1. 计算好评率统计标注为“好”的调用占比。
    好评率=NgoodNlabeled\text{好评率} = \frac{N_{\text{good}}}{N_{\text{labeled}}}
  2. 计算平均延迟与成本求出所有调用的平均耗时和平均花费。
    Lˉ=1n∑i=1nLi,Cˉ=1n∑i=1nCi\bar{L} = \frac{1}{n}\sum_{i=1}^{n}L_i, \quad \bar{C} = \frac{1}{n}\sum_{i=1}^{n}C_i
  3. 加权求和按业务目标分配权重并计算总分。
    Score=w1×好评率−w2×Lˉ−w3×Cˉ\text{Score} = w_1 \times \text{好评率} - w_2 \times \bar{L} - w_3 \times \bar{C}

AI 应用场景

AI客服团队的Prompt效果监控

阶段:Prompt 迭代优化、效果分析

解决的问题:客服 Prompt 改了十几版,却不知道哪版让用户满意度最高。传统方法靠人工抽查聊天记录,费时且主观。PromptLayer 自动记录每次客服回答的 Prompt 和结果,配合用户点“有用/无用”的反馈标签,量化出每版 Prompt 的满意度。

具体案例:某电商客服机器人接入 PromptLayer 后,团队发现 “v2.3“ 版本的回答虽然更礼貌,但”能否解决用户问题“的反馈评分反而下降。对比调用链发现,该版本过度强调共情,少了操作指引步骤。团队在 Prompt 中加入”最后请给出至少一步可执行操作”,评分回升 15%。

多模型选型的成本对比

阶段:模型选择、成本控制

解决的问题:团队在 GPT-4 和更便宜的国产模型之间犹豫。没有真实数据支撑,只能靠拍脑袋。PromptLayer 为每次调用记录模型名和成本,控制台可以按模型分组合计,直接生成“成本日报”。

具体案例:一家 SaaS 公司用 PromptLayer 追踪两周后,发现 70% 的调用其实是简单问答,用便宜模型完全够用;只有 30% 的复杂推理需要高端模型。他们据此配置了路由策略,总成本下降 52%,而用户满意度没有下降。

LangChain Agent 故障排查

阶段:调用链路追踪、问题定位

解决的问题:LangChain Agent 偶尔给出错误答案,却不知道是哪个环节出的问题。传统日志只有零散 print,无法拼接完整链路。PromptLayer 与 LangChain 的集成自动记录每个工具的输入输出。

具体案例:某金融问答 Agent 被用户投诉“推荐了不存在的理财产品”。排查时通过 PromptLayer 追踪发现,是金融产品检索工具在查询数据库时,把“保本型”错误地过滤掉了,导致推荐结果全是高风险产品。修复工具参数后,类似投诉清零。

Python 演示

python65 行
import timeimport functools  class PromptTracker:    """一个迷你版 PromptLayer:记录每次 Prompt 调用的输入、输出、耗时与估算成本。"""     def __init__(self):        self._logs = []     def _estimate_cost(self, text_in, text_out):        # 简化估算:每 4 个字符约 1 Token        tokens_in = len(text_in) // 4        tokens_out = len(text_out) // 4        price_in = 0.00003        price_out = 0.00006        return tokens_in * price_in + tokens_out * price_out     def track(self, func):        @functools.wraps(func)        def wrapper(*args, **kwargs):            prompt = kwargs.get("prompt", "")            start = time.time()            try:                result = func(*args, **kwargs)                error = None            except Exception as exc:                result = None                error = str(exc)            elapsed = time.time() - start            cost = self._estimate_cost(prompt, result or "")            log = {                "prompt": prompt,                "result": result,                "elapsed": round(elapsed, 4),                "cost": round(cost, 6),                "error": error            }            self._logs.append(log)            return result        return wrapper  def call_llm(prompt):    # 模拟一个简单的大模型调用    reply = "你好!这里是 AI 助手,你说的是:" + prompt[:20]    return reply  def main():    tracker = PromptTracker()    tracked_call = tracker.track(call_llm)     tracked_call(prompt="请介绍一下 PromptLayer")    tracked_call(prompt="帮我写一首关于月亮的小诗")    tracked_call(prompt="1+1 等于多少?")     print("调用次数:", len(tracker._logs))    for idx, entry in enumerate(tracker._logs, 1):        print(f"第{idx}次调用 | 耗时 {entry['elapsed']}s | "              f"成本 ${entry['cost']} | 输出: {entry['result'][:15]}...")  if __name__ == "__main__":    main()
目的:用一个迷你 PromptTracker 类演示 PromptLayer 的核心思想——自动记录每次调用的输入、输出、耗时和成本,为后续数据分析和优化积累台账。
  1. self._logs = []新建一个列表当作“监控台账”,每一条日志代表一次调用记录。
  2. def _estimate_cost用简化的 Token 估算方法,把字符数除以 4 近似 Token 数,再乘以单价计算成本。
  3. def track(self, func)一个装饰器工厂,它返回的 wrapper 函数会在目标调用前后自动打点。
  4. start = time.time()调用前记录当前时间,作为本次调用的“起点”。
  5. @functools.wraps(func)保留原函数的名字和文档,避免装饰器污染函数元信息。
  6. self._logs.append(log)把完整的调用信息(输入、输出、耗时、成本、错误)追加到台账列表里。

常见误区

误区我用了 PromptLayer,感觉它就是一个好看点的日志系统,想看分析图表还是得自己写代码统计。

正解PromptLayer 提供了筛选、聚合、成本汇总、延迟趋势、版本对比等内置分析能力。你可以在控制台按模型、按用户、按时间范围分组统计,也可以把数据导出到自己的 BI 工具做进一步挖掘。它不只是“存储日志”,更像一个带仪表盘的监控室,而不是单纯的录像带仓库。

为何常见:初学者往往只用了最基础的“记录调用”功能,没有探索面板上的筛选器和图表,误以为它没有分析能力。

误区PromptLayer 每次都要 HTTP 上报日志,肯定会让我的接口变慢,干脆不接或者只记录部分请求。

正解PromptLayer 的 SDK 是异步上报的,调用会先返回给用户,日志在后台线程发送。实际延迟影响通常在毫秒级别。你还可以用采样率配置,比如只记录 10% 的请求。相比之下,丢失一份日志导致问题排查的代价,远大于这份日志的上报耗时。

为何常见:人们容易把“上报日志”和“同步写数据库”混为一谈,其实正规工具的日志上报都是设计成低侵入的。

误区我的 Prompt 都在代码仓库里,每次改动有 git 记录,为什么还需要 PromptLayer 的版本管理?

正解git 记录的是“代码里写的 Prompt”,而 PromptLayer 记录的是“真实发送给模型的 Prompt”。这两者可能不一致——因为代码中可能有拼接、模板渲染、用户输入注入。当线上行为异常时,你需要的是“当时实际发出去的那份”,而不是仓库里那份静态代码。

为何常见:初学者以为 Prompt 就是代码里的字符串常量,忽略了动态构建和运行时变化。

误区既然数据都在了,那我的 Prompt 就会自动变好,团队不用再开会讨论怎么改了。

正解PromptLayer 是“增强你的观察力”,而不是“替代你的思考”。它提供数据告诉你哪些 Prompt 表现差、哪里慢了、哪里贵了,但如何改写 Prompt、如何设计实验,仍然需要人脑去分析。它像显微镜,帮你看到细菌,但治病还得靠医生开药方。

为何常见:工具给人的错觉是“用了就能变好”,实际上任何分析工具都只是决策支持,不是决策本身。

误区PromptLayer 面板上显示的费用就是我的全部成本,照着这个数控制预算就行。

正解控制台金额只统计了“经过 PromptLayer 上报的调用”。如果你有部分代码没接入 SDK、绕过了追踪,这部分成本就是“隐形消费”。而且总金额是原始 Token 费用,没算上 PromptLayer 自身的服务费(如有)以及其他基础资源费用。所以要把面板数字和实际账单对照,确认上报完整度。

为何常见:人们容易信任仪表盘上的数字,忽略了“统计口径”和“覆盖率”对数据真实性的影响。

面试题

Q1. PromptLayer 的核心定位是什么?

单选题 · easy

  • A.一个提示词自动生成器
  • B.一个提示词调用追踪与分析平台← 正确答案
  • C.一个替代大模型的推理引擎
  • D.一个数据标注专用工具

答案:B。PromptLayer 的本质是“监控室”,记录每次提示词调用的输入输出、延迟、成本等信息,供分析和优化。它不生成提示词,也不替代模型,更不是数据标注工具,所以 B 正确。

Q2. 在 PromptLayer 中,“调用链追踪”主要解决什么问题?

单选题 · easy

  • A.让代码运行得更快
  • B.把一次任务的多个步骤串联起来,便于定位问题环节← 正确答案
  • C.自动修复模型输出的错误
  • D.减少 Prompt 的 Token 消耗

答案:B。调用链追踪像“游玩路线回放”,把 Agent 的检索、推理、工具调用、生成等步骤串联成一条完整链路。当最终回答出错时,你能沿着链路找到是哪个步骤出了问题。它不直接提升速度或修复错误。

Q3. 计算单次大模型调用成本时,下列哪个公式正确?

单选题 · mid

  • A.输出 Token 数 × 输入单价
  • B.输入 Token 数 × 输出单价
  • C.输入 Token 数 × 输入单价 + 输出 Token 数 × 输出单价← 正确答案
  • D.输入和输出 Token 数之和 × 输入单价

答案:C。成本 = 输入 Token 数 × 输入单价 + 输出 Token 数 × 输出单价。输入和输出分别计费,且单价通常不同,输出一般更贵。因此 C 正确,其余选项要么算错单价,要么漏掉一部分费用。

Q4. LangChain 集成 PromptLayer 时,主要利用了什么机制实现自动上报?

单选题 · mid

  • A.多线程并发调用
  • B.回调机制(Callback)← 正确答案
  • C.数据库事务
  • D.反向代理服务器

答案:B。LangChain 的执行过程会触发各类事件,PromptLayer 通过注册回调监听这些事件,自动记录模型调用和工具调用。这就像在设备门口装感应器,人一经过就自动“滴”一声。多线程、事务、代理都不是 LangChain 与 PromptLayer 对接的机制。

Q5. 在 PromptLayer 中给 Prompt 版本打标签的主要目的是什么?

单选题 · mid

  • A.让 Prompt 占用更多存储空间
  • B.方便在代码中引入报错
  • C.便于后续按版本对比效果并快速回滚← 正确答案
  • D.让模型强制采用指定输出格式

答案:C。版本打标签相当于给配方命名,你可以快速定位“v1.0 上线版”和“v1.1 新版”,对比两者效果,发现异常时一键回滚。标签不影响模型行为,也不涉及存储和报错。

Q6. 关于 Jaccard 相似度,下面哪种说法正确?

单选题 · mid

  • A.值越接近 1,表示两个 Prompt 版本差异越大
  • B.值越接近 0,表示两个 Prompt 版本几乎相同
  • C.值越接近 1,表示两个 Prompt 版本重合度越高← 正确答案
  • D.它只能用于计算数值,不能用于文本

答案:C。Jaccard 相似度 = 交集大小 / 并集大小,值越接近 1 说明两版 Prompt 共有的词越多,改动越小;越接近 0 说明几乎重写。它同样可应用于文本集合,因此 C 正确。

Q7. 使用 PromptLayer SDK 时,API Key 应该存放在哪里?

单选题 · easy

  • A.前端 JavaScript 代码中
  • B.服务端环境变量中← 正确答案
  • C.公开的 GitHub 仓库中
  • D.用户浏览器的 localStorage 中

答案:B。API Key 是监控室的“门禁卡”,不能暴露给用户。必须放在服务端环境变量里,通过后端代码调用。放在前端或公开仓库会让任何人偷走你的钥匙,产生盗刷费用和隐私泄露风险。

Q8. PromptLayer 可以记录下列哪些信息?

多选题 · mid

  • A.每次调用的输入提示词← 正确答案
  • B.模型返回的输出内容← 正确答案
  • C.调用的延迟时间← 正确答案
  • D.调用的 Token 成本和链路信息← 正确答案

答案:ABCD。PromptLayer 的核心功能就是完整记录调用记录:输入、输出、延迟、成本、链路元数据,全部都有。这四个选项都是它记录的对象,因此全选。

Q9. 关于 PromptLayer 的“回归测试”,正确的说法有哪些?

多选题 · hard

  • A.需要用同一批测试问题分别运行新旧版本← 正确答案
  • B.可以在控制台对比两版输出结果← 正确答案
  • C.回归测试可以完全替代线上真实用户反馈
  • D.回归测试能帮助发现 Prompt 改动导致的输出退化← 正确答案

答案:ABD。回归测试就是“请老顾客回来试吃”,用固定测试集跑新旧版本,对比输出是否退化,控制台支持逐条对照,因此 A、B、D 正确。但回归测试不能覆盖所有真实场景,不能完全替代线上反馈监测,C 错误。

Q10. 下列哪些属于 PromptLayer 带来的实用价值?

多选题 · easy

  • A.快速排查一次糟糕回答出在哪个调用环节← 正确答案
  • B.按月汇总所有调用成本辅助预算控制← 正确答案
  • C.自动重写提示词并保证效果提升
  • D.支持 LangChain 等框架的全链路透明← 正确答案

答案:ABD。A、B、D 分别是调用链追踪、成本分析和框架集成的直接价值。C 错误——PromptLayer 只负责“记录与展示”,不会自动重写你的提示词,优化动作还是由人来做。