GEO-Ready CMS 标准白皮书

// GEO Editor SDK Integration
import { GEOEditor } from '@khb/geo-editor-sdk';

const editor = new GEOEditor({
  target: '#editor-container',
  geo: {
    apiKey: 'khb_geo_xxxx',
    realTimeAnalysis: true,
    scoringWeights: {
      keywordRelevance: 0.25,
      structureCompleteness: 0.20,
      authoritySignals: 0.20,
      readability: 0.15,
      eeatSignals: 0.20
    }
  },
  platforms: ['google-ai', 'perplexity', 'chatgpt', 'bing-copilot', 'claude'],
  structuredData: {
    autoGenerate: true,
    schemaTypes: ['Article', 'FAQ', 'HowTo', 'Product'],
    validateOnSave: true
  }
});

// Listen for GEO score changes
editor.on('geoScoreChange', (score) => {
  console.log(`GEO Score: ${score.total}/100`);
  console.log('Breakdown:', score.breakdown);
});

// Get optimization suggestions
editor.on('suggestionReady', (suggestions) => {
  suggestions.forEach(s => {
    console.log(`[${s.priority}] ${s.category}: ${s.message}`);
  });
});

/**
 * GEO Score Engine v1.0
 * 计算逻辑：对每个子指标打0-5分，加权汇总后映射到0-100分区间
 */

interface GEOScoringConfig {
  weights: {
    keywordRelevance: number;    // 默认 0.25
    structureCompleteness: number; // 默认 0.20
    authoritySignals: number;    // 默认 0.20
    readability: number;         // 默认 0.15
    eeatSignals: number;         // 默认 0.20
  };
  thresholds: {
    excellent: number;  // 85+
    good: number;       // 70-84
    pass: number;       // 65-69
    needsWork: number;  // 50-64
    poor: number;       // <50
  };
}

class GEOScoreEngine {
  private config: GEOScoringConfig;

  constructor(config: GEOScoringConfig) {
    this.config = config;
  }

  /**
   * 核心评分入口
   * @param content 内容对象（含title, body, meta, author等）
   * @param context 上下文（站点配置、行业类型、目标平台）
   */
  async calculateScore(content: Content, context: GEOContext): Promise<GEOScore> {
    const [
      keywordScore,
      structureScore,
      authorityScore,
      readabilityScore,
      eeatScore
    ] = await Promise.all([
      this.scoreKeywordRelevance(content, context),
      this.scoreStructureCompleteness(content),
      this.scoreAuthoritySignals(content, context),
      this.scoreReadability(content),
      this.scoreEEAT(content, context)
    ]);

    // 加权计算总分
    const total = Math.round(
      keywordScore * this.config.weights.keywordRelevance +
      structureScore * this.config.weights.structureCompleteness +
      authorityScore * this.config.weights.authoritySignals +
      readabilityScore * this.config.weights.readability +
      eeatScore * this.config.weights.eeatSignals
    );

    return {
      total: Math.min(100, Math.max(0, total)),
      breakdown: {
        keywordRelevance: Math.round(keywordScore),
        structureCompleteness: Math.round(structureScore),
        authoritySignals: Math.round(authorityScore),
        readability: Math.round(readabilityScore),
        eeatSignals: Math.round(eeatScore)
      },
      grade: this.mapToGrade(total),
      suggestions: this.generateSuggestions({
        keywordScore, structureScore, authorityScore, readabilityScore, eeatScore
      }),
      analyzedAt: new Date().toISOString()
    };
  }

