Project Kairos | Real-Time News Recommendation

The Item-Cold-Start Paradox

In the news domain, the content catalog is extremely dynamic. Unlike e-commerce or video streaming, news articles have a very short half-life (TTL < 48h).

Classical collaborative filtering algorithms collapse in this environment. The time required to gather sufficient interaction data for neural models often exceeds the relevance lifespan of the news itself.

48h Maximum Time-to-Live

0% Initial User Interactions

Stability under Stress: Cholesky vs. Sherman-Morrison

Traditional LinUCB relies on Sherman-Morrison inversion which accumulates floating-point errors. Kairos uses Cholesky rank-1 updates to mathematically guarantee positive definiteness. Watch the covariance ellipsoid deform and collapse under noise with the classical method, while Kairos remains stable.

Understanding the Condition Number (κ) & Collapse:

The Condition Number κ measures how numerically sensitive the covariance matrix is. A value of κ = 1.0 means perfect isotropic confidence (a perfect circle). As κ grows, the matrix becomes ill-conditioned (elongated ellipse).

Why does Sherman-Morrison (Classic) fail irreversibly?
The classical method directly updates the inverse covariance matrix. Due to floating-point rounding errors, symmetry is lost over time. Once the matrix loses positive definiteness (i.e., eigenvalues become negative or zero), the algorithm suffers a singular collapse (κ → ∞). Mathematically, it cannot recover from this state, leading to garbage recommendations.

Why is Cholesky (Kairos) stable?
Instead of updating the inverse directly, Kairos updates the Cholesky factor L (where A = LL^T). Because any matrix of the form LL^T is mathematically guaranteed to be positive definite, the Kairos algorithm cannot collapse, ensuring robust long-term operation even under severe numerical noise.

Numerical Noise / Sparsity

Sherman-Morrison (Classic)

Condition κ: 1.0

Cholesky (Kairos)

Condition κ: 1.0

What does this mean? The green circle (Kairos) shrinks symmetrically: The algorithm learns and confidence increases (lower variance). The red ellipsoid deforms and jumps erratically: The classical Sherman-Morrison update loses symmetry due to floating-point rounding errors. Eventually, the math breaks down entirely, leading to irrational behavior and algorithmic collapse (κ → ∞).

Matryoshka Representation Learning

To achieve sub-millisecond real-time inference, Kairos leverages MRL. The high-dimensional embedding space is adaptively truncated. Adjust the slider to see the trade-off between Semantic Variance and Inference Latency.

Embedding Dimension: 128

64 128 256 512 768

Latency (ms / 100 art.)

0.065 ms

Semantic Variance

~96.8%

4.85x Speedup at 128d

Architecture & Implementation

Click through the pipeline steps to explore the corresponding Julia implementation.

Tagesschau API Ingestion

↓

MRL Embedding (768d)

↓

MIPS Retrieval (128d)

↓

LinUCB Cholesky-Update

src/BanditCore.jl

# src/Ingest.jl
function update_news!()
    # Fetch real-time articles from Tagesschau API
    req = HTTP.get("https://www.tagesschau.de/api2/")
    data = JSON.parse(String(req.body))
    
    for article in data["news"]
        # Parse and store with TTL < 48h
        push!(ARTICLE_POOL, parse_article(article))
    end
end

# src/Model.jl
function embed_article(text::String)
    # Use Matryoshka Representation Learning model
    # Full capacity embedding
    emb_768d = Nomic.embed(text)
    
    # Truncate to 128d for MIPS speedup
    # while retaining ~96.8% semantic variance
    return normalize(emb_768d[1:128])
end

# src/BanditCore.jl
function get_recommendations(profile, articles, α)
    L_tri = LowerTriangular(profile.L)
    y = L_tri \ profile.b
    θ = L_tri' \ y # User preference vector

    scored = map(articles) do art
        x = art.embedding[1:profile.dim] # 128d
        μ = dot(θ, x)       # Exploitation
        σ = norm(L_tri \ x) # Exploration

        return (article = art, score = μ + α * σ)
    end
    return sort!(scored, by = x -> x.score, rev = true)
end

# src/BanditCore.jl
function update_factor!(profile::UserProfile, x::Vector{Float32}, reward::Float32)
    # Apply forgetting factor
    profile.L .*= sqrt(profile.γ)
    profile.b .*= profile.γ

    x_norm = x ./ (norm(x) + 1.0f-6)

    if reward > 0.05f0
        update_vec = sqrt(reward * 1.5f0) .* x_norm
        
        # Mathematically guaranteed positive definite
        C = Cholesky(profile.L, 'L', 0)
        lowrankupdate!(C, update_vec) 
        
        profile.b .+= reward .* x_norm
    end
end