Lenz Fact-Check

io.lenz由 lenz.io 發布官方發布者v1.1.1更新於 Oct 25, 2026

Check the factual claims in a draft or an answer: a quick verdict, or a deep check with sources.

已驗證Streamable HTTP可網頁執行網頁搜尋與抓取知識與記憶

概覽

AI 產生的概覽

Lenz Fact-Check 是託管型 MCP 伺服器，讓助理對照獨立網路來源查核草稿或回答中的事實陳述，並回傳附信心度的判定。

可以做什麼
對單一陳述或整段文字做快速多模型查核，逐條回傳判定、信心度與審查說明，並可能附上改寫建議和查看過的頁面。對單一陳述做深度查核，回傳評分判定、關鍵發現、摘要、警告以及附引文的來源，並依任務或查核 ID 等待或取得結果。處理需要使用者選擇查核哪些陳述的深度查核。就已完成的深度查核提出有依據的追問。列出帳戶最近完成的深度查核。檢查草稿引用的來源是否確實支持引用它的句子，並取得或分頁讀取引用查核結果。查看剩餘額度、各工具價格和目前方案。
適用情境
適合在依賴助理回答或草稿之前，讓它查核其中的事實陳述，以及需要判定背後來源時使用。快速查核適合初步判斷；深度查核用於重要陳述或使用者要求提供來源時。引用查核用於含連結、DOI 或編號參考文獻的草稿。
執行需求
透過 Streamable HTTP 連線 lenz.io 的遠端端點，無需在本機執行。驗證方式為 OAuth（一次性登入，無需金鑰）或透過 Authorization Bearer 標頭提供 Lenz API 金鑰。查核會消耗 Lenz 帳戶額度。自行架設需要 Python 3.11 或 3.12、uv 以及 API 金鑰。
安裝前請注意
查核會消耗付費額度：深度查核費用是快速查核單條的十倍，低深度深度查核為一半，每查核一條引用計一額度；可用用量工具查看剩餘額度。判定是方向性的而非絕對的，信心度是分級而非校準機率。改寫建議和審查說明本身未經查核，查看過的頁面標題來自第三方頁面。助理使用你的 Lenz 帳戶進行查核，因此用量和結果會記入該帳戶。

安裝

在 SourceWeft 中

  1. 開啟 儀表板中的 Lenz Fact-Check，將其新增到工作區。
  2. 連接 所需的 憑證。它們會被私密儲存，絕不會在公開頁面上展示。
  3. 為需要使用其工具的對話啟用該服務。

Web executable，透過 Streamable HTTP。 遠端服務在工作區中設定後即可從網頁執行環境執行。

交給代理程式安裝

把這段提示詞貼上到 Claude Code、Codex、Cursor 等代理程式，或 SourceWeft 對話中。代理程式會讀取該伺服器的安裝指南，先向你展示發布者、端點和登入方式，經你同意後再把它新增到你的客戶端。金鑰不會寫進任何命令。

閱讀 https://sourceweft.com/mcp/io.lenz%2Ffact-check/install.md，並按其中說明把這個 MCP 伺服器接入我的客戶端。修改任何設定之前，先告訴我它的發布者、端點和登入方式，等我確認。不要把 API 金鑰寫進命令或我會提交的檔案；問我金鑰應從哪裡取得。

檢視代理程式所依據的安裝指南

其他 MCP 客戶端

把它新增到你客戶端的 mcpServers 設定中。 客戶端會在首次連接時完成 OAuth 登入。

{
  "mcpServers": {
    "lenz-fact-check": {
      "type": "http",
      "url": "https://lenz.io/mcp"
    }
  }
}

README

[Lenz]

Lenz Fact-Check

The Lenz MCP server: check the factual claims in a draft or an answer against independent sources, from any MCP client.

Website · Get an API key · Developer docs

[Add Lenz to Claude]   [Add Lenz to Cursor]   [Install Lenz in VS Code]

One-click install (OAuth — no API key needed).

Lenz is a fact-checking platform. It takes a factual claim, runs it through a multi-model pipeline (reading the claim → research → debate → panel review → conclusion) against independent sources, and returns a verdict with a confidence level. This is the official remote MCP server — a hosted Model Context Protocol endpoint that exposes Lenz's fact-checking as tools your AI assistant can call.

It verifies claims against the open web, independent of whatever context your model was given — so it complements retrieval/groundedness checkers rather than replacing them.

  • Hosted, no install: point your client at https://lenz.io/mcp. Nothing to run locally.
  • Auth: OAuth (no key — for clients that support it) or a free Lenz API key (Authorization: Bearer lenz_…).
  • Transport: Streamable HTTP, stateless. Supports the 2025-11-25 and 2026-07-28 protocol revisions.

