AI-Native Content Layer

1// AI-Native Content Layer Architecture Example
2 
3// 1. Define the knowledge schema
4interface ProductKnowledge {
5  "@type": "Product";
6  "@id": string;
7  name: string;
8  description: {
9    short: string;        // < 160 chars for AI extraction
10    detailed: string;     // Full description
11    technical: string;    // Specs-focused
12  };
13  entities: {
14    category: EntityReference;
15    brand: EntityReference;
16    relatedProducts: EntityReference[];
17  };
18  attributes: Record<string, AttributeValue>;
19  temporal: {
20    created: ISO8601;
21    modified: ISO8601;
22    validFrom?: ISO8601;
23    validUntil?: ISO8601;
24  };
25  provenance: {
26    source: string;
27    confidence: number;
28    verifiedBy?: string;
29    verifiedAt?: ISO8601;
30  };
31}
32 
33interface EntityReference {
34  "@id": string;
35  "@type": string;
36  canonicalUrl: string;
37  externalIds?: {
38    wikidata?: string;
39    gtin?: string;
40    custom?: Record<string, string>;
41  };
42}
43 
44// 2. Content store with AI-native interface
45class AIContentLayer {
46  private knowledgeGraph: KnowledgeGraph;
47  
48  // Primary interface: structured queries
49  async query(sparql: string): Promise<StructuredResult[]> {
50    return this.knowledgeGraph.execute(sparql);
51  }
52  
53  // Entity-based retrieval
54  async getEntity(id: string, format: OutputFormat): Promise<Content> {
55    const entity = await this.knowledgeGraph.getById(id);
56    return this.serialize(entity, format);
57  }
58  
59  // Generate all output formats from single source
60  serialize(entity: Entity, format: OutputFormat): Content {
61    switch (format) {
62      case 'json-ld':
63        return this.toJsonLd(entity);
64      case 'llms-txt':
65        return this.toLlmsTxt(entity);
66      case 'html':
67        return this.toHtml(entity);  // Generated, not source
68      case 'api':
69        return this.toApiResponse(entity);
70    }
71  }
72  
73  // AI-specific endpoints
74  async forLLM(query: NaturalLanguageQuery): Promise<LLMOptimizedResponse> {
75    const relevant = await this.semanticSearch(query);
76    return {
77      content: this.composeForContext(relevant),
78      citations: this.extractCitations(relevant),
79      confidence: this.calculateConfidence(relevant),
80      freshness: this.getFreshnessIndicator(relevant)
81    };
82  }
83}
84 
85// 3. Multi-format generation from single source
86function generateOutputs(knowledge: ProductKnowledge): MultiFormatOutput {
87  return {
88    // For llms.txt
89    llmsTxt: `
90# ${knowledge.name}
91 
92> ${knowledge.description.short}
93 
94## Overview
95${knowledge.description.detailed}
96 
97## Technical Specifications
98${knowledge.description.technical}
99 
100## Category
101${knowledge.entities.category.canonicalUrl}
102 
103## Related Products
104${knowledge.entities.relatedProducts.map(p => p.canonicalUrl).join('\n')}
105 
106---
107Last Updated: ${knowledge.temporal.modified}
108Source: ${knowledge.provenance.source}
109Confidence: ${knowledge.provenance.confidence}
110    `.trim(),
111    
112    // For JSON-LD
113    jsonLd: {
114      "@context": "https://schema.org",
115      "@type": "Product",
116      "@id": knowledge["@id"],
117      "name": knowledge.name,
118      "description": knowledge.description.detailed,
119      "category": knowledge.entities.category["@id"],
120      "brand": {
121        "@type": "Brand",
122        "@id": knowledge.entities.brand["@id"]
123      },
124      "dateModified": knowledge.temporal.modified
125    },
126    
127    // HTML is generated, not authored
128    html: renderTemplate('product', knowledge)
129  };
130}
131 
132// 4. Change propagation for AI freshness
133class ContentChangeStream {
134  async publishChange(change: ContentChange) {
135    // Notify AI indexing systems
136    await this.notifyIndexers(change);
137    
138    // Update all derived formats
139    await this.regenerateFormats(change.entityId);
140    
141    // Invalidate caches
142    await this.invalidateCaches(change.entityId);
143    
144    // Log for AI freshness signals
145    await this.logChangeEvent({
146      entity: change.entityId,
147      type: change.type,
148      timestamp: new Date().toISOString(),
149      fields: change.modifiedFields
150    });
151  }
152}