A conversation with AI

Artificial Intelligence (AI) has been around for quite some time, everyone is familiar with the likes of ChatGPT and its friendly user interface, that allows you ask questions and get answers. Initially, ChatGPT and similar models were limited by their training data — they could only provide answers based on information available up to the point of their last training cycle (for example, data up to a specific month in 2021). However, newer versions now have the ability to search the web in real time, incorporating recent and relevant sources into their responses.

This improvement became clear to me recently while experimenting with ChatGPT.

For some time, I’ve been exploring ways AI could work behind the scenes in Sitecore to enhance user experiences. I was particularly interested in how Generative AI could drive personalization, though I wasn’t entirely sure what that might look like in practice. So, I simply posed the question to ChatGPT and followed its prompts as it asked clarifying questions in return.

To my surprise, the conversation eventually led to ChatGPT asking, “Would you like me to provide a GitHub repository with practical examples?” When I agreed, it directed me — amusingly — to my own repository: Page Recommender for Sitecore.

Aside from finding it funny, being pointed back to my own repo, the experience underscored the power of Generative AI as a research and ideation partner. It’s not just a tool for finding answers — it can help you explore new directions, suggest approaches you might not have considered, and quickly surface relevant examples.

The key takeaway is this: you can interact with AI much like you would with a colleague — asking questions, challenging ideas, and refining solutions — but with the added advantage of instant, wide-reaching research capabilities. And if you ever doubt the accuracy of its responses, you can always ask it to back them up with reputable sources — for instance, “Find an example from Sitecore’s documentation that demonstrates this concept.”

Full conversation below:

Me: List some uses for AI behind the scenes of a website

ChatGPT:

AI can be used in many behind-the-scenes roles on a website to improve performance, user experience, and operational efficiency. Here are some common uses:

🔍 1. Search Optimization

• Intelligent search engines: Use NLP to understand user intent and return relevant results.
• Auto-complete and suggestions: Predict what users are searching for.
• Semantic search: Match user queries with content meaning, not just keywords.

🧠 2. Personalization

• Content recommendations: Suggest articles, products, or media based on user behavior.
• Dynamic layout/content: Adjust content shown based on past behavior or demographics.
• Email/push notification targeting: Personalize marketing based on AI-driven segmentation.

🧾 3. Customer Support Automation

• Chatbots: Answer FAQs and help users navigate the site.
• AI-driven ticket routing: Send support tickets to the right department or priority level.
• Sentiment analysis: Detect frustrated users or urgent issues.

🔒 4. Security & Fraud Detection

• Anomaly detection: Spot unusual behavior patterns (e.g. bot activity or account takeover).
• CAPTCHA alternatives: Use behavioral analysis to distinguish bots from humans.
• Payment fraud monitoring: Detect and block suspicious transactions in real time.

📊 5. Analytics & User Behavior Insights

• Heatmaps & click tracking analysis: Determine what users focus on.
• Churn prediction: Identify users likely to leave and trigger retention actions.
• A/B test optimization: Use AI to analyze test results faster and suggest improvements.

🚀 6. Performance Optimization

• Traffic prediction: Anticipate load and scale resources accordingly.
• Image/video compression: Automatically compress or choose optimal media formats
• Latency prediction: Route users to the fastest servers or CDNs using AI models.

🛍️ 7. E-commerce Intelligence

• Dynamic pricing: Adjust prices based on demand, competition, or user profile.
• Inventory forecasting: Predict stock needs using AI-driven demand modeling.
• Visual search: Let users search using images, with AI matching products.

📄 8. Content Management

• Auto-tagging and categorization: AI can tag new content for SEO and navigation.
• Content summarization: Summarize long posts for previews or meta descriptions.
• Language translation: Use AI to offer content in multiple languages.

If you want examples specific to a certain kind of website (e.g., blog, e-commerce, SaaS), I can tailor the list.

Me: Please elaborate on content recommendations. Would that be in real time for each user. Please give an example

ChatGPT:

Yes, content recommendations can be personalized in real time for each user, depending on how sophisticated the system is and what data is available. These systems use AI to analyze behavior, preferences, and context to suggest relevant content, products, or media that a user is likely to engage with.

