Generative Engine Optimization Implementation Guide for Production 2026

# Simplified RAG Citation Flow
def rag_citation_process(user_query: str) -> AIAnswer:
    """How AI engines select content to cite"""

    # Step 1: Query understanding
    semantic_query = embed_query(user_query)

    # Step 2: Retrieval (from billions of documents)
    candidate_docs = vector_search(
        query_embedding=semantic_query,
        top_k=50,  # Initial retrieval
        filters={
            'freshness': 'last_90_days',  # Recency matters
            'authority': 'min_threshold',  # Domain authority
            'relevance': 'high_semantic_match'
        }
    )

    # Step 3: Ranking (which docs to use)
    ranked_docs = rank_by_factors(
        candidates=candidate_docs,
        factors=[
            ('semantic_relevance', 0.35),  # 35% weight
            ('freshness', 0.25),            # 25% weight
            ('authority', 0.20),            # 20% weight
            ('structure', 0.15),            # 15% weight (passage quality)
            ('engagement', 0.05)            # 5% weight (user signals)
        ]
    )

    # Step 4: Generation (create answer)
    answer = generate_answer(
        query=user_query,
        context=ranked_docs[:5],  # Top 5 sources
        citation_style='inline_attribution'
    )

    return answer

import requests
import time
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime, timedelta
import json

@dataclass
class CitationRecord:
    """Single citation instance"""
    platform: str
    query: str
    cited: bool
    position: Optional[int]  # Position in answer (1-5)
    context: str  # Surrounding text
    timestamp: datetime
    url: str  # Your URL that was cited

@dataclass
class CitationReport:
    """Aggregated citation metrics"""
    platform: str
    timeframe: str
    total_queries: int
    citations: int
    citation_rate: float
    avg_position: float
    top_cited_urls: List[Dict[str, int]]
    trending: str  # "up", "down", "stable"

