knowledge-graph-builder（知识图谱构建器）

Knowledge Graph Builder

Expert knowledge graph creation system that transforms disconnected support content into an interconnected web of concepts, relationships, and solutions. This skill provides structured workflows for mapping knowledge domains, defining relationships, and powering intelligent support experiences.

Knowledge graphs enable support systems to understand context, not just keywords. When a customer asks about "billing issues," a knowledge graph knows this relates to invoices, payment methods, subscription plans, and potentially churn risk. This skill helps you build that connective intelligence.

Built on semantic web principles and knowledge engineering best practices, this skill combines domain modeling, relationship mapping, and practical implementation to create knowledge graphs that power smarter support.

Core Workflows

Workflow 1: Domain Modeling

Define the concepts and entities in your knowledge domain

1. Entity Identification

- Core Entities: Products, features, concepts - Customer Entities: Accounts, users, segments - Support Entities: Issues, solutions, articles - Process Entities: Workflows, procedures, steps - Context Entities: Use cases, personas, scenarios

1. Entity Types for Support Entity Type Examples Purpose Product App, Feature, Module What customers use Issue Bug, Error, Question What customers face Solution Fix, Workaround, Guide How to resolve Article FAQ, How-to, Reference Content resources Concept Term, Process, Capability Understanding Persona Admin, User, Developer Who needs help
2. Entity Properties Entity: Feature Properties: - id: unique identifier - name: display name - description: what it does - status: active/deprecated/beta - complexity: basic/intermediate/advanced - related_persona: who uses it - documentation_url: help article link
3. Entity Extraction Sources

- Product documentation - Support ticket taxonomy - FAQ categories - Help center structure - Feature specifications - User research findings

Workflow 2: Relationship Mapping

Define how entities connect to each other

1. Core Relationship Types Relationship From To Example SOLVES Solution Issue "Password reset SOLVES login failure" PART_OF Feature Product "Dashboard PART_OF Analytics" REQUIRES Feature Feature "Export REQUIRES Pro plan" CAUSES Issue Issue "API limit CAUSES sync failure" DOCUMENTED_IN Concept Article "Billing DOCUMENTED_IN pricing guide" APPLIES_TO Solution Persona "Workaround APPLIES_TO admin users"
2. Relationship Properties Relationship: SOLVES Properties: - confidence: how reliable (0-1) - conditions: when this applies - effectiveness: success rate - last_verified: date checked
3. Relationship Discovery

- Analyze support ticket resolution paths - Map help article cross-references - Identify co-occurring issues - Study user journey patterns - Review expert knowledge

1. Relationship Strength

- Strong: Always true, well documented - Moderate: Usually true, common pattern - Weak: Sometimes true, contextual - Suggested: Possible, needs validation

Workflow 3: Graph Construction

Build the actual knowledge graph structure

1. Graph Architecture Nodes (Entities): - Unique identifier - Entity type - Properties - Metadata (created, updated, source) Edges (Relationships): - From node - To node - Relationship type - Properties - Metadata
2. Implementation Options Approach Best For Tools Graph Database Complex queries, scale Neo4j, Amazon Neptune RDF Triple Store Semantic web, standards Apache Jena, Stardog Property Graph Flexible modeling Neo4j, TigerGraph Embedded Simple use cases NetworkX, GraphQL
3. Schema Design

- Define node labels/types - Define relationship types - Set required properties - Define constraints (uniqueness, existence) - Create indexes for query performance

1. Data Population

- Bulk import from existing sources - API ingestion from live systems - Manual expert curation - Automated extraction (NLP) - Continuous updates from support activity

Workflow 4: Query & Inference

Extract value from the knowledge graph

1. Query Patterns Query Type Use Case Example Traversal Find related content "Articles related to X" Path finding Solution discovery "Steps from issue to resolution" Pattern matching Similar issues "Issues like X" Aggregation Analytics "Most common issue per feature" Recommendation Suggestions "Other users also viewed"
2. Inference Rules

- If A CAUSES B and B CAUSES C, suggest A might relate to C - If Solution S SOLVES Issue I, suggest similar solutions for similar issues - If Article A DOCUMENTED_IN B and B REQUIRES C, show C as prerequisite - If many users navigate A → B → C, suggest shortcut

1. Semantic Search Enhancement

- Expand search with related concepts - Rank by graph centrality - Surface related articles - Suggest alternative terms - Understand context from relationships

1. Conversational AI Integration

- Map user intent to graph entities - Follow relationships to find answers - Generate responses from connected content - Explain reasoning through graph path

Workflow 5: Maintenance & Evolution

Keep the knowledge graph accurate and growing