🔁 Real-Time Content Recommendations — How They Work
✅ Inputs (data sources):

• User’s current session behavior (clicks, time on page, scroll depth)
• Past browsing history on the site
• Demographics (age, location, device type, etc.)
• Similar users’ behavior (collaborative filtering)
• Contextual factors (time of day, device, referral source)

🧠 AI Techniques Used:

• Collaborative Filtering: Recommends items based on what similar users liked.
• Content-Based Filtering: Recommends items similar to what a user has already interacted with.
• Hybrid Models: Combine multiple strategies, often with reinforcement learning or neural networks.
• Deep Learning: For large-scale personalization on platforms like Netflix or Amazon.
• Real-time inference: Uses fast models (e.g., lightweight transformers or decision trees) to update recommendations instantly.

🔍 Example: News Website
Scenario:
A user visits a news site and reads an article titled “Global Markets Dip Amid Tech Selloff.”

Behind the Scenes:
AI detects:

• The user has read 3 finance-related articles in the last 10 minutes.
• The current article mentions "stock market", "tech stocks", and "Wall Street".
• It’s the user's first visit from a mobile device via a LinkedIn referral.

The recommendation engine:

• Filters articles with similar tags and recent high engagement.
• Uses a collaborative model to suggest what other users who read the same article also liked.
• Ranks results in real time by relevance.

What the user sees:

• 🔹 “Why Tech Stocks Are Underperforming in 2025”
• 🔹 “What the Fed's Rate Decisions Mean for Investors”
• 🔹 “3 Safe-Haven Assets for a Volatile Market”

Updates on interaction: As the user clicks another article, the engine refines future suggestions even further.

🎯 Where It’s Used:

• E-commerce: “Customers also bought…”
• Streaming: “Because you watched…”
• Blogs: “You might also like…”
• Learning platforms: “Next recommended course…”

Let me know if you'd like a code example (e.g., how to implement a basic content recommender using Python or in a web framework).

Me: Please give example for sitecore using c#. How often would information be fed to an AI model and how?

ChatGPT:

Great — let’s walk through how to implement content recommendations in Sitecore using C#, and how often data is fed into the AI model (and how that pipeline works).

✅ Scenario
You have a Sitecore-powered website (e.g., a news site or e-commerce store), and you want to show real-time content recommendations to users based on their browsing behavior.

🔁 1. Real-Time Recommendations Workflow Overview
Components:
User Interaction Tracking – Sitecore personalization & analytics

Data Collection & Logging – Send to a storage or message queue

AI Model Backend – Hosted separately (e.g., in Azure ML, AWS SageMaker, or your own API)

Content Recommendation Display – C# controller/component in Sitecore MVC

🧠 2. How Often Is Data Fed into the AI Model?
Two levels:
1. Model Training (Batch Updates)
Frequency: Daily, hourly, or based on traffic volume

How: Offline pipeline (e.g., export interaction logs to a data warehouse → retrain AI model → redeploy model or update weights)

2. Model Inference (Real-Time)
Frequency: Every page view or interaction

How: Send user/session data to a live API endpoint → get recommendations back instantly

🛠️ 3. Example: Sitecore C# Component for Content Recommendations
👇 C# Controller Example (RecommendationController.cs)


public class RecommendationController : Controller
{
private readonly IRecommendationService _recommendationService;

public RecommendationController(IRecommendationService recommendationService)
{
_recommendationService = recommendationService;
}

public ActionResult GetRecommendations()
{
var userId = Sitecore.Context.User.Name;
var currentItemId = Sitecore.Context.Item.ID.ToString();

var recommendedItems = _recommendationService.GetRecommendedItems(userId, currentItemId);

return View("~/Views/Recommendations.cshtml", recommendedItems);
}
}

👇 Interface + Service Example (RecommendationService.cs)
public interface IRecommendationService
{
List GetRecommendedItems(string userId, string currentItemId);
}

