AI 知识图谱：GraphRAG、来源治理与安全查询

{
  "claim_id": "clm_01J...",
  "subject_id": "org:acme",
  "predicate": "HEADQUARTERED_IN",
  "object_id": "place:singapore",
  "source_document_id": "doc_842",
  "source_revision": "sha256:8f1...",
  "source_span": {"start": 418, "end": 476},
  "extractor_version": "relations-2026-08-01",
  "valid_from": "2026-04-01",
  "valid_to": null,
  "tenant_id": "tenant_17",
  "policy_scopes": ["research"],
  "state": "candidate"
}

package main

import (
	"fmt"
	"strings"
)

var allowedRelations = map[string]struct{}{
	"HEADQUARTERED_IN": {},
	"OWNS":             {},
	"DEPENDS_ON":       {},
}

type Claim struct {
	SubjectID        string
	Predicate        string
	ObjectID         string
	SourceDocumentID string
	SourceRevision   string
	SpanStart        int
	SpanEnd          int
	ExtractorVersion string
	TenantID         string
}

func (c Claim) Validate(sourceLength int) error {
	if _, ok := allowedRelations[c.Predicate]; !ok {
		return fmt.Errorf("relationship %q is not in the versioned vocabulary", c.Predicate)
	}
	if c.SpanStart < 0 || c.SpanStart >= c.SpanEnd || c.SpanEnd > sourceLength {
		return fmt.Errorf("source span [%d,%d) is outside revision length %d",
			c.SpanStart, c.SpanEnd, sourceLength)
	}

	required := []string{
		c.SubjectID,
		c.ObjectID,
		c.SourceDocumentID,
		c.SourceRevision,
		c.ExtractorVersion,
		c.TenantID,
	}
	for _, value := range required {
		if strings.TrimSpace(value) == "" {
			return fmt.Errorf("claim lineage and tenant scope are required")
		}
	}
	return nil
}

func main() {
	claim := Claim{
		SubjectID:        "org:acme",
		Predicate:        "HEADQUARTERED_IN",
		ObjectID:         "place:singapore",
		SourceDocumentID: "doc_842",
		SourceRevision:   "sha256:8f1",
		SpanStart:        10,
		SpanEnd:          42,
		ExtractorVersion: "relations-v3",
		TenantID:         "tenant_17",
	}
	if err := claim.Validate(100); err != nil {
		panic(err)
	}
	fmt.Println("valid")
}

// 输出：valid

package main

import (
	"fmt"
	"strings"
)

type Intent string

const (
	EntityProfile       Intent = "entity_profile"
	DependencyNeighbors Intent = "dependency_neighbors"
)

type QueryPlan struct {
	Cypher     string
	Parameters map[string]any
}

var queryTemplates = map[Intent]string{
	EntityProfile: `
MATCH (e:Entity {tenant_id: $tenant_id, id: $entity_id})
WHERE any(scope IN e.policy_scopes WHERE scope IN $allowed_scopes)
RETURN e.id AS id, e.name AS name, e.type AS type
LIMIT 1`,
	DependencyNeighbors: `
MATCH (e:Entity {tenant_id: $tenant_id, id: $entity_id})
      -[r:DEPENDS_ON {tenant_id: $tenant_id}]->(n:Entity {tenant_id: $tenant_id})
WHERE any(scope IN e.policy_scopes WHERE scope IN $allowed_scopes)
  AND any(scope IN r.policy_scopes WHERE scope IN $allowed_scopes)
  AND any(scope IN n.policy_scopes WHERE scope IN $allowed_scopes)
RETURN n.id AS id, n.name AS name, r.claim_id AS claim_id
ORDER BY n.id
LIMIT $row_limit`,
}

func buildPlan(
	intent Intent,
	entityID string,
	tenantID string,
	allowedScopes []string,
	requestedLimit int,
) (QueryPlan, error) {
	query, ok := queryTemplates[intent]
	if !ok {
		return QueryPlan{}, fmt.Errorf("unsupported query intent %q", intent)
	}
	if strings.TrimSpace(entityID) == "" || len(entityID) > 128 {
		return QueryPlan{}, fmt.Errorf("invalid entity identifier")
	}
	if strings.TrimSpace(tenantID) == "" || len(allowedScopes) == 0 {
		return QueryPlan{}, fmt.Errorf("authoritative tenant and policy scope are required")
	}

	rowLimit := requestedLimit
	if rowLimit < 1 {
		rowLimit = 1
	}
	if rowLimit > 100 {
		rowLimit = 100
	}
	return QueryPlan{
		Cypher: query,
		Parameters: map[string]any{
			"entity_id":      entityID,
			"tenant_id":      tenantID,
			"allowed_scopes": append([]string(nil), allowedScopes...),
			"row_limit":      rowLimit,
		},
	}, nil
}

func main() {
	plan, err := buildPlan(
		DependencyNeighbors,
		"service:checkout",
		"tenant_17",
		[]string{"operations"},
		500,
	)
	if err != nil {
		panic(err)
	}
	fmt.Println(plan.Parameters["row_limit"])
}

// 输出：100

package main

import "fmt"

type RetrievalMetrics struct {
	EvidenceRecall    float64
	CitationPrecision float64
}

func toSet(values []string) map[string]struct{} {
	set := make(map[string]struct{}, len(values))
	for _, value := range values {
		set[value] = struct{}{}
	}
	return set
}

func overlapCount(left, right map[string]struct{}) int {
	count := 0
	for value := range left {
		if _, ok := right[value]; ok {
			count++
		}
	}
	return count
}

func retrievalMetrics(required, retrieved, cited []string) RetrievalMetrics {
	requiredSet := toSet(required)
	retrievedSet := toSet(retrieved)
	citedSet := toSet(cited)

	requiredCount := len(requiredSet)
	if requiredCount == 0 {
		requiredCount = 1
	}
	citedCount := len(citedSet)
	if citedCount == 0 {
		citedCount = 1
	}

	return RetrievalMetrics{
		EvidenceRecall: float64(overlapCount(requiredSet, retrievedSet)) /
			float64(requiredCount),
		CitationPrecision: float64(overlapCount(citedSet, retrievedSet)) /
			float64(citedCount),
	}
}

func main() {
	metrics := retrievalMetrics(
		[]string{"span:A", "span:B"},
		[]string{"span:A", "span:C"},
		[]string{"span:A", "span:X"},
	)
	fmt.Printf("evidence_recall=%.3f citation_precision=%.3f\n",
		metrics.EvidenceRecall, metrics.CitationPrecision)
}

// 输出：evidence_recall=0.500 citation_precision=0.500

来源版本
  -> 文本分段
  -> 候选主张
  -> 消歧实体
  -> 已接受图快照
  -> 关键词/向量索引
  -> 社区划分
  -> 生成摘要
  -> 检索与答案缓存