DEV Community

shashank ms
shashank ms

Posted on

Curated List of LLM Community Resources

#learnai #oxlo #ai

I built a small CLI tool that turns a messy pile of LLM links into a categorized weekly digest. It runs entirely through Oxlo.ai's API and costs a flat fee per request, so I can throw long context windows at it without watching token meters spin. If you maintain an internal knowledge base or a team newsletter, this saves hours of manual sorting.

What you'll need

Step 1: Prepare the raw resource feed

I start with a JSON file containing uncurated links and short descriptions. This is the messy input the agent will clean up.

import json
from pathlib import Path

RAW_FEED = [
    {
        "url": "https://github.com/QwenLM/Qwen3",
        "note": "Qwen3 release: 30B model with strong agentic capabilities and multilingual support."
    },
    {
        "url": "https://arxiv.org/abs/2501.12345",
        "note": "Paper on efficient MoE inference for long-context workloads."
    },
    {
        "url": "https://huggingface.co/blog/llama3-3-70b",
        "note": "Llama 3.3 70B fine-tuning guide and evaluation results."
    },
    {
        "url": "https://github.com/karpathy/minGPT",
        "note": "Minimal PyTorch re-implementation of GPT for educational purposes."
    }
]

feed_path = Path("raw_feed.json")
feed_path.write_text(json.dumps(RAW_FEED, indent=2))
print(f"Wrote {len(RAW_FEED)} entries to {feed_path}")

Step 2: Configure the Oxlo.ai client and system prompt

I use the OpenAI SDK as a drop-in replacement pointed at Oxlo.ai. The system prompt tells the model exactly how to curate.

from openai import OpenAI

client = OpenAI(base_url="https://api.oxlo.ai/v1", api_key="YOUR_OXLO_API_KEY")

SYSTEM_PROMPT = """You are a technical curator for an LLM developer community.
Your job is to read a list of raw resources and produce a structured markdown digest.

Rules:
- Group items into exactly these categories: Models, Research, Tutorials, Tools.
- For each item, output a bullet with the title as a markdown link, followed by a one-sentence description.
- If a category has no items, omit it.
- Do not add fluff. Use plain, precise language.
- Output only the markdown digest, nothing else."""

Step 3: Load and chunk the feed

Since I might have dozens of links, I batch them into groups of ten to keep each request focused and fast.

import json
from pathlib import Path

def load_feed(path="raw_feed.json"):
    data = Path(path).read_text()
    return json.loads(data)

def chunk_feed(entries, size=10):
    for i in range(0, len(entries), size):
        yield entries[i:i + size]

feed = load_feed()
print(f"Loaded {len(feed)} entries in {len(list(chunk_feed(feed)))} chunk(s)")

Step 4: Build the curation agent

This function formats a chunk as a numbered list, sends it to Oxlo.ai, and returns the markdown. I use Llama 3.3 70B because it follows formatting instructions reliably.

def curate_chunk(chunk):
    lines = []
    for idx, entry in enumerate(chunk, 1):
        lines.append(f"{idx}. URL: {entry['url']}\nNote: {entry['note']}")
    user_message = "Curate the following raw resources into the specified markdown digest:\n\n" + "\n".join(lines)

    response = client.chat.completions.create(
        model="llama-3.3-70b",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_message},
        ],
        temperature=0.3,
    )
    return response.choices[0].message.content

# Test on the first chunk
first_chunk = next(chunk_feed(feed))
preview = curate_chunk(first_chunk)
print(preview)

Step 5: Assemble and write the final digest

I collect markdown from all chunks, add a header with the current date, and write a single file. Because Oxlo.ai uses request-based pricing, I do not worry about the size of the system prompt or the chunky JSON I feed in. See https://oxlo.ai/pricing for details.

from datetime import datetime

def build_digest(feed_path="raw_feed.json", out_path="llm_digest.md"):
    entries = load_feed(feed_path)
    chunks = list(chunk_feed(entries))
    sections = [curate_chunk(c) for c in chunks]

    header = f"# LLM Community Digest - {datetime.utcnow().strftime('%Y-%m-%d')}\n\n"
    body = "\n\n".join(sections)
    Path(out_path).write_text(header + body)
    print(f"Digest written to {out_path} ({len(chunks)} request(s) to Oxlo.ai)")

build_digest()

Run it

Running the script processes every chunk and writes the digest. With only four sample entries, it completes in a single request.

$ python curator.py
Digest written to llm_digest.md (1 request(s) to Oxlo.ai)

The generated llm_digest.md looks like this:

# LLM Community Digest - 2025-06-24

### Models
- [QwenLM/Qwen3](https://github.com/QwenLM/Qwen3): 30B model with strong agentic capabilities and multilingual support.
- [Llama 3.3 70B](https://huggingface.co/blog/llama3-3-70b): Fine-tuning guide and evaluation results for the general-purpose flagship.

### Research
- [Efficient MoE Inference](https://arxiv.org/abs/2501.12345): Paper on efficient MoE inference for long-context workloads.

### Tutorials
- [minGPT](https://github.com/karpathy/minGPT): Minimal PyTorch re-implementation of GPT for educational purposes.

Wrap-up

This curator is easy to extend. I plan to wire it to the Hacker News and arXiv RSS feeds so it runs on a schedule and produces a living resource list. Swapping in a different Oxlo.ai model, such as Qwen 3 32B or Kimi K2.6, is a single line change if I need stronger multilingual or vision reasoning down the road.

Top comments (0)