public class RecommendationService : IRecommendationService
{
private readonly string _apiUrl = "https://your-ai-service.com/api/recommend";

public List GetRecommendedItems(string userId, string currentItemId)
{
var client = new HttpClient();
var requestData = new
{
userId = userId,
currentContentId = currentItemId
};

var response = client.PostAsJsonAsync(_apiUrl, requestData).Result;
var contentIds = response.Content.ReadAsAsync<List>().Result;

return contentIds.Select(id => Sitecore.Context.Database.GetItem(new ID(id))).ToList();
}
}

👇 View (Recommendations.cshtml)

@model List

Recommended for you

• @foreach (var item in Model)

• {
  • @item.DisplayName

}

📦 4. Feeding Data into the Model
You’d log user interaction data (like viewed content, time spent, clicks, etc.) to an event queue or logging system, for example:

Azure Event Hubs

AWS Kinesis

Apache Kafka

Flat log files sent to blob storage

Then process those logs daily with an ETL pipeline that:

• Aggregates data per user/session
• Trains or fine-tunes the model
• Deploys the updated model or stores it in a low-latency prediction API

🧪 Tech Stack Example
Layer Example Tech
Data Logging Sitecore xConnect, Azure Event Hubs
Storage Azure Blob / Data Lake / SQL
Model Training Azure ML, scikit-learn, TensorFlow
Model Deployment FastAPI, Flask API, Azure Function
Realtime Recommendation REST API called from C# code above

Would you like:

• A sample training dataset?
• An Azure Function or FastAPI example for the AI model side?
• Code to log interactions to feed the model?

Let me know what part you want to expand on.

Me: Please expand on each part

ChatGPT:

Updated saved memory
Excellent — let’s expand each part of the Sitecore-based real-time content recommendation system, from data capture to AI model deployment.

⚙️ 1. User Interaction Tracking in Sitecore
🔍 What to Track:

• Page visits (content ID, timestamp)
• Click events (e.g., links, buttons)
• Time on page
• User profile info (anonymous ID or logged-in user)
• Device type, location, referral source

✅ How to Implement:
Use Sitecore xConnect to log interactions. For example:

using Sitecore.XConnect;
using Sitecore.XConnect.Collection.Model;

public void LogPageVisit(string contentId)
{
var contact = Sitecore.Analytics.Tracker.Current.Contact;
var interaction = new Interaction(contact, InteractionInitiator.Contact, "website", "page visit");
interaction.Events.Add(new PageViewEvent(contentId));

using (var client = SitecoreXConnectClientConfiguration.Default.CreateClient())
{
client.AddInteraction(interaction);
client.Submit();
}
}
This interaction data can later be exported or streamed to your AI system.

📦 2. Data Collection and Logging
You need to stream or store interaction data in a way that allows:

Real-time inference (live API requests)

Batch training (daily logs)

🔄 Real-Time:
You send current session data to the recommendation API every time the user loads a new page.

📁 Batch Logs:
Log to a file or database (e.g., Azure SQL, Cosmos DB, AWS RDS) or push to a message queue like:

Azure Event Hubs

AWS Kinesis

Kafka

Example: Logging to Azure Blob for Training
var log = new
{
UserId = userId,
ContentId = currentItem.ID.ToString(),
Timestamp = DateTime.UtcNow
};

string json = JsonConvert.SerializeObject(log);
File.AppendAllText("userlogs.txt", json + Environment.NewLine);
Then upload to Azure Blob storage.

🧠 3. AI Model Training (Batch Process)
🎯 Goal:
Train a recommendation model using user-content interaction data.

📊 Sample Training Data:
user_id content_id timestamp
u123 c456 2025-05-25 10:45:00
u123 c789 2025-05-25 10:50:00
u999 c456 2025-05-25 11:00:00
🧠 Model Options:

• Collaborative Filtering (e.g., Matrix Factorization)
• Content-Based Filtering (using tags, categories, metadata)
• Hybrid (combine both)

🛠️ Tech Stack:

• Python (Pandas + scikit-learn / TensorFlow)
• Azure Machine Learning / AWS SageMaker
• Store model as .pkl, .onnx, or use cloud endpoint