1. Quality Monitoring

- Track usage patterns - Identify dead-end paths - Find orphaned nodes - Monitor relationship accuracy - Measure search success rates

1. Update Triggers

- New product releases - Documentation changes - Support ticket patterns - User feedback - Expert curation sessions

1. Validation Process

- Expert review of new relationships - A/B test graph-powered features - Monitor accuracy metrics - User feedback collection - Regular audits

1. Growth Strategies

- Automated entity extraction from tickets - ML-based relationship suggestion - User contribution mechanisms - Expert knowledge capture sessions - Cross-reference with external sources

Quick Reference

Best Practices

Domain Modeling

• Start with core product concepts
• Model from customer perspective
• Keep entity types focused
• Document entity definitions clearly
• Version your schema

Relationship Design

• Use verb-based relationship names
• Make relationships directional
• Add confidence/strength properties
• Avoid redundant relationships
• Document relationship semantics

Graph Construction

• Start small, grow iteratively
• Validate with domain experts
• Index frequently queried properties
• Plan for scale from start
• Maintain data lineage

Query Optimization

• Profile query performance
• Create appropriate indexes
• Cache common traversals
• Paginate large results
• Monitor query patterns

Maintenance

• Schedule regular audits
• Track content freshness
• Remove stale nodes/edges
• Validate automated additions
• Document changes

Knowledge Graph Schema

Core Entities

Product:
  properties:
    - id: string (required, unique)
    - name: string (required)
    - description: text
    - version: string
    - status: enum [active, deprecated, beta]
    - tier: enum [free, pro, enterprise]

Feature:
  properties:
    - id: string (required, unique)
    - name: string (required)
    - description: text
    - complexity: enum [basic, intermediate, advanced]
    - introduced_version: string
    - documentation_url: url

Issue:
  properties:
    - id: string (required, unique)
    - title: string (required)
    - description: text
    - severity: enum [critical, high, medium, low]
    - frequency: enum [common, occasional, rare]
    - symptoms: array[string]

Solution:
  properties:
    - id: string (required, unique)
    - title: string (required)
    - steps: array[string]
    - type: enum [fix, workaround, configuration]
    - effectiveness: float [0-1]
    - applies_to: array[string]

Article:
  properties:
    - id: string (required, unique)
    - title: string (required)
    - url: url (required)
    - type: enum [faq, how-to, reference, troubleshooting]
    - audience: enum [all, admin, developer]
    - last_updated: date

Concept:
  properties:
    - id: string (required, unique)
    - term: string (required)
    - definition: text (required)
    - aliases: array[string]
    - domain: string

Core Relationships

PART_OF:
  from: [Feature, Concept]
  to: [Product, Feature, Concept]
  properties:
    - required: boolean

SOLVES:
  from: Solution
  to: Issue
  properties:
    - confidence: float [0-1]
    - conditions: text
    - verified_date: date

CAUSES:
  from: Issue
  to: Issue
  properties:
    - probability: float [0-1]
    - mechanism: text

DOCUMENTED_IN:
  from: [Feature, Issue, Solution, Concept]
  to: Article
  properties:
    - section: string
    - is_primary: boolean

REQUIRES:
  from: [Feature, Solution]
  to: [Feature, Permission, Plan]
  properties:
    - type: enum [prerequisite, dependency, permission]

RELATED_TO:
  from: [any]
  to: [any]
  properties:
    - strength: float [0-1]
    - type: enum [similar, alternative, complementary]

APPLIES_TO:
  from: [Solution, Article]
  to: [Persona, Plan, Version]
  properties:
    - conditions: text

Implementation Guide

Phase 1: Foundation (Week 1-2)

1. Define core entity types
2. Document property schemas
3. Map primary relationships
4. Choose technology stack
5. Set up development environment

Phase 2: Core Graph (Week 3-4)

1. Extract entities from documentation
2. Create initial relationships
3. Import into graph database
4. Build basic query interface
5. Validate with domain experts

Phase 3: Integration (Week 5-6)

1. Connect to support system
2. Implement search enhancement
3. Add content recommendation
4. Create admin interface
5. Set up monitoring

Phase 4: Intelligence (Week 7-8)

1. Add inference rules
2. Implement similarity scoring
3. Enable automated extraction
4. Build feedback loops
5. Deploy to production

Red Flags

• Disconnected nodes: Entities without relationships
• Relationship soup: Too many weak relationships
• Stale data: Outdated information not updated
• Schema drift: Inconsistent entity modeling
• Query complexity: Simple questions need complex queries
• No validation: Automated additions not verified
• Missing context: Relationships without properties
• Poor coverage: Key concepts not represented

Success Metrics