class CitationMonitor:
    """
    Production-ready citation monitoring across AI platforms
    Tracks brand mentions, citations, and visibility in AI-generated answers
    """

    def __init__(self, config: Dict[str, str]):
        """
        Initialize with API credentials for each platform

        Args:
            config: Dictionary with API keys
                {
                    'openai_api_key': 'sk-...',
                    'anthropic_api_key': 'sk-ant-...',
                    'google_api_key': 'AIza...',
                    'perplexity_api_key': 'pplx-...'
                }
        """
        self.config = config
        self.citation_history: List[CitationRecord] = []

        # Platform-specific APIs
        self.chatgpt_api = self._init_chatgpt()
        self.claude_api = self._init_claude()
        self.gemini_api = self._init_gemini()
        self.perplexity_api = self._init_perplexity()

    def _init_chatgpt(self):
        """Initialize ChatGPT Search API"""
        return {
            'base_url': 'https://api.openai.com/v1/chat/completions',
            'headers': {
                'Authorization': f"Bearer {self.config['openai_api_key']}",
                'Content-Type': 'application/json'
            },
            'model': 'gpt-5.2'
        }

    def _init_claude(self):
        """Initialize Claude API"""
        return {
            'base_url': 'https://api.anthropic.com/v1/messages',
            'headers': {
                'x-api-key': self.config['anthropic_api_key'],
                'anthropic-version': '2024-01-01',
                'Content-Type': 'application/json'
            },
            'model': 'claude-sonnet-4-5-20250929'
        }

    def _init_gemini(self):
        """Initialize Gemini API"""
        return {
            'base_url': 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro:generateContent',
            'api_key': self.config['google_api_key'],
            'model': 'gemini-3-pro'
        }

    def _init_perplexity(self):
        """Initialize Perplexity API"""
        return {
            'base_url': 'https://api.perplexity.ai/chat/completions',
            'headers': {
                'Authorization': f"Bearer {self.config['perplexity_api_key']}",
                'Content-Type': 'application/json'
            },
            'model': 'pplx-70b-online'
        }

    def check_citation_chatgpt(
        self,
        query: str,
        brand_urls: List[str]
    ) -> CitationRecord:
        """
        Check if brand is cited in ChatGPT Search response

        Args:
            query: Search query to test
            brand_urls: List of your domain URLs to check for

        Returns:
            CitationRecord with results
        """
        payload = {
            'model': self.chatgpt_api['model'],
            'messages': [
                {
                    'role': 'user',
                    'content': query
                }
            ],
            'web_search': True  # Enable search mode
        }

        try:
            response = requests.post(
                self.chatgpt_api['base_url'],
                headers=self.chatgpt_api['headers'],
                json=payload,
                timeout=30
            )
            response.raise_for_status()

            data = response.json()
            answer = data['choices'][0]['message']['content']

            # Check for citations in response
            cited = any(url in answer for url in brand_urls)

            # Extract citation position if found
            position = None
            if cited:
                for i, url in enumerate(brand_urls):
                    if url in answer:
                        # Estimate position based on text location
                        position = answer.index(url) // 200 + 1
                        break

            return CitationRecord(
                platform='ChatGPT',
                query=query,
                cited=cited,
                position=position,
                context=answer[:200] if cited else '',
                timestamp=datetime.now(),
                url=brand_urls[0] if cited else ''
            )

        except Exception as e:
            print(f"Error checking ChatGPT: {e}")
            return CitationRecord(
                platform='ChatGPT',
                query=query,
                cited=False,
                position=None,
                context='',
                timestamp=datetime.now(),
                url=''
            )

    def check_citation_perplexity(
        self,
        query: str,
        brand_urls: List[str]
    ) -> CitationRecord:
        """Check if brand is cited in Perplexity response"""
        payload = {
            'model': self.perplexity_api['model'],
            'messages': [
                {
                    'role': 'user',
                    'content': query
                }
            ]
        }

        try:
            response = requests.post(
                self.perplexity_api['base_url'],
                headers=self.perplexity_api['headers'],
                json=payload,
                timeout=30
            )
            response.raise_for_status()

            data = response.json()
            answer = data['choices'][0]['message']['content']
            citations = data['choices'][0].get('citations', [])

            # Check if any of our URLs are in citations
            cited = any(url in str(citations) for url in brand_urls)

            # Find position in citation list
            position = None
            if cited:
                for i, citation in enumerate(citations):
                    if any(url in str(citation) for url in brand_urls):
                        position = i + 1
                        break

            return CitationRecord(
                platform='Perplexity',
                query=query,
                cited=cited,
                position=position,
                context=answer[:200] if cited else '',
                timestamp=datetime.now(),
                url=brand_urls[0] if cited else ''
            )

        except Exception as e:
            print(f"Error checking Perplexity: {e}")
            return CitationRecord(
                platform='Perplexity',
                query=query,
                cited=False,
                position=None,
                context='',
                timestamp=datetime.now(),
                url=''
            )

    def monitor_citations(
        self,
        queries: List[str],
        brand_urls: List[str],
        platforms: List[str] = ['ChatGPT', 'Perplexity', 'Claude', 'Gemini']
    ) -> Dict[str, List[CitationRecord]]:
        """
        Monitor citations across multiple platforms and queries

        Args:
            queries: List of test queries
            brand_urls: List of your domain URLs
            platforms: Platforms to monitor

        Returns:
            Dictionary mapping platform to citation records
        """
        results = {platform: [] for platform in platforms}

        for query in queries:
            print(f"Testing query: {query}")

            if 'ChatGPT' in platforms:
                record = self.check_citation_chatgpt(query, brand_urls)
                results['ChatGPT'].append(record)
                self.citation_history.append(record)
                time.sleep(2)  # Rate limiting

            if 'Perplexity' in platforms:
                record = self.check_citation_perplexity(query, brand_urls)
                results['Perplexity'].append(record)
                self.citation_history.append(record)
                time.sleep(2)

            # Add Claude and Gemini checks similarly
            # (abbreviated for space - follow same pattern)

        return results

    def generate_report(
        self,
        timeframe_days: int = 7
    ) -> Dict[str, CitationReport]:
        """
        Generate citation report for specified timeframe

        Args:
            timeframe_days: Number of days to analyze

        Returns:
            Report for each platform
        """
        cutoff = datetime.now() - timedelta(days=timeframe_days)
        recent = [r for r in self.citation_history if r.timestamp > cutoff]

        reports = {}

        for platform in ['ChatGPT', 'Perplexity', 'Claude', 'Gemini']:
            platform_records = [r for r in recent if r.platform == platform]

            if not platform_records:
                continue

            total_queries = len(platform_records)
            citations = sum(1 for r in platform_records if r.cited)
            citation_rate = (citations / total_queries) * 100 if total_queries > 0 else 0

            # Calculate average position
            cited_records = [r for r in platform_records if r.cited and r.position]
            avg_position = (
                sum(r.position for r in cited_records) / len(cited_records)
                if cited_records else 0
            )

            # Top cited URLs
            url_counts = {}
            for r in platform_records:
                if r.cited and r.url:
                    url_counts[r.url] = url_counts.get(r.url, 0) + 1

            top_urls = sorted(
                [{'url': url, 'count': count} for url, count in url_counts.items()],
                key=lambda x: x['count'],
                reverse=True
            )[:5]

            # Calculate trend
            mid_point = timeframe_days // 2
            mid_cutoff = datetime.now() - timedelta(days=mid_point)
            recent_half = [r for r in platform_records if r.timestamp > mid_cutoff]
            older_half = [r for r in platform_records if r.timestamp <= mid_cutoff]

            recent_rate = (
                (sum(1 for r in recent_half if r.cited) / len(recent_half) * 100)
                if recent_half else 0
            )
            older_rate = (
                (sum(1 for r in older_half if r.cited) / len(older_half) * 100)
                if older_half else 0
            )

            if recent_rate > older_rate + 5:
                trending = "up"
            elif recent_rate < older_rate - 5:
                trending = "down"
            else:
                trending = "stable"

            reports[platform] = CitationReport(
                platform=platform,
                timeframe=f"{timeframe_days} days",
                total_queries=total_queries,
                citations=citations,
                citation_rate=citation_rate,
                avg_position=avg_position,
                top_cited_urls=top_urls,
                trending=trending
            )

        return reports

    def print_report(self, reports: Dict[str, CitationReport]):
        """Print formatted citation report"""
        print("\n" + "="*80)
        print("CITATION MONITORING REPORT")
        print("="*80 + "\n")

        for platform, report in reports.items():
            print(f"\n{platform}")
            print("-" * 40)
            print(f"Timeframe: {report.timeframe}")
            print(f"Total Queries: {report.total_queries}")
            print(f"Citations: {report.citations}")
            print(f"Citation Rate: {report.citation_rate:.1f}%")
            print(f"Avg Position: {report.avg_position:.1f}" if report.avg_position > 0 else "Avg Position: N/A")
            print(f"Trend: {report.trending.upper()}")

            if report.top_cited_urls:
                print("\nTop Cited URLs:")
                for url_data in report.top_cited_urls:
                    print(f"  - {url_data['url']}: {url_data['count']} citations")

