如果你正在准备2026年的大模型面试，或者正在构建一个复杂的AI Agent应用，那么你很可能面临一个核心困境：如何证明你的Agent不只是“看起来能跑”，而是真正可靠、可观测、可评估的？

面试官不会只问你“LangChain是什么”，他们会追问：“你的Agent在真实场景下调用链路的耗时分布是怎样的？”“如何量化评估RAG系统的回答质量？”“当Agent陷入循环时，你怎么发现并干预？”这些问题背后，考察的是你对大模型应用工程化的深度理解。

传统的开发模式是“写代码 -> 跑起来 -> 看日志”。但在Agent、RAG这类非确定性系统中，这远远不够。你需要一套完整的**可观测性（Observability）和评估（Evaluation）**体系。这正是Langfuse、LangChain、LangGraph等技术栈组合要解决的核心问题。

本文将从一个面试官和资深开发者的双重视角，为你系统梳理这套技术栈。我们不止于回答“是什么”，更聚焦于“为什么重要”、“怎么落地”以及“面试会怎么考”。你将看到如何用Langfuse追踪Agent的每一步，用科学的评估指标衡量RAG效果，并用LangGraph构建可控的复杂工作流。文章包含大量可运行的代码示例、配置细节和真实场景的避坑指南，目标是让你不仅能通过面试，更能构建出真正可交付的AI应用。

1. 为什么“可观测性”和“评估”是Agent面试的必答题？

很多开发者对LangChain、LangGraph的认知停留在“框架”和“库”的层面，认为会用它们构建一个能跑的Agent就足够了。这是一个巨大的误区。在2026年的技术面试中，这甚至可能成为你被淘汰的直接原因。

面试官的真正意图是什么？他们想考察你是否具备生产级AI应用的思维。一个在Demo里运行良好的Agent，在生产环境中可能因为大模型输出的微小变化、外部API的延迟或自身逻辑缺陷而完全失控。面试官抛出“Agent追踪”、“评估”这类问题，是在测试你：

1. 工程化意识：你是否意识到AI应用的“黑盒”特性带来的挑战？
2. 问题定位能力：当用户反馈“答案不对”时，你的排查路径是什么？是盲目调整Prompt，还是能追溯到具体的工具调用、上下文检索环节？
3. 量化思维：你如何用数据证明你的优化是有效的？是凭感觉，还是通过A/B测试和评估指标？

Langfuse、LangChain、LangGraph的分工与定位理解这三者的关系，是回答一切高阶问题的基础。它们不是替代关系，而是互补的“铁三角”：

• LangChain：是应用构建框架。它提供了连接大模型、工具、记忆、数据等组件的标准化接口和抽象，让你能快速组装出一个AI应用的原型。它关心的是“如何构建”。
• LangGraph：是复杂工作流编排引擎。它基于LangChain，但引入了“图”和“状态”的概念，专门用于构建有循环、有条件分支、有持久化状态的复杂Agent。它关心的是“如何控制流程”。
• Langfuse：是可观测性与评估平台。它不参与应用的构建和运行，而是作为一个“旁观者”和“分析师”，记录下LangChain/LangGraph应用运行过程中的所有细节（追踪），并帮助你定义和计算评估指标。它关心的是“运行得怎么样”和“效果好不好”。

简单来说：你用LangChain/LangGraph“造车”，用Langfuse“装上车载诊断系统（OBD）和性能测试仪”。没有后者，你只知道车能开，但不知道油耗多少、哪个零件容易坏、加速性能如何优化。

2. 核心概念拆解：从黑盒到白盒的关键技术

在深入实操前，我们必须统一语言，理解几个容易混淆但至关重要的概念。

2.1 追踪（Tracing） vs. 日志（Logging）

这是最基础的区分。传统日志是开发者主动埋点输出的离散信息（如print(“调用API”)）。而追踪（Tracing）是自动化的、结构化的、贯穿整个请求生命周期的记录。