  /**
   * A. 关键词相关性评分 (0-100)
   */
  private async scoreKeywordRelevance(content: Content, context: GEOContext): Promise<number> {
    let score = 0;

    // A1: 标题含核心词 (0-6分 → 映射到0-24分区间)
    const titleKeywords = this.extractKeywords(content.title);
    const coreKeywordMatch = titleKeywords.filter(k =>
      context.targetKeywords.some(tk => this.similarity(k, tk) > 0.8)
    ).length;
    score += Math.min(6, coreKeywordMatch * 2);

    // A2: 首段覆盖 (0-4分)
    const firstParagraph = content.body.split('\n')[0];
    const paragraphCoverage = this.calculateKeywordCoverage(firstParagraph, context.targetKeywords);
    score += Math.min(4, paragraphCoverage * 4);

    // A3: H2含长尾词 (0-4分)
    const h2Keywords = content.headings.filter(h => h.level === 2)
      .flatMap(h => this.extractKeywords(h.text));
    const longTailMatch = h2Keywords.filter(k => k.length > 4).length;
    score += Math.min(4, longTailMatch);

    // A4: 正文TF-IDF密度 (0-6分)
    const tfidfScore = this.calculateTFIDF(content.body, context.targetKeywords);
    score += Math.min(6, tfidfScore * 6);

    // A5: 语义相关词覆盖 (0-5分)
    const semanticCoverage = await this.checkSemanticCoverage(content.body, context.targetKeywords);
    score += Math.min(5, semanticCoverage * 5);

    // 映射到0-100
    return (score / 25) * 100;
  }

  /**
   * B. 结构完整性评分 (0-100)
   */
  private async scoreStructureCompleteness(content: Content): Promise<number> {
    let score = 0;

    // B1: 结构化数据完整度 (0-5分)
    const schemaScore = content.structuredData ?
      Object.keys(content.structuredData).length / 15 * 5 : 0;
    score += Math.min(5, schemaScore);

    // B2: H标签层级规范 (0-4分)
    const headingHierarchy = this.validateHeadingHierarchy(content.headings);
    score += headingHierarchy ? 4 : 2;

    // B3: FAQ/HowTo组件 (0-4分)
    const hasFAQ = content.faqs && content.faqs.length >= 3;
    const hasHowTo = content.howToSteps && content.howToSteps.length >= 3;
    score += hasFAQ ? 2 : 0;
    score += hasHowTo ? 2 : 0;

    // B4: 内部链接密度 (0-3分)
    const internalLinkRatio = content.internalLinks.length / (content.body.length / 500);
    score += Math.min(3, internalLinkRatio);

    // B5: 多媒体标注 (0-4分)
    const mediaScore = content.media.filter(m => m.alt && m.caption).length /
      Math.max(1, content.media.length) * 4;
    score += Math.min(4, mediaScore);

    return (score / 20) * 100;
  }

  /**
   * 映射到等级
   */
  private mapToGrade(score: number): 'S' | 'A' | 'B' | 'C' | 'D' {
    if (score >= 85) return 'S';
    if (score >= 70) return 'A';
    if (score >= 65) return 'B';
    if (score >= 50) return 'C';
    return 'D';
  }

  /**
   * 生成优化建议 —— 基于得分最低的三个维度
   */
  private generateSuggestions(scores: Record<string, number>): GEOSuggestion[] {
    const sorted = Object.entries(scores)
      .sort(([,a], [,b]) => a - b)
      .slice(0, 3);

    return sorted.map(([dimension, score]) => ({
      dimension,
      currentScore: score,
      priority: score < 50 ? 'critical' : score < 70 ? 'high' : 'medium',
      actionable: this.getActionableAdvice(dimension, score)
    }));
  }
}

