World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
One relation, one predicate (#569)
WaylandYangf92c2762577d
diff --git a/crates/utopia-ingest/src/ontology_rdf.rs b/crates/utopia-ingest/src/ontology_rdf.rsindex e926aad2..1f7fd1d4 100644--- a/crates/utopia-ingest/src/ontology_rdf.rs+++ b/crates/utopia-ingest/src/ontology_rdf.rs@@ -50,6 +50,10 @@ pub struct OwlProperty {/// `rdfs:subPropertyOf` 的父属性 IRI。多写几条只留第一条——/// OWL 允许多父,而 R1 的规则一次只升一级,多父要另一套形状pub sub_property_of: Option<String>,+ /// `schema:supersededBy` 的对端 IRI:这条属性已经被另一条取代。schema.org 里+ /// `employees` 让位给 `employee`、`founders` 让位给 `founder`,两条都还在词表里。+ /// 不读这一位,两条都建成关系,抽取时精确 key 各自命中,一个关系永久分成两个(#560)+ pub superseded_by: Option<String>,pub domains: Vec<String>,pub ranges: Vec<String>,/// **多条 range 是并集还是交集**。`rdfs:range` 写多条是交集@@ -229,6 +233,7 @@ pub fn project(bytes: &[u8], format: RdfFormat) -> anyhow::Result<OwlProjection>// 属性之间的两条关系(不是类型声明,所以单独收)let mut inverse_of: BTreeMap<String, String> = BTreeMap::new();let mut sub_property_of: BTreeMap<String, String> = BTreeMap::new();+ let mut superseded_by: BTreeMap<String, String> = BTreeMap::new();let mut asymmetric: BTreeSet<String> = BTreeSet::new();let mut irreflexive: BTreeSet<String> = BTreeSet::new();let mut plain_props: BTreeSet<String> = BTreeSet::new();@@ -315,6 +320,7 @@ pub fn project(bytes: &[u8], format: RdfFormat) -> anyhow::Result<OwlProjection>|| is_schema(p, "rangeIncludes")|| p == format!("{OWL}disjointWith")|| p == format!("{OWL}inverseOf")+ || is_schema(p, "supersededBy")};for t in &triples {let p = t.predicate.as_str();@@ -352,6 +358,11 @@ pub fn project(bytes: &[u8], format: RdfFormat) -> anyhow::Result<OwlProjection>if let Some(o) = &t.object_iri {inverse_of.entry(t.subject.clone()).or_insert(o.clone());}+ } else if is_schema(p, "supersededBy") {+ // 取代关系只在 schema.org 词表里出现;多写几条只留第一条+ if let Some(o) = &t.object_iri {+ superseded_by.entry(t.subject.clone()).or_insert(o.clone());+ }} else if p == format!("{RDFS}subPropertyOf") {// 从前这条只出现在 `known()` 白名单里——认得出、不报警、**然后扔掉**。// 导一份带 subPropertyOf 的本体进来,那部分信息当场消失且没有提示@@ -509,6 +520,7 @@ pub fn project(bytes: &[u8], format: RdfFormat) -> anyhow::Result<OwlProjection>asymmetric: asymmetric.contains(iri),inverse_of: inverse_of.get(iri).cloned(),sub_property_of: sub_property_of.get(iri).cloned(),+ superseded_by: superseded_by.get(iri).cloned(),irreflexive: irreflexive.contains(iri),domains: domains.get(iri).cloned().unwrap_or_default(),ranges: rs,@@ -1480,6 +1492,39 @@ mod against_real_packs {mod property_axiom_tests {use super::*;+ /// `schema:supersededBy` 要被读出来:让位的属性带着它让给了谁+ #[test]+ fn a_superseded_property_names_its_successor() {+ let ttl = r#"+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .+@prefix schema: <https://schema.org/> .+schema:Organization a rdfs:Class ; rdfs:label "Organization" .+schema:Person a rdfs:Class ; rdfs:label "Person" .+schema:employee a rdf:Property ; rdfs:label "employee" ;+ schema:domainIncludes schema:Organization ; schema:rangeIncludes schema:Person .+schema:employees a rdf:Property ; rdfs:label "employees" ;+ schema:domainIncludes schema:Organization ; schema:rangeIncludes schema:Person ;+ schema:supersededBy schema:employee .+"#;+ let p = project(ttl.as_bytes(), RdfFormat::Turtle).expect("解析");+ let by = |k: &str| {+ p.properties+ .iter()+ .find(|x| x.key == k)+ .unwrap_or_else(|| panic!("没有 {k}"))+ };+ assert_eq!(+ by("employees").superseded_by.as_deref(),+ Some("https://schema.org/employee")+ );+ assert!(by("employee").superseded_by.is_none());+ assert!(+ !p.unprojected.keys().any(|k| k.contains("supersededBy")),+ "认了就不该再算进「暂未投影」"+ );+ }+/// `owl:inverseOf` 与 `rdfs:subPropertyOf` 要被读出来。////// 从前 `subPropertyOf` 只出现在 `known()` 白名单里——认得出、不报警、diff --git a/crates/utopia-server/src/bootstrap_ontology.rs b/crates/utopia-server/src/bootstrap_ontology.rsindex c0240f68..628245c6 100644--- a/crates/utopia-server/src/bootstrap_ontology.rs+++ b/crates/utopia-server/src/bootstrap_ontology.rs@@ -109,10 +109,84 @@ async fn counted_relation_groups(existing,});}+ fold_by_meaning(state, kb_id, &mut out).await;out.sort_by(|a, b| b.facts.cmp(&a.facts).then(a.key.cmp(&b.key)));Ok(out)}+/// 拼写对不上、意思对得上的,也不新建(#560)。+///+/// `PredicateIndex` 只认写法、屈折与被动;`comprised` 对 `has_member`、`ceo` 对+/// `chief_executive` 它看不出来,于是本体里长出第二个关系,图上同一件事两种谓词,+/// 查询按谓词分组时它们各站一边。这里把没落地的说法嵌一次,与已有关系的向量比,+/// 够近的就落到那一条上。阈值取得紧:折错一次是把两个关系永久并成一个,+/// 而不折只是多一个关系,后者便宜得多。每个候选的距离都进日志,好在真语料上校+const FOLD_DISTANCE: f32 = 0.20;++async fn fold_by_meaning(state: &AppState, kb_id: Uuid, groups: &mut [RelationGroup]) {+ let unmatched: Vec<usize> = groups+ .iter()+ .enumerate()+ .filter(|(_, g)| g.existing.is_none())+ .map(|(i, _)| i)+ .collect();+ if unmatched.is_empty() {+ return;+ }+ let Ok(kb) = utopia_store::kbs::get(&state.pool, kb_id).await else {+ return;+ };+ let Ok(Some(settings)) = utopia_store::settings::get(&state.pool, kb.workspace_id).await else {+ return;+ };+ let Some(client) = crate::llm_util::embed_client(&settings) else {+ return;+ };+ let texts: Vec<String> = unmatched+ .iter()+ .map(|i| groups[*i].key.replace('_', " "))+ .collect();+ let vectors = match client.embed(&texts).await {+ Ok(v) if v.len() == texts.len() => v,+ Ok(_) => return,+ Err(e) => {+ tracing::warn!(%kb_id, error = %e, "说法嵌入失败,按拼写采纳");+ return;+ }+ };+ for (i, vec) in unmatched.into_iter().zip(vectors) {+ let near = utopia_store::ontology::nearest_relation_types(+ &state.pool,+ kb_id,+ &vec,+ 3,+ Some("relation"),+ )+ .await+ .unwrap_or_default();+ for c in &near {+ tracing::debug!(%kb_id, form = %groups[i].key, key = %c.key, distance = c.distance, "同义候选");+ }+ if let Some(hit) = fold_pick(&near, FOLD_DISTANCE) {+ tracing::info!(+ %kb_id, form = %groups[i].key, onto = %hit.key, distance = hit.distance,+ "说法按意思落到已有关系上"+ );+ groups[i].existing = Some((hit.id, false));+ }+ }+}++/// 最近的一个在阈值内就是它;候选按距离升序来+fn fold_pick(+ near: &[utopia_core::models::TypeCandidate],+ max_distance: f32,+) -> Option<&utopia_core::models::TypeCandidate> {+ near.iter()+ .min_by(|a, b| a.distance.total_cmp(&b.distance))+ .filter(|c| c.distance <= max_distance)+}+pub async fn bootstrap_ontology(state: &AppState, kb_id: Uuid) -> anyhow::Result<()> {// 并发的两个抽取任务可能都看到"空闲"而各入队一次;开关也可能刚被关掉let kb = utopia_store::kbs::get(&state.pool, kb_id).await?;@@ -298,6 +372,20 @@ pub async fn bootstrap_ontology(state: &AppState, kb_id: Uuid) -> anyhow::Result}}+ // 新建的关系要有向量:抽取按分块检索候选靠它,谓词对齐(#558)靠它,下一次+ // 同义归并也靠它。从前 `embed_ontology` 只在导入时跑一次,冷启动建的关系+ // 永远没有向量——这个库里 76 个,`comprised` 是其中之一+ if !added_relations.is_empty() {+ if let Err(e) = crate::ontology_index::refresh_scoped(+ state,+ kb_id,+ Some(utopia_store::ontology::TypeKind::Relation),+ )+ .await+ {+ tracing::warn!(%kb_id, error = %e, "新建关系的向量没补上");+ }+ }// 属性那一档:宾语是字面值的说法。//// domain 不从提案里读——它从这些事实的主语类型里取,见 adopt_attribute。@@ -477,3 +565,32 @@ fn str_of<'a>(v: &'a serde_json::Value, key: &str) -> Option<&'a str> {.map(str::trim).filter(|s| !s.is_empty())}++#[cfg(test)]+mod tests {+ use super::*;+ use utopia_core::models::TypeCandidate;++ fn cand(key: &str, distance: f32) -> TypeCandidate {+ TypeCandidate {+ id: Uuid::now_v7(),+ key: key.into(),+ label: key.into(),+ description: String::new(),+ kind: Some("relation".into()),+ distance,+ }+ }++ /// 只认阈值内最近的那个;差一点也不折——折错比不折贵+ #[test]+ fn a_form_folds_only_onto_a_close_enough_relation() {+ let near = vec![cand("has_member", 0.18), cand("member_of", 0.31)];+ assert_eq!(+ fold_pick(&near, 0.20).map(|c| c.key.as_str()),+ Some("has_member")+ );+ assert!(fold_pick(&near, 0.15).is_none());+ assert!(fold_pick(&[], 0.20).is_none());+ }+}diff --git a/crates/utopia-server/src/owl_import.rs b/crates/utopia-server/src/owl_import.rsindex cf6edcf5..1734ecbb 100644--- a/crates/utopia-server/src/owl_import.rs+++ b/crates/utopia-server/src/owl_import.rs@@ -27,6 +27,11 @@ pub enum Disposition {/// key 被另一个 IRI 占着,但对齐表说那两个是**同一个东西** → 跳过且不算冲突。/// 与 KeyTaken 分开,是因为它不需要人裁:少建一个重复的类正是想要的结果Aligned,+ /// 词表自己说这条属性已被另一条取代(`schema:supersededBy`),而取代它的那条+ /// 在这个文件里或库里 → 不建。建了就是两个 key 指同一个关系:抽取的精确 key+ /// 命中让 `employees` 与 `employee` 永久分家,屈折归一根本没机会开口(#560)。+ /// 不建之后,模型说 `employees` 会折到 `employee` 上+ Superseded,}/// 一个属性在这次导入里会不会被建出来,以及为什么。@@ -143,6 +148,10 @@ impl ImportPlan {*out.entry("key_taken").or_default() += 1;continue;}+ if a.disposition == Disposition::Superseded {+ *out.entry("superseded").or_default() += 1;+ continue;+ }let reason = match a.attr.as_ref() {Some(AttrNote::Datatype(_))| Some(AttrNote::NoRange)@@ -272,8 +281,17 @@ pub async fn plan(let mut relations = Vec::new();let mut attributes = Vec::new();+ // 让位的属性只在取代它的那条**能落地**时才跳过:取代者在这个文件里,或库里已有。+ // 取代者不在场时照建——否则一份只带了让位方的小词表会一条都建不出来+ let prop_iris: HashSet<&str> = proj.properties.iter().map(|p| p.iri.as_str()).collect();for p in &proj.properties {- let (disposition, conflict_with) = if let Some(prev) = claimed_prop.get(p.key.as_str()) {+ let successor = p+ .superseded_by+ .as_deref()+ .filter(|s| prop_iris.contains(s) || r_by_iri.contains_key(s));+ let (disposition, conflict_with) = if let Some(s) = successor {+ (Disposition::Superseded, Some(s.to_string()))+ } else if let Some(prev) = claimed_prop.get(p.key.as_str()) {(Disposition::KeyTaken, Some((*prev).to_string()))} else if r_by_iri.contains_key(p.iri.as_str()) {(Disposition::Update, None)@@ -282,7 +300,7 @@ pub async fn plan(} else {(Disposition::Create, None)};- if disposition != Disposition::KeyTaken {+ if !matches!(disposition, Disposition::KeyTaken | Disposition::Superseded) {claimed_prop.insert(p.key.as_str(), p.iri.as_str());}let mut item = PlannedItem {@@ -490,7 +508,8 @@ pub async fn apply(}}}- Disposition::KeyTaken => {}+ // 类没有让位一说(schema:supersededBy 只标属性),穷举是为了编译器替我们看着+ Disposition::KeyTaken | Disposition::Superseded => {}}}@@ -551,7 +570,10 @@ pub async fn apply(// (key, domains, ranges):关系 id 要等批量插完才有,先按 key 记着let mut pending_links: Vec<(String, Vec<Uuid>, Vec<Uuid>)> = Vec::new();for item in &plan.relations {- if item.disposition == Disposition::KeyTaken {+ if matches!(+ item.disposition,+ Disposition::KeyTaken | Disposition::Superseded+ ) {continue;}let Some(p) = by_prop_iri.get(item.iri.as_str()) else {@@ -657,7 +679,10 @@ pub async fn apply(let mut new_attrs: Vec<utopia_store::ontology::BulkRelation> = Vec::new();let mut pending_attr_domains: Vec<(String, Vec<Uuid>)> = Vec::new();for item in &plan.attributes {- if item.disposition == Disposition::KeyTaken {+ if matches!(+ item.disposition,+ Disposition::KeyTaken | Disposition::Superseded+ ) {continue;}let (Some(note), Some(p)) = (item.attr.as_ref(), by_prop_iri.get(item.iri.as_str())) else {@@ -716,6 +741,8 @@ pub async fn apply("inverse_linked": linked_inv,"sub_property_linked": linked_sub,"relations_created": created_rels,+ // 词表自己让位的那些:不建,也不算冲突+ "relations_superseded": plan.relations.iter().filter(|r| r.disposition == Disposition::Superseded).count(),"relations_updated": updated_rels,"attributes_seen": plan.attributes.len(),"attributes_created": created_attrs,diff --git a/web/src/api.ts b/web/src/api.tsindex 66ac1594..9bdc760e 100644--- a/web/src/api.ts+++ b/web/src/api.ts@@ -1110,7 +1110,7 @@ export interface PlannedItem {key: string;label: string;has_description: boolean;- disposition: "create" | "update" | "key_taken";+ disposition: "create" | "update" | "key_taken" | "aligned" | "superseded";functional?: boolean;conflict_with?: string | null;}@@ -1137,6 +1137,7 @@ export interface OntologyImportSummary {classes_without_description?: number;relations_seen?: number;relations_created?: number;+ relations_superseded?: number;relations_updated?: number;functional_relations?: number;/** 逆属性 / 父属性连上了几条——目标 IRI 不在这个库里时会静默跳过 */