• 日志：告诉你“发生了什么事”。
• 追踪：告诉你“这件事在完整的调用链中处于什么位置，它的父步骤是谁，子步骤有哪些，耗时多少，输入输出是什么”。 在Langfuse中，一次LLM调用、一次工具执行、一次检索，都是一个独立的“Span”（跨度），它们通过层级关系组织成一个完整的“Trace”（追踪）。这让你能像看调用链监控图一样，洞察Agent的完整执行路径。

2.2 评估（Evaluation）的多个维度

评估不是简单的“对”或“错”。针对大模型应用，尤其是Agent和RAG，我们需要多维度评估：

1. 事实性（Faithfulness）：模型的回答是否严格基于你提供的上下文（Retrieved Context）？有没有“胡编乱造”（Hallucination）？
2. 相关性（Relevance）：检索到的上下文与用户问题是否真正相关？
3. 答案质量（Answer Quality）：答案是否完整、清晰、有用？这通常需要LLM作为裁判（LLM-as-a-Judge）或与人工标注的答案（Ground Truth）进行对比。
4. 延迟（Latency）：整个流程或每个步骤的耗时，直接影响用户体验和成本。
5. 成本（Cost）：每次调用消耗的Token数，折算成API费用。

Langfuse的核心价值在于，它能将追踪数据与评估结果自动关联。你可以看到得分低的回答，具体是哪个检索步骤或模型调用出了问题。

2.3 LangGraph中的状态（State）与编排（Orchestration）

LangGraph将Agent的运行抽象为一个有状态图（Stateful Graph）。

• 节点（Nodes）：代表一个执行单元，比如“调用LLM”、“执行工具”。
• 边（Edges）：决定流程的走向，通常基于当前状态（State）的条件来决定下一步去哪个节点。
• 状态（State）：一个贯穿整个图执行过程的共享数据结构。它包含了所有节点需要读取和写入的信息，例如用户输入、聊天历史、中间结果等。

这种设计使得构建像“ReAct Agent”（思考-行动-观察循环）或带审批流程的多步Agent变得异常清晰和可控。面试中常问的“Agent陷入循环怎么办”，其解决方案就依赖于对状态和边条件的合理设计。

3. 环境准备：搭建你的可观测性实验台

理论需要实践验证。我们首先搭建一个集成了Langfuse、LangChain和LangGraph的最小化开发环境。

前置条件：

• Python 3.10 或更高版本。
• 一个OpenAI API密钥（或其他兼容OpenAI的模型API密钥）。
• 一个Langfuse云账户（免费套餐足够实验）或自托管实例。

步骤1：安装依赖我们使用pip安装核心库。建议使用虚拟环境。

# 创建并激活虚拟环境 (可选) python -m venv venv source venv/bin/activate # Linux/macOS # venv\Scripts\activate # Windows # 安装核心包 pip install langchain langchain-openai langgraph langfuse

• langchain: 核心框架。
• langchain-openai: 官方维护的OpenAI集成。
• langgraph: 用于构建图工作流。
• langfuse: 用于追踪和评估。

步骤2：配置密钥永远不要将密钥硬编码在代码中。使用环境变量管理。

# 在终端中设置环境变量 (临时) export OPENAI_API_KEY="sk-你的OpenAI密钥" export LANGFUSE_SECRET_KEY="sk-lf-你的Langfuse Secret Key" export LANGFUSE_PUBLIC_KEY="pk-lf-你的Langfuse Public Key" export LANGFUSE_HOST="https://cloud.langfuse.com" # 云服务地址

你可以在Langfuse项目设置中找到PUBLIC KEY和SECRET KEY。

步骤3：初始化Langfuse并创建基础链让我们写一个最简单的脚本，验证环境是否正常，并看到第一次追踪。