{
  "@context": "https://schema.org",
  "@type": "Article",
  "@id": "https://example.com/articles/geo-ready-cms-guide#article",
  "headline": "GEO-Ready CMS完整实施指南",
  "description": "了解如何将您的CMS升级为GEO-Ready，提升AI搜索可见性",
  "author": {
    "@type": "Person",
    "name": "张三",
    "url": "https://example.com/authors/zhangsan",
    "jobTitle": "GEO战略总监",
    "sameAs": [
      "https://linkedin.com/in/zhangsan",
      "https://twitter.com/zhangsan"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "KHB.COM",
    "url": "https://khb.com",
    "logo": {
      "@type": "ImageObject",
      "url": "https://khb.com/logo.png"
    }
  },
  "datePublished": "2025-06-01T08:00:00+08:00",
  "dateModified": "2025-06-12T14:30:00+08:00",
  "image": "https://example.com/images/geo-ready-hero.jpg",
  "articleBody": "...",
  "mainEntityOfPage": "https://example.com/articles/geo-ready-cms-guide",
  "keywords": ["GEO", "CMS", "AI搜索", "结构化数据"],
  "inLanguage": "zh-CN",
  "isAccessibleForFree": true,
  "hasPart": [
    { "@type": "WebPageElement", "name": "实施阶段一", "cssSelector": "#phase1" },
    { "@type": "WebPageElement", "name": "实施阶段二", "cssSelector": "#phase2" }
  ],
  "about": {
    "@type": "Thing",
    "name": "GEO-Ready CMS",
    "description": "AI搜索优化的内容管理系统标准"
  }
}

interface GEOContentModel {
  // 基础内容字段
  id: string;
  title: string;
  body: string;
  locale: string;
  createdAt: Date;
  updatedAt: Date;

  // GEO核心字段
  structuredData: JSONLD;
  geoTags: GeoTags[];
  aiVisibility: AIVisibilityConfig;
  platformTargeting: PlatformTarget[];

  // EEAT信号
  eeatSignals?: {
    author: AuthorProfile;
    citations: Citation[];
    certifications: string[];
    lastReviewedAt: Date;
    expertReviewer?: AuthorProfile;
  };

  // GEO评分
  geoScore: {
    total: number;        // 0-100
    breakdown: {
      keywordRelevance: number;
      structureCompleteness: number;
      authoritySignals: number;
      readability: number;
      eeatSignals: number;
    };
    lastAnalyzed: Date;
    trend: 'up' | 'stable' | 'down';
  };

  // 内容关系图谱
  contentGraph?: {
    relatedContent: string[];   // 相关内容ID
    parentTopic: string;         // 父主题ID
    semanticCluster: string;     // 语义聚类ID
  };

  // 多语言GEO配置
  multilingual?: {
    [locale: string]: {
      geoTags: GeoTags[];
      aiVisibility: AIVisibilityConfig;
      localizedStructuredData: JSONLD;
    };
  };
}

// POST /api/v1/geo/analyze
// Request
{
  "content": {
    "title": "如何选择GEO-Ready CMS",
    "body": "在AI搜索时代，选择合适的内容管理系统...",
    "locale": "zh-CN",
    "targetKeywords": ["GEO", "CMS", "AI搜索"],
    "contentType": "article"
  },
  "options": {
    "platforms": ["google-ai", "perplexity", "chatgpt"],
    "detailedAnalysis": true
  }
}

// Response
{
  "status": "success",
  "data": {
    "geoScore": {
      "total": 72,
      "breakdown": {
        "keywordRelevance": 78,
        "structureCompleteness": 65,
        "authoritySignals": 60,
        "readability": 82,
        "eeatSignals": 75
      }
    },
    "suggestions": [
      {
        "priority": "high",
        "category": "structure",
        "message": "建议添加FAQ子章节以提升Google AI Overviews匹配度",
        "action": "add_faq_section"
      },
      {
        "priority": "medium",
        "category": "authority",
        "message": "添加3-5个权威外部引用以增强EEAT信号",
        "action": "add_citations"
      }
    ],
    "structuredData": {
      "schemaType": "Article",
      "jsonld": "{ ... }",
      "validation": { "valid": true, "warnings": [] }
    }
  }
}

openapi: 3.0.3
info:
  title: GEO-Ready CMS API
  version: 1.0.0
  description: AI搜索优化的内容管理系统标准API
servers:
  - url: https://api.khb.com/v1

security:
  - BearerAuth: []

paths:
  /geo/analyze:
    post:
      summary: 对内容进行GEO分析
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [content]
              properties:
                content:
                  type: object
                  properties:
                    title: { type: string, maxLength: 200 }
                    body: { type: string, maxLength: 50000 }
                    locale: { type: string, pattern: '^[a-z]{2}-[A-Z]{2}$' }
                    targetKeywords: { type: array, items: { type: string } }
                    contentType: { enum: [article, product, faq, howto, event] }
                options:
                  type: object
                  properties:
                    platforms: { type: array, items: { enum: [google-ai, perplexity, chatgpt, bing, claude] } }
                    detailedAnalysis: { type: boolean, default: false }
      responses:
        '200':
          description: 分析成功
          content:
            application/json:
              schema:
                type: object
                properties:
                  status: { enum: [success] }
                  data:
                    type: object
                    properties:
                      geoScore:
                        type: object
                        properties:
                          total: { type: integer, minimum: 0, maximum: 100 }
                          breakdown:
                            type: object
                            properties:
                              keywordRelevance: { type: integer }
                              structureCompleteness: { type: integer }
                              authoritySignals: { type: integer }
                              readability: { type: integer }
                              eeatSignals: { type: integer }
                          grade: { enum: [S, A, B, C, D] }
                      suggestions:
                        type: array
                        items:
                          type: object
                          properties:
                            priority: { enum: [critical, high, medium, low] }
                            category: { enum: [keyword, structure, authority, readability, eeat] }
                            message: { type: string }
                            action: { type: string }
                      structuredData:
                        type: object
                        properties:
                          schemaType: { type: string }
                          jsonld: { type: string }
                          validation:
                            type: object
                            properties:
                              valid: { type: boolean }
                              errors: { type: array }
        '429':
          description: 速率限制
          headers:
            X-RateLimit-Remaining:
              schema: { type: integer }
            X-RateLimit-Reset:
              schema: { type: integer }

  /geo/publish:
    post:
      summary: 多平台自适应发布
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [contentId, platforms]
              properties:
                contentId: { type: string, format: uuid }
                platforms:
                  type: array
                  items: { enum: [google-ai, perplexity, chatgpt, bing, claude] }
                publishOptions:
                  type: object
                  properties:
                    indexingPriority: { enum: [high, normal, low], default: normal }
                    customMetadata: { type: object }
      responses:
        '200':
          description: 发布成功
          content:
            application/json:
              schema:
                type: object
                properties:
                  status: { enum: [success] }
                  data:
                    type: object
                    properties:
                      publishId: { type: string }
                      platformResults:
                        type: array
                        items:
                          type: object
                          properties:
                            platform: { type: string }
                            status: { enum: [success, pending, failed] }
                            url: { type: string, format: uri }
                            indexedAt: { type: string, format: date-time }
                            error: { type: string }

components:
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

  schemas:
    Error:
      type: object
      properties:
        code: { type: string }
        message: { type: string }
        details: { type: object }

  responses:
    UnauthorizedError:
      description: 认证失败
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: AUTH_INVALID_TOKEN
            message: 提供的Bearer Token无效或已过期

-- ============================================================
-- 核心内容表
-- ============================================================
CREATE TABLE contents (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  slug VARCHAR(255) UNIQUE NOT NULL,
  title VARCHAR(500) NOT NULL,
  body TEXT NOT NULL,
  excerpt VARCHAR(500),
  locale VARCHAR(10) NOT NULL DEFAULT 'zh-CN',
  content_type VARCHAR(50) NOT NULL, -- article, product, faq, howto, event
  status VARCHAR(20) NOT NULL DEFAULT 'draft', -- draft, review, published, archived
  author_id UUID REFERENCES authors(id),
  published_at TIMESTAMPTZ,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW(),
  deleted_at TIMESTAMPTZ  -- 软删除
);

CREATE INDEX idx_contents_locale ON contents(locale);
CREATE INDEX idx_contents_type ON contents(content_type);
CREATE INDEX idx_contents_status ON contents(status);
CREATE INDEX idx_contents_published ON contents(published_at) WHERE status = 'published';

-- ============================================================
-- GEO元数据表（核心扩展表）
-- ============================================================
CREATE TABLE geo_metadata (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  content_id UUID NOT NULL REFERENCES contents(id) ON DELETE CASCADE,
  locale VARCHAR(10) NOT NULL DEFAULT 'zh-CN',

  -- GEO评分（实时计算后缓存）
  geo_score_total INT CHECK (geo_score_total >= 0 AND geo_score_total <= 100),
  geo_score_breakdown JSONB NOT NULL DEFAULT '{
    "keywordRelevance": 0,
    "structureCompleteness": 0,
    "authoritySignals": 0,
    "readability": 0,
    "eeatSignals": 0
  }',
  geo_score_grade VARCHAR(1), -- S, A, B, C, D
  geo_score_calculated_at TIMESTAMPTZ,

  -- 结构化数据
  structured_data JSONB NOT NULL DEFAULT '{}',
  schema_types TEXT[] DEFAULT '{}',
  schema_validated BOOLEAN DEFAULT FALSE,
  schema_validation_errors JSONB DEFAULT '[]',
  schema_last_validated_at TIMESTAMPTZ,

  -- AI平台可见性配置
  ai_visibility JSONB DEFAULT '{
    "google_ai": { "enabled": true, "priority": 1 },
    "perplexity": { "enabled": true, "priority": 2 },
    "chatgpt": { "enabled": true, "priority": 3 },
    "bing": { "enabled": true, "priority": 4 },
    "claude": { "enabled": true, "priority": 5 }
  }',
  platform_targeting TEXT[] DEFAULT '{}',

  -- EEAT信号
  eeat_signals JSONB DEFAULT '{}',
  eeat_score INT CHECK (eeat_score >= 0 AND eeat_score <= 100),

  -- 内容关系图谱
  related_content_ids UUID[] DEFAULT '{}',
  parent_topic_id UUID,
  semantic_cluster_id UUID,

  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW(),

  UNIQUE(content_id, locale)
);