# Usage Example
config = {
    'openai_api_key': 'your-openai-key',
    'anthropic_api_key': 'your-anthropic-key',
    'google_api_key': 'your-google-key',
    'perplexity_api_key': 'your-perplexity-key'
}

monitor = CitationMonitor(config)

# Define test queries relevant to your brand
test_queries = [
    "best AI deployment tools 2026",
    "how to monitor LLM costs",
    "production AI observability solutions",
    "enterprise AI monitoring platforms"
]

brand_urls = [
    "https://yourcompany.com",
    "https://yourcompany.com/blog"
]

# Run monitoring
results = monitor.monitor_citations(
    queries=test_queries,
    brand_urls=brand_urls,
    platforms=['ChatGPT', 'Perplexity']
)

# Generate and print report
reports = monitor.generate_report(timeframe_days=7)
monitor.print_report(reports)

This approach significantly reduces latency. Our tests showed improvements
across all scenarios. The results were consistent with industry benchmarks.

Prompt caching reduces LLM latency by 40-60% in production. OpenAI's GPT-5.2
and Anthropic's Claude Sonnet 4.5 both support prompt caching, enabling
reuse of common context across requests. Tests on 10,000 production requests
showed median latency drop from 2.3s to 0.9s with caching enabled.

The study found that companies implementing AI monitoring experienced
significant improvements in deployment success rates, with many seeing
increases of around 80 percent compared to baseline measurements.

**AI Monitoring Impact on Deployment Success:**
- 80% improvement in deployment success rates
- Reduced time-to-production from 6 months to 3.5 months
- 60% fewer production incidents in first 90 days

Companies with comprehensive AI monitoring achieve these results by implementing
real-time dashboards, automated alerting, and cost attribution systems.

