HackerNews Topic Brief

    # 3a. Relevance check (MapOver)
    b.vertex("map_relevance").map_over("titles", "title") \
        .vertex("relevant").op("AIBoolOp").params({
            "predicate": f"Is this HackerNews story title actually about the topic {query!r}? Respond true or false.",
        }).input("input", "title").output("result", "is_relevant") \
        .collect_into("is_relevant", "relevant_flags")
        
    # 3b. Label classification (MapOver)
    b.vertex("map_classify").map_over("titles", "title") \
        .vertex("classify").op("AIClassifyMultiLabelOp").params({
            "categories": "technical,business,policy,human_interest,other",
        }).input("input", "title").output("result", "labels") \
        .collect_into("labels", "label_lists")

  // Stage 2a — per-story relevance check (map).
  const relevantFlags = wf.map(
    titles,
    (title, ctx) => ai.aiBool(title, { predicate: `Is this story relevant?` }, ctx),
    { name: "map_relevance" }
  );

  // Stage 2b — per-story multi-label classification (map).
  const labelLists = wf.map(
    titles,
    (title, ctx) => ai.aiClassifyMultiLabel(title, { categories: RELEVANCE_CATEGORIES }, ctx),
    { name: "map_classify" }
  );

@register_operator("FilterAndFlattenOp")
class FilterAndFlattenOp(Operator, BaseModel):
    titles: Input = []
    relevant_flags: Input = []
    label_lists: Input = []
    kept_titles: Output = []
    all_labels: Output = []

    async def run(self, ctx: Any) -> None:
        n = min(len(self.titles), len(self.relevant_flags), len(self.label_lists))
        
        self.kept_titles = []
        self.all_labels = []
        
        for i in range(n):
            if self.relevant_flags[i]:
                self.kept_titles.append(self.titles[i])
                labels = self.label_lists[i]
                if isinstance(labels, list):
                    self.all_labels.extend(labels)
                elif isinstance(labels, str) and labels:
                    self.all_labels.extend([s.strip() for s in labels.split(",") if s.strip()])

  // Stage 3 — zip and filter.
  const rows = wf.zip([titles, relevantFlags, labelLists], { name: "zip_stories" });
  const filtered = wf.op({ rows }, ({ rows }) => {
    const keptTitles: string[] = [];
    const allLabels: string[] = [];
    for (const [title, relevant, labels] of rows) {
      if (!relevant) continue;
      keptTitles.push(title);
      allLabels.push(...labels);
    }
    return { keptTitles, allLabels };
  }, { name: "filter_flatten" });

    # 5. Dominant Category
    b.vertex("dominant_cat").op("DominantCategoryOp").input("all_labels", "all_labels").output("dominant", "dominant")
    
    # 6. AI Style Selector
    b.vertex("mode_select").op("ModeSelectOp").params({
        "categories": "technical_brief,business_brief,policy_brief",
    }).input("input", "dominant").output("result", "brief_style")

  // Stage 4 — dominant category.
  const dominant = wf.op({ filtered }, ({ filtered }) => {
    const counts = new Map();
    for (const label of filtered.allLabels) {
      counts.set(label, (counts.get(label) ?? 0) + 1);
    }
    let best = "technical";
    let max = 0;
    for (const [l, c] of counts) {
      if (c > max) { max = c; best = l; }
    }
    return best;
  }, { name: "dominant_cat" });

  // Stage 5 — AI style selector.
  const briefStyle = wf.ai.modeSelect(dominant, { categories: STYLE_CATEGORIES, name: "mode_select" });

    # 7. Brief Style Lanes
    lanes = [
        ("technical", "style_is_technical_brief", "summarize the following HackerNews story titles as a technical engineering newsletter: write one concise bullet point per story and group related stories by sub-topic"),
        ("business", "style_is_business_brief", "summarize the following HackerNews story titles as an executive business brief: write a 3-sentence overview then a bulleted impact list"),
        ("policy", "style_is_policy_brief", "summarize the following HackerNews story titles as a policy memo: list legislative items, affected parties, and likely timeline"),
    ]
    
    for name, cond, op_text in lanes:
        b.vertex(f"{name}_lane").op("AISummarizeOp") \
            .condition(cond).condition_input("brief_style") \
            .params({"operation": op_text}) \
            .input("input", "kept_titles") \
            .output("result", f"{name}_text")

  // Stage 6 — three brief-style lanes.
  const keptTitles = wf.op({ filtered }, ({ filtered }) => filtered.keptTitles, { name: "kept_titles" });
  const lanes = STYLE_CATEGORIES.map((style) =>
    wf.ai.summarize(keptTitles, {
      operation: LANE_OPS[style] as string,
      name: style,
      gate: { briefStyle },
      condition: (_in, { briefStyle }) => briefStyle === style,
    })
  );

export CLAUDE_API_KEY=

# Live API
python examples/hn_topic_brief/main.py --query golang
python examples/hn_topic_brief/main.py --query kubernetes

export CLAUDE_API_KEY=

# Live API
npx tsx examples/hn_topic_brief/index.ts --query golang
npx tsx examples/hn_topic_brief/index.ts --query kubernetes

# Speak MCP over stdin/stdout instead of running once
python examples/hn_topic_brief/main.py --mcp

# Speak MCP over stdin/stdout instead of running once
npx tsx examples/hn_topic_brief/index.ts --mcp

{
  "mcpServers": {
    "hn-topic-brief": {
      "command": "python",
      "args": ["examples/hn_topic_brief/main.py", "--mcp"]
    }
  }
}

{
  "mcpServers": {
    "hn-topic-brief": {
      "command": "npx",
      "args": ["tsx", "examples/hn_topic_brief/index.ts", "--mcp"]
    }
  }
}