# 文件：01_basic_tracing.py import os from langchain_openai import ChatOpenAI from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser from langfuse.callback import CallbackHandler # 1. 初始化Langfuse回调处理器 # 它会自动将链的执行过程发送到Langfuse langfuse_handler = CallbackHandler() # 2. 构建一个简单的链：提示词 -> 模型 -> 输出解析 prompt = ChatPromptTemplate.from_template("请用一句话介绍{topic}。") model = ChatOpenAI(model="gpt-3.5-turbo") output_parser = StrOutputParser() chain = prompt | model | output_parser # 3. 调用链，并传入回调处理器 response = chain.invoke( {"topic": "量子计算"}, config={"callbacks": [langfuse_handler]} # 关键：注入回调 ) print("模型回复：", response)

运行这个脚本后，登录你的Langfuse控制台，在“Traces”页面，你应该能看到一条新的追踪记录。点击进入，可以看到完整的提示词、模型响应、耗时和Token使用量。至此，你的可观测性基础环境已经就绪。

4. 实战：构建一个可追踪、可评估的RAG问答系统

RAG（检索增强生成）是面试最高频的场景之一。我们来构建一个带评估的简易RAG系统，并演示如何用Langfuse追踪其内部步骤。

4.1 构建基础RAG流水线

我们将实现一个从文档加载、切分、向量化存储到检索生成的完整流程。

# 文件：02_rag_pipeline.py import os from langchain_community.document_loaders import TextLoader from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_openai import OpenAIEmbeddings, ChatOpenAI from langchain_community.vectorstores import Chroma from langchain.chains import RetrievalQA from langfuse.callback import CallbackHandler # 初始化回调 langfuse_handler = CallbackHandler() # 1. 加载与切分文档（假设我们有一个 knowledge.txt 文件） loader = TextLoader("./knowledge.txt", encoding="utf-8") documents = loader.load() text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50) splits = text_splitter.split_documents(documents) print(f"文档被切分为 {len(splits)} 个片段。") # 2. 向量化存储 embeddings = OpenAIEmbeddings() vectorstore = Chroma.from_documents(documents=splits, embedding=embeddings, persist_directory="./chroma_db") retriever = vectorstore.as_retriever(search_kwargs={"k": 3}) # 检索Top-3相关片段 # 3. 构建RAG链 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # 简单地将检索到的上下文“堆叠”进提示词 retriever=retriever, return_source_documents=True # 返回源文档用于评估 ) # 4. 提问并追踪 question = "Langfuse的主要作用是什么？" result = qa_chain.invoke( {"query": question}, config={"callbacks": [langfuse_handler]} ) print("问题：", question) print("答案：", result["result"]) print("\n--- 检索到的源文档 ---") for i, doc in enumerate(result["source_documents"]): print(f"[{i+1}] {doc.page_content[:200]}...") # 打印前200字符

运行后，在Langfuse控制台查看这条Trace。你会发现它包含了多个Span：可能包括retrieval（检索）、llm（大模型调用）等。你可以清晰地看到检索到的文本片段、发送给模型的完整提示词以及模型的回复。

4.2 为RAG回答添加自动化评估

现在，我们不止于记录，还要评估。我们将评估“答案相关性”和“事实性”。

# 文件：03_rag_evaluation.py from langchain.evaluation import load_evaluator from langchain.evaluation import EvaluatorType from langfuse.callback import CallbackHandler import asyncio # 假设我们已经有了上一步的 qa_chain 和 langfuse_handler # 这里我们直接定义一个评估函数 async def evaluate_rag_response(question, predicted_answer, retrieved_context, langfuse_handler): """评估RAG回答的质量""" # 初始化评估器 faithfulness_evaluator = load_evaluator(EvaluatorType.FAITHFULNESS) relevance_evaluator = load_evaluator(EvaluatorType.RELEVANCE) # 评估事实性（答案是否基于上下文） faithfulness_result = await faithfulness_evaluator.aevaluate( input=question, prediction=predicted_answer, context=retrieved_context, # 传入检索到的上下文 callbacks=[langfuse_handler] ) print(f"事实性得分: {faithfulness_result['score']} ({faithfulness_result['reasoning']})") # 评估相关性（答案是否与问题相关） relevance_result = await relevance_evaluator.aevaluate( input=question, prediction=predicted_answer, callbacks=[langfuse_handler] ) print(f"相关性得分: {relevance_result['score']} ({relevance_result['reasoning']})") return { "faithfulness": faithfulness_result['score'], "relevance": relevance_result['score'] } # 模拟一次调用和评估 async def main(): handler = CallbackHandler() # 这里简化处理，假设我们已经通过qa_chain得到了结果 mock_question = "如何安装Langfuse？" mock_answer = "可以通过pip install langfuse命令进行安装。" mock_context = "Langfuse的Python SDK可以通过pip安装，命令是'pip install langfuse'。同时也支持Docker部署。" scores = await evaluate_rag_response(mock_question, mock_answer, mock_context, handler) print("评估结果汇总:", scores) if __name__ == "__main__": asyncio.run(main())

