AI-Driven Personalization: Real-Time Content Adaptation

public class PersonalizationService : IPersonalizationService
{
    private readonly IMLModelService _mlService;
    private readonly IMemoryCache _cache;
    private readonly IHubContext<PersonalizationHub> _hubContext;
    
    public async Task<PersonalizedContent> GetAdaptiveContentAsync(
        string userId, 
        ContentContext context)
    {
        // Retrieve user behavior profile
        var userProfile = await GetUserProfileAsync(userId);
        
        // Calculate personalization score in real-time
        var predictions = await _mlService.PredictAsync(new
        {
            UserProfile = userProfile,
            Context = context,
            Timestamp = DateTime.UtcNow
        });
        
        // Generate personalized content configuration
        var personalizedConfig = new PersonalizedContent
        {
            PrimaryContent = await SelectOptimalContent(
                predictions.ContentScores),
            LayoutVariant = predictions.PreferredLayout,
            FeatureFlags = predictions.RecommendedFeatures,
            AdaptationReason = predictions.SignalStrength
        };
        
        // Cache for consistency during session
        await CachePersonalizationAsync(userId, personalizedConfig);
        
        // Push updates to connected clients
        await _hubContext.Clients.User(userId)
            .SendAsync("ContentUpdated", personalizedConfig);
        
        return personalizedConfig;
    }
    
    private async Task<UserBehaviorProfile> GetUserProfileAsync(
        string userId)
    {
        var cacheKey = $"profile:{userId}";
        
        if (_cache.TryGetValue(cacheKey, out UserBehaviorProfile profile))
            return profile;
        
        // Aggregate recent interactions
        profile = await BuildProfileFromEventsAsync(userId);
        
        _cache.Set(cacheKey, profile, TimeSpan.FromMinutes(5));
        return profile;
    }
}

public class MLModelService : IMLModelService
{
    private readonly PredictionEngine<UserFeatures, PersonalizationPrediction> 
        _predictionEngine;
    
    public async Task<PersonalizationPrediction> PredictAsync(
        dynamic inputData)
    {
        var features = new UserFeatures
        {
            SessionDuration = inputData.UserProfile.AverageSessionMinutes,
            PageDepth = inputData.UserProfile.AveragePageDepth,
            ConversionHistory = inputData.UserProfile.PastConversions,
            DeviceType = inputData.Context.DeviceCategory,
            TimeOfDay = inputData.Timestamp.Hour,
            DayOfWeek = (int)inputData.Timestamp.DayOfWeek,
            EngagementScore = CalculateEngagementScore(inputData.UserProfile)
        };
        
        // Run prediction synchronously (model is in-memory)
        var prediction = _predictionEngine.Predict(features);
        
        // Apply business rules and thresholds
        return await Task.FromResult(new PersonalizationPrediction
        {
            ContentScores = prediction.ContentAffinityScores,
            PreferredLayout = DetermineOptimalLayout(
                prediction.LayoutPreference),
            RecommendedFeatures = SelectFeatures(
                prediction.FeatureImportance),
            ConfidenceLevel = prediction.Probability,
            SignalStrength = prediction.Score
        });
    }
}

import { useEffect, useState } from 'react';
import { HubConnectionBuilder } from '@microsoft/signalr';

interface PersonalizationConfig {
  primaryContent: ContentBlock[];
  layoutVariant: string;
  featureFlags: Record<string, boolean>;
  adaptationReason: string;
}

export const usePersonalization = (userId: string) => {
  const [config, setConfig] = useState<PersonalizationConfig | null>(null);
  const [loading, setLoading] = useState(true);
  
  useEffect(() => {
    const connection = new HubConnectionBuilder()
      .withUrl('/hubs/personalization')
      .withAutomaticReconnect()
      .build();
    
    connection.on('ContentUpdated', (newConfig: PersonalizationConfig) => {
      setConfig(newConfig);
      setLoading(false);
    });
    
    connection.start()
      .then(() => {
        // Request initial personalization
        return fetch(`/api/personalization/${userId}`);
      })
      .then(response => response.json())
      .then(initialConfig => {
        setConfig(initialConfig);
        setLoading(false);
      })
      .catch(error => {
        console.error('Personalization error:', error);
        setLoading(false);
      });
    
    return () => {
      connection.stop();
    };
  }, [userId]);
  
  return { config, loading };
};

export const AdaptiveContentSection: React.FC<{userId: string}> = 
  ({ userId }) => {
  const { config, loading } = usePersonalization(userId);
  
  const ContentComponent = useMemo(() => {
    if (!config) return DefaultContent;
    
    // Dynamically select component based on personalization
    switch (config.layoutVariant) {
      case 'high-engagement':
        return HighEngagementLayout;
      case 'conversion-focused':
        return ConversionOptimizedLayout;
      case 'discovery':
        return DiscoveryLayout;
      default:
        return StandardLayout;
    }
  }, [config?.layoutVariant]);
  
  if (loading) {
    return <ContentSkeleton />;
  }
  
  return (
    <ContentComponent 
      content={config.primaryContent}
      features={config.featureFlags}
      analyticsContext={{
        variant: config.layoutVariant,
        reason: config.adaptationReason
      }}
    />
  );
};

public class PersonalizationEventProcessor
{
    private readonly IEventBus _eventBus;
    private readonly IMLModelService _mlService;
    
    public async Task ProcessUserInteractionAsync(
        UserInteractionEvent interaction)
    {
        // Enrich event with profile data
        var enrichedEvent = await EnrichEventAsync(interaction);
        
        // Check if personalization update is warranted
        if (!ShouldUpdatePersonalization(enrichedEvent))
            return;
        
        // Generate new personalization configuration
        var newConfig = await _mlService.PredictAsync(new
        {
            Event = enrichedEvent,
            Timestamp = DateTime.UtcNow
        });
        
        // Publish personalization update event
        await _eventBus.PublishAsync(new PersonalizationUpdatedEvent
        {
            UserId = interaction.UserId,
            Configuration = newConfig,
            Trigger = interaction.EventType,
            Timestamp = DateTime.UtcNow
        });
    }
    
    private bool ShouldUpdatePersonalization(
        EnrichedUserEvent enrichedEvent)
    {
        // Apply threshold logic to prevent update spam
        return enrichedEvent.SignificanceScore > 0.7 ||
               enrichedEvent.TimeSinceLastUpdate > TimeSpan.FromMinutes(5);
    }
}

public class PersonalizationCacheStrategy
{
    private readonly IDistributedCache _cache;
    private readonly ILogger _logger;
    
    public async Task<T> GetOrComputeAsync<T>(
        string key,
        Func<Task<T>> computeFunc,
        CacheLevel level)
    {
        var cacheKey = $"personalization:{level}:{key}";
        var cached = await _cache.GetStringAsync(cacheKey);
        
        if (cached != null)
        {
            return JsonSerializer.Deserialize<T>(cached);
        }
        
        var computed = await computeFunc();
        var ttl = GetTTLForLevel(level);
        
        await _cache.SetStringAsync(
            cacheKey,
            JsonSerializer.Serialize(computed),
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = ttl
            });
        
        return computed;
    }
    
    private TimeSpan GetTTLForLevel(CacheLevel level)
    {
        return level switch
        {
            CacheLevel.Profile => TimeSpan.FromMinutes(5),
            CacheLevel.Prediction => TimeSpan.FromSeconds(30),
            CacheLevel.Content => TimeSpan.FromSeconds(10),
            _ => TimeSpan.FromSeconds(60)
        };
    }
}