RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
Refactor: use type_kwd instead of knowledge_graph_kwd (#20475)
Wang Qi519e7d98a565
diff --git a/internal/engine/elasticsearch/chunk.go b/internal/engine/elasticsearch/chunk.goindex b1683cb7cc..e228aee305 100644--- a/internal/engine/elasticsearch/chunk.go+++ b/internal/engine/elasticsearch/chunk.go@@ -1997,6 +1997,31 @@ func buildBoolQueryFromCondition(filter map[string]interface{}, kbIDs []string,}continue}+ if k == "knowledge_graph_kwd" {+ var graphTypeClauses []interface{}+ for _, field := range []string{"type_kwd", "knowledge_graph_kwd"} {+ switch val := v.(type) {+ case []interface{}:+ if len(val) > 0 {+ graphTypeClauses = append(graphTypeClauses, map[string]interface{}{"terms": map[string]interface{}{field: val}})+ }+ case []string:+ if len(val) > 0 {+ graphTypeClauses = append(graphTypeClauses, map[string]interface{}{"terms": map[string]interface{}{field: val}})+ }+ case string:+ if val != "" {+ graphTypeClauses = append(graphTypeClauses, map[string]interface{}{"term": map[string]interface{}{field: val}})+ }+ }+ }+ if len(graphTypeClauses) > 0 {+ filterClauses = append(filterClauses, map[string]interface{}{"bool": map[string]interface{}{+ "should": graphTypeClauses, "minimum_should_match": 1,+ }})+ }+ continue+ }if k == "id" {if v == nil || v == "" {continuediff --git a/internal/engine/elasticsearch/chunk_test.go b/internal/engine/elasticsearch/chunk_test.goindex 8a3f233a64..a4c5ca2837 100644--- a/internal/engine/elasticsearch/chunk_test.go+++ b/internal/engine/elasticsearch/chunk_test.go@@ -367,6 +367,27 @@ func TestSearchAfterPaginateLimitLargerThanBatchSize(t *testing.T) {}}+func TestBuildBoolQueryFromConditionUsesLegacyGraphFallback(t *testing.T) {+ got := buildBoolQueryFromCondition(map[string]interface{}{"knowledge_graph_kwd": "entity"}, nil, false, false)+ outer, ok := got["bool"].(map[string]interface{})+ if !ok {+ t.Fatalf("missing bool wrapper: %v", got)+ }+ filters, ok := outer["filter"].([]interface{})+ if !ok || len(filters) != 1 {+ t.Fatalf("graph filter = %#v, want one compatibility clause", outer["filter"])+ }+ encoded, err := json.Marshal(filters[0])+ if err != nil {+ t.Fatal(err)+ }+ for _, field := range []string{"type_kwd", "knowledge_graph_kwd"} {+ if !strings.Contains(string(encoded), "\""+field+"\":\"entity\"") {+ t.Errorf("graph filter %s does not match %s: %s", field, field, encoded)+ }+ }+}+// TestBuildBoolQueryFromConditionIDFilter is the regression for the// "id filter encoded as a nested array inside bool.should" bug.//diff --git a/internal/engine/infinity/chunk.go b/internal/engine/infinity/chunk.goindex 28b4a6f5b2..b3d5507360 100644--- a/internal/engine/infinity/chunk.go+++ b/internal/engine/infinity/chunk.go@@ -2505,6 +2505,33 @@ func floatsEqual(a, b float64) bool {return diff < 1e-9}+func buildGraphTypeFilterCondition(value interface{}) string {+ var values []string+ switch val := value.(type) {+ case []string:+ values = val+ case []interface{}:+ for _, item := range val {+ values = append(values, fmt.Sprintf("%v", item))+ }+ case string:+ values = []string{val}+ default:+ values = []string{fmt.Sprintf("%v", value)}+ }+ conditions := make([]string, 0, len(values)*2)+ for _, value := range values {+ if strings.TrimSpace(value) == "" {+ continue+ }+ conditions = append(conditions,+ keywordFilterCondition("type_kwd", value),+ fmt.Sprintf("knowledge_graph_kwd='%s'", escapeFilterValue(value)),+ )+ }+ return joinBalanced(conditions, " OR ")+}+// equivalentConditionToStr converts a condition map to an Infinity filter stringfunc equivalentConditionToStr(condition map[string]interface{}, tableColumns map[string]struct {Type string@@ -2540,6 +2567,13 @@ func equivalentConditionToStr(condition map[string]interface{}, tableColumns mapcontinue}+ if k == "knowledge_graph_kwd" {+ if graphTypeCondition := buildGraphTypeFilterCondition(v); graphTypeCondition != "" {+ cond = append(cond, graphTypeCondition)+ }+ continue+ }+// JSON-list fields use member containment. Legacy varchar columns keep// the old full-text behavior.if fieldJSONList(k) && tableColumns != nil {diff --git a/internal/engine/infinity/common.go b/internal/engine/infinity/common.goindex 9a4c551d5b..8d648214d1 100644--- a/internal/engine/infinity/common.go+++ b/internal/engine/infinity/common.go@@ -400,6 +400,13 @@ func buildFilterFromCondition(condition map[string]interface{}, tableColumns mapcontinue}+ if k == "knowledge_graph_kwd" {+ if graphTypeCondition := buildGraphTypeFilterCondition(v); graphTypeCondition != "" {+ conditions = append(conditions, graphTypeCondition)+ }+ continue+ }+// JSON-list fields use member containment. Legacy tables stored these// columns as ###-joined varchar values, so retain their full-text fallback.if fieldJSONList(k) && tableColumns != nil {diff --git a/internal/engine/infinity/sql_test.go b/internal/engine/infinity/sql_test.goindex 951132e11c..f66c51987a 100644--- a/internal/engine/infinity/sql_test.go+++ b/internal/engine/infinity/sql_test.go@@ -644,6 +644,26 @@ func TestBuildFilterFromConditionMissingJSONListColumnNeverMatches(t *testing.T)// filter_fulltext() query, so a whitespace-bearing value matched NOTHING (nav's// parent_kwd child lookup, cluster updates and cleanup all no-op'd); the ES// columns are keywords and match exactly.+func TestGraphTypeFilterSupportsCurrentAndLegacyRows(t *testing.T) {+ condition := map[string]interface{}{"knowledge_graph_kwd": []string{"entity", "relation"}}+ for name, got := range map[string]string{+ "search": equivalentConditionToStr(condition, nil),+ "mutation": buildFilterFromCondition(condition, nil),+ } {+ for _, want := range []string{+ "filter_fulltext('type_kwd', 'entity')",+ "knowledge_graph_kwd='entity'",+ "filter_fulltext('type_kwd', 'relation')",+ "knowledge_graph_kwd='relation'",+ } {+ if !strings.Contains(got, want) {+ t.Errorf("%s graph filter = %q, missing %q", name, got, want)+ }+ }+ }+}++// TestKeywordFilterConditionExactForWhitespaceValues covers exact matching for multi-token keywords.func TestKeywordFilterConditionExactForWhitespaceValues(t *testing.T) {cases := []struct {name, field, value, want stringdiff --git a/internal/engine/oceanbase/filter.go b/internal/engine/oceanbase/filter.goindex ecd129a55f..0c5f3225f3 100644--- a/internal/engine/oceanbase/filter.go+++ b/internal/engine/oceanbase/filter.go@@ -76,6 +76,29 @@ func buildFilter(condition map[string]interface{}, kind string) (string, []interparts = append(parts, part)args = append(args, partArgs...)}+ case "knowledge_graph_kwd":+ if kind != "chunk" {+ continue+ }+ values, isSlice := interfaceSlice(value)+ if !isSlice {+ values = []interface{}{value}+ }+ if len(values) == 0 {+ continue+ }+ placeholders := make([]string, len(values))+ for i := range values {+ placeholders[i] = "?"+ }+ predicate := "= ?"+ if len(values) > 1 {+ predicate = "IN (" + strings.Join(placeholders, ", ") + ")"+ }+ parts = append(parts, fmt.Sprintf("(%s %s OR %s %s)",+ quoteIdentifier("type_kwd"), predicate, quoteIdentifier("knowledge_graph_kwd"), predicate))+ args = append(args, values...)+ args = append(args, values...)default:if !valid[key] {continuediff --git a/internal/engine/oceanbase/schema.go b/internal/engine/oceanbase/schema.goindex ac929d3133..ac07091b69 100644--- a/internal/engine/oceanbase/schema.go+++ b/internal/engine/oceanbase/schema.go@@ -74,6 +74,7 @@ var chunkColumns = []columnDefinition{{"page_num_int", "ARRAY(INTEGER) NULL"},{"top_int", "ARRAY(INTEGER) NULL"},{"knowledge_graph_kwd", "VARCHAR(256) NULL"},+ {"type_kwd", "VARCHAR(256) NULL"},{"source_id", "ARRAY(VARCHAR(256)) NULL"},{"entity_kwd", "VARCHAR(256) NULL"},{"entity_type_kwd", "VARCHAR(256) NULL"},@@ -148,7 +149,7 @@ var skillColumns = []columnDefinition{}var chunkIndexColumns = []string{- "kb_id", "doc_id", "available_int", "knowledge_graph_kwd", "entity_type_kwd", "removed_kwd",+ "kb_id", "doc_id", "available_int", "knowledge_graph_kwd", "type_kwd", "entity_type_kwd", "removed_kwd",}var memoryIndexColumns = []string{"message_id", "memory_id", "status_int"}diff --git a/internal/engine/oceanbase/sql_test.go b/internal/engine/oceanbase/sql_test.goindex b1a082f882..992fb86281 100644--- a/internal/engine/oceanbase/sql_test.go+++ b/internal/engine/oceanbase/sql_test.go@@ -17,6 +17,7 @@package oceanbaseimport (+ "reflect""regexp""strings""testing"@@ -129,6 +130,20 @@ func TestMemorySourceIDUsesScalarSQL(t *testing.T) {}}+func TestKnowledgeGraphFilterSupportsCurrentAndLegacyRows(t *testing.T) {+ where, args, err := buildFilter(map[string]interface{}{"knowledge_graph_kwd": []string{"entity", "relation"}}, "chunk")+ if err != nil {+ t.Fatal(err)+ }+ want := "(`type_kwd` IN (?, ?) OR `knowledge_graph_kwd` IN (?, ?))"+ if where != want {+ t.Fatalf("graph filter = %q, want %q", where, want)+ }+ if !reflect.DeepEqual(args, []interface{}{"entity", "relation", "entity", "relation"}) {+ t.Fatalf("graph filter args = %#v", args)+ }+}+func TestChunkSourceIDUsesArraySQL(t *testing.T) {where, args, err := buildFilter(map[string]interface{}{"source_id": "source-1"}, "chunk")if err != nil {diff --git a/internal/engine/serenedb/common.go b/internal/engine/serenedb/common.goindex 31d510e970..af28630c4c 100644--- a/internal/engine/serenedb/common.go+++ b/internal/engine/serenedb/common.go@@ -146,6 +146,20 @@ func buildFilters(condition map[string]interface{}) []string {}}}+ case k == "knowledge_graph_kwd":+ var values []interface{}+ switch list := v.(type) {+ case []interface{}:+ values = list+ case []string:+ values = make([]interface{}, len(list))+ for i := range list {+ values[i] = list[i]+ }+ default:+ values = []interface{}{v}+ }+ filters = append(filters, "("+inList("type_kwd", values)+" OR "+inList("knowledge_graph_kwd", values)+")")case isArrayColumn(k):vals := toStringSlice(v)if len(vals) == 0 {diff --git a/internal/engine/serenedb/schema.go b/internal/engine/serenedb/schema.goindex 34bdf674ce..f7bd4b480f 100644--- a/internal/engine/serenedb/schema.go+++ b/internal/engine/serenedb/schema.go@@ -55,7 +55,7 @@ var (textColumns = []string{"docnm_kwd", "doc_type_kwd", "title_tks", "title_sm_tks", "content_with_weight","content_ltks", "content_sm_ltks", "important_tks", "question_tks", "create_time",- "img_id", "knowledge_graph_kwd", "entity_kwd", "entity_type_kwd", "from_entity_kwd",+ "img_id", "knowledge_graph_kwd", "type_kwd", "entity_kwd", "entity_type_kwd", "from_entity_kwd","to_entity_kwd", "removed_kwd", "raptor_kwd", "group_id", "mom_id", "n_hop_with_weight",}arrayColumns = []string{"important_kwd", "question_kwd", "tag_kwd", "source_id", "entities_kwd"}diff --git a/internal/engine/serenedb/serenedb_test.go b/internal/engine/serenedb/serenedb_test.goindex e18e0e9cba..1418d8efc2 100644--- a/internal/engine/serenedb/serenedb_test.go+++ b/internal/engine/serenedb/serenedb_test.go@@ -71,6 +71,14 @@ func TestBuildFiltersArrayUsesListContains(t *testing.T) {mustContain(t, got[0], "list_contains(tag_kwd, 'b')")}+func TestBuildFiltersKnowledgeGraphCompatibility(t *testing.T) {+ got := buildFilters(map[string]interface{}{"knowledge_graph_kwd": []string{"entity", "relation"}})+ want := "(type_kwd IN ('entity', 'relation') OR knowledge_graph_kwd IN ('entity', 'relation'))"+ if len(got) != 1 || got[0] != want {+ t.Fatalf("graph filter = %v, want %q", got, want)+ }+}+func TestBuildFiltersScalarAndIn(t *testing.T) {scalar := buildFilters(map[string]interface{}{"doc_id": "d1"})if len(scalar) != 1 || scalar[0] != "doc_id = 'd1'" {diff --git a/internal/handler/dataset.go b/internal/handler/dataset.goindex 2e09b00f46..7591c6528e 100644--- a/internal/handler/dataset.go+++ b/internal/handler/dataset.go@@ -769,7 +769,7 @@ func (h *DatasetsHandler) GetKnowledgeGraph(c *gin.Context) {KbIDs: []string{datasetID},Offset: 0,Limit: 1,- SelectFields: []string{"content_with_weight", "knowledge_graph_kwd"},+ SelectFields: []string{"content_with_weight", "type_kwd", "knowledge_graph_kwd"},Filter: map[string]interface{}{"kb_id": []string{datasetID},"knowledge_graph_kwd": []string{"graph"},@@ -785,7 +785,10 @@ func (h *DatasetsHandler) GetKnowledgeGraph(c *gin.Context) {}chunk := searchResult.Chunks[0]- graphType := firstStringValue(chunk["knowledge_graph_kwd"])+ graphType := firstStringValue(chunk["type_kwd"])+ if graphType == "" {+ graphType = firstStringValue(chunk["knowledge_graph_kwd"])+ }contentWithWeight, _ := chunk["content_with_weight"].(string)if strings.TrimSpace(contentWithWeight) == "" {common.SuccessWithData(c, result, "success")diff --git a/internal/ingestion/component/knowledge_compiler/component.go b/internal/ingestion/component/knowledge_compiler/component.goindex 7eb1113b6e..5dbb2c0aed 100644--- a/internal/ingestion/component/knowledge_compiler/component.go+++ b/internal/ingestion/component/knowledge_compiler/component.go@@ -512,7 +512,7 @@ func applyVariantColumns(doc *schema.ChunkDoc, p common.Product) error {switch p.Variant {case common.VariantStructure:- // knowledge_graph_kwd: "entity" | "relation" | "graph".+ // type_kwd: "entity" | "relation" | "graph".return applyStructureGraphColumns(doc, p, kind)case common.VariantWiki:@@ -595,7 +595,7 @@ func applyVariantColumns(doc *schema.ChunkDoc, p common.Product) error {case "entity", "relation", "graph":// The tree is also projected onto the structure-graph shape (Python// raptor_tree_to_graph + _struct_upsert_tree_graph_rows): entity /- // relation rows carry knowledge_graph_kwd and the compact graph blob+ // relation rows carry type_kwd and the compact graph blob// (kind "graph") is the /structure/graph discovery row. This is the// same storage contract as the structure variant, so both share// applyStructureGraphColumns.@@ -604,9 +604,9 @@ func applyVariantColumns(doc *schema.ChunkDoc, p common.Product) error {// Claim rows are searchable on their own (global KNN) but are NOT// part of the structure graph: they carry no relation, and a// relation-less row would be rendered as a root in the artifacts- // tree. So they deliberately skip knowledge_graph_kwd, which keeps+ // tree. So they deliberately skip type_kwd, which keeps// them out of the artifacts query (it filters- // knowledge_graph_kwd=["entity","relation"]) without a frontend+ // type_kwd=["entity","relation"]) without a frontend// change. Python mirrors this in _struct_upsert_tree_claim_rows.if v := metaString(p.Meta, "name"); v != "" {if err := doc.SetExtraValue("name_kwd", strings.ToLower(v)); err != nil {@@ -651,7 +651,7 @@ func applyVariantColumns(doc *schema.ChunkDoc, p common.Product) error {// Mindmap now emits entity/relation rows (plan §1.2) so it participates in// dataset-level merge exactly like graph/timeline: each node is an entity,// each parent→child edge is a relation. Reuse the shared structure-graph- // column contract (knowledge_graph_kwd + from/to_entity_kwd + name_kwd ++ // column contract (type_kwd + from/to_entity_kwd + name_kwd +// entity_type_kwd + mention_count_int). The relation type lives in the// content_with_weight payload ({"from","to","type"}), matching Python —// NOT a dedicated relation_type_kwd column.@@ -663,7 +663,7 @@ func applyVariantColumns(doc *schema.ChunkDoc, p common.Product) error {// applyStructureGraphColumns emits the structure-graph row columns shared by the// structure and tree variants (Python _struct_to_doc_storage_doc contract):-// - knowledge_graph_kwd: "entity" | "relation" | "graph"+// - type_kwd: "entity" | "relation" | "graph"// - relations: from_entity_kwd / to_entity_kwd// - entities: name_kwd (lowercased) / entity_type_kwd// - mention_count_int@@ -672,7 +672,7 @@ func applyVariantColumns(doc *schema.ChunkDoc, p common.Product) error {// diverging (review Major).func applyStructureGraphColumns(doc *schema.ChunkDoc, p common.Product, kind string) error {if kind != "" {- if err := doc.SetExtraValue("knowledge_graph_kwd", kind); err != nil {+ if err := doc.SetExtraValue("type_kwd", kind); err != nil {return err}}diff --git a/internal/ingestion/component/knowledge_compiler/component_test.go b/internal/ingestion/component/knowledge_compiler/component_test.goindex 58a8807d5c..3b06bd49da 100644--- a/internal/ingestion/component/knowledge_compiler/component_test.go+++ b/internal/ingestion/component/knowledge_compiler/component_test.go@@ -217,7 +217,7 @@ func TestKnowledgeCompiler_Structure_EndToEnd(t *testing.T) {// 2 input chunks + 3 entities + 2 relations = 7 total. The structure// variant no longer emits a separate compact graph blob (#19474): the// per-row entity/relation products are the whole output, mirroring the- // storage-model change that dropped the knowledge_graph_kwd="graph" row.+ // storage-model change that dropped the type_kwd="graph" row.if len(chunks) != 7 {t.Fatalf("len(chunks) = %d, want 7 (2 input + 3 entities + 2 relations)", len(chunks))}@@ -229,8 +229,8 @@ func TestKnowledgeCompiler_Structure_EndToEnd(t *testing.T) {if !ok {continue}- // knowledge_graph_kwd discriminates the graph row.- if kind, _ := cm["knowledge_graph_kwd"].(string); kind == "graph" {+ // type_kwd discriminates the graph row.+ if kind, _ := cm["type_kwd"].(string); kind == "graph" {graphChunks++}}@@ -567,18 +567,18 @@ func TestKnowledgeCompiler_Mindmap_EndToEnd(t *testing.T) {// children). Mindmap now emits entity/relation rows (plan §1.2): every node// is an entity, every parent→child edge a relation. With a flat reply there// is at least one entity (the root) and it must carry name_kwd +- // knowledge_graph_kwd="entity" (the structure-graph storage contract).+ // type_kwd="entity" (the structure-graph storage contract).chunks := runVariant(t, "mindmap", nil)entityCount := 0for _, c := range chunks {- kind, _ := c["knowledge_graph_kwd"].(string)+ kind, _ := c["type_kwd"].(string)if kind == "entity" {entityCount++if _, ok := c["name_kwd"]; !ok {t.Fatalf("mindmap entity chunk missing name_kwd: %+v", c)}- if kg, _ := c["knowledge_graph_kwd"].(string); kg != "entity" {- t.Fatalf("mindmap entity chunk knowledge_graph_kwd = %q, want entity", kg)+ if kg, _ := c["type_kwd"].(string); kg != "entity" {+ t.Fatalf("mindmap entity chunk type_kwd = %q, want entity", kg)}}}@@ -690,7 +690,7 @@ func TestKnowledgeCompiler_TemplateIDsAndProvenance(t *testing.T) {t.Fatalf("compiled chunk %v: compilation_template_ids = %v, want 1 (the resolved template id)", cm["id"], cm["compilation_template_ids"])}// Entity rows must carry source_chunk_ids.- if kg, _ := cm["knowledge_graph_kwd"].(string); kg == "entity" {+ if kg, _ := cm["type_kwd"].(string); kg == "entity" {var idsCount intswitch ids := cm["source_chunk_ids"].(type) {case []any:diff --git a/internal/ingestion/component/knowledge_compiler/golden_test.go b/internal/ingestion/component/knowledge_compiler/golden_test.goindex cbde245b01..53b885c999 100644--- a/internal/ingestion/component/knowledge_compiler/golden_test.go+++ b/internal/ingestion/component/knowledge_compiler/golden_test.go@@ -165,8 +165,8 @@ func TestGolden_Structure_ProductCount(t *testing.T) {// compact graph blob was removed by #19474).graphCount, nodeCount, edgeCount := 0, 0, 0for _, p := range prods {- // knowledge_graph_kwd discriminates the structure graph rows.- kind, _ := p.GetExtraString("knowledge_graph_kwd")+ // type_kwd discriminates the structure graph rows.+ kind, _ := p.GetExtraString("type_kwd")switch kind {case "graph":graphCount++diff --git a/internal/ingestion/knowledge_compile/reader.go b/internal/ingestion/knowledge_compile/reader.goindex 97c424ca6d..374dff8155 100644--- a/internal/ingestion/knowledge_compile/reader.go+++ b/internal/ingestion/knowledge_compile/reader.go@@ -110,10 +110,10 @@ var compiledSelectFields = []string{"create_timestamp_flt", "create_time","compilation_template_kind_kwd", "compilation_template_ids",// The product kind discriminator for structure/tree: the component stores it- // under knowledge_graph_kwd (structure: graph/entity/relation) / raptor_kwd+ // under type_kwd (structure: graph/entity/relation) / raptor_kwd// (tree: root/summary). Without these the reader cannot restore Meta["kind"]// and the dataset-nav dispatch would skip structure/tree products (B2).- "knowledge_graph_kwd", "raptor_kwd",+ "type_kwd", "knowledge_graph_kwd", "raptor_kwd",// mention_count_int round-trips the entity mention count for reprojection.// (relation type lives in the content_with_weight payload, matching Python —// there is NO relation_type_kwd column.)@@ -421,12 +421,14 @@ func productFromChunkMap(c map[string]interface{}, tenant string, expect kccommo}}// Restore the structure/tree product kind. The component stores it under- // knowledge_graph_kwd (structure: graph/entity/relation) / raptor_kwd (tree:+ // type_kwd (structure: graph/entity/relation) / raptor_kwd (tree:// root/summary), and the dataset-nav dispatch (B2) keys off Meta["kind"] to// pick the root/graph summary. Prefer these over the generic entity default.// Use asString (not a bare type assertion): the engine may return a// list-wrapped keyword column (review Major).- if v := asString(c["knowledge_graph_kwd"]); v != "" {+ if v := asString(c["type_kwd"]); v != "" {+ meta["kind"] = v+ } else if v := asString(c["knowledge_graph_kwd"]); v != "" {meta["kind"] = v} else if v := asString(c["raptor_kwd"]); v != "" {meta["kind"] = vdiff --git a/internal/ingestion/knowledge_compile/writer.go b/internal/ingestion/knowledge_compile/writer.goindex 3efbae47c2..85ec2c764d 100644--- a/internal/ingestion/knowledge_compile/writer.go+++ b/internal/ingestion/knowledge_compile/writer.go@@ -160,7 +160,7 @@ func (w engineWriter) DeleteMergedWikiPages(ctx context.Context, tenant, kb stri}// datasetStructureSupported reports whether the running doc engine can filter-// the dataset-structure fields (knowledge_graph_kwd + scope_kwd + raw+// the dataset-structure fields (type_kwd + scope_kwd + raw// compile_kwd) this feature writes/deletes. Only infinity and elasticsearch// support them today; OceanBase/SeekDB/SereneDB have explicit schemas that lack// these filter keys and would reject the query or silently drop unknown fields.@@ -466,7 +466,7 @@ func pageEngineString(value any) string {// description, the union of source docs/chunks, and the bucket vector. Rows are// available_int=1 so the dataset-level structure index is searchable; the raw// compile kind (timeline/graph/mindmap) is stamped on compile_kwd and the-// entity/relation discriminator on knowledge_graph_kwd.+// entity/relation discriminator on type_kwd.func (w engineWriter) WriteMergedStructure(ctx context.Context, tenant, kb string, buckets []StructureBucket) error {if len(buckets) == 0 {return nil@@ -560,12 +560,10 @@ func (w engineWriter) WriteMergedStructure(ctx context.Context, tenant, kb strin}if b.FromEntity != "" || b.ToEntity != "" {// relation row: carries from/to entities; kind=relation, no name_kwd.- row["knowledge_graph_kwd"] = "relation"row["type_kwd"] = "relation"row["from_entity_kwd"] = b.FromEntityrow["to_entity_kwd"] = b.ToEntity} else {- row["knowledge_graph_kwd"] = "entity"row["type_kwd"] = "entity"row["name_kwd"] = b.Namerow["entity_type_kwd"] = b.Type@@ -585,7 +583,7 @@ func (w engineWriter) WriteMergedStructure(ctx context.Context, tenant, kb strin// Python _META_ROW_KWD legacy field NOT present in the Infinity/ES/OS schemas,// so writing it would fail with an undefined-column error — see review). It is// a write/delete-side marker — GET discovery does NOT read it (it scans- // knowledge_graph_kwd=["entity"] rows instead, per §6).+ // type_kwd=["entity"] rows instead, per §6).seenKwd := map[string]bool{}for _, b := range buckets {ckwd := b.CompileKwd@@ -603,7 +601,7 @@ func (w engineWriter) WriteMergedStructure(ctx context.Context, tenant, kb strin"available_int": 0,"compile_kwd": ckwd,"scope_kwd": "dataset",- "knowledge_graph_kwd": "kg_build_meta",+ "type_kwd": "kg_build_meta","create_time": now.Format("2006-01-02 15:04:05"),"create_timestamp_flt": float64(now.Unix()),})@@ -654,7 +652,7 @@ func mergeExistingStructureBuckets(ctx context.Context, eng engine.DocEngine, baKbIDs: []string{kb},SelectFields: []string{"id", "compile_kwd", "compilation_template_ids", "compilation_template_kind_kwd",- "knowledge_graph_kwd", "name_kwd", "entity_type_kwd", "from_entity_kwd", "to_entity_kwd",+ "type_kwd", "knowledge_graph_kwd", "name_kwd", "entity_type_kwd", "from_entity_kwd", "to_entity_kwd","content_with_weight", "source_doc_ids", "source_chunk_ids",},Filter: map[string]interface{}{@@ -743,7 +741,7 @@ func structureRowIdentity(row map[string]interface{}) string {template := structureTemplateIdentity(templateID, structureString(row["compilation_template_kind_kwd"]))compileKwd := structureCompileKind(structureString(row["compile_kwd"]))payload := structureRowPayload(row)- if strings.EqualFold(structureString(row["knowledge_graph_kwd"]), "relation") {+ if strings.EqualFold(structureRowType(row), "relation") {from := structureString(row["from_entity_kwd"])to := structureString(row["to_entity_kwd"])if from == "" {@@ -761,6 +759,13 @@ func structureRowIdentity(row map[string]interface{}) string {return "entity\x00" + template + "\x00" + compileKwd + "\x00" + normalizedStructureEntityName(name)}+func structureRowType(row map[string]interface{}) string {+ if value := structureString(row["type_kwd"]); value != "" {+ return value+ }+ return structureString(row["knowledge_graph_kwd"])+}+func structureRowPayload(row map[string]interface{}) map[string]interface{} {// The payload is content_with_weight verbatim (Python json.dumps's it there);// there is no separate payload column.@@ -831,7 +836,7 @@ func (w engineWriter) DeleteStructureForDocs(ctx context.Context, tenant, kb strSelectFields: []string{"id", "source_doc_ids", "compile_kwd"},// Match dataset-scope entity/relation rows across ALL structure kinds// (timeline/graph/session_graph/mindmap), which now each stamp their- // raw compile_kwd; knowledge_graph_kwd ∈ {entity,relation} + scope_kwd+ // raw compile_kwd; type_kwd ∈ {entity,relation} + scope_kwd// =dataset is the kind-agnostic predicate (plan §1, §4.2).Filter: map[string]interface{}{"kb_id": kb,@@ -1614,8 +1619,8 @@ func (w engineWriter) DeleteMergedForVariant(ctx context.Context, tenant, kb strreturn errDatasetStructureUnsupported()}// structure/mindmap dataset rows are scope_kwd="dataset" +- // knowledge_graph_kwd ∈ {entity,relation,kg_build_meta} with a raw- // compile_kwd (timeline/graph/session_graph/mindmap). knowledge_graph_kwd+ // type_kwd ∈ {entity,relation,kg_build_meta} with a raw+ // compile_kwd (timeline/graph/session_graph/mindmap). type_kwd// is required: wiki merged rows ALSO carry scope_kwd="dataset" (W5), so// a scope-only sweep would wrongly delete wiki merged rows too (review// Major). kg_build_meta (the build marker) is deleted together with thediff --git a/internal/ingestion/knowledge_compile/writer_test.go b/internal/ingestion/knowledge_compile/writer_test.goindex 69e2fb657e..caab047ff4 100644--- a/internal/ingestion/knowledge_compile/writer_test.go+++ b/internal/ingestion/knowledge_compile/writer_test.go@@ -199,7 +199,7 @@ func TestWriteMergedStructureMigratesTypeScopedEntityID(t *testing.T) {}var entity map[string]interface{}for _, row := range eng.insertedChunks {- if row["knowledge_graph_kwd"] == "entity" {+ if row["type_kwd"] == "entity" {entity = rowbreak}@@ -207,6 +207,21 @@ func TestWriteMergedStructureMigratesTypeScopedEntityID(t *testing.T) {if entity == nil {t.Fatalf("inserted rows contain no entity: %+v", eng.insertedChunks)}+ if _, ok := entity["knowledge_graph_kwd"]; ok {+ t.Fatalf("new entity row still writes knowledge_graph_kwd: %+v", entity)+ }+ var foundBuildMeta bool+ for _, row := range eng.insertedChunks {+ if row["type_kwd"] == "kg_build_meta" {+ foundBuildMeta = true+ if _, ok := row["knowledge_graph_kwd"]; ok {+ t.Fatalf("new build marker still writes knowledge_graph_kwd: %+v", row)+ }+ }+ }+ if !foundBuildMeta {+ t.Fatalf("inserted rows contain no type_kwd=kg_build_meta marker: %+v", eng.insertedChunks)+ }if entity["id"] == oldID {t.Fatalf("old type-scoped id was reused: %v", entity["id"])}diff --git a/internal/rag/agentic-rag/runtime/tool_navigation.go b/internal/rag/agentic-rag/runtime/tool_navigation.goindex 33a1afe66a..72dfc98424 100644--- a/internal/rag/agentic-rag/runtime/tool_navigation.go+++ b/internal/rag/agentic-rag/runtime/tool_navigation.go@@ -95,7 +95,7 @@ func loadStructureGraph(ctx context.Context, indexName, docID string, kinds map[return nil, nil}idx := indexName- selectFields := []string{"content_with_weight", "compile_kwd", "compilation_template_kind_kwd", "knowledge_graph_kwd"}+ selectFields := []string{"content_with_weight", "compile_kwd", "compilation_template_kind_kwd", "type_kwd", "knowledge_graph_kwd"}if vecField != "" {selectFields = append(selectFields, vecField)}@@ -111,7 +111,10 @@ func loadStructureGraph(ctx context.Context, indexName, docID string, kinds map[}rows := make([]StructureRow, 0, len(res.Chunks))for _, row := range res.Chunks {- kg, _ := row["knowledge_graph_kwd"].(string)+ kg, _ := row["type_kwd"].(string)+ if kg == "" {+ kg, _ = row["knowledge_graph_kwd"].(string)+ }sr := StructureRow{CompileKwd: fmt.Sprint(row["compile_kwd"]),TemplateKind: fmt.Sprint(row["compilation_template_kind_kwd"]),diff --git a/internal/service/dataset_structure_graph.go b/internal/service/dataset_structure_graph.goindex dd686cfb96..8c0a657590 100644--- a/internal/service/dataset_structure_graph.go+++ b/internal/service/dataset_structure_graph.go@@ -33,7 +33,7 @@ var graphEntityFields = []string{"id", "content_with_weight", "name_kwd", "mentivar graphRelationFields = []string{"id", "content_with_weight", "from_entity_kwd", "to_entity_kwd", "doc_id", "doc_ids_kwd", "source_doc_ids"}var graphAllFields = []string{"id", "content_with_weight", "name_kwd", "mention_count_int", "source_chunk_ids",- "from_entity_kwd", "to_entity_kwd", "knowledge_graph_kwd", "doc_id", "doc_ids_kwd", "source_doc_ids",+ "from_entity_kwd", "to_entity_kwd", "type_kwd", "knowledge_graph_kwd", "doc_id", "doc_ids_kwd", "source_doc_ids","compile_kwd", "compilation_template_ids", "compilation_template_kind_kwd",}@@ -481,7 +481,10 @@ func (s *DatasetArtifactService) buildBucket(ctx context.Context, tenantID, dataif !rowHasEnabledSource(row, excludedDocIDs) {continue}- kg := firstStringValue(row["knowledge_graph_kwd"])+ kg := firstStringValue(row["type_kwd"])+ if kg == "" {+ kg = firstStringValue(row["knowledge_graph_kwd"])+ }if kg == "relation" {if edge := projectRelation(row); edge != nil {relations = append(relations, edge)diff --git a/internal/service/nlp/retrieval.go b/internal/service/nlp/retrieval.goindex 290500c136..748315b386 100644--- a/internal/service/nlp/retrieval.go+++ b/internal/service/nlp/retrieval.go@@ -698,7 +698,7 @@ func (s *RetrievalService) Search(ctx context.Context, req *RetrievalSearchReque// Build Source field listsrc := []string{"docnm_kwd", "content_ltks", "kb_id", "img_id", "title_tks", "important_kwd", "position_int",- "doc_id", "chunk_order_int", "page_num_int", "top_int", "create_timestamp_flt", "knowledge_graph_kwd",+ "doc_id", "chunk_order_int", "page_num_int", "top_int", "create_timestamp_flt", "type_kwd", "knowledge_graph_kwd",// Fields the projection below reads off each chunk. This list IS the ES// _source filter, so omitting one returns it empty even though the// document carries it: content_with_weight is the text the caller