关键点：

1. load_evaluator加载了LangChain内置的评估器，它们底层也是通过调用LLM（如GPT-4）来扮演裁判角色。
2. 评估过程本身也被langfuse_handler追踪，你可以在Langfuse中看到“评估”这个Span，以及它给出的分数和推理过程。
3. 在Langfuse UI中，你可以将评估分数与原始的Trace关联起来，进行聚合分析，例如“找出所有事实性得分低于0.8的回答”。

5. 进阶：用LangGraph构建一个可追踪的ReAct Agent

Agent面试题常涉及循环、工具调用和状态管理。我们用LangGraph构建一个经典的ReAct（Reasoning + Acting）Agent，并用Langfuse追踪其每一步决策。

5.1 定义工具和Agent状态

首先，我们定义几个简单的工具和一个共享状态。

# 文件：04_react_agent_graph.py from typing import TypedDict, Annotated, List import operator from langgraph.graph import StateGraph, END from langchain_openai import ChatOpenAI from langchain.tools import tool from langchain_core.messages import HumanMessage, AIMessage from langfuse.callback import CallbackHandler # 1. 定义Agent的状态结构 class AgentState(TypedDict): messages: Annotated[List, operator.add] # 对话消息历史 current_step: str # 当前步骤描述，用于追踪 # 2. 定义几个工具 @tool def search_web(query: str) -> str: """模拟一个网络搜索工具。在实际应用中，这里会调用SerperAPI或Google Search API。""" # 这里是模拟返回 return f"根据搜索'{query}'，结果是：Langfuse是一个开源的LLM应用可观测性平台。" @tool def calculator(expression: str) -> str: """一个简单的计算器工具。""" try: result = eval(expression) # 注意：生产环境请勿使用eval，此处仅为演示 return f"计算结果：{expression} = {result}" except: return "计算表达式无效。" tools = [search_web, calculator] # 3. 绑定工具到LLM llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) llm_with_tools = llm.bind_tools(tools)

5.2 构建LangGraph工作流

定义图中的节点和边，控制Agent的推理循环。

# 文件：04_react_agent_graph.py (续) from langgraph.prebuilt import ToolExecutor from langgraph.graph.message import add_messages # 4. 创建工具执行器 tool_executor = ToolExecutor(tools) # 5. 定义节点函数 def agent_node(state: AgentState): """Agent节点：决定是回复用户还是调用工具。""" messages = state['messages'] # 调用LLM，它会根据对话历史和工具描述决定下一步 response = llm_with_tools.invoke(messages) # 将AI的响应（可能包含工具调用请求）添加到消息历史 return {"messages": [response], "current_step": "Agent决策"} def tool_node(state: AgentState): """工具节点：执行AI请求调用的工具。""" last_message = state['messages'][-1] # 获取AI消息中请求调用的工具信息 tool_calls = last_message.tool_calls outputs = [] for tool_call in tool_calls: tool_name = tool_call['name'] tool_input = tool_call['args'] print(f"[执行工具] {tool_name}，输入：{tool_input}") # 执行工具 result = tool_executor.invoke({tool_name: tool_input}) outputs.append(result) # 将工具执行结果作为一条新消息返回 result_message = AIMessage(content=str(outputs), tool_calls=[]) return {"messages": [result_message], "current_step": f"执行工具 {[tc['name'] for tc in tool_calls]}"} # 6. 定义条件边函数 def should_continue(state: AgentState) -> str: """根据AI的最后一条消息，决定下一步是调用工具还是结束。""" last_message = state['messages'][-1] if last_message.tool_calls: return "call_tools" # 有工具调用，转向工具节点 else: return END # 没有工具调用，结束流程 # 7. 构建图 workflow = StateGraph(AgentState) # 添加节点 workflow.add_node("agent", agent_node) workflow.add_node("tools", tool_node) # 设置入口点 workflow.set_entry_point("agent") # 添加条件边 workflow.add_conditional_edges( "agent", should_continue, { "call_tools": "tools", # 如果should_continue返回"call_tools"，则前往"tools"节点 END: END } ) # 从工具节点执行完后，无条件回到Agent节点进行下一轮思考 workflow.add_edge("tools", "agent") # 编译图 app = workflow.compile()

