Maintaining a curated list of LLM community resources is tedious. In this tutorial, I will build a Resource Curator Agent that ingests raw links and notes, then categorizes and summarizes them into a structured markdown digest using Oxlo.ai. The agent runs entirely through the OpenAI-compatible API, so you can drop it into any existing pipeline.
What you'll need
- Python 3.10 or newer.
- An Oxlo.ai API key from https://portal.oxlo.ai.
- The OpenAI SDK:
pip install openai.
Step 1: Scaffold the project and configure the Oxlo.ai client
I start by importing the SDK and pointing the base URL at Oxlo.ai. Because the platform is fully OpenAI SDK compatible, the only changes are the endpoint and the model identifier.
from openai import OpenAI
client = OpenAI(base_url="https://api.oxlo.ai/v1", api_key="YOUR_OXLO_API_KEY")
MODEL = "llama-3.3-70b"Step 2: Define the curator system prompt
The system prompt acts as a schema contract. It forces the model to return a flat JSON array and defines exact categories that map to common LLM practitioner needs.
SYSTEM_PROMPT = """You are a technical curator for LLM practitioners.
You receive a raw list of community resources. For each resource, produce a JSON object with these fields:
- title: a concise, accurate name.
- url: the link if provided, otherwise null.
- category: one of [LLMs & Reasoning, Code & Agents, Vision, Image Generation, Audio, Embeddings, Object Detection, Training, Deployment].
- summary: one sentence, max 15 words, describing what the resource does.
- relevance_score: integer 1-10 based on utility for production engineers.
Rules:
1. Output a single JSON array containing all objects.
2. Do not wrap the output in markdown code fences.
3. Skip resources that are obviously spam or completely off-topic.
4. Be strict with categories."""Step 3: Ingest raw community submissions
In production this could be a Slack export or RSS feed, but here I use a Python list of messy strings to simulate uncurated community input.
RAW_RESOURCES = [
"Awesome-LLM repo on GitHub - curated list of large language model resources https://github.com/Hannibal046/Awesome-LLM",
"New Qwen3 paper just dropped on arXiv, looks like strong multilingual reasoning benchmarks",
"Kokoro TTS is an open source text-to-speech model with 82M params, really natural sounding",
"Someone shared a guide on fine-tuning Llama with LoRA on a single GPU, very detailed walkthrough",
"YOLOv11 object detection weights are available on HuggingFace now",
"Oxlo.ai has flat per-request pricing for inference, might be cheaper for long context workloads than token-based providers",
"DeepSeek V4 Flash supports 1M context window and MoE architecture",
"Flux.1 image generation model comparison blog post",
"OpenAI SDK compatibility docs for Oxlo.ai - shows how to switch base_url",
"BGE-Large embeddings benchmark on MTEB leaderboard"
]
def format_input(resources):
return "\n".join(f"{i+1}. {r}" for i, r in enumerate(resources))
user_message = format_input(RAW_RESOURCES)
print(f"Prepared {len(RAW_RESOURCES)} resources for curation.")Step 4: Generate structured curations with JSON mode
I send the formatted batch to Oxlo.ai with JSON mode enabled. This guarantees parseable output and eliminates regex hacks on the response. Oxlo.ai's flat per-request pricing also means I can stuff a large batch into the context window without worrying about token costs scaling by input length.
import json
response = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": user_message},
],
response_format={"type": "json_object"},
temperature=0.2,
)
raw_content = response.choices[0].message.content
curated = json.loads(raw_content)
print(f"Received {len(curated)} curated items.")
print(json.dumps(curated[:2], indent=2))Step 5: Render the final markdown digest
The final step converts the structured JSON into a grouped markdown page that you can commit to a repository or publish on an internal wiki.
def render_markdown(items):
categories = {}
for item in items:
cat = item.get("category", "Uncategorized")
categories.setdefault(cat, []).append(item)
lines = ["# LLM Community Resource Digest\n"]
for cat in sorted(categories.keys()):
lines.append(f"## {cat}\n")
for item in categories[cat]:
url = item.get("url") or "No URL"
lines.append(f"- **{item['title']}** ({url})")
lines.append(f" {item['summary']} (score: {item['relevance_score']}/10)\n")
lines.append("")
return "\n".join(lines)
markdown_output = render_markdown(curated)
with open("curated_resources.md", "w", encoding="utf-8") as f:
f.write(markdown_output)
print("Wrote curated_resources.md")
print(markdown_output[:1000])Run it
Save the complete script as curator.py, export your key, and run it. Here is the expected output after processing the sample batch.
$ export OXLO_API_KEY="sk-oxlo.ai-..."
$ python curator.py
Prepared 10 resources for curation.
Received 9 curated items.
[
{
"title": "Awesome-LLM GitHub Repository",
"url": "https://github.com/Hannibal046/Awesome-LLM",
"category": "LLMs & Reasoning",
"summary": "Curated list of large language model papers and tools.",
"relevance_score": 9
},
{
"title": "Qwen3 Multilingual Reasoning Paper",
"url": null,
"category": "LLMs & Reasoning",
"summary": "New research on strong multilingual reasoning benchmarks.",
"relevance_score": 8
}
]
Wrote curated_resources.md
# LLM Community Resource Digest
## Audio
- **Kokoro TTS** (No URL)
Open source 82M parameter text-to-speech model. (score: 8/10)
## Deployment
- **Oxlo.ai Inference Pricing** (No URL)
Flat per-request pricing for long context workloads. (score: 9/10)
## Image Generation
- **Flux.1 Model Comparison** (No URL)
Blog post comparing image generation model variants. (score: 7/10)
...Wrap-up and next steps
The agent now turns noisy community chatter into a maintainable knowledge base. A concrete next step is to wire this script into a scheduled GitHub Action that polls a Slack channel or Google Form and opens a pull request with the updated digest.
Because Oxlo.ai bills per request rather than per token, you can upgrade the agent to read full READMEs or documentation pages in a single shot using long-context models like DeepSeek V4 Flash or Kimi K2.6 without costs scaling by input length. See the Oxlo.ai pricing page to compare plans.
Top comments (0)