World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
// 中文语言包。结构由 en.ts 定死(`Strings = typeof en`)——漏一条、多一条、
// 函数签名对不上,都是编译错误。这是唯一靠得住的同步办法:512 条字符串靠人眼对不齐。
//
// 术语约定:知识库 / 工作区 / 本体 / 类 / 实体 / 关系 / 属性 / 事实 / 证据 /
// 抽取 / 摄入 / 来源 / 文本块 / 图谱 / 审阅 / 冲突 / 合并 / 置信度 / 时态 /
// 函数性 / 提示词 / 三元组。
//
// **不译的东西**:品牌字标(Utopia / Persona / Charter)、标识符(key、IRI)、
// 产品名(DeepSeek、Ollama…)、URL。字标不译是因为它们是标记不是词。
import type { Strings } from "./en";
export const zh: Strings = {
expressionDraft: {
title: "表达式草稿探索",
unsaved: "仅为未保存的草稿,不会写入知识库,也不检查单位兼容性。",
undeclared: "未声明",
attribute: "属性",
constant: "数字",
add: "加 (+)",
sub: "减 (−)",
mul: "乘 (×)",
div: "除 (÷)",
expression: "表达式",
left: "左操作数",
right: "右操作数",
kind: "节点类型",
depthLimit: "已达嵌套深度上限,请选择属性或数字。",
choose: "搜索并选择…",
missing: "属性已不可用",
loading: "正在读取属性和规则…",
loadError: "无法读取此知识库,请检查访问权限后重试。",
retry: "重试",
empty: "此知识库尚无属性。",
conclusion: "结论",
condition: "条件",
existing: "探索已有表达式",
unsupported: "此表达式结构尚不支持,未对其进行转换。名称和说明仍可在原规则编辑器中修改。",
preview: "草稿预览(未保存)",
incomplete: "请为每个操作数选择可用属性或填写有限数字以预览。",
reset: "新建草稿",
count: (n: number) => `已读取此知识库的 ${n} 个属性`,
},
app: {
name: "Utopia",
/* 标语与出处都与 Utopia / Persona / Charter 同类:品牌的一部分,两种语言同值 */
tagline: "We rather wish than hope to see.",
taglineSource: "— Thomas More, 1516",
siteUrl: "https://utopia.bi",
docsUrl: "https://utopia.bi/docs",
},
err: {
bad_email: "这看起来不像一个邮箱地址。",
password_too_short: "密码至少 8 位。",
bad_display_name: "显示名需要 1–64 个字符。",
wrong_password: "当前密码不对。",
registration_closed: "本部署已关闭自助注册——请找管理员开通账户。",
password_login_disabled: "本部署已关闭密码登录,请用单点登录。",
no_chat_model: "还没有配置对话模型。到「管理 → 模型」里配一个。",
// 对话流里没答成的那一轮:`error` 帧带的 code(服务端的英文原句只给日志)
answer_empty: "模型没有给出回答,请再问一次。",
answer_tool_text: "模型把工具调用写成了正文,没有作答,请再问一次。",
answer_tool_call: "查证次数用完后模型仍在调用工具,请再问一次。",
answer_too_long: "回答超出了长度上限,没有保留。",
answer_failed: "这次没能答完,请再问一次。",
answer_not_saved: "回答没能保存,请稍后再试。",
search_failed: "没能检索文档。",
mapping_search_failed: "没能检索相关数据映射。",
stream_ended: "回答的连接意外中断了。重新打开这个对话,看看结果如何。",
stream_lagged: "这个页面跟不上回答的速度,请重新打开这个对话。",
model_out_of_credit: "模型账号付不起这次请求。去给账号充值,或者在「管理 → 模型」里换一个能用的端点。",
model_rate_limited: "模型端点在限流,稍等一会儿再问。",
model_unavailable: "模型端点暂时不可用,请稍后再试。",
model_unreachable: "模型端点没有给出可用的回答。去「管理 → 模型」里检查端点地址。",
context_too_long: "这场对话超出了模型的上下文长度。请新建一场对话。",
model_rejected: "模型端点拒绝了这次请求。去「管理 → 模型」里检查模型设置。",
answer_running: "这个对话里还有一个回答正在生成,等它写完再试。",
retry_answered: "这个问题已经有回答了,或者后面已经接着问了别的。",
retry_not_question: "只有问题可以重答。",
retry_needs_conversation: "重答要指明问题所在的对话。",
bad_upload: "这次上传读不出来。",
upload_read_failed: "文件没能读完。",
no_files: "没有附带文件。",
upload_needs_folder: "文件只能上传到「文件夹」类型的来源里。",
empty_file: "这个文件是空的。",
file_too_large: "文件太大了——上限是 8 MB。",
bad_ontology_file: "这不是一个能读的 OWL 或 RDFS 文件。",
bad_name: "名称需要 1–64 个字符。",
default_kb_open: "默认知识库对所有人开放——需要私密空间就另建一个。",
default_kb_undeletable: "默认知识库不能删除。",
last_owner_demote: "这是最后一位所有者——先把另一个人提上来。",
last_owner_remove: "这是最后一位所有者——先把所有权交出去。",
key_required: "需要填 key。",
forms_required: "至少选一个这个关系涵盖的说法。",
bad_key: "key 只能用小写字母、数字和下划线,最长 40 个字符。",
self_parent: "一个类不能是自己的父类。",
parent_cycle: "那个类已经在这个类下面了——层级会成环。",
bad_lang: "选一个支持的语言。",
attr_needs_class: "属性必须挂在某个类上。",
builtin_name_attribute: "名字属性是内建的,不能修改。",
attr_has_no_link:
"属性没有逆,也没有父属性——它的宾语是字面值,谈不上反过来指回来。",
link_target_is_attr: "要选一条关系,不是属性——属性的值是字面量。",
sub_property_self: "一条关系不能是自己的父属性。",
unknown_relation: "这个知识库里没有这条关系。",
entity_name_required: "名称不能为空。",
entity_name_too_long: "名称太长了——最多 100 个字符。",
unknown_entity_type: "这个类不在当前本体里。",
nothing_to_update: "没有要改的内容。",
self_merge: "实体不能合并到自己身上。",
close_at_required: "选一个这条事实结束的日期——新的那条没说自己何时开始。",
empty_query: "输入点什么再检索。",
no_data_sources: "这个知识库没有挂载任何数据库。",
// 授权是逐工作区的(0014):源没授权给本库所属的工作区
source_not_granted:
"这个数据源没有授权给本工作区。请部署管理员在「管理 → 数据源」里授权。",
memory_source_permanent: "「记忆」是知识库自带的来源,会一直在。",
source_name_required: "给这个来源起个名字。",
bad_cron: "这个 cron 表达式解析不了。",
bad_cron_fields: "cron 表达式有五段:分 时 日 月 周。",
ds_name_required: "给这个数据源起个名字。",
only_postgres: "目前只支持 PostgreSQL。",
bad_conn_string: "连接串要以 postgres:// 开头",
// 刷新结构失败;引擎的原话走 detail(括号里那句)
schema_sync_failed:
"库表结构没能读出来——引擎的原话在括号里。确认连接串里的库、schema 与账号权限," +
"再点「刷新结构」试试。",
concurrency_range: "填一个 1 到 256 之间的数。",
inference_off: "这个库没有打开物化推理。到设置里开。",
bad_resolution: "这不是一个有效的裁决。",
interval_inverted: "终点早于起点。请给一个晚于起点的终点。",
empty_state_span: "起止相同的状态任何时刻都不成立。给一个晚于起点的终点,或者让它开着。",
unknown_marks: "单个日期标的是开始、结束,或者都不是。",
marks_needs_state: "只有状态属性才说单个日期标的是什么,事件与恒常属性不说。",
// 采纳提案(0061 决定 3):撞上别的写、整次回滚了;复用要写的都已由人另定
alignment_busy: "另一项操作正在改同样的内容,这次什么都没保存,请稍后再试。",
proposal_stale:
"这条提案已经没有可采纳的了:它的每个短语或类别词要么已由人另行判定,要么已不在任何陈述里。拒绝它就能清掉。",
},
errDetail: (msg: string, detail: string) => `${msg}(${detail})`,
toast: {
saved: "已保存",
created: "已创建",
deleted: "已删除",
added: "已加入本体",
copyFailed: "无法复制,请选中文字后手动复制。",
},
account: {
brand: "Utopia Persona",
titleTag: "Persona",
profile: "个人资料",
cancel: "取消",
colLastUsed: "上次使用",
colCreated: "创建于",
pickBases: "搜索知识库…",
administration: "管理",
adminChip: "管理员",
backToApp: "← 返回",
profileTitle: "个人资料",
displayName: "显示名称",
email: "邮箱",
save: "保存",
passwordTitle: "修改密码",
currentPassword: "当前密码",
newPassword: "新密码(至少 8 位)",
changePassword: "更新密码",
passwordChanged: "密码已更新",
sso: {
title: "单点登录",
hint: "绑定你在身份提供方的账号,之后可以用单点登录。会跳到身份提供方那边确认是你本人。",
linkedAs: (subject: string) => `已绑定:${subject}`,
notLinked: "尚未绑定。",
link: "绑定身份",
unlink: "解绑",
unlinkTitle: "解绑单点登录?",
unlinkHint: "重新绑定之前,没法再用单点登录。已经打开的会话仍保持登录。",
linked: "身份已绑定,可以用单点登录了。",
unlinked: "身份已解绑。",
},
avatarHint: "头像目前由你的名字生成。",
language: "语言",
theme: "主题",
themeNames: { dark: "深色", light: "浅色", system: "跟随系统" } as Record<"dark" | "light" | "system", string>,
kbsNav: "知识库",
kbsTitle: "知识库",
kbsFilter: "按名字筛选…",
kbOpen: "公开",
kbRestricted: "受限",
kbNameLabel: "知识库",
kbRoleLabel: "我的身份",
kbDocsLabel: "文档",
kbMembersLabel: "成员",
kbAccessLabel: "权限来源",
addedBy: (name: string, date: string) => `由 ${name} 加入 · ${date}`,
joinedOn: (date: string) => `${date} 加入`,
openToEveryone: "对所有人开放",
deploymentAdmin: "部署管理员",
openKb: "打开",
kbSettingsBtn: "设置",
tokensNav: "Agent 与令牌",
tokensTitle: "个人访问令牌",
tokensHint: "令牌让 agent 以你的身份通过 MCP 访问 Utopia,权限不超过你自己。默认只读,限定在你选的库,可随时在这里撤销。",
newToken: "新令牌",
tokenName: "名字",
tokenNamePlaceholder: "我的笔记本",
tokenScope: "范围",
scopeRead: "只读",
scopeWrite: "可写",
scopeHint: "是上限,不是授权——令牌永远不会比你自己能做的更多。",
tokenKbs: "知识库",
kbsAllHint: "一个都不选 = 你能进的全部库。",
tokenExpires: "过期",
expiresDays: (n: number) => `${n} 天`,
expiresNever: "不过期",
issueToken: "创建令牌",
issuedTitle: "现在就复制,之后不会再显示。",
issuedHint: "Utopia 只保存它的哈希。丢了就在这里撤销,再建一枚。",
copy: "复制",
copied: "已复制",
mcpTitle: "MCP 客户端配置",
mcpHint:
"适用于 Claude Code、Claude Desktop 及其它 Streamable HTTP 客户端。每个库有自己的端点,选 agent 要对话的那个库。别的客户端键名可能不同。",
mcpBase: "库",
yourTokens: "你的令牌",
noTokens: "还没有令牌。",
allBases: "全部库",
nBases: (n: number) => `${n} 个库`,
lastUsed: (d: string) => `最近使用 ${d}`,
neverUsed: "从未使用",
expiresOn: (d: string) => `${d} 过期`,
noExpiry: "不过期",
createdOn: (d: string) => `${d} 创建`,
revoke: "撤销",
revokeConfirm: "确认撤销?",
revokedOn: (d: string) => `${d} 已撤销`,
tokenDone: "完成",
roleNames: {
owner: "所有者",
admin: "管理员",
editor: "编辑者",
viewer: "只读",
},
},
docs: {
brand: "Utopia Charter",
backTitle: "返回 Utopia",
searchPlaceholder: "搜索文档…",
noResults: "没有匹配。",
},
alerts: {
title: "告警",
badgeLabel: "告警",
empty: "没有需要处理的",
emptyHint: "摄入、同步、模型端点出问题时会出现在这里,而不是只留在日志里。",
markAllRead: "全部标为已读",
close: "关闭",
searchPlaceholder: "搜索来源、知识库、报错",
noMatch: "没有匹配的",
andMore: (n: number) => `还有 ${n} 条`,
system: "系统",
partialRows: (sheet: string, read: number, total: number) =>
`${sheet}:只读了 ${read}/${total} 行`,
partialRecords: (read: number, total: number) =>
`只读了 ${read}/${total} 条记录`,
kinds: {
"source.sync_failed": {
title: "来源同步失败",
hint: "它没有带进新内容。去来源设置里看一下。",
},
"data_source.schema_sync_failed": {
title: "数据源挂上了,库表结构没进来",
hint: "问数看不见有哪些表,只能猜列名。检查连接串,然后点「刷新结构」。",
},
"mapping.exploration_empty": {
title: "映射探索没有提出任何口径",
hint: "模型读了挂载的库表结构,但没找到可提的指标或维度。到「数据映射 > 数据源」刷新结构、给列加注释,再探索一次。",
},
"document.needs_reader": {
title: "有文件要靠模型才读得出来",
hint: "扫描件和图片要配文档识别服务,录音要配能分出说话人的转写模型;每一行写着缺的是什么。文件已经留着,还没读出任何内容;到「管理 > 模型」存好读取模型,就会自动读。",
},
"document.contents_truncated": {
title: "文件只读了一部分",
hint: "解析器到了安全上限。提示行会写明漏掉的是哪个工作表或记录范围;检索和回答不包含被省略的部分。",
},
"governance.tripped": {
title: "agent 停止自动裁决了",
hint: "七天内它的合并被撤回了两次,开关已自动关掉。到「审核 > Agent」看看它做了什么,想让它接着跑就在库设置里再打开。",
},
"llm.unreachable": {
title: "模型端点没有给出可用的回答",
hint: "抽取与向量化已停摆。去「管理 → 模型」里检查端点地址。",
},
"llm.rate_limited": {
title: "模型端点在限流",
hint: "退避重试之后仍然被挡回来,有文档因此缺了事实。去「管理」里降低模型并发,或者把账号配额升一档。",
},
"llm.out_of_credit": {
title: "模型账号付不起请求",
hint: "抽取与向量化已停摆,而且不会自己恢复。去给账号充值,或者在「管理 → 模型」里换一个能用的端点。",
},
} as Record<string, { title: string; hint: string } | undefined>,
unknownKind: (kind: string) => kind,
runAgain: "再跑一遍",
requeued: (n: number) => `${n} 个任务回到队列`,
},
kbScope: {
deniedTitle: "你没有这个知识库的权限",
deniedBody:
"链接指向的库你打不开。找分享给你的人开通权限,或者回到自己的库。",
missingTitle: "这个知识库不在了",
missingBody: "它已被删除,或者链接抄错了。下面是你自己的库。",
myKbs: "我的知识库",
},
nav: {
workspaceLabel: "工作区",
kbLabel: "知识库",
findKb: "查找知识库…",
noKbMatch: "没有匹配的知识库",
ask: "对话",
askHint: "与你的知识库对话——它会记住",
search: "检索",
searchHint: "混合检索",
graph: "图谱",
graphHint: "实体与时间线",
library: "文库",
libraryHint: "文档与摄入",
settings: "设置",
settingsHint: "模型与成员",
signOut: "退出登录",
docs: "文档",
loading: "加载中…",
serverUnreachable: "罚则 500:Utopia 沉默了——它没有回应。",
notFound: "罚则 404:你在 Utopia 里迷了路。",
returnHome: "回到首页",
reportIssue: "反馈问题",
refresh: "刷新",
},
/* 空状态的共用文案(#313):状态一句话,动作在按钮上,不解释原理 */
steps: {
noModel: "还没配置对话模型。",
noModelAsk: "还没配置对话模型,请联系管理员。",
configureModel: "配置模型",
noDocs: "还没有文档。",
upload: "上传文档",
processing: (n: number) => `正在读取 ${n} 份文档…`,
viewProgress: "查看进度",
someFailed: (n: number) => `${n} 份文档处理失败。`,
nothingExtracted: "还没抽取出内容。",
openLibrary: "打开文库",
},
login: {
signIn: "登录",
signUp: "注册",
displayName: "显示名称",
email: "邮箱",
password: "密码(至少 8 位)",
submitting: "稍候…",
createAccount: "创建账户",
networkError: "网络异常,请重试",
orDivider: "或",
ssoButton: "使用单点登录",
ssoErrors: {
unlinked: "这个身份还没绑定任何账号。先用密码登录,再到账户页绑定。",
unlinked_sso_only: "这个身份登不进本部署,请找管理员开通。",
cancelled: "单点登录已取消。",
denied: "身份提供方的应答没能通过校验。",
session: "这次登录是在另一个浏览器会话里开始的,请重试。",
expired: "登录耗时太久,请重试。",
busy: "同时进行的登录太多,请稍后再试。",
unavailable: "单点登录暂时不可用。",
invalid: "登录请求不完整,请重试。",
taken: "这个身份已经绑定到另一个账号。",
already_linked: "你的账号已经绑定了一个身份,请先解绑。",
} as Record<string, string>,
ssoErrorOther: "单点登录失败,请重试。",
agreePrefix: "继续即表示你同意",
agreeAnd: ",并已知悉",
agreeSuffix: "。",
githubUrl: "https://github.com/deeplethe/utopia",
},
legal: {
privacyTitle: "隐私政策",
termsTitle: "使用条款",
backToSignIn: "← 返回登录",
privacy: {
title: "隐私政策",
note: "Utopia 自带的默认文本。运营本部署的组织可以替换成自己的政策。",
sections: [
{
h: "一个自部署的平台",
body: [
"Utopia 完全运行在部署方(运营者)自行选择的基础设施上。Utopia 项目本身接触不到这个部署:软件不向任何人发送遥测、分析或崩溃报告。",
],
},
{
h: "本实例存了什么",
body: ["以下全部存放在运营者自己的服务器上:"],
bullets: [
"账户信息——你的邮箱、显示名,以及密码的哈希值。",
"内容——上传的文档、从中抽取的文本、检索索引与向量,以及据此构建的知识图谱(实体、关系及其出处)。",
"活动记录——你与助手的对话、审阅决定与摄入日志,保留它们是为了让依赖它们的功能能够工作。",
],
},
{
h: "数据在什么情况下会离开这台服务器",
body: [
"若运营者为对话或向量化配置了外部模型服务商,文档片段与你的消息会被发送给该服务商,用于回答问题与索引内容。用哪家服务商——或是否使用完全本地的模型——是一项部署设置。除此之外不向任何地方发送任何内容。",
],
},
{
h: "谁能看到什么",
body: [
"访问权限按知识库角色划分:只读成员能看到被授权的知识库,编辑者可以修改内容,管理员管理成员与设置。部署管理员可以创建账户并查看用户列表。",
],
},
{
h: "留存与删除",
body: [
"删除一篇文档会把它移出知识库,并让只以它为出处的事实一并失效;另有出处的事实保留,出处照旧。内容会留着以便撤销:删除可以恢复,重新上传同一份文件也会恢复它。知识库管理员可以清除已删除的文档,其存储内容将被彻底移除。删除一个知识库会永久移除它的文档、图谱与来源。",
],
},
{
h: "有疑问",
body: [
"本部署由你所在的组织运营。关于数据在此如何被处理的问题,请联系该组织的管理员。",
],
},
],
},
terms: {
title: "使用条款",
note: "Utopia 自带的默认文本。运营本部署的组织可以替换成自己的条款。",
sections: [
{
h: "关于这份条款",
body: [
"这个 Utopia 实例由部署它的组织运营,而非 Utopia 项目。你对它的使用受该组织自身政策约束;在运营者替换之前,这份默认条款覆盖基本事项。",
],
},
{
h: "你的账户",
body: [
"请勿将凭据交给他人。管理员可依据运营者的政策创建、停用或移除账户。",
],
},
{
h: "可接受的使用",
body: [],
bullets: [
"只上传你有权在组织内存储与共享的内容。",
"尊重访问级别:不要试图查看或修改超出你所获角色的知识库。",
"不得利用本平台存储或传播违法内容。",
],
},
{
h: "AI 生成的回答",
body: [
"助手的回答由语言模型基于你所在组织的文档生成,并附引用。它们可能出错或不完整——在依赖之前,请对照被引用的原文核实。",
],
},
{
h: "关于本软件",
body: [
"Utopia 是开源软件,按「原样」提供,不附带任何形式的担保。运营本部署的责任——包括备份、可用性与合规——由运营者承担。",
],
},
],
},
},
library: {
deletedWithFacts: (n: number) =>
n === 0 ? "文档已删除" : `文档已删除 · 随之失效 ${n} 条事实`,
undo: "撤销",
restored: "文档已恢复",
deleted: "已删除",
colDeleted: "删除时间",
restore: "恢复",
purge: "清除",
purgeTitle: "清除这篇文档?",
purgeHint: (name: string) =>
`「${name}」已删除,内容还留着以便撤销。清除会把原文、分块与证据引文彻底移除;` +
"随它失效的事实保持失效,删除记录保留。此操作不可撤销。",
purgeConfirm: "清除",
purged: "内容已清除",
deletedEmpty: "没有已删除的文档。删掉的文档会在这里等着被恢复或清除。",
title: "文库",
upload: "上传文件",
uploading: "上传中…",
uploadFailed: "上传失败",
dropHint: "把文件拖到这里,或点击「上传文件」",
formats: "PDF · Word · Excel · PowerPoint · Markdown · HTML · TXT · CSV 等",
emptyPull: "还没有文档——这个来源同步时它们会出现。",
filterPlaceholder: "按名称筛选",
filterNoMatch: "没有文档匹配当前筛选。",
anyStatus: "全部抽取状态",
statusFailed: "失败",
statusDone: "已抽取",
statusQueued: "排队中",
statusExtracting: "抽取中",
statusNone: "未抽取",
retryFailed: (n: number) => `重试 ${n} 篇失败`,
retryQueued: (n: number) => `${n} 篇已排队`,
colFile: "文件",
colStatus: "状态",
colGraph: "图谱",
colChunks: "文本块",
colSize: "大小",
colSource: "来源",
delete: "删除",
extract: "抽取",
reExtract: "重新抽取",
reprocess: "重新处理",
extractProgress: (done: number, total: number) =>
`抽取中 · ${done} / ${total}`,
errorTitle: "失败详情",
errorParse: "摄入管道",
errorGraph: "图谱抽取",
copyError: "复制",
errorCopied: "错误信息已复制",
dropsChip: (n: number) => `丢弃 ${n} 条`,
dropsTitle: "没能落地的事实",
dropsNote:
"这些是从文档里抽出来的,但在写入途中被挡下了。每行说明原因与条数。",
dropsExample: "例如",
dropReason: {
object_missing: "关系缺少宾语",
malformed_item: "模型给的这一条结构不合",
truncated_reply: "模型的输出被截断",
quote_not_in_chunk: "已保留,但引文不是原文原样",
time_not_in_quote: "时间词不在原文里",
unknown_ref: "这一条指向的东西不在回复里",
chunk_unextracted: "这一段端点没能答上,没有进图",
phrase_is_value: "已保留,但短语就是那个值",
phrase_is_subject: "已保留,但短语就是主语的名字",
object_is_value: "已保留,宾语按值记下",
},
reExtractSource: "重新抽取",
reExtractTitle: "重新抽取这个来源?",
reExtractHint: (n: number, name: string) =>
`「${name}」中全部 ${n} 篇已就绪的文档会再走一遍抽取模型。` +
`已有的合并、审阅决定与已确认的事实都会保留。`,
reExtractConfirm: "重新抽取",
queuedDocs: (n: number) => `已排队 ${n} 篇文档`,
rebuild: "重建图谱",
rebuildTitle: "重建知识图谱?",
rebuildHint: (docs: number, name: string) =>
`输入「${name}」确认。本知识库中的每一个实体、事实、合并与待审阅项都会被永久移除,` +
`随后全部 ${docs} 篇文档从头重新抽取。` +
`文档、检索索引与本体不受影响;决策台账保留。`,
rebuildConfirm: "永久重建",
rebuildDone: (e: number, f: number, q: number) =>
`已清除 ${e} 个实体与 ${f} 条事实 · ${q} 篇文档已排队`,
status: {
pending: "排队中",
parsing: "解析中",
indexing: "索引中",
embedding: "向量化",
ready: "就绪",
failed: "失败",
},
graphStatus: {
none: "—",
queued: "排队中",
extracting: "抽取中",
done: "完成",
failed: "失败",
skipped: "不抽取",
},
sources: "来源",
allDocs: "全部文档",
uploads: "上传",
sourceType: "类型",
sourceKinds: {
folder: "文件夹",
url: "网页",
rss: "RSS 订阅",
api: "API",
statements: "陈述",
custom: "自定义",
github_issues: "GitHub 工单",
github_repo: "GitHub 仓库文件",
jira_issues: "Jira 工单",
s3: "S3 / MinIO",
azure_blob: "Azure Blob",
gcs: "Google Cloud Storage",
webdav: "WebDAV",
notion: "Notion",
},
sourceKindHints: {
folder: "可在文件夹中管理上传的文件:上传、拖入、删除都在这里。",
url: "抓取所列的网页;内容变化时更新同一篇文档。",
rss: "订阅一个源;每条目成为一篇文档,日期取其发布时间。",
jira_issues:
"同步一个 Jira 项目的工单。**每张工单连同它的字段级变更史**成为一篇文档——" +
"状态、负责人、优先级何时从什么变成什么,都带着日期。一次调用取全,不逐张翻。",
github_issues:
"同步一个仓库的工单。**每张工单连同它的状态变更史**成为一篇文档——" +
"何时开出、何时关闭、标签与负责人怎么变的,都带着日期。未配令牌时" +
"每小时只有 60 次请求配额。",
github_repo:
"读取一个仓库默认分支上的 markdown 文件。每个文件成为一篇文档," +
"日期取最后一次改动它的提交;没变的文件不会重抓。",
s3:
"从 S3 桶里读文档,或者任何说同一套协议的东西(MinIO、Ceph、R2)。" +
"**端点留空就是 AWS**,填了就是自建。每个对象成为一篇文档," +
"日期取它最后一次修改的时刻。",
azure_blob:
"从 Azure Blob 容器里读文档。用 Azure 本身就把端点留空," +
"填了是指向 Azurite 或某个网关。",
gcs:
"从 Google Cloud Storage 桶里读文档。服务账号 JSON 整份贴进来——" +
"服务器上没有那个文件可以指。",
webdav:
"从 WebDAV 网盘读文档——Nextcloud、ownCloud、群晖,以及一切说这套协议的。" +
"逐层走目录,每个文件成为一篇文档,日期取它最后一次修改的时刻。",
notion:
"同步一个 Notion 集成能看见的页面——把页面分享给集成,它就会出现在这里。" +
"日期取页面最后一次编辑的时刻,那是页面自己的时钟,不是我们抓它的时刻。",
api: "外部系统把 JSON 文档推送到这里,用这个来源自己的令牌认证。",
statements:
"外部系统把已经是抽取契约形状的陈述推送到这里,不经模型;发事件,别发整张表的状态。",
custom:
"按计划轮询一个你控制的 URL——你的服务返回 JSON 条目,Utopia 保持同步。",
memory:
"从「对话」中记下的片段。只追加:被推翻的记忆是闭合有效区间,而不是删除——" +
"时间线保留完整的来龙去脉。",
},
ingestGuide: "阅读摄入接口指南 →",
ingestGuideTitle: "摄入接口指南",
endpointField: "接口地址",
feedPlaceholder: "https://your-service/utopia-feed",
endpointCopied: "接口地址已复制",
copyEndpoint: "点击复制完整地址",
pushStatus: {
never: "尚未推送",
queued: "—",
running: "—",
ok: "已收到推送",
failed: "推送失败",
},
tokenTitle: "来源令牌",
tokenWarning:
"持有这个令牌的任何人都能往这个来源推送文档。一旦泄露就轮换——旧令牌立即失效。",
tokenUsage: "每次推送时这样带上:",
tokenCopied: "令牌已复制",
viewToken: "令牌",
rotateToken: "轮换",
noToken: "这个来源还没有令牌——生成一个即可开始推送。",
generateToken: "生成令牌",
close: "关闭",
authHeaderField: "Authorization 头(可选,不再显示)",
syncNow: "立即同步",
syncStatus: {
never: "从未同步",
queued: "排队中",
running: "同步中…",
ok: "已同步",
failed: "同步失败",
},
lastSyncAdded: (n: number) => `上次同步 +${n}`,
sourceName: "名称",
urlsField: "网页地址(每行一个)",
feedUrl: "订阅地址",
rssContentMode: "RSS 内容模式",
rssModeFeed: "仅使用订阅内容",
rssModeFull: "新条目获取完整文章",
rssModeFeedShort: "仅订阅",
rssModeFullShort: "完整文章",
rssContentModeHint: "只为开启之后新出现的条目抓取全文。",
rssFullModeHint:
"第一次同步只记下订阅当前有哪些条目,不导入。之后新出现的条目,订阅自带的正文够长就用它,不够就去抓链接的文章;两者都没有的条目记为跳过。",
rssFeedModeHint: "只存订阅自带的内容——正文或摘要——不去打开链接的文章。",
rssHydrationCounts: (c: { pending: number; queued: number; retrying: number; complete: number; terminal: number }) =>
`待处理 ${c.pending} · 排队 ${c.queued} · 重试 ${c.retrying} · 完成 ${c.complete} · 终止 ${c.terminal}`,
repoField: "仓库(owner/name)",
jiraUrlField: "Jira 地址",
jiraProjectField: "项目 key",
s3BucketField: "桶名",
s3PrefixField: "前缀(可选——不填则读整个桶)",
s3EndpointField: "端点(用 AWS S3 就留空)",
s3RegionField: "区域",
s3KeyField: "Access Key ID",
s3SecretField: "Secret Access Key",
azAccountField: "存储账号名",
azKeyField: "账号密钥",
gcsKeyField: "服务账号 JSON(整个文件贴进来)",
davUrlField: "服务器地址",
davPathField: "目录(可选——默认从根开始)",
davUserField: "用户名",
davPassField: "密码",
notionTokenField: "内部集成令牌",
notionQueryField: "搜索词(可选——留空则取全部已分享页面)",
tokenField: "GitHub 令牌(可选,不再显示)",
includePullRequests: "把 PR 也当工单收进来",
includeGlobsField: "包含的 glob(逗号分隔,可选)",
excludeGlobsField: "排除的 glob(逗号分隔,可选)",
interval: "同步计划",
intervalManual: "仅手动",
intervalEvery: (m: number) =>
m < 60 ? `每 ${m} 分钟` : `每 ${m / 60} 小时`,
schedule: {
manual: "手动",
interval: "间隔",
daily: "每天",
weekly: "每周",
advanced: "高级",
every: "每",
minutes: "分钟",
hours: "小时",
at: "于",
cronPlaceholder: "输入 cron 表达式",
whatIsCron: "什么是 cron?",
cronDocsUrl: "https://crontab.guru",
daysShort: ["周一", "周二", "周三", "周四", "周五", "周六", "周日"],
dailyAt: (t: string) => `每天 ${t}`,
},
createSource: "创建",
cancel: "取消",
deleteSource: "删除来源",
deleteSourceHint: "文档会保留,并移入「上传」。",
newSourceTitle: "新建来源",
iconLabel: "图标",
pageOf: (from: number, to: number, total: number) =>
`${from}–${to} / 共 ${total}`,
syncHistory: "历史",
runNew: (n: number) => `新增 ${n}`,
runUpdated: (n: number) => `更新 ${n}`,
runNothing: "无变化",
noRuns: "还没有同步记录。",
sourceSettings: "来源设置",
editSourceTitle: "来源设置",
saveChanges: "保存修改",
authHeaderEditField: "Authorization 头",
authKeepHint: "留空则保持当前值。",
editKeepNote:
"改变这个来源抓取什么,绝不会删除已有文档。新配置不再返回的条目会在下次同步后" +
"标记为「已不在来源中」。要整个换成另一个服务?那就新建一个来源。",
notInSource: "已不在来源中",
cleanupMissing: (n: number) => `清理 ${n} 篇缺失`,
cleanupTitle: "删除缺失的文档",
cleanupHint: (n: number, name: string) =>
`「${name}」中有 ${n} 篇文档已不在来源里。` +
"删除会把它们移出知识库,只以它们为出处的事实随之失效;" +
"内容会留着,删掉的文档可以恢复。",
cleanupConfirm: "删除它们",
deleteSourceTitle: "删除这个来源",
deleteSourceBody: (name: string) =>
`输入「${name}」确认。文档会保留并移入「上传」;定时同步停止。`,
dangerZone: "危险操作",
},
search: {
placeholder: "检索知识库…(关键词 + 语义)",
button: "检索",
searching: "检索中…",
noResults: "没有结果",
chunkOf: (filename: string, seq: number) => `${filename} · 第 ${seq} 段`,
},
ask: {
streamInterrupted: "回答连接已中断,请重新打开会话查看状态。",
noActiveAnswer: "最后一个问题没有回答。可以重试,或发送新消息。",
historyLoadFailed: "无法读取此会话。",
retryHistory: "重试",
retryQuestion: "重试",
loadingHistory: "正在读取会话…",
loadEarlierConversations: "加载更早的会话",
conversationsLoadFailed: "无法读取会话列表。",
retryConversations: "重试",
greeting: "问问 Utopia 都记住了什么",
emptyTitle: "对话",
emptyBody:
"与你的知识库对话——带引用的回答、关于时间的提问,而且它会记住。\n请先在「文库」上传文档,并在「管理 → 模型」里配置模型。",
placeholder: "问点什么…",
composerHint: "回车发送 · Shift+回车 换行",
scopeLabel: "知识库",
send: "发送",
stop: "停止",
stopping: "正在停止…",
stopped: "已停止",
thinking: "思考中…",
step: {
failed: "失败",
documentNotFound: "未找到文档",
entityNotFound: "未找到实体",
sourceNotFound: "没有这个数据源",
unknownTool: "未知工具",
unparsed: "参数不完整",
missing: (param: string) => `缺少 ${param}`,
invalid: (param: string) => `${param} 无效`,
sources: (n: number) => `${n} 个来源`,
sections: (n: number) => `${n} 段`,
matches: (n: number, total?: number) =>
total === undefined ? `${n} 个匹配` : `${n} 个匹配(共 ${total} 个)`,
facts: (n: number, at: string | null, recorded: string | null) =>
`${at ? `${at} 时的 ` : ""}${n} 条事实${recorded ? `,${recorded}` : ""}`,
recordedBy: (t: string) => `按 ${t} 时的记录`,
recordedBefore: (t: string) => `按 ${t} 之前的记录`,
linked: (n: number, total: number) =>
n === total ? `关联 ${n} 个` : `关联 ${total} 个,列出 ${n} 个`,
dated: (n: number, total: number) =>
n === total ? `${n} 条有日期的事实` : `${total} 条有日期的事实,列出 ${n} 条`,
paths: (n: number, more: boolean, hops: number) =>
n === 0 ? "没有路径" : `${n}${more ? "+" : ""} 条路径,最短 ${hops} 跳`,
changes: (n: number, more: boolean) =>
n === 0 ? "没有变更" : `${n}${more ? "+" : ""} 处变更`,
now: "现在",
rows: (n: number, more: boolean) => `${n}${more ? "+" : ""} 行`,
rules: (n: number) => (n === 0 ? "无" : `${n} 条规则`),
marked: (n: number) => `标出 ${n} 处`,
sql: "SQL",
},
newChat: "新对话",
recent: "最近",
untitled: "未命名",
noConversations: "还没有对话。",
deleteConversation: "删除对话",
searchConversations: "搜索会话",
moreActions: "更多",
rename: "重命名",
copyTitle: "复制标题",
deleteTitle: "删除这个对话?",
deleteHint: (name: string) => `「${name}」及其消息将被永久移除。`,
deleteBtn: "删除",
cancel: "取消",
noSources: "未引用任何来源",
openOriginal: "打开原文",
copyAnswer: "复制回答",
copyCode: "复制代码",
copied: "已复制",
},
graph: {
untyped: "未分类",
legendMore: (n: number) => `全部 ${n} 个类`,
nodeBudget: "画多少个实体",
nodeBudgetMore: "多画一些",
nodeBudgetLess: "少画一些",
legendSearch: "筛选类",
legendNone: "没有匹配的类",
legendOnly: "只看",
legendShowAll: (n: number) => `显示全部(隐藏了 ${n} 个)`,
legendHideAll: "全部隐藏",
legendAllHint: "画面上的全部类,按出现次数排。点一下显示或隐藏。",
searchMore: (n: number) => `还有 ${n} 个——再加载 20`,
zoomIn: "放大",
zoomOut: "缩小",
fitView: "适应视图",
layoutForce: "力导布局",
layoutCircular: "环形布局",
layoutPack: "按类型聚簇",
searchEntity: "搜索实体…",
searchInSubgraph: "在子图中搜索…",
backToOverview: "← 全图",
facts: "条事实",
noFacts: "这个实体还没有事实",
confidence: "置信度",
evidence: "证据",
noEvidence: "没有记录证据",
noQuote: "(无引文)",
openInDoc: "在文档里看这一段",
proposedPredicate: (p: string) => `从原文读作「${p}」`,
/* 本体没认下这条关系:显示的词来自原文,不是词表里的关系 */
saidAs: (words: string) => `原文的说法:“${words}”`,
inferredPredicate: "本体里没有这个关系,这是原文的说法",
/* 连原文说法都没留下的老数据(0052 之前)。不编一个「有关联」出来 */
unknownPredicate: "说不出是什么关系",
sectionRef: (filename: string, seq: number) =>
`${filename} · 第 ${seq} 段 →`,
fromVersion: (v: number) => `v${v}`,
sourceDeleted: "出处已删",
sourceDeletedHint: "这句引文所在的文档已被删除。事实还在,因为它另有出处。",
staleEvidenceHint:
"这条证据来自文档的较早版本。文档此后已更新;事实本身不受影响。",
staleFactChip: "未确认",
staleFactHint:
"这条事实的全部证据都来自来源文档的较早版本——现行内容不再这么说。" +
"它可能仍然成立;请到「审阅」里核对。",
edit: "编辑",
editName: "名称",
editType: "类型",
editSave: "保存",
editCancel: "取消",
editSaved: "实体已更新",
editEmptyName: "名称不能为空",
viewRelations: "关系",
viewTimeline: "时间线",
viewHistory: "记录历史",
viewDerived: "推出来的",
derivedEdges: (n: number) => `推出来的 ${n}`,
derivedHint:
"这里没有一条是谁断言的——都是引擎推出来的:或按本体声明的公理,或按有人写下的规则。每一条都附着它用到的前提。",
derivedNoProof: "前提已经不在了。",
contestedChip: "有争议",
contestedHint: (kind: string, derived: string | null) =>
kind === "derived_contradiction"
? `有一条推出来的事实与它抵触${derived ? `:${derived}` : ""}。去 Review 看。`
: kind === "temporal_conflict"
? "有一条更新的断言在时间上与它冲突。去 Review 看。"
: "这条断言违反了本体声明的公理。去 Review 看。",
blockedTitle: "没落地的",
blockedHint: "引擎本可以画出这些边,被一条断言挡住了。图上画成幽灵边。",
blockedBy: (t: string) => `挡住它的:${t}`,
blockedReview: "去 Review",
proofStep: (n: number) => `第 ${n} 步`,
proofRetracted: "后来撤了",
proofLoading: "正在展开证明…",
derivedPanel: "推理",
derivedRunAsk: "对整个库重跑一遍推理?",
derivedRunGo: "跑",
derivedRunCancel: "取消",
derivedCountLabel: "推出来的边",
derivedStateLabel: "定时",
derivedLastLabel: "上次推理",
derivedOn: (mins: number) => `每 ${mins} 分钟`,
derivedOff: "已关闭",
derivedNever: "从未",
derivedAgo: (mins: number) =>
mins < 1
? "刚刚"
: mins < 60
? `${mins} 分钟前`
: `${Math.round(mins / 60)} 小时前`,
derivedRun: "现在跑一遍",
derivedRunning: "推理中…",
derivedNoChange: "没有变化。",
derivedChanged: (added: number, gone: number) =>
`新增 ${added} · 作废 ${gone}`,
derivedCapped: (n: number) => `${n} 个谓词没推完`,
close: "关闭",
ruleNames: {
transitive: "传递",
symmetric: "对称",
inverse: "互逆",
sub_property: "子属性",
} as Record<string, string | undefined>,
historyHint: "这个实体的记录如何变化——以及是谁改的。",
historyEmpty: "这个实体还没有记录。",
historyKind: {
asserted: "记入",
corrected: "区间被修正",
rejected: "已撤回",
merged: "并入了已有事实",
merged_in: "有实体并了进来",
merged_away: "并进了另一个实体",
merge_reverted: "合并已撤销",
retyped: "改了类",
retype_reverted: "改类被撤销",
},
historyGoneEntity: "一个已不存在的实体",
historyEngine: "引擎",
historyClosedAt: (t: string) => `闭合于 ${t}`,
historyFrom: (t: string) => `自 ${t} 起`,
historyOngoing: "未闭合",
historicalNote: (n: number) => `另有 ${n} 条历史事实未显示——见时间线 →`,
undated: "无日期",
asOf: (date: string, by: string | null) =>
by ? `截至 ${date}(${by})` : `截至 ${date}`,
fromEntity: (name) => `从 ${name} 出发`,
toEntity: (name) => `指向 ${name}`,
openEntity: (name) => `打开 ${name}`,
past: (n) => `${n} 条已结束`,
sources: (n) => `${n} 处来源`,
names: "名字",
shownName: "显示名",
nameUntil: (d) => `至 ${d}`,
removeName: "移除",
removeNameAsk: "移除这个名字?",
removeNameCancel: "留着",
removeNameGo: "移除",
nameRemoved: "已移除这个名字",
timelineEmpty: "还没有带日期的事实。",
lastConfirmed: (d: string) => `${d} 确认`,
correctedHint:
"这个区间来自一次修正,并非文档里逐字这么写:自动接续、审阅决定,或有人手工改过。" +
"被取代的那条断言仍留在台账里——谁改的、何时改的见「变更」。",
editTime: "修正区间",
editTitle: "编辑实体",
timeStart: "起点",
timeEnd: "终点",
timeEndOpen: "仍在持续",
timeEndUnknown: "已结束,日期不详",
timeEndDate: "结束于",
timeFormat: "2023 · 2023-06 · 2023-06-15 · 2023-06-15T14:32Z",
timeBadDate:
"写成 2023、2023-06、2023-06-15,或带时区的钟点如 2023-06-15T14:32Z——没有时区的钟点不是一个时刻。",
timeNote: "原因(选填)",
timeNotePlaceholder: "文档说的是 2023 年上半年",
timeSave: "保存",
timeCancel: "取消",
timeSaved: "区间已修正",
timeSavedClosed: (n: number) => `区间已修正——顺带闭合了 ${n} 条现行事实`,
timeSavedConflicts: (n: number) =>
`区间已修正——${n} 条冲突待在审阅里裁决`,
ongoing: "至今",
endedUnknown: "已结束(时间不详)",
stats: (n: number, e: number, active: number | null) =>
`${n} 个实体 · ${e} 条事实${active === null ? "" : ` · ${active} 条现行`}`,
statsCapped: (
shown: number,
total: number,
shownE: number,
totalE: number,
active: number | null,
) =>
`已画 ${shown} / 共 ${total} 个实体 · ${shownE} / 共 ${totalE} 条事实${active === null ? "" : ` · ${active} 条现行`}`,
cappedHint: (shown: number, total: number) =>
`画布只画连接最密的 ${shown} 个,库里共 ${total} 个。其余的用搜索找。`,
stabilizing: "布局收敛中",
scrubUnitHint: "播放的步长,也是每根柱子的跨度",
scrubUnitYear: "年",
scrubUnitMonth: "月",
scrubUnitDay: "日",
scrubBarMerged: (n: number) => `每根柱子含 ${n} 步`,
allTime: "全部时间",
nowBtn: "现在",
play: "播放时间线",
pause: "暂停",
},
origin: {
ocr: (page: number | null) => (page === null ? "OCR 识别" : `OCR 识别 · 第 ${page} 页`),
transcribed: (span: string | null, speakers: string[]) =>
["转写", span, speakers.length > 0 ? speakers.join("、") : null]
.filter(Boolean)
.join(" · "),
described: "模型描述",
ocrHint: "从扫描件或图片上识别出来的文字,个别字或数字可能认错。",
transcribedHint: "从录音转写出来的文字,人名可能听错。",
describedHint: "模型对一张图的描述,没有人这样写过或说过。",
readBy: (model: string) => `读取模型:${model}。`,
},
doc: {
backToLibrary: "← 返回文库",
sections: "段",
section: "第",
citedHere: "← 此处被引用",
loading: "加载中…",
extracted: "已抽取",
ongoing: "至今",
/** `#610`:`doc_time` 是从文件里读出来的日期;与上传时刻是两件事 */
docDate: "文档日期",
docDateFromContent: "从文件名或正文首行认出来的",
uploadedAt: "上传于",
},
settings: {
title: "管理",
tabModels: "模型",
tabMembers: "用户",
tabKbs: "知识库",
tabDeployment: "部署",
tabSso: "单点登录",
cardAccounts: "账号",
newUser: "创建用户",
initialPassword: "初始密码(至少 8 位)",
createUserBtn: "创建",
searchUsers: "按名称或邮箱筛选…",
deployment: {
openReg: "允许自助注册",
openRegHint: "关闭后注册表单不再开放,只有管理员能在此创建账户。",
workers: "后台工作线程",
workersHint:
"同时运行的任务数的外层上限(1–256),作用是防止工作无限堆积。" +
"真正的节流是下面的按模型上限,所以这个数留得比它们之和宽裕些。即时生效。",
workersApply: "应用",
modelConcurrency: "模型并发",
modelConcurrencyHint:
"一个模型同时接多少个调用。真正起作用的上限属于服务商,而且是按模型算的——" +
"本地 Ollama 也许只扛得住两个,托管 API 能到五十。" +
"后台工作(抽取、消解、索引)会等空位;对话与检索永远不等。即时生效。",
ontologyLang: "默认本体语言",
ontologyLangHint:
"新建知识库时本体从哪种语言开始——类描述会进抽取提示词," +
"所以它跟你预期的文档走,不跟界面走。每个知识库之后可以自己改。" +
"界面语言是每个人自己的选择,在账户菜单里。",
modelDefault: "默认",
modelReset: "重置",
modelResetHint: "去掉这个模型自己的上限,回落到默认值。",
},
datasources: {
tab: "数据源",
title: "数据源",
hint:
"只读的数据库连接,用于在「对话」里就你的数据提问。" +
"在这里登记连接;每个知识库各自挂载允许查询的那些。",
name: "名称",
connString: "连接串,前缀决定引擎",
connSchemes:
"postgres://user:pass@host:5432/db\n" +
"mysql://user:pass@host:3306/db (MariaDB、TiDB、OceanBase、Doris、StarRocks)\n" +
"trino://user[:pass]@host:8080/catalog[/schema] (Iceberg、Delta Lake、Hive)\n" +
"databricks://:TOKEN@host/sql/1.0/warehouses/ID?catalog=main\n" +
"snowflake://:[email protected]/DB/SCHEMA?warehouse=WH\n" +
"clickhouse://user:pass@host:8123/db (?ssl=true 走 https,8443)",
add: "添加数据源",
newTitle: "登记数据源",
engine: "引擎",
engineRaw: "连接串",
optional: "(可不填)",
testConn: "测试连接",
testing: "连接中…",
colConn: "连接",
colStatus: "状态",
grantsNoneShort: "未授权",
grantsCount: (n: number) => `${n} 个工作区`,
fHost: "主机",
fPort: "端口",
fDatabase: "库",
fUser: "用户",
fPassword: "密码",
fCatalog: "Catalog",
fSchema: "Schema",
fToken: "令牌",
fWarehouse: "Warehouse",
fWarehouseId: "Warehouse ID",
fAccount: "账号主机",
test: "测试",
testOk: "已连接",
testFail: "失败",
neverTested: "未测试",
remove: "移除",
empty: "还没有注册数据源。在下面注册一个。",
grants: "可用于",
grantsHint:
"授权哪些工作区可以用这个源。授权之后,那些工作区的知识库管理员自己挑挂不挂——" +
"这里管的是「能不能拿到」,不是「挂没挂」。",
grantsNone: "还没授权给任何工作区——现在没有知识库挂得上它。",
grantAdd: "授权工作区…",
grantRevoke: "收回",
grantRevoked: (n: number) =>
n === 0 ? "已收回。" : `已收回,顺带卸掉了 ${n} 个知识库上的挂载。`,
},
sso: {
title: "单点登录",
hint:
"通过身份提供方(OIDC)登录,用环境变量配置(见 .env.example)。每个人在自己的账户页" +
"绑定自己的身份;管理员能看到、能解绑,但不能替别人绑定。",
disabled:
"这个部署还没配置。设置 UTOPIA_OIDC_ISSUER、UTOPIA_OIDC_CLIENT_ID、" +
"UTOPIA_OIDC_REDIRECT_URI(身份提供方要求的话还有 UTOPIA_OIDC_CLIENT_SECRET)后重启。",
issuer: "Issuer",
clientId: "Client ID",
redirectUri: "Redirect URI",
colUser: "用户",
colSubject: "Subject",
empty: "还没有人绑定身份。",
unlink: "解绑",
unlinkTitle: (email: string) => `解绑 ${email}?`,
unlinkHint:
"重新绑定之前,这个人没法再用单点登录。已经打开的会话仍保持登录;要立刻切断访问请停用账号。",
},
kbs: {
hint:
"本部署中的全部知识库。公开的对所有成员可读;受限的仅限受邀者。" +
"创建知识库是管理员动作——成员在顶栏切换。",
defaultChip: "默认",
newKb: "新建知识库",
packsLabel: "预置本体",
packsHint: "可不选,之后还能再导入。",
packsPick: "搜索本体包…",
packsNone: "不选 —— 本体从文档里长出来",
packsCount: (c: number, p: number) => `${c} 个类 · ${p} 个属性`,
name: "名称",
description: "描述",
visibility: "可见性",
visOpen: "公开——本部署内所有人",
visRestricted: "仅受邀者",
create: "创建",
openSettings: "设置",
empty: "还没有知识库。在上面建第一个。",
docs: (n: number) => `${n} 篇文档`,
},
modelsIntro:
"OpenAI 兼容协议——DeepSeek、Qwen、GLM、Ollama、vLLM 都可用。完全内网友好。",
chatModel: "对话模型",
reasoningEffort: "推理强度",
reasoningDefault: "端点默认",
reasoningHint: "推理模型先想再答,输出的大半是思考。每一种调用都用这一个值;哪个值关得掉思考看端点:有的认 minimal,有的(DeepSeek)只认 none。",
embedModel: "向量模型(可选,启用语义检索)",
baseUrl: "接口地址",
model: "模型",
apiKey: "API 密钥",
keyConfigured: "(已配置——留空即保持不变)",
save: "保存",
saving: "保存中…",
saved: "已保存",
test: "测试连接",
testing: "测试中…",
chatLabel: "对话",
embedLabel: "向量",
ok: (reply: string) => `已连通,认证通过(${reply})`,
okDim: (dim: number) => `已连通,认证通过(维度 ${dim})`,
unsaved: "有未保存的修改。先保存这张卡,再测试。",
readersTitle: "读扫描件与录音",
readersIntro:
"扫描件、图片和录音没有可以直接解析的文字,各要一个读取模型。它们和对话模型分开配置,敏感文件可以留在自己的服务器上。读取模型配好之前传上来的文件会先等着,消息中心会提示;存好之后自动读。",
ocrService: "文档识别(OCR)",
ocrHint: "MinerU 服务(mineru-api)。先识别每页版面再认字,每段文字都记着所在的页和位置。",
ocrHintArk: "火山方舟的视觉模型逐页读,只返回页上写着的字。每段文字记着所在的页,没有位置。每一页都是一次付费的模型调用。",
readerProvider: "供应商",
arkProvider: "火山方舟",
serviceUrl: "服务地址",
backend: "后端(可选)",
transcribeModel: "录音转写",
transcribeHint:
"会标注说话人的 OpenAI 兼容转写接口(diarized_json),例如 gpt-4o-transcribe-diarize。分不出谁说的转写不会采用。",
okVersion: (version: string) => `已连通(${version})`,
okReachable: "已连通,认证通过",
savedRequeued: (n: number) => `已保存。${n} 个等待中的文件开始读取。`,
},
ontology: {
casesShort: "回归案例",
casesTitle: "属性回归案例",
casesHint: "显示最近记录的预期属性与对齐决定的对比结果。刷新只读取这些结果;修改属性后由现有对齐流程更新。",
casesEmpty: "还没有案例。采纳属性提案,或从文档中添加一条开放陈述。",
caseStatement: "陈述",
caseExpected: "预期",
caseActual: "实际",
caseResult: "结果",
caseChecked: "最近检查",
caseOrigin: "添加来源",
casePassed: "一致",
caseMismatch: "不一致",
caseNotChecked: "未检查",
caseUnbound: "未绑定属性",
caseUndecided: "未决定",
caseUnavailableProperty: "原绑定属性已不可用",
caseDecidedAt: "决定时间",
caseNoProperties: "请先在本体中创建适合的属性,再添加此案例。",
caseHumanBound: "保留人工决定",
caseHumanHint: "人工绑定予以保留,并按通过计入。这不代表一次独立的模型检查。",
caseAdoption: "采纳提案",
casePerson: "手动添加",
caseUnknownCreator: "已离开的成员",
caseEvidence: "展开原文证据",
caseHideEvidence: "收起原文证据",
caseMake: "添加回归案例",
caseAddTitle: "添加属性回归案例",
caseAddHint: "保存这条开放陈述应绑定的属性及方向,再将已有的对齐决定与此预期比较。",
caseExpectedProperty: "预期属性",
caseDirection: "方向",
caseForward: "主语 → 宾语",
caseReverse: "宾语 → 主语",
caseAdded: "回归案例已添加",
caseAdd: "添加案例",
title: "本体",
hint: "类与属性",
tabClasses: "类",
colName: "名称",
multiParentHint: "这个类有不止一个父类;缩进挂在其中一个,父类那一列把它们都列着",
colSignature: "主语 → 宾语",
colInstances: "实例",
colFacts: "事实",
colOnClass: "挂在",
colDatatype: "类型",
colUnit: "单位",
colSingleValued: "单值",
yes: "是",
rowsShown: (n: number) => `${n} 行`,
viewTable: "表格",
switchToTable: "切换到表格视图",
switchToGraph: "切换到图视图",
viewDiagram: "图",
axiomTransitive: "传递",
axiomSymmetric: "对称",
axiomAsymmetric: "反对称",
axiomIrreflexive: "非自反",
tabProperties: "关系",
newClass: "新建类",
newSubClass: "新建子类",
newProperty: "新建关系",
filter: "筛选…",
missesShort: "未匹配",
uniquenessShort: "并存",
refineShort: "类型消解",
rulesShort: "业务规则",
ruleExpressionReadOnly: "此表单只读展示这条规则的定义。可修改名称和说明,表达式和条件保持原样。",
ruleUnknownExpression: "暂不支持的表达式(只读)",
ruleDependencies: "潜在依赖",
ruleDependenciesHint: "根据规则定义列出的候选关系,不代表实际执行。读数、条件和时间决定哪些规则成立;这里也包括已停用的定义。",
ruleDependenciesIncomplete: "部分定义或类信息无法完整读取,此列表可能不完整。",
rulePotentialProducers: "可能从这些规则获得输入",
rulePotentialConsumers: "可能为这些规则提供输入",
ruleDependenciesEmpty: "在可读取的定义中未找到候选关系。",
rulesTitle: "业务规则",
rulesHint: "按实体自己的属性判定类别、或算出取值的规则。结论是派生的,依据没了就自动失效。",
rulesEmpty: "还没有规则。",
rulesNoMatch: "没有规则匹配。",
ruleSearch: "搜索规则、属性、取值",
ruleNew: "新建规则",
ruleNeedsAttribute:
"规则判的是属性的值,而这个本体还没有属性。先打开一个类,在「属性」里加一个。",
ruleNeedsClass: "先建一个类——规则得出的就是一个类。",
ruleColRule: "规则",
ruleColDerived: "推出",
ruleColStatus: "状态",
ruleAnd: "并且",
ruleOr: "或者",
ruleWhere: "满足",
ruleDropCondition: "删掉这个条件",
ruleOperandPlaceholder: (kind: string) =>
kind === "set" ? "气测异常, 效应后气测异常" : kind === "range" ? "8 - 12" : "12.0",
ruleName: "名称",
ruleNamePlaceholder: "含气井",
ruleDescription: "它是什么意思(选填)",
ruleSubject: "适用于",
ruleSubjectHint: "及其子类",
ruleConcludes: "得出",
ruleConcludesTyping: "这个类",
ruleConcludesAttribute: "这个属性",
ruleConcludesRelation: "这条关系",
ruleConcludesRelationText: (join: string, conclude: string): string =>
`经「${join}」从 X 到「${conclude}」`,
ruleSideX: "X",
ruleSideY: "Y",
ruleConditions: "当满足",
ruleConditionsHint: "一块里的条件要同时成立;再加一块就是另一种情况,任意一块成立即可。",
ruleAddCondition: "加一个条件",
ruleAddGroup: "另一种情况",
ruleOpGt: "大于",
ruleOpGte: "不小于",
ruleOpLt: "小于",
ruleOpLte: "不大于",
ruleOpBetween: "介于",
ruleOpIn: "属于",
ruleOpNotIn: "不属于",
ruleOpPresent: "有记录",
ruleOperandNumber: "12.0",
ruleOperandSet: "气测异常, 气测异常后效",
ruleOperandSetHint: "逗号分隔",
ruleSave: "保存规则",
ruleSaved: "规则已保存",
ruleDeleted: "规则已删除",
ruleDelete: "删除",
ruleDeleteConfirm: (n: string) => `删除「${n}」?凭它得出的结论一并消失。`,
ruleEnabled: "启用",
ruleDisabled: "停用",
ruleDerivedCount: (n: number) => `${n} 个实体`,
ruleRun: "立刻跑一遍",
ruleRunning: "正在跑…",
ruleRunDone: (hits: number, inserted: number, invalidated: number) =>
`命中 ${hits} · 新增 ${inserted} · 退场 ${invalidated}`,
ruleRunCapped: (n: number) =>
`${n} 对(规则,实体)的读数组合太多没有展开完,它们的结论不完整`,
ruleRunRoundsCapped: (n: number) =>
`跑满 ${n} 轮还在往下推,链再往后的那几环没有接上`,
ruleNeedsCondition: "一条规则至少要有一个条件。",
ruleEdit: "编辑",
ruleEditing: "正在编辑",
ruleMatchesTitle: "它标住了谁",
ruleMatchesEmpty: "此刻一个也没有。",
ruleVersion: (n: number) => `v${n}`,
ruleHistoryTitle: "这条规则改过几次、每一版怎么说",
ruleHistoryEmpty: "还没有历史。",
ruleVersionCurrent: "当前",
ruleVersionSince: (from: string, to: string | null) => (to ? `${from} 至 ${to}` : `自 ${from}`),
ruleVersionStanding: (n: number) => `此刻凭它成立 ${n} 条`,
ruleMatchBecause: (premises: string) => `凭 ${premises}`,
ruleMatchSpan: (from: string, to: string | null) =>
to ? `${from} 至 ${to}` : `${from} 起`,
ruleMatchesMore: (shown: number, total: number) =>
`显示 ${shown} / ${total}`,
ruleCappedChip: "不完整",
ruleCappedHint:
"有些实体同一属性的读数太多,组合展不完,这条规则在它们身上的结论是不完整的。",
refineTitle: "类型消解",
refineHint: "人工收窄定得过宽的实体类型。",
refinePreview: "先看一遍",
refineLooking: "计算中…",
refineRun: "跑一遍并落库",
refineRunning: "运行中…",
refineNothing: "没有可精化的。",
refineCandidates: (n: number) => `会考虑 ${n} 个实体`,
refineNoCandidates: "检索没给它找到任何类。",
refineModelSays: (t: string) => `模型说它是「${t}」`,
refineRetyped: (n: number) => `自动改了 ${n} 个`,
refineUndo: "撤销这一批",
refineUndone: (n: number) => `已放回 ${n} 个`,
refineForReview: (n: number) => `${n} 个要你拍板`,
refineCrossesAxis: "换了分类轴",
refineApprovePair: "认可这一对类",
refineLeftAlone: (n: number) => `${n} 个原样不动`,
refineTopCandidate: (c: string) => `最近的候选是 ${c}`,
instances: "实例",
instanceFacts: (n: number) => `${n} 条事实`,
description: "描述",
descriptionHint:
"指导抽取器:什么属于这里,配上几个例子。它会被原样送进抽取提示词。",
attributes: "属性",
attributesHint:
"这个类的字面值字段(一个人的薪资、一份合同的金额)。和任何事实一样带证据与历史。",
newAttribute: "新建属性",
edit: "编辑",
editClass: "编辑类",
editProperty: "编辑关系",
editAttribute: "编辑属性",
attributeHost: "挂在哪个类",
connectTitle: "连接一个关系",
connectOpen: "用已有的关系连接…",
noDescription: "还没有描述。",
axiomsNone: "没有声明。",
attrDatatype: "值类型",
attrUnit: "单位",
attrUnitHint: "可选——如 CNY、%",
attrSingle: "单值——新值会闭合上一个",
datatypeNames: {
text: "文本",
number: "数字",
date: "日期",
bool: "布尔",
},
cancel: "取消",
key: "Key",
label: "标签",
color: "颜色",
shapeColor: "形状与颜色",
parent: "父类",
noParent: "(顶层)",
subclasses: "子类",
qualifiers: "边上的属性",
noQualifiers: "无",
qualifiersHint: "这条关系的边能带的属性,例如 invested_in 上的金额",
noSubclasses: "无",
disjoint: "不可能同时是",
disjointHint:
"任何东西不可能同时属于的类。人不是组织。一致性检查据此找出永远不可能有实例的类。",
noDisjoint: "尚未声明",
disjointWithParent:
"这个类继承自一个它声明不可能是的类——没有任何东西能满足它。",
primaryParentHint: "左栏的树里挂在第一个下面。",
signature: "类型签名",
signatureHint:
"这个关系连接哪些类。它作为提示进抽取提示词,不是闸门——" +
"它在模型落笔那一刻引导,而本体写错时原文仍然说了算。",
domainLabel: "主语",
rangeLabel: "宾语",
anyType: "不限类型",
searchTypes: "搜索类…",
temporal: "时态语义",
temporalState: "状态(有区间)",
temporalEvent: "事件(时间点)",
temporalEternal: "恒常(无时间)",
functional: "函数性(同一时刻只有一个值)",
inverseFunctional: "反函数性(同一时刻一个宾语只对一个主语)",
axioms: "公理",
axiomsHint:
"这条关系保证什么。**它们不是描述,是会改变系统行为的声明**:时态引擎据此闭合旧值,推理机据此往图里加边。",
functionalHint: "同一主语同一时刻只有一个值。新值会闭合旧值。",
inverseFunctionalHint: "同一宾语只有一个主语。一个项目一个负责人。",
transitive: "传递",
transitiveHint: "A→B 且 B→C 就有 A→C。引擎会把那些边推出来。",
symmetric: "对称",
symmetricHint: "A→B 就有 B→A。引擎会把反方向补上。",
asymmetric: "反对称",
asymmetricHint: "有 A→B 就不该有 B→A。两个方向并存会被报成矛盾。",
irreflexive: "自反禁止",
irreflexiveHint: "任何东西不能通过这条关系指向自己。",
axiomConflict:
"对称与反对称同时成立,只对一条事实都没有的关系为真——两者必有一个写错了。",
noLink: "无",
inverseOf: "逆关系",
inverseOfHint:
"反过来说同一件事的那条关系。只需在一侧声明,另一个方向自动成立。",
subPropertyOf: "父属性",
subPropertyOfHint: "这条关系是谁的特例。说了具体的那条,宽泛的那条也成立。",
linkMeansInverse: (p: string, q: string) =>
`A ${p} B 同时也是 B ${q} A。`,
linkMeansSuper: (p: string, q: string) => `A ${p} B 同时也是 A ${q} B。`,
usage: (n: number) => `${n} 处在用`,
builtin: "内置",
save: "保存",
delete: "删除",
deleteBlocked: "在用中——无法删除",
importShort: "导入",
importTitle: "导入本体",
importHint: "导入 OWL 或 RDFS 文件(.owl、.rdf、.ttl)。类与属性按 IRI 匹配,导入同一份词汇表的新版本会更新已有的,不会再进一份。",
importPick: "选择文件",
importChange: "换一个",
importReading: "读取中…",
importApplying: "导入中…",
importApply: "导入",
importCancel: "取消",
importParsed: (fmt: string, triples: number) =>
`${fmt === "rdfxml" ? "RDF/XML" : "Turtle"} · ${triples.toLocaleString()} 个三元组`,
importNothing: "没有可导入的内容——这个文件里没有找到类或属性。",
importWillCreate: (n: number) => `新建 ${n}`,
importWillUpdate: (n: number) => `更新 ${n}`,
importKeyTaken: (n: number) => `跳过 ${n}`,
importClasses: "类",
importRelations: "关系",
importAttributes: "属性",
importAttributesLater:
"已解析,但尚未建立——属性需要挂在某个类上,那一步在下一版落地。",
warnFunctional: (n: number) => `${n} 个关系自称是函数性的`,
warnFunctionalBody:
"函数性关系同一时刻只能有一个值,所以一条新事实会自动闭合上一条。当词汇表声称的唯一性你的数据并不遵守时,结果就是一队冲突。导入后请去核对它们。",
warnNoDescription: (n: number) => `${n} 个类没有描述`,
warnNoDescriptionBody:
"类的描述会被原样送进抽取提示词——它是唯一告诉模型「什么算这个类」的东西。给它们补上,否则它们会悄悄少抽。",
warnKeyTaken: (n: number) => `${n} 个 key 已被占用`,
warnKeyTakenBody:
"已经有另一个身份占着这个 key。它们被原样留下——如果你想要导入的那一份,先把现有的改名。",
importTakenBy: (iri: string | null) =>
iri ? `被 ${iri} 占用` : "被这个知识库里已有的条目占用",
importUnprojected: "暂未投影",
importUnprojectedBody:
"这个文件用到、而 Utopia 目前还不消费的公理。什么都没丢:原文按上传时的样子存着,将来的版本可以投影它们。",
importDone: (created: number, updated: number) =>
`导入完成——新建 ${created} 个类,更新 ${updated} 个。`,
importHistory: "历次导入",
importColFile: "文件",
importColFormat: "格式",
importColSize: "大小",
importColTriples: "三元组",
importColWhen: "导入",
importDetail: "详情",
importCreatedN: (n: number) => `新增 ${n}`,
importUpdatedN: (n: number) => `更新 ${n}`,
importSkippedN: (n: number) => `跳过 ${n}`,
importTakenN: (n: number) => `键被占 ${n}`,
statClassesCreated: "新建的类",
statClassesUpdated: "更新的类",
statClassesTaken: "键被占住的类",
statClassesNoDesc: "没有描述的类",
statTriples: "读到的三元组",
statRelationsSeen: "文件里的关系",
statRelationsCreated: "新建的关系",
statRelationsUpdated: "更新的关系",
statFunctional: "声明为函数式的关系",
statInverseLinked: "连上的逆属性",
statSubPropertyLinked: "连上的父属性",
statAttributesSeen: "文件里的属性",
statAttributesCreated: "新建的属性",
statAttributesSkipped: "跳过的属性",
skipReason: {
key_taken: "键已被占用",
unusable_range: "值域不能当数据类型",
no_domain: "没有域——没说它属于哪个类",
domain_skipped: "它的域类也被跳过了",
unknown_domain: "域类不在这个库里",
} as Record<string, string | undefined>,
importNoHistory: "还没有导入过。",
importBy: (who: string, when: string) => `${who} · ${when}`,
importSize: (bytes: number) =>
bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(0)} KB`,
misses: "本体里还没有的",
missesHint: "文档说到了、本体还放不下的东西,以及代理为它们提的建议。",
/* 一端挂着两个以上开放值的谓词(#341):状态一句话,后果一句话,动作在按钮上 */
uniqueness: "并存的取值",
uniquenessHint: "标明哪些关系同时只能有一个值,之后新值会自动结束旧值。",
uniquenessEmpty: "没有并存:每个持有者至多一个开放取值。",
uniquenessSubject: (n: number) => `${n} 个主语挂着两个以上开放取值`,
uniquenessObject: (n: number) => `${n} 个取值被两个以上主语挂着`,
uniquenessEffect: (close: number, review: number) =>
review > 0 ? `闭合 ${close} 条,${review} 条进人审` : `闭合 ${close} 条`,
uniquenessDeclare: "声明并闭合",
uniquenessReconcile: "闭合它们",
uniquenessDeclared: "已声明",
uniquenessBusy: "闭合中…",
uniquenessDone: (close: number, review: number) =>
review > 0 ? `已闭合 ${close} 条 · ${review} 条待审` : `已闭合 ${close} 条`,
uniquenessSince: (d: string) => `自 ${d}`,
noMisses: "文档说到的东西里,没有在等本体给位置的。",
uncovered: (kindWords: number, phrases: number) => {
const what = [
kindWords > 0 ? `${kindWords} 种东西` : "",
phrases > 0 ? `${phrases} 种关系说法` : "",
]
.filter(Boolean)
.join("、");
return `文档里有 ${what},本体里还没有位置。可以让代理为它们提出类和属性;你采纳之前什么都不会加进本体。`;
},
approve: "加入",
mapOver: "用已有的",
proposals: "AI 提案",
keyHint: "小写下划线命名",
/* ---- 0061:本体代理与能力问题 ---- */
askAgent: "请代理提案",
askAgentHint:
"从本体还没覆盖的短语和类别词里提出该建的类与属性,对着能力问题判断。",
agentQueued: "代理在看——看完了提案会出现在这里。",
agentWaiting: "代理在看…",
agentChip: "代理",
servesQuestions: (n: number) => `服务 ${n} 个问题`,
bindsShapes: (n: number) => `会绑 ${n} 种短语形状`,
bindsKindWords: (n: number) => `${n} 个类别词`,
closestExisting: (key: string, label: string) => `最近的已有:${key} ${label}`,
rejectProposal: "拒绝",
rejectReasonPrompt: "为什么不要?(可不填——代理下次提案前会读)",
rejectedProposal: "已拒绝",
adoptKept: (n: number) => `已保存。其中 ${n} 条已由人另行判定,按人的判定保留。`,
questions: "能力问题",
questionsHint:
"这个知识库应该答得上来的问题。代理提的类与属性要服务它们;它们就是本体的验收标准。",
questionPlaceholder: "例:每位创始人创办了哪些公司、什么时候?",
addQuestion: "添加",
noQuestions: "还没有问题。没有它们,代理只能按文档里的说法判断提案。",
retireQuestion: "退役",
deleteQuestion: "删除",
questionAdded: "已添加问题",
questionRetired: "问题已退役",
askQuestions: "请代理提问题",
askQuestionsHint: "从文档说得最多的东西里提问题,等你接受了才算数。",
questionsQueued: "代理在写问题——写完了会出现在这里。",
acceptQuestion: "接受",
questionAnswered: "答上了",
questionUnanswered: "没答上",
questionVia: { graph: "来自图谱", text: "来自正文", both: "图谱与正文" },
questionsScore: (answered: number, checked: number) =>
`${checked} 条问过,${answered} 条答上`,
questionsScoreHint: "competency bench 对图谱问过的已接受问题,答上了几条。",
viaGraph: (withGraph: number, graphOnly: number) =>
`${withGraph} 条经过图谱 · ${graphOnly} 条只靠图谱`,
viaGraphHint:
"答上的问题里,几条途中从图谱拿到过事实,几条根本没读正文。只靠正文答上的不需要本体。",
proposalsChanged: (changed: number, decided: number) =>
`${decided} 条提案表过态,${changed} 条被改或被拒`,
proposalsChangedHint: "代理的提案里人表过态的,有几条被拒或改过再采纳。",
/* ---- 模式图 ---- */
schemaDiagram: "模式图",
schemaEmpty:
"还没有类。没有类文档也照常读;类和属性是把读到的内容变成类型化事实的那一步。可以让代理按你的文档提出来、导入一份本体,或者自己加一个类。",
schemaEmptyAction: "看看文档需要什么",
schemaFitView: "归位",
schemaZoomIn: "放大",
schemaZoomOut: "缩小",
schemaLegendInheritance: "继承",
schemaLegendRelation: "关系",
schemaLegendDisjoint: "互斥",
schemaLegendRule: "业务规则",
schemaUnscoped: (n: number) => `未限定的属性(${n})`,
schemaUnscopedHint: "没有限定在具体的类上,画到画布上的连线会是本体没说过的话。选一个来查看或编辑。",
schemaMoreClasses: (n) => `+${n} 个类`,
schemaScopeInUseHint: "画的是有实例的类及其祖先。想看别的类,在左栏点它。",
schemaScopeTopHint: "还没有类有实例,画的是层级最上面两层。想看别的类,在左栏点它。",
schemaClosePanel: "关闭",
schemaTabDefinition: "定义",
schemaTabRelations: "关系",
schemaTabAttributes: "属性",
schemaTabInstances: "实例",
schemaAddRelationship: "新建关系…",
schemaCheckDefects: (n) =>
n === 1 ? "这次改动带来 1 个新的本体问题" : `这次改动带来 ${n} 个新的本体问题`,
schemaCheckReview: "去审阅",
schemaBundle: (n) => `${n} 条关系`,
schemaOutgoing: "从这个类出发",
schemaIncoming: "指向这个类",
schemaNoRelationships: "这个类没有参与任何关系。继承信息显示在“定义”中。",
schemaNoInstances: "还没有实例。",
schemaConnectHint: "用一个已有的关系连接",
schemaConnectPlaceholder: "搜索关系…",
schemaConnectAs: "作为",
schemaConnect: "连接",
schemaConnected: (label) => `已通过 ${label} 连接。`,
},
mapping: {
title: "数据映射",
hint: "每个业务概念对应库里的哪张表、哪一列,以及怎么算。对话只用已确认的定义作答。",
tabDefinitions: "口径",
tabSources: "数据源",
filterAll: "全部",
filterProposed: "待审批",
filterConfirmed: "已确认",
filterRejected: "已拒绝",
searchPlaceholder: "搜概念、数据源或表名…",
total: (n: number) => `共 ${n} 条`,
range: (from: number, to: number, total: number) =>
`第 ${from}–${to} 条,共 ${total} 条`,
prev: "上一页",
next: "下一页",
empty: "还没有口径。挂上数据源后点「探查映射」,让智能体先提一批。",
emptyFiltered: "没有符合条件的口径。",
rejectedHint:
"拒绝过的也列在这里——否则「这个概念为什么没被映射」永远答不上来。",
colConcept: "概念",
colSource: "数据源",
colDefinition: "怎么算",
colStatus: "状态",
derivedBadge: "派生",
noDefinition: "(未填)",
approve: "确认",
reject: "拒绝",
selectPage: "全选本页",
selectMapping: (name, source) => `选择 ${source} 中的 ${name}`,
selected: (n) => `已选 ${n} 条`,
edit: "编辑",
editTitle: "改口径",
fieldTable: "表",
fieldExpr: "表达式",
fieldSql: "SQL",
fieldUnit: "单位",
fieldSummary: "说明",
fieldDerived: "派生指标(算出来的,不是表里的列)",
save: "保存",
cancel: "取消",
needOne: "表、表达式、SQL 至少填一个。",
history: "改版历史",
historyHint:
"改之前那一版的整版快照。留着是为了答得出「上季度这个数是怎么算的」。",
historyEmpty: "还没有改过。",
historyBy: (who: string) => `由 ${who} 修改`,
historyUnknown: "一位已移除的用户",
sourcesHint:
"已挂载的只读数据库。挂载会摄入库表结构,问数写 SQL 前才知道有哪些表。",
mount: "挂载",
unmount: "卸载",
syncSchema: "刷新结构",
schemaSynced: (n: number) => `结构已摄入(${n} 张表)`,
// 挂载成了、结构没成。**别说成失败**——源是真挂上的
schemaFailed:
"数据源已挂载,但库表结构没能摄入——问数看不见有哪些表。已报进告警中心;" +
"检查连接串后点「刷新结构」重试。",
explore: "探查映射",
exploreHint:
"一个智能体读这些库表结构,提出指标/维度的口径。提出来的落在「待审批」,确认之后问数才会用。",
exploreQueued: "探索已排队,提议会出现在「待确认」里;一条都提不出来时,铃铛会告诉你。",
// **最近一轮探索的账**——光看列表答不了「漏了多少」(#503):
// 十二条提议对着八十列的宽表与刚好覆盖完一个小库长得一样。这条贴出来人
// 才能从「等量提议」里看出覆盖范围。
lastRun: (r: {
tables: number;
columns: number;
returned: number;
accepted: number;
truncated: boolean;
}) => {
const parts = [
`${r.tables} 张表`,
`${r.columns} 列`,
`返回 ${r.returned}`,
`落库 ${r.accepted}`,
];
if (r.truncated) parts.push("(结构被截)");
return `上一轮探索:${parts.join(" / ")}`;
},
lastRunMissing: "还没有跑过探索。",
sourcesEmpty: "没有挂载任何数据源。",
sourcesNoneAvailable: "还没有登记数据源——请部署管理员登记一个。",
newConn: "登记新连接",
},
review: {
title: "审阅",
hint: "重复项与低置信度事实",
tabHistory: "历史",
empty: "没有待审阅的——图谱是干净的。",
historyEmpty: "还没有合并记录。",
railOverview: "总览",
railPending: "等你点头",
railDuplicates: "重复项",
railConflicts: "冲突",
railUnconfirmed: "未确认",
railLowConfidence: "低置信度",
railMappings: "数据映射",
railViolations: "公理",
railDefects: "本体",
railAlignment: "对齐",
railErrata: "勘误",
railDecisions: "决定",
railMerges: "合并",
railAgent: "Agent",
categoryEmpty: "这个队列是空的。",
agentTitle: "Agent",
agentHint:
"agent 依据这个库里人以前的决定,提议或裁决了什么。在这里回答就是你的决定,也会成为它下一次的先例。",
agentEmpty: "agent 还没看过任何一对。",
agentActions: { merge: "合并", keep: "分开", unsure: "说不准" } as Record<string, string>,
agentStatus: {
proposed: "建议",
applied: "已裁",
accepted: "已接受",
overridden: "已改判",
reverted: "已撤回",
superseded: "已过时",
} as Record<string, string>,
agentSuggests: (action, pct) => `agent 建议${action} · ${pct}%`,
agentPrecedents: (n) => `${n} 条先例`,
agentPrecedentMerged: "人合过",
agentPrecedentKept: "人分开过",
agentPrecedentReverted: "人撤回过合并",
agentPrecedentHabit: (merged, kept, reverted) =>
`这种类型对在本库:合 ${merged}、分 ${kept}、撤回 ${reverted}`,
agentAnsweredBy: (name, date) => `${name} · ${date}`,
agentAsks: "问:",
agentLookups: (n) => `查了 ${n} 次`,
agentLookedAt: "看了",
overviewAgent: "Agent",
overviewAgentOff: "这个库的治理没有打开。",
overviewAgentSettings: "去设置里打开",
overviewAgentOpen: "等你回答",
overviewAgentApplied: "自己裁的",
overviewAgentAccepted: "你接受的建议",
overviewAgentOverridden: (n) => `改判 ${n},近 30 天`,
overviewAgentReverted: "你撤回的",
overviewAgentRunning: (n) => (n === 0 ? "agent 在处理最后一簇" : `agent 处理中 · 还有 ${n} 对没看`),
overviewAgentQueue: (n) => `${n} 对等 agent 看`,
agentDeciding: "agent 正在裁这一对",
overviewTitle: "总览",
overviewHint: "这个库要你做什么:有多少在等、等了多久、办过什么、还有多少是暂定的。",
overviewWaiting: "等着办的",
overviewAllClear: "没有在等的——库是干净的。",
overviewOldest: (days) => (days === 0 ? "最老的今天进来" : days === 1 ? "最老的昨天进来" : `最老的等了 ${days} 天`),
overviewOpen: "去处理",
overviewDecided: "办过的",
overviewLast7: "近 7 天",
overviewLast30: "近 30 天",
overviewAutomatic: (n) => `其中裁决器自裁 ${n} 条`,
overviewDaily: "近 14 天每天的决定",
overviewByAction: "按类型",
overviewByActor: "谁办的",
overviewNoDecisions: "近 30 天没有决定。",
overviewHealth: "库的成色",
overviewFacts: (n) => `现在持有 ${n} 条事实。其中:`,
overviewContested: "有争议",
decisionsTitle: "决定",
decisionsHint:
"每一次审阅决定、由谁在何时做出——快照在决定当时留存,即使底下的事实已经不在了也保留。",
decisionsEmpty: "还没有决定记录。",
aiActor: "AI 裁决",
decisionActions: {
"review.merge": "已合并",
"review.keep": "保持分开",
"fact.confirm": "已确认",
"fact.reject": "已驳回",
"fact.nod_confirmed": "已确认一条记忆事实",
"fact.nod_rejected": "已驳回一条记忆事实",
"fact.close": "已闭合",
"conflict.close_old": "闭合旧的",
"conflict.keep_both": "两条都留",
"conflict.reject_new": "驳回新的",
"merge.revert": "撤销合并",
"merge.manual": "手动合并",
"fact.time_corrected": "改了时间",
},
escalated: {
escalate_no_model: "没有对话模型——裁决跑不起来",
escalate_no_verdict: "裁决没有给出结论",
escalate_entity_changed: "裁决过程中实体发生了变化",
escalate_unsure: "裁决的把握不够",
escalate_sample: "抽给人看的一份;裁决器本有把握",
escalate_impact: "留给人;这次合并不会只留在图里",
proposed: "agent 看过了,留了一条建议",
governed: "agent 按先例裁的",
namesake: "同一篇文档里有两个同名实体",
namesake_tie: "同名,画像分不出谁是谁",
shared_name: "另一个实体已经叫这个名字",
name_vector: "名字相近(向量召回),等裁决",
contains: "一个名字包含另一个",
ambiguous_name: "同名,但上下文没能定夺",
type_drift: "同名,但类型不同",
auto_merged: "AI 裁决已自动合并",
kept_apart: "AI 裁决认为不是同一个",
} as Record<string, string>,
impact: {
contradiction: (p) => `合了会让一个实体有两条“${p}”`,
derived: (n) => `有 ${n} 条派生事实靠着一边`,
answered: (n) => `有一边在 ${n} 个回答里被点过名`,
} as Record<string, (v: string) => string>,
duplicates: "可能重复",
duplicatesHint:
"同名,但上下文不同。AI 在后台裁决明确的情形;其余等你。合并永远可撤销。",
stageAdjudicating: "AI 裁决中",
stageHuman: "需要你来定",
similarity: (pct: number) => `上下文相似度 ${pct}%`,
factsCount: (n: number) => `${n} 条事实`,
noFacts: "没有记录的事实",
merge: "合并",
keep: "保持分开",
rationalePlaceholder: "什么让你这么定?可不写",
typesAny: "全部",
typesSame: "同类型",
typesConflict: "类型不同",
typesEmpty: "这一档没有东西。",
typesDiffer: (a, b) => `${a} / ${b}`,
typesDifferHint: "两边不是一种东西,合了等于把一个意思并进另一个。",
pickPair: "选中这一对",
selectPage: "全选本页",
selected: (n) => `已选 ${n} 对`,
mergeSelected: "合并所选",
keepSelected: "所选保持分开",
batchDone: (ok, failed) =>
failed === 0 ? `已裁 ${ok} 对` : `已裁 ${ok} 对,${failed} 对没成,留在队列里`,
lowConfidence: "低置信度事实",
// 对齐队列(#725)
alignment: "对齐器拿不定的",
alignmentHint:
"两类东西之间的一个说法,或一个类别词,对齐器的两票不一致。选出文档这个说法对应本体的哪个属性或类,或者说没有对得上的:那些陈述就留在开放图谱里。你定了就算数,对齐器不会改人的判定。",
alignmentValue: "一个值",
alignmentNone: "没有对得上的",
alignmentForward: "照原文方向",
alignmentReverse: "反过来",
alignmentBind: "绑定",
alignmentLeaveOpen: "留在开放图谱",
alignmentStatements: (n: number) => `${n} 条陈述`,
alignmentEntities: (n: number) => `${n} 样东西`,
alignmentVotes: (first: string, second: string) => `两票:${first} · ${second}`,
// 状态属性下,单个日期标的是什么(#966)
alignmentMarks: "单个日期",
alignmentMarksStart: "是开始",
alignmentMarksEnd: "是结束",
alignmentMarksNone: "都不是",
alignmentMarksStartHint: "加入、被任命、接手:从那天起成立",
alignmentMarksEndHint: "离开、辞去、卸任:到那天为止",
alignmentMarksNoneHint: "只是那时看到它成立:只带一个日期的陈述留在开放图谱",
alignmentMarksRequired: "先说单个日期标的是什么。",
alignmentAwaitsMarks: (property: string) =>
`已绑到 ${property},单个日期标的是什么还没定。你说之前,只带一个日期的陈述留在开放图谱。`,
alignmentRuleImplies: (property: string) => `同时蕴含 ${property}`,
alignmentRuleObjectIsStatement: "宾语:陈述自己的宾语",
alignmentRuleReading: (reading: string) => `宾语:按「${reading.replace(/_/g, " ")}」从字里读出`,
alignmentRuleKindWord: (word: string) => `叫作「${word}」的东西`,
alignmentApprove: "批准规则",
alignmentReject: "驳回",
alignmentRuleAccepted: "已保存,隐含事实正在后台计算。",
// 勘误队列(0044 决定 7)
errata: "勘误 agent 留给你的",
errataHint:
"抽取之后,一个 agent 按文档复读类型化事实,结构报了的先看,撤、改、加都以文档原话为证据。会牵动图外东西的动作(有派生靠着它、有人问过它、会让只许一个值的属性有两个值)留在这里等人。",
errataRetract: "想撤掉",
errataRevise: "想改成",
errataAdd: "想加上",
errataFlag: (flag: string) =>
({
domain: "结构报的:主语不在属性允许的类里",
range: "结构报的:宾语不在属性允许的类里",
name_absent: "结构报的:名字不在文档里",
no_date: "结构报的:日期属性没有日期",
})[flag] ?? flag,
errataHeld: (detail: string) => {
const [kind, ...rest] = detail.split(" ");
const value = rest.join(" ");
if (kind === "derived") return `留下的原因:有 ${value} 条派生靠着它`;
if (kind === "answered") return `留下的原因:它在 ${value} 次回答里被提到`;
if (kind === "contradiction") return `留下的原因:「${value}」只许一个值,这样会有两个`;
if (kind === "unflagged") return "留下的原因:结构没报过这条,撤或改要人确认";
return `留下的原因:${detail}`;
},
errataQuote: "文档原话:",
errataApprove: "执行",
errataReject: "否",
errataDecided: "已保存。",
alignmentTooMany: (n: number) => `有 ${n} 条属性都可能对得上,多到没法问模型。请选一条或留在开放图谱。`,
alignmentConflict: "此决定与当前状态冲突。请刷新并核对后再试。",
alignmentKindWordBusy: "这个类别词正在被其他操作更新,请稍后重试。",
alignmentAccepted: "已保存。类型化图谱正在后台重算,算完会在这里自动刷新。",
defects: "本体自相矛盾",
defectsHint:
"定义本身的问题,没有牵涉任何事实。这一档排在前面:定义站不住的时候,据它报出来的每一条事实级结论都可疑。",
defectSymAsym: "同时声明了对称与反对称",
defectTransFunc: "传递与函数性并存",
defectCycle: "subClassOf 绕成了环",
defectDisjointAncestor: "与自己的祖先互斥",
defectInheritsDisjoint: "继承了两个互斥的类",
defectInverseSelf: "自己是自己的逆——写成「对称」更直白",
defectInverseNotMutual: "逆关系没有指回来",
defectSubPropertyCycle: "子属性绕成了环",
defectRulesDisagree: "两条规则推出互相抵触的结论",
rulesDisagreeCount: (n: number) => `${n} 对派生等这里定了再落地`,
rulesDisagreeRule: (
a: string,
va: string,
b: string,
vb: string,
axiom: string,
) => `${va} 上的 ${a} 与 ${vb} 上的 ${b},撞在 ${axiom} 上`,
defectNeverInstantiable: "这个类永远不可能有实例",
defectFixed: "已去本体里改了",
defectAccepted: "先放着",
runInference: "跑一遍推理",
inferring: "推理中…",
inferenceNoRules: "本体没有声明传递或对称属性,编不出规则。",
inferenceAdded: (n: number) => `推出 ${n} 条`,
inferenceRetracted: (n: number) => `作废 ${n} 条`,
inferenceNothing: "没有新的可推",
inferenceCapped: (n: number) => `${n} 个谓词撞上单谓词上限,没有推完`,
violations: "公理违规",
violationsHint:
"与本体自己声明的公理相抵触的事实。这里没有猜测——谓词没声明公理就不查。",
violationSelfLoop: "指向了自己",
violationAsymmetry: "两个方向同时成立",
violationCycle: "传递链绕成了环",
violationFunctional: "同一时间有不止一个值",
violationInverseFunctional: "同一时间有不止一个持有者",
violationSignature: "主语或宾语不在关系声明的类型里",
violationDerived: "推出来的与断言相抵触",
derivedLine: (s: string, p: string, o: string) =>
`推出:${s} · ${p} · ${o}`,
derivedBy: (rule: string, via: string) => `由 ${via} 上的 ${rule}`,
assertedLine: (t: string) => `断言:${t}`,
hintStale: "这条断言没写结束日期,而推出来的那条起得更晚——它可能只是结束了。",
hintDuplicate: "有两个同名实体,它们可能是同一个。",
hintUnsure: "这条断言抽取时把握不大,去读一下原句。",
hintReadBoth: "读一下两边的原句,判断哪条错了。",
closeAssertion: "给断言一个结束日期",
retractAssertion: "撤掉断言",
seeDuplicates: "去看重复实体",
openOntology: "去本体页",
letBothStand: "两边都成立",
violationVia: (p: string) => `依据 ${p}`,
violationPath: (n: number) => `环上 ${n} 条事实`,
retractFact: "数据错了",
retractThis: "撤这条",
retractThisHint: "把这条事实撤出图谱,其余的不动。",
relaxAxiom: "公理错了",
acceptBoth: (n: number) => (n > 2 ? "都对" : "两边都对"),
runCheck: "跑一遍检查",
checkNeverRun:
"还没查过。矛盾是拿本体自己声明的公理量出来的——跑一遍只会报公理确实说了的那些。",
checking: "检查中…",
checkNoAxioms: "本体没有声明任何公理,无从判起。先导一份带公理的本体。",
checkFound: (n: number) => `新增 ${n} 处`,
/** 算出来了,但都是已经在队列里或已被裁决过的——说「3 处矛盾」而列表只有
* 一条会让人以为界面漏了东西 */
checkNothingNew: "没有新的",
checkClean: (n: number) => `查了 ${n} 条事实,没有矛盾`,
mappings: "数据映射",
mappingsHint:
"从业务概念到「这个数怎么算」的提议。确认之后问数直接用这个口径,而不是每次从 schema 猜。",
mappingDerived: "派生",
// 记忆抽出、等人点头的事实(0015)
pending: "等你确认",
pendingHint:
"从你让助手记住的话里抽出的事实。这里的东西都还没进图:那句话已经存下,事实等你点头。" +
"确认后以那句话为证据进账本;驳回后不会再被提议。",
pendingNoPredicate: "本体里没有这个关系,这个词是模型自己的说法。",
pendingOwnWords: "文档自己的话;对到本体上是对齐那一步的事。",
pendingNoPredicateChip: "本体里没有这个关系",
pendingSaidBy: (name: string) => `${name} 说的`,
pendingSaidVia: (name: string, agent: string) => `${name} 说的 · 经 ${agent}`,
nodCardTitle: (n: number) =>
n === 1 ? "从这句话里抽出 1 条事实。确认进图,或驳回。" : `从这句话里抽出 ${n} 条事实。确认进图,或驳回。`,
lowConfidenceHint:
"抽取时置信度低于 75%。确认表示采信,驳回表示从图谱移除(台账仍留有记录)。",
confirm: "确认",
reject: "驳回",
confidence: (pct: number) => `${pct}%`,
mergeHistory: "合并历史",
mergedBy: (name: string) => `由 ${name}`,
mergedByAi: "由 AI 裁决",
revert: "撤销",
reverted: "已撤销",
ongoing: "至今",
conflicts: "时态冲突",
conflictsHint:
"两条事实主张同一个单值关系。明确的接续会自动闭合;" +
"这些需要人来定。闭合可通过台账撤销。",
conflictReason: {
no_time: "新事实没有日期",
simultaneous: "起始日期相同",
described_evidence: "新的那条是看图读出来的",
low_confidence: "新的那条不够确信",
},
conflictVs: "对",
conflictSince: (d: string) => `自 ${d} 起`,
closeOld: "闭合旧的",
closeOldAt: (d: string) => `在 ${d} 闭合旧的`,
keepBoth: "两条都留",
rejectNew: "驳回新的",
closeAtPlaceholder: "2024-06-15 · 2024-06 · 2024 · 2024-06-15T14:32Z",
unconfirmed: "已不再被陈述",
unconfirmedHint:
"曾经陈述这些事实的每一个来源,此后都更新过且不再包含它们。" +
"系统不会自动删除任何东西——没提到不等于否定。抽取错误就驳回," +
"真正结束了的就闭合(选它结束的日期)。",
closeFact: "闭合",
closeFactAt: (d: string) => `在 ${d} 闭合`,
},
ui: {
close: "关闭",
noMatches: "没有匹配",
keepTyping: (n: number) => `还有 ${n} 项——继续输入以缩小范围`,
},
kbset: {
title: "知识库设置",
general: "常规",
members: "成员",
materialize: "物化推理",
materializeNote:
"把本体蕴含的事实写进账本——传递链与对称对。它们带派生标记、单列一段,背后的声明要是错了,撤掉只要一下。",
autoResolveTypes: "抽取后自动消解实体类型",
autoResolveTypesNote:
"每篇文档抽完,对引擎还没看过的实体跑一轮类型消解。只有在现类子树里精化的才自动落地,跨轴的改判仍留在本体页等你。每一批都列在本体页,随时可以撤回。",
governance: "让 agent 处理重复项队列",
governanceNote:
"先进先出。裁一对之前,agent 先读这个库里的人对同样的名字、同样的类型对做过什么决定:有先例撑着才合并,有把握就分开,其余的写成建议留给你。每一笔都列在审核页的 Agent 里,可以撤回。关掉,队列就停。",
inferEvery: "每隔",
minutes: "分钟重推",
lastInference: (when: string) => `上次 ${when}`,
failedJobs: (n: number) => `${n} 个失败的任务`,
requeue: "再跑一遍",
requeued: (n: number) => `${n} 个任务回到队列`,
exportKb: "导出整个知识库(RDF)",
exportKbNote: "把所有事实及其出处下载为 Turtle 文件。",
exportKbAction: "导出",
cardIdentity: "名字与描述",
cardIdentityNote: "最长 64 个字符。切换器和这个库每一页的顶上用的都是它。",
cardVisibilityNote:
"Open 是部署里的所有人都读得到;Restricted 只有成员名单上的人读得到。",
cardVisibilityFoot: "改完立刻生效。成员名单上授过的角色两种情况下都留着。",
cardAutomation: "自动跑的那几件事",
cardAutomationNote: "从下一次抽取起生效。它们做的每一步都记着,可以撤回。",
cardJobs: "后台任务",
ontologyLang: "本体的语言",
ontologyLangNote:
"类与关系的描述用哪种语言写。它们会被原样送进抽取提示词," +
"所以读者是正在读你文档的模型——跟你的文档一致,而不是跟界面一致。" +
"改这一项不会重写已经写好的;它决定的是此后新写的描述用什么语言。",
defaultOpenLabel: "对所有人开放",
defaultOpenNote:
"这是本部署的默认知识库,所以可见性被锁定:每位成员在这里至少有只读权限," +
"这保证了没有人登录后面对一片空白。出于同样的原因它也不能被删除。" +
"要给某人超出只读的权限,在「成员」里授予角色;需要私密空间的话," +
"另建一个知识库并设为受限。",
data: "数据",
dataHint:
"已挂载的只读数据库,本知识库可以在「对话」里查询它们。" +
"挂载会摄入数据库模式,好让助手知道有哪些表。",
dataMount: "挂载",
dataUnmount: "卸载",
dataSyncSchema: "刷新模式",
dataSchemaSynced: (n: number) => `模式已摄入(${n} 张表)`,
dataExplore: "探查映射",
dataExploreHint:
"一个智能体读取这些模式并提出指标/维度定义——在「对话」用上它们之前,先到「审阅」里过一遍。",
dataExploreQueued: "探查已排队——提案稍后会出现在「审阅」中。",
dataNone: "没有挂载任何数据源。",
dataNoneAvailable: "还没有登记数据源——请部署管理员登记一个。",
dataNewConn: "登记新连接",
activity: "活动",
activityHint: "谁在这个知识库里改了什么。纯审计——记录只追加。",
auditAllActions: "全部动作",
auditSince: "起始日期",
auditUntil: "截止日期",
auditClear: "清除筛选",
auditTotal: (n: number) => `共 ${n} 条`,
activityEmpty: "还没有记录。",
deletedUser: "一位已移除的用户",
adjudicator: "AI 裁决器",
engine: "引擎",
auditActions: {
"entity_type.created": "创建了实体类型",
"entity_type.updated": "更新了实体类型",
"entity_type.deleted": "删除了一个实体类型",
"relation_type.created": "创建了关系类型",
"relation_type.updated": "更新了关系类型",
"relation_type.deleted": "删除了一个关系类型",
"kb.updated": "更新了知识库设置",
"kb.member_set": "设置了成员角色",
"kb.member_removed": "移除了成员",
"source.created": "创建了来源",
"source.updated": "更新了来源",
"source.deleted": "删除了一个来源",
"document.deleted": "删除了文档",
"ontology.imported": "导入了一份本体",
},
membersHintOpen:
"本部署内的所有人已经能读这个知识库,所以没有「查看者」可授——" +
"在这里列出某个人,只是为了给他写权限。部署管理员始终拥有。",
membersHintRestricted:
"只有这里列出的人能看到这个知识库,角色决定他能改什么。" +
"部署管理员始终有访问权。",
addMember: "添加…",
addMemberTitle: "添加成员",
roles: { viewer: "只读", editor: "编辑者", admin: "管理员" },
remove: "移除",
noMembers: "没有设置任何库内角色。",
noWriters: "还没有给任何人写权限。",
save: "保存",
saved: "已保存",
danger: "危险操作",
deleteKb: "删除这个知识库",
deleteHint: (name: string) =>
`输入「${name}」确认。文档、图谱与来源都将被永久移除。`,
deleteBtn: "永久删除",
deleteRowTitle: "删除这个知识库",
deleteRowHint: "文档、图谱与来源都将被永久移除。",
deleteRowBtn: "删除",
},
members: {
title: "部署用户",
systemAdmin: "系统管理员",
systemAdminHint: "可进入系统管理:部署配置、账号、数据源。不能收回自己的。",
remove: "移除",
deactivate: "停用账号",
cancel: "取消",
deactivateHint:
"断掉整个系统的访问——登录与已签发的 token 都失效。他做过的事仍然记在他名下。",
deactivatedTitle: "已停用的账号",
deactivatedHint:
"他们登不进来,也不出现在任何成员列表里。做过的事仍然算在他们名下——账号被保留而不是删除,正是为了这个。",
editMember: "编辑成员",
close: "关闭",
save: "保存",
reactivate: "恢复",
roleLabel: "角色",
filterAll: "全部用户",
filterAllRoles: "全部角色",
statusLabel: "状态",
filterActive: "在用",
filterDeactivated: "已停用",
deactivateConfirm: (name: string) =>
`停用 ${name}?他将无法再登录任何地方,但过往的决定仍然留痕。`,
addExisting: "添加已有用户",
userLabel: "用户",
pickUser: "选择要添加的用户…",
add: "添加",
roles: {
owner: "所有者",
admin: "管理员",
editor: "编辑者",
viewer: "只读",
},
},
};