class AISchemaGenerator:
    """Generate AI-friendly schema markup"""

    @staticmethod
    def create_article_schema(article: Dict) -> Dict:
        """
        Generate NewsArticle schema optimized for AI citation

        Args:
            article: Dictionary with title, description, author, date, etc.

        Returns:
            JSON-LD schema for insertion into HTML <head>
        """
        return {
            "@context": "https://schema.org",
            "@type": "NewsArticle",
            "headline": article['title'],
            "description": article['description'],
            "author": {
                "@type": "Person",
                "name": article['author'],
                "jobTitle": "AI/ML Engineer",  # Add credibility
                "url": f"https://yoursite.com/author/{article['author']}"
            },
            "publisher": {
                "@type": "Organization",
                "name": "Your Company",
                "logo": {
                    "@type": "ImageObject",
                    "url": "https://yoursite.com/logo.png"
                }
            },
            "datePublished": article['published_date'],
            "dateModified": article['modified_date'],
            "image": article['featured_image'],

            # AI-specific enhancements
            "articleSection": article['category'],
            "keywords": ", ".join(article['tags']),
            "wordCount": article['word_count'],
            "inLanguage": "en-US",

            # Citation-friendly additions
            "citation": [
                {
                    "@type": "CreativeWork",
                    "name": source['title'],
                    "url": source['url']
                }
                for source in article.get('sources', [])
            ],

            # Data points for AI extraction
            "mainEntity": {
                "@type": "Thing",
                "name": article['main_topic'],
                "description": article['key_findings']
            }
        }

    @staticmethod
    def create_howto_schema(guide: Dict) -> Dict:
        """
        Generate HowTo schema for implementation guides
        Helps AI understand step-by-step instructions
        """
        return {
            "@context": "https://schema.org",
            "@type": "HowTo",
            "name": guide['title'],
            "description": guide['description'],
            "totalTime": f"PT{guide['time_minutes']}M",

            "step": [
                {
                    "@type": "HowToStep",
                    "name": step['title'],
                    "text": step['description'],
                    "url": f"https://yoursite.com/guide#{step['id']}",
                    "position": i + 1,
                    "itemListElement": {
                        "@type": "HowToDirection",
                        "text": step['instruction']
                    }
                }
                for i, step in enumerate(guide['steps'])
            ],

            "tool": [
                {
                    "@type": "HowToTool",
                    "name": tool['name']
                }
                for tool in guide.get('required_tools', [])
            ]
        }

    @staticmethod
    def create_faq_schema(faqs: List[Dict]) -> Dict:
        """
        Generate FAQPage schema
        Perfect for Q&A content that AI loves to cite
        """
        return {
            "@context": "https://schema.org",
            "@type": "FAQPage",
            "mainEntity": [
                {
                    "@type": "Question",
                    "name": faq['question'],
                    "acceptedAnswer": {
                        "@type": "Answer",
                        "text": faq['answer']
                    }
                }
                for faq in faqs
            ]
        }

# Usage in your CMS/blog system
article_data = {
    'title': 'AI Agent Cost Tracking in Production',
    'description': 'Learn to implement cost attribution...',
    'author': 'Your Name',
    'published_date': '2026-01-10',
    'modified_date': '2026-01-10',
    'category': 'AI Monitoring',
    'tags': ['AI cost tracking', 'agent monitoring'],
    'word_count': 5000,
    'featured_image': 'https://yoursite.com/images/og-image.png',
    'sources': [
        {'title': 'Research Paper', 'url': 'https://example.com/paper'}
    ],
    'main_topic': 'AI Cost Attribution',
    'key_findings': '60% cost reduction with proper attribution'
}

schema_generator = AISchemaGenerator()
schema = schema_generator.create_article_schema(article_data)

# Insert into HTML <head>
# <script type="application/ld+json">{json.dumps(schema)}</script>