Example (Python using Surprise for collaborative filtering):
from surprise import Dataset, SVD, Reader
from surprise.model_selection import train_test_split

df = pd.read_csv('interactions.csv')
reader = Reader(rating_scale=(1, 1)) # Just implicit feedback
data = Dataset.load_from_df(df[['user_id', 'content_id', 'rating']], reader)

trainset, testset = train_test_split(data, test_size=0.2)
model = SVD()
model.fit(trainset)
Save the model:

import joblib
joblib.dump(model, 'recommender_model.pkl')
🚀 4. Model Deployment & Serving

🔧 Options:

• Azure Function / AWS Lambda: Fast, serverless API
• FastAPI / Flask App: More customizable ML service
• Real-time endpoint (Azure ML, SageMaker)

🧪 FastAPI Example:
from fastapi import FastAPI, Request
import joblib

app = FastAPI()
model = joblib.load("recommender_model.pkl")

@app.post("/recommend")
async def recommend(data: dict):
user_id = data["userId"]
content_id = data["currentContentId"]
# Logic to find top-N content
recommendations = get_recommendations(user_id)
return recommendations
Deploy to Azure App Service or AWS EC2.

🖥️ 5. Integrating with Sitecore (as shown earlier)
In your C# Sitecore MVC Controller:

Call this recommendation API

Get back a list of recommended content IDs

Fetch items from Sitecore DB

Render in the view

Already covered in your earlier example.

🔄 6. Update Frequency
Component Frequency Tooling Suggestion
Model Training Daily / hourly Azure ML pipeline, Airflow, Cron
Model Inference Per page load REST API call from Sitecore backend
Interaction Logging Realtime xConnect + Event Hub / Blob storage
Model Deployment Weekly / as needed Azure ML, Docker, or serverless
✅ Summary Diagram
[Sitecore Web] -- logs --> [Azure Blob / Event Hub]
\ /
\-- calls --> [Recommendation API (FastAPI)]
|
[AI Model (daily trained)]
|
<--- content IDs returned ---

Would you like me to generate a full working prototype with:

• A Sitecore-compatible C# wrapper
• Python model training notebook
• FastAPI deployment setup
• Let me know your target environment (e.g., Azure or AWS), and I can tailor it.

Me: Yes please for azure

ChatGPT:

Perfect — here’s a step-by-step prototype setup tailored for Azure, covering everything from Sitecore logging to AI model training and deployment via FastAPI in Azure App Service.

🔧 AI Content Recommendation System for Sitecore on Azure
📁 Part 1: Logging User Interactions from Sitecore to Azure Blob Storage
➕ Add Logging in Sitecore (C#)
public void LogUserInteraction(string userId, string contentId)
{
var log = new
{
UserId = userId,
ContentId = contentId,
Timestamp = DateTime.UtcNow
};

var json = JsonConvert.SerializeObject(log);
var blobClient = new BlobContainerClient("", "interaction-logs");

var blobName = $"log_{Guid.NewGuid()}.json";
var blob = blobClient.GetBlobClient(blobName);

using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(json)))
{
blob.Upload(stream);
}
}
Make sure to install Azure.Storage.Blobs via NuGet.

🧠 Part 2: Model Training with Azure ML & Python
Step 1: Prepare Python Script (locally or in a Jupyter Notebook)
import pandas as pd
from surprise import Dataset, Reader, SVD
from surprise.model_selection import train_test_split
import joblib

# Read interaction logs (after merging blobs)
df = pd.read_json("all_user_logs.json", lines=True)

# Assign implicit rating (1) for interactions
df["rating"] = 1

reader = Reader(rating_scale=(1, 1))
data = Dataset.load_from_df(df[['UserId', 'ContentId', 'rating']], reader)

trainset, testset = train_test_split(data, test_size=0.2)

model = SVD()
model.fit(trainset)

# Save trained model
joblib.dump(model, "recommender_model.pkl")
Upload this to Azure ML as a pipeline step or scheduled notebook.

