- Updated: March 17, 2026
- 7 min read
Personalizing Moltbook Feeds with OpenClaw Plugin Ratings
You can personalize Moltbook feeds by retrieving rating data from the OpenClaw Rating API, converting that data into user‑preference profiles, and feeding those profiles into Moltbook’s feed algorithm.
1. Introduction
Moltbook is a modern content‑discovery platform that serves articles, videos, and podcasts based on a generic relevance model. While this works for most users, developers often need a tighter fit—showing each reader exactly the items they love. The OpenClaw plugin rating system provides a rich, real‑time signal that can be turned into a personalisation engine. In this guide we walk through:
- How the OpenClaw Rating API is structured.
- Fetching rating data with a clean Python client.
- Building deterministic user‑preference profiles.
- Injecting those profiles into Moltbook’s feed algorithm.
- A step‑by‑step integration checklist.
By the end of this article, you’ll have a production‑ready code snippet and a clear roadmap to ship personalised feeds in under an hour.
2. Overview of OpenClaw Rating API
OpenClaw exposes a RESTful endpoint that aggregates user interactions (likes, dislikes, star ratings, and time‑spent metrics) for every plugin installed on a Moltbook instance. The API follows a predictable JSON schema:
{
"user_id": "string",
"plugin_id": "string",
"ratings": [
{
"item_id": "string",
"score": 0-5,
"timestamp": "ISO8601"
}
]
}Key points:
- Authentication: Bearer token passed in the
Authorizationheader. - Pagination:
limitandoffsetquery parameters. - Rate limits: 120 requests per minute per token.
The official documentation can be consulted for edge‑case handling: OpenClaw Rating API documentation.
3. Retrieving Rating Data – Python Client Example
Below is a self‑contained Python client that:
- Authenticates with the OpenClaw service.
- Iterates through paginated results.
- Normalises scores to a 0‑1 range for downstream ML pipelines.
import requests
import time
from typing import List, Dictclass OpenClawClient:
BASE_URL = "https://api.openclaw.io/v1/ratings"
def __init__(self, api_key: str, timeout: int = 10):
self.headers = {
"Authorization": f"Bearer {api_key}",
"Accept": "application/json"
}
self.timeout = timeout
def _get_page(self, user_id: str, limit: int = 100, offset: int = 0) -> Dict:
params = {
"user_id": user_id,
"limit": limit,
"offset": offset
}
response = requests.get(
self.BASE_URL,
headers=self.headers,
params=params,
timeout=self.timeout
)
response.raise_for_status()
return response.json()
def fetch_all_ratings(self, user_id: str) -> List[Dict]:
all_ratings = []
offset = 0
while True:
page = self._get_page(user_id, limit=200, offset=offset)
ratings = page.get("ratings", [])
if not ratings:
break
all_ratings.extend(ratings)
offset += len(ratings)
# Respect rate limit
time.sleep(0.5)
return all_ratings
@staticmethod
def normalise_score(score: int) -> float:
"""Convert 0‑5 star rating to 0‑1 float."""
return max(0.0, min(1.0, score / 5.0))
# Usage example
if __name__ == "__main__":
API_KEY = "YOUR_OPENCLAW_API_KEY"
USER_ID = "example_user_123"
client = OpenClawClient(API_KEY)
raw_ratings = client.fetch_all_ratings(USER_ID)
# Transform to normalised format
normalised = [
{
"item_id": r["item_id"],
"score": OpenClawClient.normalise_score(r["score"]),
"timestamp": r["timestamp"]
}
for r in raw_ratings
]
print(f"Fetched {len(normalised)} normalised ratings for user {USER_ID}")
Replace YOUR_OPENCLAW_API_KEY with the token you obtain from the OpenClaw hosting page. The client returns a list of dictionaries ready for the next stage—profile construction.
4. Building User Preference Profiles
A preference profile is a compact vector that captures a user’s taste across content dimensions (topic, format, sentiment, etc.). The simplest approach is to aggregate normalised scores per topic tag. More sophisticated pipelines can feed the raw rating stream into a collaborative‑filtering model.
4.1. Tag‑Based Aggregation (Fast‑Track)
Assuming each Moltbook item carries a list of tags (e.g., ["AI", "Productivity"]), we can compute a weighted average per tag:
from collections import defaultdictdef build_tag_profile(ratings, tag_lookup):
tag_scores = defaultdict(list)
for r in ratings:
item_tags = tag_lookup.get(r["item_id"], [])
for tag in item_tags:
tag_scores[tag].append(r["score"])
# Compute mean score per tag
profile = {tag: sum(scores)/len(scores) for tag, scores in tag_scores.items()}
return profile
# Example tag lookup (normally fetched from Moltbook DB)
TAG_LOOKUP = {
"item_001": ["AI", "Machine Learning"],
"item_002": ["Productivity"],
# …
}
profile = build_tag_profile(normalised, TAG_LOOKUP)
print(profile)
The resulting profile dictionary might look like {'AI': 0.84, 'Productivity': 0.62}, indicating a stronger affinity for AI‑centric content.
4.2. Matrix Factorisation (Scalable for Millions)
For large‑scale deployments, consider a lightweight matrix factorisation library such as implicit or lightfm. The workflow:
- Encode
(user_id, item_id, score)triples into a sparse matrix. - Train an alternating‑least‑squares (ALS) model.
- Extract the user latent vector as the preference profile.
The vector can be stored in Redis or a dedicated feature store and later merged with Moltbook’s existing relevance scores.
5. Integrating Profiles into Moltbook Feed Algorithm
Moltbook’s default feed ranking is a weighted sum of recency, global popularity, and content score. To inject personalisation, we add a preference boost term:
final_score = α·recency + β·popularity + γ·content_score + δ·preference_score
Where preference_score is derived from the user’s profile:
- Lookup the item’s tags.
- Average the corresponding tag weights from the profile.
- Scale by
δ(typically 0.1‑0.3) to avoid overwhelming the base algorithm.
5.1. Sample Scoring Function (Python)
def preference_score(item_id, profile, tag_lookup):
tags = tag_lookup.get(item_id, [])
if not tags:
return 0.0
scores = [profile.get(tag, 0.0) for tag in tags]
return sum(scores) / len(scores)def final_feed_score(item, base_score, profile, tag_lookup, delta=0.2):
pref = preference_score(item["id"], profile, tag_lookup)
return base_score + delta * pref
Integrate this function into Moltbook’s recommendation micro‑service (usually a Flask or FastAPI endpoint). The service should:
- Fetch the user’s latest profile from Redis.
- Compute
final_feed_scorefor each candidate item. - Return the top‑N items sorted by the new score.
6. Step‑by‑Step Integration Guide
Follow these nine steps to bring personalisation live:
- Provision OpenClaw credentials. Generate an API key from the OpenClaw hosting page and store it securely (e.g., Vault or AWS Secrets Manager).
- Deploy the Python client. Add
openclaw_client.pyto your service repository and installrequestsviapip. - Schedule nightly rating sync. Use a cron job or serverless scheduler (AWS EventBridge) to pull fresh ratings for active users.
- Build the tag lookup table. Export Moltbook’s item‑to‑tag mapping to a key‑value store (Redis hash or DynamoDB).
- Generate preference profiles. Run the aggregation script (tag‑based or matrix factorisation) and persist the resulting vectors with a TTL of 24 hours.
- Extend the feed service. Import
preference_scoreandfinal_feed_scoreinto the ranking pipeline. - Expose a personalised endpoint. Create
/feed/personalised?user_id=…that returns the top‑10 items after applying the boost. - Monitor key metrics. Track CTR, dwell time, and “rating‑to‑feed latency” to ensure the boost improves engagement without adding noticeable latency.
- Iterate & optimise. Adjust the
δweight, experiment with hybrid models (content‑based + collaborative), and A/B test against the baseline feed.
“Personalisation is a continuous loop: collect signals → update profiles → re‑rank → measure impact.” – UBOS Engineering Team
7. Conclusion
Personalising Moltbook feeds with OpenClaw plugin ratings is a pragmatic way to turn raw user interactions into a measurable boost in relevance. By leveraging the lightweight Python client, a deterministic tag‑based profile, and a simple scoring extension, developers can ship a customised experience in days rather than weeks.
Remember to keep the data pipeline fresh, respect rate limits, and continuously validate the impact with real‑world metrics. When you master this loop, Moltbook becomes not just a content aggregator, but a truly personal discovery engine.
Ready to try it?
Visit the OpenClaw hosting page to obtain your API key and start building personalised feeds today.