-- 核心索引
CREATE INDEX idx_geo_score ON geo_metadata(geo_score_total DESC);
CREATE INDEX idx_geo_grade ON geo_metadata(geo_score_grade);
CREATE INDEX idx_geo_schema_types ON geo_metadata USING GIN(schema_types);
CREATE INDEX idx_geo_platform_targeting ON geo_metadata USING GIN(platform_targeting);
CREATE INDEX idx_geo_structured_data ON geo_metadata USING GIN(structured_data jsonb_path_ops);
CREATE INDEX idx_geo_content_relation ON geo_metadata USING GIN(related_content_ids);

-- ============================================================
-- AI搜索追踪表（时序数据，大量写入）
-- ============================================================
CREATE TABLE geo_tracking (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  content_id UUID NOT NULL REFERENCES contents(id) ON DELETE CASCADE,
  platform VARCHAR(50) NOT NULL, -- google_ai, perplexity, chatgpt, bing, claude

  -- 核心指标
  citation_rate DECIMAL(5,2),        -- 被引用率 (%)
  recommendation_rate DECIMAL(5,2),  -- 推荐率 (%)
  impression_share DECIMAL(5,2),     -- 展示份额 (%)
  ctr_from_ai DECIMAL(5,2),          -- AI来源点击率 (%)

  -- 位置数据
  avg_position DECIMAL(4,1),         -- 平均展示位置
  top3_rate DECIMAL(5,2),            -- TOP3展示率

  -- 竞品对比
  competitor_benchmark JSONB DEFAULT '{}',

  tracked_at TIMESTAMPTZ DEFAULT NOW(),

  -- 分区键（按周分区）
  tracking_week INT GENERATED ALWAYS AS (
    EXTRACT(YEAR FROM tracked_at) * 100 + EXTRACT(WEEK FROM tracked_at)
  ) STORED
);