🚀 Part 3: Deploying a FastAPI Recommendation Service to Azure App Service
Step 1: Create main.py
from fastapi import FastAPI, Request
import joblib
import pandas as pd

app = FastAPI()
model = joblib.load("recommender_model.pkl")

# Sample list of all content IDs (replace with DB or CMS lookup)
all_items = ["c123", "c456", "c789", "c999", "c101"]

@app.post("/recommend")
async def recommend(data: dict):
user_id = data["userId"]
content_id = data["currentContentId"] # Optional, can be used for context

# Predict scores for all items
predictions = [(item, model.predict(user_id, item).est) for item in all_items]
top_items = sorted(predictions, key=lambda x: x[1], reverse=True)[:3]

return {"recommendedContentIds": [item[0] for item in top_items]}
Step 2: requirements.txt
fastapi
uvicorn
joblib
pandas
scikit-learn
scipy
surprise
Step 3: Deploy to Azure
Create Azure App Service (Linux, Python 3.9)

Enable deployment via GitHub Actions, FTP, or Azure CLI

Use:

uvicorn main:app --host 0.0.0.0 --port 8000
in the startup command

🖥️ Part 4: Calling the Recommendation API from Sitecore (C#)
public class RecommendationService : IRecommendationService
{
private readonly HttpClient _client;

public RecommendationService()
{
_client = new HttpClient();
}

public List GetRecommendedItems(string userId, string currentItemId)
{
var data = new
{
userId = userId,
currentContentId = currentItemId
};

var response = _client.PostAsJsonAsync("https://.azurewebsites.net/recommend", data).Result;
var result = response.Content.ReadFromJsonAsync().Result;

return result.RecommendedContentIds
.Select(id => Sitecore.Context.Database.GetItem(new ID(id)))
.ToList();
}
}

public class RecommendationResponse
{
public List RecommendedContentIds { get; set; }
}
🧪 Optional: Automate Daily Training
Use Azure ML Pipelines or Azure Data Factory to:

Aggregate blob logs into one file daily.

Train or fine-tune the model.

Upload the new .pkl to Azure Blob Storage.

Auto-redeploy the FastAPI app with the updated model (or load from blob on boot).

✅ Summary Flow
[User Interaction in Sitecore]
↓
[Logs written to Azure Blob]
↓
[Python script in Azure ML]
↓
[Model saved to Blob or App Service]
↓
[FastAPI model deployed to Azure App Service]
↓
[C# Controller fetches recommendations per page load]

Would you like:

• A GitHub repo with the FastAPI app ready for deployment?
• A Sitecore integration package sample?
• An Azure ML pipeline YAML or notebook?

Let me know which part you'd like next.

Me: Github repo

ChatGPT:

Certainly! To assist you in building an AI-driven content recommendation system for your Sitecore website using Azure services, I've identified a GitHub repository that provides a practical example:

🔗 Page Recommender for Sitecore
This repository offers a companion codebase to a series of blog posts detailing the setup of a page recommendation service for Sitecore. It includes:

• Integration with Sitecore Cortex: Demonstrates how to utilize Sitecore's Cortex Engine to train and call a machine learning model for content recommendations.
• Deployment Instructions: Guides on deploying the xConnect model to the xConnect server and Cortex Processing Engine, as well as integrating the Page Recommender feature into your Sitecore instance.
• Customization: While not production-ready, it provides a clear example of the code required to implement a recommendation system within Sitecore.

Please note that this project may require adjustments to fit your specific environment and use case.

If you're interested in a more comprehensive solution that includes:

• Logging user interactions from Sitecore to Azure Blob Storage
• Training a recommendation model using Azure Machine Learning
• Deploying a FastAPI-based recommendation service to Azure App Service
• Integrating the recommendation API with your Sitecore frontend

I can assist you in setting up a GitHub repository with a structured project layout, including:

• sitecore-logger/: C# code for logging user interactions.
• model-training/: Python scripts and notebooks for training the recommendation model.
• fastapi-service/: FastAPI application for serving recommendations.
• deployment/: Azure Resource Manager (ARM) templates or Bicep files for deploying resources.

Would you like me to proceed with creating this repository structure for you?