5.3 运行Agent并集成Langfuse追踪

现在，我们运行这个Agent，并用Langfuse记录下完整的思考-行动循环。

# 文件：04_react_agent_graph.py (续) from langfuse.callback import CallbackHandler def run_agent_with_tracing(user_input: str): """运行Agent并启用Langfuse追踪""" langfuse_handler = CallbackHandler() # 初始化状态 initial_state: AgentState = { "messages": [HumanMessage(content=user_input)], "current_step": "开始" } # 使用Langfuse回调来调用图 config = {"callbacks": [langfuse_handler]} print(f"用户输入: {user_input}") print("-" * 30) final_state = None # 流式输出每一步的结果，方便观察 for event in app.stream(initial_state, config=config): for node_name, node_output in event.items(): step_info = node_output.get("current_step", node_name) last_message = node_output["messages"][-1] content = last_message.content if hasattr(last_message, 'content') else str(last_message) print(f"[步骤: {step_info}] -> {content[:100]}...") # 打印部分内容 final_state = node_output print("-" * 30) if final_state: final_answer = final_state["messages"][-1].content print(f"最终回答: {final_answer}") if __name__ == "__main__": # 测试一个需要多步推理和工具调用的复杂问题 run_agent_with_tracing("请先搜索一下Langfuse是什么，然后用计算器算一下(15*3)+20等于多少？")

运行这个脚本。你不仅会在控制台看到Agent一步步的思考（“我需要先搜索，然后计算”）、行动（调用搜索工具、计算器工具）和最终回答，更重要的是，整个过程的每一个节点（agent, tools）的输入输出、耗时，都会作为一条完整的Trace记录在Langfuse中。

在Langfuse控制台，你可以展开这条Trace，清晰地看到“Agent决策 -> 执行工具[search_web] -> Agent决策 -> 执行工具[calculator] -> Agent决策 -> 结束”的完整图谱。这对于调试Agent逻辑错误、分析工具调用性能瓶颈至关重要。

6. 运行结果分析与效果验证

运行上述代码后，你应该获得以下可验证的结果：

1. 控制台输出：你会看到类似以下的执行日志，清晰地展示了Agent的ReAct循环。

   用户输入: 请先搜索一下Langfuse是什么，然后用计算器算一下(15*3)+20等于多少？ ------------------------------ [步骤: Agent决策] -> 我需要先搜索Langfuse的信息，然后计算表达式。首先，我将调用搜索工具... [步骤: 执行工具 ['search_web']] -> 根据搜索'Langfuse是什么'，结果是：Langfuse是一个开源的LLM应用可观测性平台。... [步骤: Agent决策] -> 好的，我得到了Langfuse的信息。现在我需要计算(15*3)+20。我将调用计算器工具... [步骤: 执行工具 ['calculator']] -> 计算结果：(15*3)+20 = 65... [步骤: Agent决策] -> 搜索结果显示Langfuse是一个开源的LLM应用可观测性平台。计算结果是65。... ------------------------------ 最终回答: Langfuse是一个开源的LLM应用可观测性平台。您要求的计算(15*3)+20的结果是65。