CREATE INDEX idx_tracking_content ON geo_tracking(content_id, platform);
CREATE INDEX idx_tracking_time ON geo_tracking(tracked_at DESC);
CREATE INDEX idx_tracking_week ON geo_tracking(tracking_week);

-- ============================================================
-- 作者/EEAT权威信号表
-- ============================================================
CREATE TABLE authors (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name VARCHAR(200) NOT NULL,
  slug VARCHAR(255) UNIQUE NOT NULL,
  bio TEXT,
  avatar_url TEXT,

  -- EEAT核心字段
  job_title VARCHAR(200),
  organization VARCHAR(200),
  credentials TEXT[], -- 资质证书列表
  expertise_areas TEXT[], -- 专业领域
  publications_count INT DEFAULT 0,
  years_of_experience INT,

  -- 社交证明
  social_profiles JSONB DEFAULT '{}',
  same_as_urls TEXT[], -- Schema.org sameAs

  -- 权威度评分（自动计算）
  authority_score INT CHECK (authority_score >= 0 AND authority_score <= 100),

  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_authority_score ON authors(authority_score DESC);

-- ============================================================
-- 多语言GEO配置表
-- ============================================================
CREATE TABLE geo_locale_configs (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  locale VARCHAR(10) NOT NULL UNIQUE,

  -- 该语言的GEO策略配置
  keyword_strategy JSONB NOT NULL DEFAULT '{}',
  platform_priorities JSONB NOT NULL DEFAULT '{}',
  schema_extensions JSONB DEFAULT '{}', -- 地区特定的Schema扩展

  -- 本地化规则
  content_guidelines TEXT,
  cultural_notes TEXT,

  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- ============================================================
-- 触发器：自动更新 updated_at
-- ============================================================
CREATE OR REPLACE FUNCTION update_updated_at_column()
RETURNS TRIGGER AS $$
BEGIN
  NEW.updated_at = NOW();
  RETURN NEW;
END;
$$ language 'plpgsql';

CREATE TRIGGER update_contents_updated_at BEFORE UPDATE ON contents
  FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
CREATE TRIGGER update_geo_metadata_updated_at BEFORE UPDATE ON geo_metadata
  FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
CREATE TRIGGER update_authors_updated_at BEFORE UPDATE ON authors
  FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

wp-content/plugins/geo-ready/
├── geo-ready.php                 # 主插件文件
├── includes/
│   ├── class-geo-analyzer.php    # GEO分析引擎
│   ├── class-schema-generator.php # 结构化数据生成器
│   ├── class-geo-editor.php      # 编辑器增强
│   ├── class-geo-tracker.php     # 效果追踪
│   └── class-api-handler.php     # REST API处理
├── admin/
│   ├── geo-meta-box.php          # 编辑器侧边栏
│   ├── geo-dashboard.php         # GEO仪表盘
│   └── geo-settings.php          # 插件设置页
├── assets/
│   ├── css/geo-editor.css
│   └── js/geo-editor.js
├── languages/
│   └── geo-ready-zh_CN.po
└── readme.txt

{
  "event": "content.published",
  "timestamp": "2025-06-12T10:30:00Z",
  "content": {
    "id": "art_20250612_001",
    "url": "https://example.com/geo-ready-guide",
    "title": "GEO-Ready CMS实施指南",
    "geoScore": 85,
    "structuredData": { "...": "..." },
    "platformTargeting": ["google-ai", "perplexity", "chatgpt"]
  },
  "webhook": {
    "id": "wh_xxxx",
    "attempt": 1,
    "maxAttempts": 3
  }
}

-- GEO内容元数据表
CREATE TABLE geo_content_metadata (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  content_id UUID NOT NULL REFERENCES contents(id) ON DELETE CASCADE,
  locale VARCHAR(10) NOT NULL DEFAULT 'zh-CN',
  
  -- GEO评分
  geo_score_total INT CHECK (geo_score_total >= 0 AND geo_score_total <= 100),
  geo_score_breakdown JSONB NOT NULL DEFAULT '{}',
  geo_score_updated_at TIMESTAMPTZ,
  
  -- 结构化数据
  structured_data JSONB NOT NULL DEFAULT '{}',
  schema_types TEXT[] DEFAULT '{}',
  schema_validated BOOLEAN DEFAULT FALSE,
  schema_validation_errors JSONB DEFAULT '[]',
  
  -- AI可见性配置
  ai_visibility JSONB DEFAULT '{}',
  platform_targeting TEXT[] DEFAULT '{}',
  
  -- EEAT信号
  eeat_signals JSONB DEFAULT '{}',
  eeat_score INT CHECK (eeat_score >= 0 AND eeat_score <= 100),
  
  -- 追踪数据
  citation_rate DECIMAL(5,2),
  recommendation_rate DECIMAL(5,2),
  impression_share DECIMAL(5,2),
  tracking_updated_at TIMESTAMPTZ,
  
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW(),
  
  UNIQUE(content_id, locale)
);

-- 索引
CREATE INDEX idx_geo_content_score ON geo_content_metadata(geo_score_total);
CREATE INDEX idx_geo_content_locale ON geo_content_metadata(locale);
CREATE INDEX idx_geo_platform_targeting ON geo_content_metadata USING GIN(platform_targeting);
CREATE INDEX idx_geo_structured_data ON geo_content_metadata USING GIN(structured_data jsonb_path_ops);