class GEOMetrics:
    """Calculate GEO performance metrics"""

    @staticmethod
    def calculate_som(
        your_citations: int,
        total_queries: int
    ) -> float:
        """
        Calculate Share of Model (SoM)

        Args:
            your_citations: Number of times your brand was cited
            total_queries: Total queries tested in category

        Returns:
            SoM percentage (0-100)
        """
        if total_queries == 0:
            return 0.0

        som = (your_citations / total_queries) * 100
        return round(som, 2)

    @staticmethod
    def calculate_citation_velocity(
        current_rate: float,
        previous_rate: float,
        days_between: int
    ) -> float:
        """
        Calculate how quickly citation rate is changing

        Returns:
            Change per week (percentage points)
        """
        total_change = current_rate - previous_rate
        weeks = days_between / 7

        if weeks == 0:
            return 0.0

        velocity = total_change / weeks
        return round(velocity, 2)

    @staticmethod
    def calculate_citation_quality(
        citations_by_position: Dict[int, int]
    ) -> float:
        """
        Weight citations by position (1st position is best)

        Args:
            citations_by_position: {1: 5, 2: 3, 3: 2} = 5 at position 1, etc.

        Returns:
            Quality score (0-100, higher is better)
        """
        if not citations_by_position:
            return 0.0

        # Weight by position: position 1 = 1.0, position 2 = 0.8, etc.
        weights = {1: 1.0, 2: 0.8, 3: 0.6, 4: 0.4, 5: 0.2}

        weighted_sum = sum(
            count * weights.get(pos, 0.1)
            for pos, count in citations_by_position.items()
        )

        total_citations = sum(citations_by_position.values())

        quality_score = (weighted_sum / total_citations) * 100
        return round(quality_score, 2)

    @staticmethod
    def calculate_platform_efficiency(
        platform_data: Dict[str, Dict]
    ) -> Dict[str, float]:
        """
        Compare efficiency across platforms

        Args:
            platform_data: {
                'ChatGPT': {'citations': 10, 'queries': 50},
                'Perplexity': {'citations': 15, 'queries': 50}
            }

        Returns:
            Efficiency score per platform
        """
        efficiency = {}

        for platform, data in platform_data.items():
            rate = (data['citations'] / data['queries']) * 100 if data['queries'] > 0 else 0
            efficiency[platform] = round(rate, 2)

        return efficiency

# Example usage
metrics = GEOMetrics()

# Calculate SoM
som = metrics.calculate_som(
    your_citations=42,  # You were cited 42 times
    total_queries=100   # Out of 100 test queries
)
print(f"Share of Model: {som}%")  # 42%

# Calculate velocity (are we improving?)
velocity = metrics.calculate_citation_velocity(
    current_rate=42.0,   # Current: 42%
    previous_rate=28.0,  # Last month: 28%
    days_between=30
)
print(f"Citation velocity: +{velocity}pp per week")  # +3.27pp per week

# Calculate quality (position matters)
citations_by_position = {
    1: 15,  # 15 citations at position 1 (best)
    2: 12,  # 12 at position 2
    3: 10,  # 10 at position 3
    4: 5    # 5 at position 4
}
quality = metrics.calculate_citation_quality(citations_by_position)
print(f"Citation quality score: {quality}/100")  # Higher is better

# Platform efficiency comparison
platform_performance = {
    'ChatGPT': {'citations': 18, 'queries': 50},
    'Perplexity': {'citations': 22, 'queries': 50},
    'Claude': {'citations': 12, 'queries': 50},
    'Gemini': {'citations': 15, 'queries': 50}
}
efficiency = metrics.calculate_platform_efficiency(platform_performance)

print("\nPlatform Efficiency:")
for platform, rate in sorted(efficiency.items(), key=lambda x: x[1], reverse=True):
    print(f"  {platform}: {rate}%")

# Add to your analytics tracking code
def track_ai_traffic(request):
    """Identify traffic from AI sources"""

    referrers = {
        'chat.openai.com': 'ChatGPT',
        'perplexity.ai': 'Perplexity',
        'claude.ai': 'Claude',
        'gemini.google.com': 'Gemini'
    }

    referrer = request.headers.get('Referer', '')
    user_agent = request.headers.get('User-Agent', '')

    # Check referrer
    for domain, source in referrers.items():
        if domain in referrer:
            analytics.track_custom_source(source)
            return source

    # Check user agent (some AI crawlers identify themselves)
    if 'GPTBot' in user_agent:
        analytics.track_custom_source('ChatGPT-Bot')
        return 'ChatGPT-Bot'
    elif 'ClaudeBot' in user_agent:
        analytics.track_custom_source('Claude-Bot')
        return 'Claude-Bot'

    # Check for AI-specific URL parameters
    utm_source = request.args.get('utm_source', '')
    if 'ai' in utm_source.lower() or 'chat' in utm_source.lower():
        analytics.track_custom_source(f'AI-{utm_source}')
        return utm_source

    return None

from datetime import datetime, timedelta
from typing import List, Dict

