LLM-监控和可观察性-Langfuse-实战
LLM 监控和可观察性：Langfuse 实战
在本教程中，我们将从学习 LLM 监控和可观察性的基础知识开始。然后，我们将探索开源生态系统，最终讨论Langfuse。最后，我们将使用 Langfuse 实现基于 Python 的 LLM 应用程序的监控和可观察性。
什么是监控和可观察性？
监控和可观察性是维护任何 IT 系统健康的关键概念。虽然“监控”和“可观察性”这两个术语经常被合并使用，但它们代表的是略有不同的概念。
根据IBM 的定义，监控是收集和分析系统数据以跟踪性能随时间变化的过程。它依赖于预定义的指标来检测异常或潜在的故障。常见的例子包括跟踪系统的 CPU 和内存使用情况，并在某些阈值被突破时发出警报。
可观察性基于系统外部输出，提供了对系统内部状态的更深入理解。它允许你诊断和理解为什么某些事情会发生，而不仅仅是某处出了问题。例如，可观察性允许你通过系统的各个部分追踪输入和输出，以发现瓶颈发生的位置。
上述定义在 LLM 应用程序领域也是有效的。正是通过监控和可观察性，我们可以追踪 LLM 应用程序的内部状态，例如用户查询是如何通过各种模块（例如检索、生成）处理的，以及相关的延迟和成本。
一个基本的 LLM-RAG 应用程序架构 - 使用 excalidraw.com 制作
下面是一些在监控和可观察性中使用的关键术语：
遥测：遥测是一个广泛的概念，它包括在应用程序运行和处理时收集数据，并对其进行处理以了解应用程序的行为。
仪器化: 仪器化是将代码添加到您的应用程序中以收集遥测数据的过程。对于 LLM 应用程序来说，这意味着在各个关键点添加钩子以捕获内部状态，例如对 LLM 或检索器的 API 调用或其输出。
跟踪: 跟踪是仪器化的直接后果，它突出了请求在整个应用程序中的详细执行路径。这包括每个关键点的输入/输出以及每个点的相应时间。每个跟踪由一系列 Span 组成。
观察: 每个跟踪由一个或多个观察组成，这些观察可以是 Span、Event 或 Generation 类型。
Span: Span 是工作单元或操作，它解释了在每个关键点上执行的过程。
生成: 生成是一种特殊的 Span，它跟踪发送到 LLM 模型的输入请求及其输出响应。
日志: 日志是 LLM 应用程序中事件和交互的时间戳记录。
指标: 指标是提供关于 LLM 行为和性能的聚合洞察的数值测量，例如幻觉或答案的相关性。
包含多个 Span 和生成的示例跟踪。图片来源：Langfuse 跟踪
为什么 LLM 监控和可观察性是必要的？
随着 LLM 应用程序变得越来越复杂，LLM 监控和可观察性在优化应用程序性能方面可以发挥关键作用。以下是为什么它很重要的几个原因：
可靠性: LLM 应用程序对于组织至关重要；性能下降可以直接影响他们的业务。监控确保应用程序在质量、延迟和正常运行时间等方面在可接受的范围内运行。
调试: 一个复杂的 LLM 应用程序可能是不可预测的；它可能产生错误的响应或遇到错误。通过筛选每个请求的完整生命周期并确定根本原因，监控和可观察性可以帮助识别应用程序中的问题。
用户体验: 监控用户体验和反馈对于直接与客户群互动的 LLM 应用程序至关重要。这允许组织通过跟踪用户对话并做出明智的决策来提高用户体验。最重要的是，它允许收集用户反馈以改进模型和下游流程。
偏见与公平性: LLM 是在公开可用的数据上训练的，因此有时会内化可用数据中的可能偏见。这可能导致它们产生冒犯性或有害的信息。可观察性可以通过适当的纠正措施帮助减轻此类响应。
成本管理：监控可以帮助您跟踪和优化常规操作中产生的成本，例如 LLM 的每令牌 API 成本。您还可以在过度使用的情况下设置警报。
监控和可观察性工具
有许多令人惊叹的工具和库可用于启用 LLM 应用程序的监控和可观察性。其中许多工具都是开源的，它们在本地基础设施上提供免费自托管解决方案，同时在各自的云服务器上提供企业级部署。这些工具都提供一些常见功能，如跟踪、令牌计数、延迟、总请求和时间过滤等。除此之外，每个解决方案都有其独特的功能和优势。
在这里，我们只列举一些提供免费自托管解决方案的开源工具。
Langfuse: 一个流行的开源 LLM 监控工具，对模型和框架都是中立的。它提供了一整套使用专为 Python 和 JavaScript/TypeScript 构建的客户端 SDK 定制的监控选项。
Arize Phoenix: 另一个流行的工具，提供自托管和 Phoenix Cloud 部署。Phoenix 为 Python 和 JavaScript/TypeScript 提供了 SDK。
AgentOps: AgentOps 是一个知名的解决方案，用于跟踪 LLM 输出、检索器，允许基准测试并确保合规性。它提供与多个 LLM 提供商的集成。
Grafana: 一个经典且广泛使用的监控工具，可以与 OpenTelemetry 结合使用，提供详细的 LLM 跟踪和监控。
Weave: Weights & Biases 的 Weave 是另一个针对基于 LLM 应用的 LLM 跟踪和实验工具，提供自管理和专用云环境。客户端 SDK 可在 Python 和 TypeScript 中使用。
Langfuse 介绍
Langfuse 提供了一系列功能，如 LLM 可观察性、跟踪、LLM 令牌和成本监控、提示管理、数据集和 LLM 安全。此外，Langfuse 还提供使用各种技术（如 LLM-as-a-Judge 和用户反馈）评估 LLM 响应的功能。此外，Langfuse 还为高级用户提供 LLM 游乐场，允许你现场调整 LLM 提示和参数，并观察 LLM 对这些变化的响应。我们将在教程中稍后讨论更多细节。
Langfuse 针对 LLM 监控和可观察性的解决方案包括两个部分：
-
Langfuse SDKs
-
Langfuse 服务器
Langfuse SDKs是 Langfuse 的编码部分，适用于各种平台，允许你在应用程序代码中启用仪器化。它们不过是几行代码，可以在你的应用程序代码库中适当使用。
另一方面，Langfuse 服务器是基于 UI 的仪表板，以及其他底层服务，可以用来记录、查看和持久化所有跟踪和指标。Langfuse 的仪表板通常可以通过任何现代网络浏览器访问。
在设置仪表板之前，需要注意的是 Langfuse 提供了三种不同的仪表板托管方式，它们是：
-
自托管（本地）
-
托管托管（使用 Langfuse 的云基础设施）
-
本地部署
托管和本地部署超出了本教程的范围。你可以访问 Langfuse 的官方文档以获取所有相关信息。
正如其名所示，自托管解决方案允许你简单地在自己的机器上运行 Langfuse 的一个实例（例如，PC、笔记本电脑、虚拟机或网络服务）。然而，这种简单性中存在一个陷阱。Langfuse 服务器需要一个持久的 Postgres 数据库服务器来持续维护其状态和数据。这意味着除了 Langfuse 服务器外，我们还需要设置一个 Postgres 服务器。但别担心，我们已经控制了局面。你可以使用任何云服务（如 Azure、AWS）上托管的 Postgres 服务器，或者你可以像 Langfuse 服务一样轻松地自托管它。明白了吗？
Langfuse 的自托管是如何实现的？Langfuse 提供了几种方式来实现这一点，例如使用 docker/docker-compose 或 Kubernetes，以及/或者部署在云服务器上。目前，让我们坚持使用 docker 命令。
设置 Langfuse 服务器
现在，是时候亲自动手设置 Langfuse 仪表板以用于 LLM 应用程序，并将跟踪和指标记录到其中了。当我们说 Langfuse 服务器时，我们指的是 Langfuse 的仪表板和其他允许记录、查看和持久化跟踪的服务。这需要对 Docker 和其相关概念有基本的了解。如果您还不熟悉 Docker，可以查看这个 教程。
使用 docker-compose
在您的机器上设置 Langfuse 最方便、最快的方法是使用一个 docker-compose 文件。这只是一个两步的过程，涉及在本地机器上克隆 Langfuse 并简单地调用 docker-compose。
第 1 步：克隆 Langfuse 的仓库：
$ git clone https://github.com/langfuse/langfuse.git
$ cd langfuse
第 2 步：启动所有服务
$ docker compose up
就这样！打开您的网页浏览器并访问 http://localhost:3000 来见证 Langfuse UI 的工作。同时也要珍惜这样一个事实，即 docker-compose 会自动处理 Postgres 服务器。
从这一点开始，我们可以安全地继续到设置 Python SDK 和在代码中启用仪表功能的章节。
使用 Docker
Langfuse 服务器的 Docker 设置类似于 docker-compose 实现，但有一个明显的区别：我们将分别设置两个容器（Langfuse 和 Postgres）并将它们通过内部网络连接起来。这可能有助于那些 docker-compose 不是首选选择的情况，也许是因为您已经运行了 Postgres 服务器，或者您想分别运行这两个服务以获得更多控制，例如由于资源限制，在 Azure Web App 服务上分别托管这两个服务。
第 1 步：创建一个自定义网络
首先，我们需要设置一个自定义网桥网络，这将允许两个容器相互私密通信。
$ docker network create langfuse-network
此命令创建了一个名为 langfuse-network 的网络。请随意根据您的喜好更改它。
第 2 步：设置 Postgres 服务
我们将首先运行 Postgres 容器，因为 Langfuse 服务依赖于它，使用以下命令：
$ docker run -d \
--name postgres-db \
--restart always \
-p 5432:5432 \
--network langfuse-network \
-v database_data:/var/lib/postgresql/data \
-e POSTGRES_USER=postgres \
-e POSTGRES_PASSWORD=postgres \
-e POSTGRES_DB=postgres \
postgres:latest
说明:
此命令将在名为 langfuse-network 的网络上运行 postgres:latest 的 Docker 镜像作为名为 postgres-db 的容器，并在您的本地机器上将其服务暴露在端口 5432 上。为了持久化（即为了将来使用保持数据完整），它将创建一个卷并将其连接到本地机器上名为 database_data 的文件夹。此外，它还将设置并分配三个至关重要的 Postgres 服务器超级用户环境变量的值：POSTGRES_USER、POSTGRES_PASSWORD 和 POSTGRES_DB。
第 3 步：设置 Langfuse 服务
$ docker run –d \
--name langfuse-server \
--network langfuse-network \
-p 3000:3000 \
-e DATABASE_URL=postgresql://postgres:postgres@postgres-db:5432/postgres \
-e NEXTAUTH_SECRET=mysecret \
-e SALT=mysalt \
-e ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000 \
-e NEXTAUTH_URL=http://localhost:3000 \
langfuse/langfuse:2
说明:
同样，此命令将在分离模式（-d）下运行 langfuse/langfuse:2 的 Docker 镜像，作为名为 langfuse-server 的容器，在同一网络 langfuse-network 上运行，并将此服务暴露在端口 3000 上。它还将分配必要的环境变量。NEXTAUTH_URL 必须指向 langfuse-server 将部署的 URL。
ENCRYPTION_KEY 必须是 256 位，64 个十六进制格式的字符串字符。您可以在 Linux 中通过以下方式生成：
$ openssl rand -hex 32
DATABASE_URL 是一个环境变量，它定义了完整的数据库路径和凭据。Postgres URL 的一般格式如下：
postgresql://[POSTGRES_USER[:POSTGRES_PASSWORD]@][host[:port]/[POSTGRES_DB]
在这里，host 是我们 PostgreSQL 服务器的主机名（即容器名称）或 IP 地址。
最后，转到您的网页浏览器并打开 http://localhost:3000 以验证 Langfuse 服务器是否可用。
配置 Langfuse 仪表板
成功设置 Langfuse 服务器后，在开始跟踪应用程序数据之前，您需要配置 Langfuse 仪表板。
按照上一节中的说明，在您的网页浏览器中转到 http://localhost:3000。您必须创建一个新的组织、成员和一个项目，您将在其中跟踪和记录所有指标。按照仪表板上的步骤完成整个过程。
例如，我们已创建一个名为 datamonitor 的组织，添加了一个名为 data-user1 的“所有者”角色的成员，以及一个名为 data-demo 的项目。这将带我们到以下屏幕：
Langfuse 仪表板设置屏幕（作者截图）
此屏幕显示公共和私有 API 密钥，在设置使用 SDK 的跟踪时将使用这些密钥；请保存它们以备将来使用。完成此步骤后，我们终于完成了 langfuse 服务器的配置。剩下的唯一任务是启动应用程序代码侧的仪器过程。
使用 SDK 启用 Langfuse 跟踪
Langfuse 提供了一种简单的方法，通过最少的代码行启用 LLM 应用程序的跟踪。如前所述，Langfuse 为各种语言、框架和 LLM 模型提供跟踪解决方案，例如 Langchain、LlamaIndex、OpenAI 等。您甚至可以在 AWS Lambda 等无服务器函数中启用 Langfuse 跟踪。
但在我们跟踪应用程序之前，让我们实际上使用 OpenAI 的框架创建一个示例应用程序。我们将仅为了演示目的创建一个非常简单的聊天完成应用程序，使用 OpenAI 的 gpt-4o-mini。
首先，安装所需的包：
$ pip install openai
import os
import openai
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_KEY','')
client = openai.OpenAI(api_key=api_key)
country = 'Pakistan'
query = f"Name the capital of {country} in one phrase only"
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": query}],
max_tokens=100,
)
print(response.choices[0].message.content)
输出：
Islamabad.
现在，让我们在给定的代码中启用 langfuse 跟踪。您需要对代码进行一些小的调整，从安装 langfuse 包开始。
再次安装所有必需的包：
$ pip install langfuse openai --upgrade
启用 langfuse 的代码看起来像这样：
import os
#import openai
from langfuse.openai import openai
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_KEY','')
client = openai.OpenAI(api_key=api_key)
LANGFUSE_SECRET_KEY="sk-lf-..."
LANGFUSE_PUBLIC_KEY="pk-lf-..."
LANGFUSE_HOST="http://localhost:3000"
os.environ['LANGFUSE_SECRET_KEY'] = LANGFUSE_SECRET_KEY
os.environ['LANGFUSE_PUBLIC_KEY'] = LANGFUSE_PUBLIC_KEY
os.environ['LANGFUSE_HOST'] = LANGFUSE_HOST
country = 'Pakistan'
query = f"Name the capital of {country} in one phrase only"
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": query}],
max_tokens=100,
)
print(response.choices[0].message.content)
你看，我们只是将import openai替换为from langfuse.openai import openai来启用跟踪。
如果你现在访问你的 Langfuse 仪表板，你会观察到 OpenAI 应用程序的痕迹。
一个完整的端到端示例
现在，让我们深入了解如何在完整的 LLM 应用程序上启用监控和可观察性。我们将实现一个 RAG 管道，该管道从向量数据库中检索相关上下文。我们将使用 ChromaDB 作为向量数据库。
我们将使用 Langchain 框架来构建我们的基于 RAG 的应用程序（参见图上“基本 LLM-RAG 应用程序”）。您可以通过追求这篇如何使用 Langchain 构建 LLM 应用程序的教程来学习 Langchain。
如果您想学习 RAG 的基础知识，这篇教程可以是一个好的起点。至于向量数据库，请参阅设置 ChromaDB 的这篇教程。
本节假设您已经按照上一节所述在本地主机上设置并配置了 Langfuse 服务器。
第 1 步：安装和设置
安装所有必需的包，包括langchain、chromadb和langfuse。
pip install -U langchain-community langchain-openai chromadb langfuse
接下来，我们导入所有必需的包和库：
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from langfuse.callback import CallbackHandler
from dotenv import load_dotenv
load_dotenv包用于加载所有环境变量，这些变量保存在一个.env文件中。确保您的 OpenAI 的密钥保存在.env文件中的OPENAI_API_KEY。
最后，我们将 Langfuse 的 Langchain 回调系统集成到我们的应用程序中，以启用跟踪。
langfuse_handler = CallbackHandler(
secret_key="sk-lf-...",
public_key="pk-lf-...",
host="http://localhost:3000"
)
第 2 步：设置知识库
为了模拟 RAG 系统，我们将：
-
使用
WebBaseLoader从 Confiz 博客部分抓取一些有洞察力的文章 -
使用
RecursiveCharacterTextSplitter将它们分成更小的块 -
使用 OpenAI 的嵌入将它们转换为向量嵌入
-
将它们导入我们的 Chroma 向量数据库。这将成为我们 LLM 查找和回答用户查询的知识库。
urls = [
"https://www.confiz.com/blog/a-cios-guide-6-essential-insights-for-a-successful-generative-ai-launch/",
"https://www.confiz.com/blog/ai-at-work-how-microsoft-365-copilot-chat-is-driving-transformation-at-scale/",
"https://www.confiz.com/blog/setting-up-an-in-house-llm-platform-best-practices-for-optimal-performance/",
]
loader = WebBaseLoader(urls)
docs = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=20,
length_function=len,
)
chunks = text_splitter.split_documents(docs)
# Create the vector store
vectordb = Chroma.from_documents(
documents=chunks,
embedding=OpenAIEmbeddings(model="text-embedding-3-large"),
persist_directory="chroma_db",
collection_name="confiz_blog"
)
retriever = vectordb.as_retriever(search_type="similarity",search_kwargs={"k": 3})
我们假设在递归文本分割器中，块大小为 500 个标记，重叠 20 个标记，在给定大小之前考虑了各种因素。ChromaDB的vectordb对象被转换为检索对象，使我们能够方便地在 Langchain 检索管道中使用它。
第 3 步：设置 RAG 管道
下一步是设置 RAG 链，利用 LLM 的力量以及向量数据库的知识库来回答用户查询。像之前一样，我们将使用 OpenAI 的gpt-4o-mini作为我们的基础模型。
model = ChatOpenAI(
model_name="gpt-4o-mini",
)
template = """
You are an AI assistant providing helpful information based on the given context.
Answer the question using only the provided context."
Context:
{context}
Question:
{question}
Answer:
"""
prompt = PromptTemplate(
template=template,
input_variables=["context", "question"]
)
qa_chain = RetrievalQA.from_chain_type(
llm=model,
retriever=retriever,
chain_type_kwargs={"prompt": prompt},
)
我们使用了RetrievalQA，它实现了包含文档检索和 LLM 问答能力的端到端管道。
第 4 步：运行 RAG 管道
是时候运行我们的 RAG 管道了。让我们构建一些与 ChromaDB 中摄取的文章相关的查询，并在 Langfuse 仪表板中观察 LLM 的响应。
queries = [
"What are the ways to deal with compliance and security issues in generative AI?",
"What are the key considerations for a successful generative AI launch?",
"What are the key benefits of Microsoft 365 Copilot Chat?",
"What are the best practices for setting up an in-house LLM platform?",
]
for query in queries:
response = qa_chain.invoke({"query": query}, config={"callbacks": [langfuse_handler]})
print(response)
print('-'*60)
如您可能已经注意到的，qa_chain中的callbacks参数赋予了 Langfuse 捕获完整 RAG 管道跟踪的能力。Langfuse 支持各种框架和 LLM 库，可以在这里找到。
第 5 步：观察跟踪
最后，是时候打开在网页浏览器中运行的 Langfuse 仪表板，收获我们辛勤工作的果实。如果您从开始就遵循了我们的教程，我们在名为datamonitor的组织下创建了一个名为data-demo的项目。在您的 Langfuse 仪表板首页上，您将找到这个项目。点击“进入项目”，您将找到一个具有各种面板的仪表板，例如跟踪和模型成本等。
带有跟踪和成本的 Langfuse 仪表板
如所见，您可以根据需要调整时间窗口并添加过滤器。酷的地方在于，您不需要手动添加 LLM 的描述和输入/输出令牌成本来启用成本跟踪；Langfuse 会自动为您完成。但这还不是全部；在左侧栏中，选择跟踪 > 跟踪来查看所有单个跟踪。由于我们已经提出了四个查询，我们将观察到四个不同的跟踪，每个跟踪代表针对每个查询的完整管道。
仪表板上的跟踪列表
每个跟踪都由一个 ID、时间戳区分，并包含相应的延迟和总成本。使用列显示了每个跟踪的总输入和输出令牌使用情况。
如果您点击任何这些跟踪，Langfuse 将描绘底层过程的完整图景，例如每个阶段的输入和输出，涵盖从检索、LLM 调用到生成的所有内容。有洞察力，不是吗？
跟踪详情
评估指标
作为一项额外功能，让我们也在同一仪表板上添加与 LLM 响应相关的自定义指标。在自托管解决方案中，就像我们实施的那样，这可以通过从仪表板获取所有跟踪，对这些跟踪应用定制评估并将它们发布回仪表板来实现。
评估可以通过简单地使用另一个合适的提示的 LLM 来实现。否则，我们可以使用评估框架，例如DeepEval或promptfoo等，这些框架在底层也使用了 LLM。我们将选择DeepEval，这是一个开源框架，旨在评估 LLM 的响应。
让我们按以下步骤进行此过程：
第 1 步：安装和设置
首先，我们安装deepeval框架：
$ pip install deepeval
接下来，我们进行必要的导入：
from langfuse import Langfuse
from datetime import datetime, timedelta
from deepeval.metrics import AnswerRelevancyMetric
from deepeval.test_case import LLMTestCase
from dotenv import load_dotenv
load_dotenv()
第 2 步：从仪表板获取跟踪
第一步是从运行中的 Langfuse 服务器中获取给定时间窗口内的所有跟踪到我们的 Python 代码中。
langfuse_handler = Langfuse(
secret_key="sk-lf-...",
public_key="pk-lf-...",
host="http://localhost:3000"
)
now = datetime.now()
five_am_today = datetime(now.year, now.month, now.day, 5, 0)
five_am_yesterday = five_am_today - timedelta(days=1)
traces_batch = langfuse_handler.fetch_traces(
limit=5,
from_timestamp=five_am_yesterday,
to_timestamp=datetime.now()
).data
print(f"Traces in first batch: {len(traces_batch)}")
注意，我们正在使用与之前相同的密钥和公钥，因为我们正在从我们的data-demo项目中获取跟踪。还请注意，我们正在从昨天的早上 5 点获取跟踪，直到当前时间。
第 3 步：应用评估
一旦我们有了跟踪数据，我们可以应用各种评估指标，例如偏差、毒性、幻觉和相关性。为了简化，让我们只关注AnswerRelevancyMetric指标。
def calculate_relevance(trace):
relevance_model = 'gpt-4o-mini'
relevancy_metric = AnswerRelevancyMetric(
threshold=0.7,model=relevance_model,
include_reason=True
)
test_case = LLMTestCase(
input=trace.input['query'],
actual_output=trace.output['result']
)
relevancy_metric.measure(test_case)
return {"score": relevancy_metric.score, "reason": relevancy_metric.reason}
# Do this for each trace
for trace in traces_batch:
try:
relevance_measure = calculate_relevance(trace)
langfuse_handler.score(
trace_id=trace.id,
name="relevance",
value=relevance_measure['score'],
comment=relevance_measure['reason']
)
except Exception as e:
print(e)
continue
在上面的代码片段中，我们定义了calculate_relevance函数，使用 DeepEval 的标准指标计算给定跟踪的相关性。然后我们遍历所有跟踪，并单独计算每个跟踪的相关性得分。langfuse_handler对象负责将这个得分记录到仪表板上的每个跟踪 ID。
第 4 步：观察指标
现在如果您关注与之前相同的仪表板，‘得分’面板也已经填充完毕。
您会注意到相关性得分已经添加到单个跟踪中。
您还可以查看 DeepEval 为每个跟踪提供的反馈。
这个例子展示了在仪表板上记录评估指标的简单方法。当然，在指标计算和处理方面还有更多内容，但让我们留待将来。同样重要的是，您可能会想知道在运行应用程序的仪表板上记录评估指标的最合适方式。对于自托管解决方案，一个直接的答案是运行评估脚本作为Cron Job，在特定时间执行。对于企业版本，Langfuse 提供了 LLM 响应的实时评估指标，因为它们已经在仪表板上填充。
高级功能
Langfuse 提供了许多高级功能，例如：
提示管理
这允许使用 Langfuse 仪表板 UI 进行提示的管理和版本控制。这使用户能够关注提示的演变，并记录每个版本的提示的所有指标。此外，它还支持提示游乐场来调整提示和模型参数，并直接在 Langfuse UI 中观察它们对整体 LLM 响应的影响。
数据集
数据集功能允许用户创建一个基准数据集来衡量 LLM 应用程序对不同模型参数和调整后的提示的性能。随着新的边缘情况被报告，它们可以直接输入到现有的数据集中。
用户管理
这个功能允许组织跟踪与每个用户相关的成本和指标。这也意味着组织可以追踪每个用户的活动，鼓励公平使用 LLM 应用程序。
结论
在本教程中，我们探讨了 LLM 监控和可观测性及其相关概念。我们使用 Langfuse——一个开源框架，提供免费和企业级解决方案——实现了监控和可观测性。选择自托管解决方案，我们使用 Docker 文件和 PostgreSQL 服务器设置了 Langfuse 仪表板以实现持久化。然后，我们使用 Langfuse Python SDK 在我们的示例 LLM 应用程序中启用了仪表化。最后，我们在仪表板中观察了所有跟踪，并使用 DeepEval 框架对这些跟踪进行了评估。
在未来的教程中，我们可能还会探索 Langfuse 框架的高级功能或探索其他开源框架，如 Arize Phoenix。我们可能还会致力于在云服务（如 Azure、AWS 或 GCP）上部署 Langfuse 仪表板。
浙公网安备 33010602011771号