2. Langfuse UI 验证：

   • 登录Langfuse控制台，进入“Traces”页面。
   • 你应该能看到一条新的Trace，其名称或输入包含你的问题。
   • 点击进入这条Trace，你将看到：
     • 概览：总耗时、总Token消耗、总成本。
     • 时间线视图：一个瀑布图，展示了agent和tools节点的先后执行顺序和耗时。
     • 详细信息：点击每个Span，可以查看其精确的输入（如发送给LLM的提示词）和输出（如LLM的回复或工具的执行结果）。
   • 对于03_rag_evaluation.py的评估结果，你可以在“Scores”或“Evaluations”相关页面看到为Trace打上的分数标签。

如何判断成功？

• 功能成功：Agent正确理解了多步指令，按顺序调用了正确的工具，并给出了整合后的答案。
• 追踪成功：在Langfuse中，Trace包含了所有关键步骤的Span，且层级关系正确（例如，工具调用是Agent决策的子步骤）。
• 评估成功：评估脚本运行后，在Langfuse中能找到对应的评估记录，并与原始Trace关联。

7. 常见问题与排查思路

在集成和使用这套技术栈时，以下是高频问题及解决方案：

8. 最佳实践与工程建议

要将这些技术用于生产或应对高级面试，请遵循以下建议：

1. 分环境配置：在开发、测试、生产环境使用不同的Langfuse项目或标签，便于数据隔离和分析。可以通过环境变量动态设置LANGFUSE_HOST（指向自托管实例）和项目密钥。

2. 为Trace和Span命名：在调用时通过config传入metadata，为你的追踪添加有意义的名称和标签，便于后续搜索和过滤。

   chain.invoke( input, config={ "callbacks": [langfuse_handler], "metadata": {"trace_name": "用户注册问答", "environment": "staging"} } )

3. 定义核心评估指标看板：在Langfuse中，基于追踪数据创建Dashboard。关注：

   • 成功率：任务完成的比率。
   • 平均延迟：P50， P95， P99分位的响应时间。
   • Token消耗与成本：每日/每周成本趋势。
   • 工具调用错误率：外部API调用失败的比例。
   • 评估分数分布：事实性、相关性分数的平均值和标准差。

4. 实现评估的自动化与持续监控：

   • 为关键的用户对话或任务流编写自动化评估脚本。
   • 将评估作为CI/CD流水线的一部分，在代码合并前对核心用例进行回归测试。
   • 设置警报，当评估分数或延迟超过阈值时通知团队。

5. LangGraph设计原则：

   • 状态最小化：只在State中存储必要的数据，避免图变得笨重。
   • 节点职责单一：每个节点只做一件事，提高可测试性和可复用性。
   • 善用“中断”：使用interrupt_before/interrupt_after来实现人工审核、异常处理等复杂流程控制。
   • 可视化调试：利用app.get_graph().draw_mermaid()输出Mermaid图，直观理解你的工作流。

6. 安全与权限：

   • 确保Langfuse的密钥安全存储，不要提交到代码仓库。
   • 在生产环境中，仔细审查发送到Langfuse的数据，避免记录和传输个人敏感信息（PII）。可以利用Langfuse的数据脱敏功能或回调处理器进行过滤。

掌握Langfuse进行Agent追踪与评估，结合LangChain和LangGraph构建稳健应用，这不再是加分项，而是2026年大模型面试中的核心竞争力。它标志着你从“原型开发者”向“AI应用工程师”的转变。本文提供的从概念到代码的完整路径，希望能成为你学习和面试的实用手册。建议你亲手运行每一个示例，并在Langfuse控制台中探索数据，这种直观的感受远比阅读文档来得深刻。下一步，你可以尝试将这套方法论应用到你的实际项目中，例如为一个客服聊天机器人添加全链路追踪和自动化质量评估，真正体验数据驱动的AI应用迭代。