class ContentRefreshScheduler:
    """
    Automated content refresh scheduling to maintain RAG freshness
    Ensures content stays in AI citation rotation
    """

    def __init__(self, content_inventory: List[Dict]):
        """
        Args:
            content_inventory: List of {
                'url': str,
                'title': str,
                'published_date': datetime,
                'last_updated': datetime,
                'priority': str  # 'high', 'medium', 'low'
            }
        """
        self.content = content_inventory

    def calculate_refresh_priority(
        self,
        article: Dict
    ) -> int:
        """
        Calculate when article needs refresh

        Returns:
            Days until refresh needed (lower = more urgent)
        """
        # Base refresh intervals by content priority
        intervals = {
            'high': 14,    # 2 weeks
            'medium': 30,  # 1 month
            'low': 60      # 2 months
        }

        base_interval = intervals.get(article['priority'], 30)

        # Calculate days since last update
        now = datetime.now()
        days_since_update = (now - article['last_updated']).days

        # Days until refresh needed
        days_until = base_interval - days_since_update

        return days_until

    def generate_refresh_schedule(
        self,
        next_n_days: int = 30
    ) -> List[Dict]:
        """
        Generate content refresh schedule for next N days

        Returns:
            List of articles to refresh with suggested dates
        """
        schedule = []

        for article in self.content:
            days_until_refresh = self.calculate_refresh_priority(article)

            if days_until_refresh <= next_n_days:
                refresh_date = datetime.now() + timedelta(days=max(0, days_until_refresh))

                schedule.append({
                    'article': article,
                    'refresh_date': refresh_date,
                    'urgency': 'high' if days_until_refresh < 0 else
                              'medium' if days_until_refresh < 7 else 'low'
                })

        # Sort by urgency then date
        schedule.sort(key=lambda x: (
            {'high': 0, 'medium': 1, 'low': 2}[x['urgency']],
            x['refresh_date']
        ))

        return schedule

    def suggest_updates(
        self,
        article: Dict
    ) -> List[str]:
        """
        Suggest what to update in article refresh

        Returns:
            List of suggested updates
        """
        suggestions = []

        # Always update statistics
        suggestions.append("Update statistics with 2026 data")

        # Add recent developments section
        suggestions.append("Add 'Recent Developments' section with Q1 2026 updates")

        # Refresh examples
        suggestions.append("Update code examples with latest framework versions")

        # Check publication date
        if (datetime.now() - article['published_date']).days > 180:
            suggestions.append("Add significant new section (500+ words) to justify refresh")

        # Platform-specific recommendations
        suggestions.append("Test current citation rate before/after refresh")

        return suggestions

    def print_schedule(self, schedule: List[Dict]):
        """Print formatted refresh schedule"""
        print("\n" + "="*80)
        print("CONTENT REFRESH SCHEDULE (Next 30 Days)")
        print("="*80 + "\n")

        for item in schedule:
            article = item['article']
            refresh_date = item['refresh_date']
            urgency = item['urgency']

            urgency_symbol = {
                'high': '🔴',
                'medium': '🟡',
                'low': '🟢'
            }[urgency]

            print(f"{urgency_symbol} {refresh_date.strftime('%Y-%m-%d')} - {article['title']}")
            print(f"   Priority: {article['priority']} | Urgency: {urgency}")
            print(f"   Last updated: {article['last_updated'].strftime('%Y-%m-%d')}")

            suggestions = self.suggest_updates(article)
            print("   Suggestions:")
            for suggestion in suggestions:
                print(f"     - {suggestion}")
            print()

# Example usage
content_inventory = [
    {
        'url': 'https://yoursite.com/ai-monitoring',
        'title': 'AI Agent Monitoring Guide',
        'published_date': datetime(2025, 6, 15),
        'last_updated': datetime(2025, 12, 20),
        'priority': 'high'
    },
    {
        'url': 'https://yoursite.com/llm-costs',
        'title': 'LLM Cost Optimization',
        'published_date': datetime(2025, 8, 1),
        'last_updated': datetime(2025, 12, 15),
        'priority': 'high'
    },
    {
        'url': 'https://yoursite.com/rag-guide',
        'title': 'RAG Systems Guide',
        'published_date': datetime(2025, 3, 10),
        'last_updated': datetime(2025, 9, 5),
        'priority': 'medium'
    }
]

scheduler = ContentRefreshScheduler(content_inventory)
schedule = scheduler.generate_refresh_schedule(next_n_days=30)
scheduler.print_schedule(schedule)