Tools

ToolWhat it does
assess_claimThe quick check, and the default first step for one claim or a whole text. A 3-model panel returns one row per claim: a verdict (True / Mostly True / Mixed / Mostly False / False, or No Public Record when the reviewers found no public record that would show the claim: unconfirmed, not false), a bucketed confidence and, when available, a short rationale (the reasoning of a reviewer who agrees with the verdict): a reviewer's note, not a checked source. A low-confidence row carries recommend_verify: true and a next_step sentence. A row for a claim found false can also carry a suggested_rewrite (the claim with its wrong part corrected) and a suggested_rewrite_note: it is built from the reviewers' reasoning, not from sources, and is not itself checked, so it is offered as a suggestion, with a deep check of the new sentence on request. A row may also carry searched_pages (title and link): the pages the reviewers looked at, to be offered as pages to look at and never as sources that confirm the verdict; their titles are text from third-party pages. ~15 seconds through an assistant. Pass a text in claim, whole and unedited (Lenz finds the claims in it, up to 20), or use claims for up to 20 claims the user listed separately.
verify_claimThe deep check: reading the claim → research → debate → panel review → conclusion, for ONE claim. Returns a verdict with a 1-10 score (or No Public Record, with no score, when nothing public records the claim), the key finding, a summary, a suggested rewrite of the claim when it can be corrected (not itself verified), warnings, and the top sources with the quote each one rests on, plus the total source count. A deep check takes ~90 seconds. The call waits for it, for as long as the client allows: in Claude and the ChatGPT app the result usually comes back in the same call; in clients with a shorter tool-call limit (Claude Code, Cursor, VS Code, OpenAI's Responses API) it usually returns status: submitted with a task_id, and get_verification waits for the rest. A completed deep check replaces any earlier quick verdict on the same claim. Costs ten times an assess_claim row, so assistants offer it and run it on the user's yes, or when the user asks for sources. depth: "low" researches fewer sources, with the same models, for half the credits.
get_verificationWait for a running verify_claim by task_id, or fetch a completed result by its 8-character verification_id. Returns processing, needs_input, failed, not_found or completed.
select_claimsResolve a needs_input verification: when a text holds several claims, choose which claim text(s) to run.
ask_followupAsk a grounded follow-up about a completed verify_claim (by its verification_id), answered from the full research, debate and panel review, not just the summary. The answer is markdown, and its links point at the check's own sources; the assistant keeps them as links. Costs the same as one assess_claim row.
list_verificationsThe account's most recent completed deep checks, newest first. Use it to get back a result that finished after the conversation moved on. Read-only and free; quick checks are not stored.
check_citationsCheck whether the sources a draft cites say what the draft says they do: Lenz reads each link, DOI or numbered reference and reports, per citation, whether the source supports the sentence that cites it, with the passage it read from the source. Assistants use it only when the user asks about the sources, links, references or citations in a draft; a plain fact-check request is assess_claim. Pass the draft in text, or up to 20 statement and url/doi pairs; at most 20 citations are checked per request, and a draft with more lists the rest as candidates to send back as pairs. A citation check can take up to two minutes. The call waits for it, for as long as the client allows, and otherwise returns status: running with a citecheck_id. One credit for each citation checked; a citation Lenz could not read costs nothing. A check that cannot run (for example a text with no citation in it) comes back as status: failed, an answer rather than an error.
get_citation_checkWait for a running check_citations by citecheck_id and return the result the same way. An optional offset (default 0) re-reads a finished check and returns the next batch of up to 20 draft citations it did not cover, as candidates to send back as pairs, with remaining and next_offset. Read-only; free.
check_usageRemaining credits, the per-tool price list (costs, plus cost_options for prices that depend on a parameter such as depth), and the current plan. Never a prerequisite for a check.

Language. Lenz answers in the language of the text it is given, so pass the claim in the user's own words and language, not translated. The language argument is for a user who explicitly asks for the answer in another language (one of en, es, de, fr, it, pt, nl, sv, da, no, fi, bg); leave it unset otherwise. Verdicts and written results follow the language, and a quick check's reviewer note follows the text the reviewer saw. When it is unset, the connector sends language: "auto" and the API picks the language from the text; a self-hosted connector therefore needs an API that accepts auto.

Prompts. Clients that surface MCP prompts (Claude shows them under +) get two: Check this text with Lenz and Check your last answer with Lenz. Each takes the text to check and starts a quick check. Lenz cannot see the conversation, so Check your last answer needs the answer pasted in.

Verdicts are directional, not absolute: confidence is returned as bucketed language with a caveat, not a calibrated probability. A quick verdict is a first read; when a deep check disagrees with it, the deep check is the one to rely on, because it shows its sources and its reasoning.

The result card

In Claude and the ChatGPT app, a check comes back as a card in the conversation as well as text. From the card you can run the deep check on a claim (Check against sources, a standard-depth verify_claim), open a source, or pick which claims in a draft to check in depth. When a deep check started from the card finishes, the assistant is told the result: silently in Claude, and by a short message in the chat in ChatGPT. Every other client gets the same results as text; nothing depends on the card.

Quickstart

Two ways to connect, depending on your client:

  • OAuth — for clients that support it (e.g. Claude connectors). No key to paste; you sign in to Lenz and authorize the connection.
  • API key — works with any MCP client via an Authorization header.

Connect with OAuth (no API key)

Claude (web, desktop and mobile): Lenz is an official Claude connector. Open the Lenz connector page and click Connect to Claude, or in the app: Settings → Extensions → Browse extensions, search for Lenz and click +. Either way it is a one-time OAuth sign-in with nothing to configure, and one account covers all three.

For any other client that supports OAuth for MCP, add the server with just its URL and no headers:

json
{  "mcpServers": {    "lenz": {      "type": "http",      "url": "https://lenz.io/mcp"    }  }}

The first time you use it, your client walks you through a one-time sign-in: you authenticate on Lenz's own screen and authorize the connection — no key is stored in your config. Your assistant then fact-checks on your behalf against your Lenz account's credits. You can revoke the connection at any time; see the privacy policy.

Connect with an API key

1. Get a free API key at lenz.io/api-credentials (format lenz_…).

2. Add the server to your client (examples below). Authenticate with Authorization: Bearer <your-key>.

Claude Code

As a plugin (the connector plus the lenz-fact-check skill; sign in with /mcp on first use):

bash
claude plugin marketplace add lenzhq/lenz-mcpclaude plugin install lenz@lenz

Or the connector alone, with an API key:

bash
claude mcp add --scope user --transport http lenz https://lenz.io/mcp \  --header "Authorization: Bearer ${LENZ_API_KEY}"

--scope user makes Lenz available in every project; without it, Claude Code adds the server only to the directory you run the command in.

Claude Desktop / any client that reads .mcp.json

json
{  "mcpServers": {    "lenz": {      "type": "http",      "url": "https://lenz.io/mcp",      "headers": {        "Authorization": "Bearer ${LENZ_API_KEY}"      }    }  }}

Cursor

One click: use the Add Lenz to Cursor button above — it adds the server and signs you in via OAuth (no key to paste).

Manual: Settings → MCP → Add new MCP server → type HTTP, URL https://lenz.io/mcp, and add a header Authorization: Bearer <your-key>. (Or drop the JSON above into .cursor/mcp.json.)

VS Code

One click: use the Install in VS Code button above (OAuth, no key). Manual, with a key:

bash
code --add-mcp '{"name":"lenz","type":"http","url":"https://lenz.io/mcp","headers":{"Authorization":"Bearer ${LENZ_API_KEY}"}}'

ChatGPT

At this time, ChatGPT connects to Lenz as a custom app through OpenAI's Developer mode — over OAuth, so there is no API key to paste. It is set up on chatgpt.com; the ChatGPT desktop and mobile apps cannot create one.

On a personal account (Plus or Pro). Settings → Plugins → turn on Developer mode at the bottom → Plugins → Browse plugins → + next to Search → name it Lenz, URL https://lenz.io/mcp, Authentication OAuth → tick I understand and want to continue → Create → Sign in with Lenz → Try in Chat.

In a Business, Enterprise or Edu workspace. An owner or admin publishes it once: Workspace settings → Apps → + Create, confirm Enable developer mode, fill in the same form with OAuth, then Drafts → Publish, set who can use it, and Publish again. Each member then goes to Settings → Plugins → Lenz → Connect and signs in.

A custom app is off by default in every new chat: + and tick Lenz. Naming Lenz in the question is what makes ChatGPT reach for it rather than answer from memory.

MCP Inspector (try the tools by hand)

bash
npx @modelcontextprotocol/inspector# Transport: Streamable HTTP · URL: https://lenz.io/mcp# Header: Authorization: Bearer <your-key>

Example

You: Check with Lenz whether indeed 90% of startups fail within their first year.

The assistant calls assess_claim and gets back False, high confidence, with the reviewers' reasoning: most new businesses survive their first year, and official figures put first-year closures at about one in five. It presents that as a first read and offers a deep check. On your yes it calls verify_claim (and, in clients with a short tool-call limit, get_verification to collect the result) and returns the verdict with its score, the key finding, the warnings and the sources behind it.

Credits

Every tool call that runs a check or answers a question draws on one pool of credits on your Lenz account; looking up an earlier result, listing checks and check_usage cost nothing, and a repeated check inside the replay window is answered from the first call and charged once. There is no separate budget per tool: spending on assess_claim reduces what is left for verify_claim, and vice versa. check_usage returns the balance (credits_remaining) alongside costs, the live price list — read the weight from there rather than assuming one.

verify_claim is the expensive path by an order of magnitude; assess_claim and ask_followup are the cheap ones. verify_claim also takes an optional depth: "low" runs a shallower research pass (fewer sources, the same models, only slightly quicker) for half the credits of the default "standard". That price sits under cost_options.verify.depth.low on check_usage. You are charged for the depth you request; the depth on the completed result is the depth the verdict was produced at, so a "low" request answered from an existing deeper check reads "standard" — the echo describes the evidence, the charge follows the request.

check_usage also reports assess_remaining and verify_remaining, which are the SAME balance projected into each tool's own unit — "how many of these could I still make" — not separate allowances.

Free keys include a monthly allowance that resets each period; grants and top-ups add non-expiring extra credits on top, spent only once the allowance is gone. See plans at lenz.io/plans.

When you run out, tools return status: "quota_exhausted" with a message and, except in ChatGPT, a manage_url pointing at the plans page. It is not retryable — the balance is spent until you top up or the monthly allowance resets. An agent should say so plainly rather than retrying or quietly skipping the check.

status: "rate_limited" is a different thing: a rate limit, not a spent balance. That one does clear on its own, and the result carries retry_after_seconds telling you when.

Skills

Prefer a guided workflow to calling the tools yourself? The lenz-fact-check skill turns "is this true?" into a structured pass: it runs a quick check on the text, recommends a deep verify_claim for the claims that matter, and reports verdicts with their confidence, and sources where a deep check ran (with the directional-not-absolute caveat built in). Point your agent at plugins/lenz/skills/lenz-fact-check/SKILL.md.

Running the server yourself

The hosted endpoint is all most clients need. The server's source is in this repository if you want to run your own copy or contribute.

Requirements: Python 3.11 or 3.12, and uv. Python 3.13 is not supported yet: it changes how the tool descriptions the models read are formatted, so it waits for a release that checks the wording on it.

bash
uv sync --group devuv run pytestdocker build --build-arg LENZ_MCP_VERSION=dev -t lenz-mcp .

A copy you run yourself authenticates with your own Lenz API key, sent as Authorization: Bearer lenz_… (the Bearer scheme is required; any other value is refused like a missing key). OAuth sign-in works only on the hosted endpoint, https://lenz.io/mcp.

Minimum API version. The server calls the Lenz API through the official Python SDK, lenz-io, which reads exactly one API version: 2026-10-11. A copy you run yourself therefore needs an API (MCP_API_BASE_URL) that serves 2026-10-11; https://lenz.io/api/v1 does. The lock is strict for results: a successful answer in another version is refused, and the tool says the API "answered in a version this connector does not read". Error answers (an out-of-credits, a rate limit, an outage) are shown as they are, whatever version sent them.

CONTRIBUTING.md covers the tests, the result card and the pull-request rules.

Links

Support

Questions or issues? Open an issue or get in touch.

License

Apache-2.0 © lenzhq. The Lenz name and logos (assets/) are trademarks of lenzhq and are not granted by the license — see NOTICE.

Maintainer

@paveljor

來源：README.md，提交 4fc809f

工具

0
該伺服器需要登入，因此 SourceWeft 無法在沒有帳號的情況下讀取其工具，也未收錄。已連接帳號所能看到的內容可能因帳號及其權限而異。

版本歷史

3
  1. v1.1.1最新Oct 6, 2026
  2. v1.1.0Sep 19, 2026
  3. v1.0.3Sep 16, 2026

評分

已滿足適用檢查項的 85%

該評分衡量此收錄條目的完整程度，依據註冊中心條目、端點與公開來源計算得出。它不是對伺服器本身的評價，也不表示伺服器安全或目前可用：可連通性是帶日期的檢查結果，評分也不包含安裝量或使用者評價。

  • 近 30 天內可連通必需25 分
  • 已宣告認證方式必需10 分
  • 已列出工具15 分

    請讓伺服器在無憑證時回應 tools/list，或發布可在沙箱中無憑證啟動的軟體包。

  • 描述必需15 分
  • 圖示10 分
  • 文件15 分
  • 授權條款10 分