@lightcone-ai/daemon 0.11.0 → 0.13.0

package/mcp-servers/official/image-search-licensed/index.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const SOURCE_RISK = 'normal';
+
+const PEXELS_API_KEY = String(process.env.PEXELS_API_KEY ?? '').trim();
+const PEXELS_BASE_URL = String(process.env.PEXELS_BASE_URL ?? 'https://api.pexels.com/v1').trim();
+
+const UNSPLASH_ACCESS_KEY = String(process.env.UNSPLASH_ACCESS_KEY ?? '').trim();
+const UNSPLASH_BASE_URL = String(process.env.UNSPLASH_BASE_URL ?? 'https://api.unsplash.com').trim();
+
+const REQUEST_TIMEOUT_MS = clampInt(process.env.IMAGE_SEARCH_TIMEOUT_MS, 1000, 60000, 15000);
+
+const PEXELS_LICENSE = Object.freeze({
+  name: 'Pexels License',
+  url: 'https://www.pexels.com/license/',
+});
+
+const UNSPLASH_LICENSE = Object.freeze({
+  name: 'Unsplash License',
+  url: 'https://unsplash.com/license',
+});
+
+function clampInt(value, min, max, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(min, Math.min(max, Math.trunc(n)));
+}
+
+function hashString(text) {
+  let hash = 2166136261;
+  const raw = String(text ?? '');
+  for (let i = 0; i < raw.length; i += 1) {
+    hash ^= raw.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function parseJsonMaybe(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeOrientation(raw) {
+  const value = String(raw ?? 'auto').trim().toLowerCase();
+  if (value === 'landscape' || value === 'portrait' || value === 'square') return value;
+  return 'auto';
+}
+
+function buildUrl(baseUrl, route, query = {}) {
+  const normalizedBase = String(baseUrl ?? '').trim().replace(/\/$/, '');
+  const path = route.startsWith('/') ? route : `/${route}`;
+  const url = new URL(`${normalizedBase}${path}`);
+
+  for (const [key, value] of Object.entries(query)) {
+    if (value === null || value === undefined) continue;
+    const text = String(value).trim();
+    if (!text) continue;
+    url.searchParams.set(key, text);
+  }
+
+  return url;
+}
+
+async function fetchJson(url, headers = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const res = await fetch(url.toString(), {
+      method: 'GET',
+      headers,
+      signal: controller.signal,
+    });
+    const text = await res.text();
+    const payload = parseJsonMaybe(text) ?? { raw: text.slice(0, 500) };
+    if (!res.ok) {
+      throw new Error(`http_${res.status}:${payload?.error ?? payload?.errors?.[0] ?? text.slice(0, 200)}`);
+    }
+    return payload;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function searchPexels({ query, limit, page, orientation }) {
+  const payload = await fetchJson(
+    buildUrl(PEXELS_BASE_URL, '/search', {
+      query,
+      per_page: limit,
+      page,
+      orientation: orientation === 'auto' ? null : orientation,
+    }),
+    {
+      Authorization: PEXELS_API_KEY,
+    }
+  );
+
+  const photos = Array.isArray(payload?.photos) ? payload.photos : [];
+  return photos.map((photo, index) => ({
+    id: String(photo?.id ?? `pexels-${index + 1}`),
+    title: String(photo?.alt ?? '').trim() || String(photo?.photographer ?? '').trim() || query,
+    preview_url: String(photo?.src?.large ?? photo?.src?.medium ?? '').trim(),
+    full_url: String(photo?.src?.original ?? photo?.src?.large2x ?? '').trim(),
+    thumbnail_url: String(photo?.src?.tiny ?? '').trim(),
+    source_page_url: String(photo?.url ?? '').trim(),
+    author: String(photo?.photographer ?? '').trim() || null,
+    author_url: String(photo?.photographer_url ?? '').trim() || null,
+    width: Number.isFinite(Number(photo?.width)) ? Number(photo.width) : null,
+    height: Number.isFinite(Number(photo?.height)) ? Number(photo.height) : null,
+    provider: 'pexels',
+    license: PEXELS_LICENSE.name,
+    license_url: PEXELS_LICENSE.url,
+    license_verified: true,
+    source_risk: SOURCE_RISK,
+  }));
+}
+
+async function searchUnsplash({ query, limit, page, orientation }) {
+  const unsplashOrientation = orientation === 'square' ? 'squarish' : orientation;
+  const payload = await fetchJson(
+    buildUrl(UNSPLASH_BASE_URL, '/search/photos', {
+      query,
+      per_page: limit,
+      page,
+      orientation: unsplashOrientation === 'auto' ? null : unsplashOrientation,
+      content_filter: 'high',
+    }),
+    {
+      Authorization: `Client-ID ${UNSPLASH_ACCESS_KEY}`,
+      'Accept-Version': 'v1',
+    }
+  );
+
+  const photos = Array.isArray(payload?.results) ? payload.results : [];
+  return photos.map((photo, index) => ({
+    id: String(photo?.id ?? `unsplash-${index + 1}`),
+    title: String(photo?.alt_description ?? photo?.description ?? '').trim() || query,
+    preview_url: String(photo?.urls?.small ?? '').trim(),
+    full_url: String(photo?.urls?.full ?? photo?.urls?.regular ?? '').trim(),
+    thumbnail_url: String(photo?.urls?.thumb ?? '').trim(),
+    source_page_url: String(photo?.links?.html ?? '').trim(),
+    author: String(photo?.user?.name ?? '').trim() || null,
+    author_url: String(photo?.user?.links?.html ?? '').trim() || null,
+    width: Number.isFinite(Number(photo?.width)) ? Number(photo.width) : null,
+    height: Number.isFinite(Number(photo?.height)) ? Number(photo.height) : null,
+    provider: 'unsplash',
+    license: UNSPLASH_LICENSE.name,
+    license_url: UNSPLASH_LICENSE.url,
+    license_verified: true,
+    source_risk: SOURCE_RISK,
+  }));
+}
+
+function buildMockResults({ query, limit }) {
+  const count = clampInt(limit, 1, 20, 8);
+  const items = [];
+  for (let i = 0; i < count; i += 1) {
+    const provider = i % 2 === 0 ? 'pexels' : 'unsplash';
+    const seed = hashString(`${query}|${provider}|${i + 1}`);
+    const license = provider === 'pexels' ? PEXELS_LICENSE : UNSPLASH_LICENSE;
+    items.push({
+      id: `mock-${provider}-${i + 1}`,
+      title: `${query} ${provider} reference ${i + 1}`,
+      preview_url: `https://picsum.photos/seed/licensed-${seed}/720/480`,
+      full_url: `https://picsum.photos/seed/licensed-${seed}/1600/1200`,
+      thumbnail_url: `https://picsum.photos/seed/licensed-${seed}/320/240`,
+      source_page_url: provider === 'pexels'
+        ? `https://www.pexels.com/search/${encodeURIComponent(query)}/`
+        : `https://unsplash.com/s/photos/${encodeURIComponent(query)}`,
+      author: null,
+      author_url: null,
+      width: 1600,
+      height: 1200,
+      provider,
+      license: `${license.name} (fallback)`,
+      license_url: license.url,
+      license_verified: false,
+      source_risk: SOURCE_RISK,
+    });
+  }
+  return items;
+}
+
+function dedupeItems(items) {
+  const output = [];
+  const seen = new Set();
+  for (const item of items) {
+    const key = String(item?.full_url ?? item?.source_page_url ?? item?.id ?? '').trim();
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    output.push(item);
+  }
+  return output;
+}
+
+function providerAttemptOrder(requestedProvider) {
+  const requested = String(requestedProvider ?? 'auto').trim().toLowerCase();
+  if (requested === 'pexels') return ['pexels'];
+  if (requested === 'unsplash') return ['unsplash'];
+  return ['pexels', 'unsplash'];
+}
+
+async function searchLicensedImages(input) {
+  const query = String(input.query ?? '').trim();
+  if (!query) throw new Error('query_required');
+
+  const limit = clampInt(input.limit, 1, 20, 8);
+  const page = clampInt(input.page, 1, 50, 1);
+  const orientation = normalizeOrientation(input.orientation);
+  const requestedProvider = String(input.provider ?? 'auto').trim().toLowerCase() || 'auto';
+
+  const providers = providerAttemptOrder(requestedProvider);
+  const attempted = [];
+  const errors = [];
+  let items = [];
+
+  for (const provider of providers) {
+    attempted.push(provider);
+
+    if (provider === 'pexels' && !PEXELS_API_KEY) {
+      errors.push('pexels_missing_api_key');
+      continue;
+    }
+    if (provider === 'unsplash' && !UNSPLASH_ACCESS_KEY) {
+      errors.push('unsplash_missing_access_key');
+      continue;
+    }
+
+    try {
+      const result = provider === 'pexels'
+        ? await searchPexels({ query, limit, page, orientation })
+        : await searchUnsplash({ query, limit, page, orientation });
+      items = items.concat(result);
+    } catch (error) {
+      errors.push(`${provider}_error:${error.message}`);
+    }
+  }
+
+  items = dedupeItems(items).slice(0, limit);
+
+  if (items.length === 0) {
+    items = buildMockResults({ query, limit });
+    return {
+      query,
+      provider_requested: requestedProvider,
+      provider_used: 'mock',
+      providers_attempted: attempted,
+      fallback_reason: errors.length > 0 ? errors[0] : 'no_provider_available',
+      total: items.length,
+      items,
+      source_risk: SOURCE_RISK,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  const providersUsed = [...new Set(items.map(item => item.provider))];
+  return {
+    query,
+    provider_requested: requestedProvider,
+    provider_used: providersUsed.join('+'),
+    providers_attempted: attempted,
+    fallback_reason: errors.length > 0 ? errors[0] : null,
+    total: items.length,
+    items,
+    source_risk: SOURCE_RISK,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+function toolError(error) {
+  return {
+    isError: true,
+    content: [{ type: 'text', text: `Error: ${error.message}` }],
+  };
+}
+
+const server = new McpServer({ name: 'official-image-search-licensed', version: '0.1.0' });
+
+server.tool(
+  'image_search_licensed',
+  'Search licensed images from Pexels/Unsplash and return license metadata with source_risk=normal.',
+  {
+    query: z.string().min(1).describe('Search keyword, e.g. 科技蓝色封面。'),
+    provider: z.enum(['auto', 'pexels', 'unsplash']).optional().describe('Image provider selection.'),
+    limit: z.number().int().min(1).max(20).optional().describe('Max items, default 8.'),
+    page: z.number().int().min(1).max(50).optional().describe('Page number for provider APIs.'),
+    orientation: z.enum(['auto', 'landscape', 'portrait', 'square']).optional().describe('Optional orientation hint.'),
+  },
+  async (input) => {
+    try {
+      const payload = await searchLicensedImages(input);
+      return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+      };
+    } catch (error) {
+      return toolError(error);
+    }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('[official-image-search-licensed] MCP Server started');

package/mcp-servers/official/image-search-licensed/manifest.json

@@ -0,0 +1,18 @@
+{
+  "id": "image-search-licensed",
+  "name": "Official Image Search Licensed MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "image_search_licensed", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "image_search_licensed",
+    "arguments": {
+      "query": "蓝色科技背景",
+      "provider": "auto",
+      "limit": 3
+    }
+  }
+}

package/mcp-servers/official/keyword-research/index.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { startFixtureServer } from '../../official-common/server.js';
+
+const FIXTURE_META = Object.freeze({
+  mode: 'fixture',
+  as_of: '2026-04-29',
+  capability: 'keyword-research',
+  disclaimer: 'Keyword stats are deterministic fixtures for planning rehearsal, not live platform telemetry.',
+});
+
+const PLATFORM_ALIAS = Object.freeze({
+  xiaohongshu: 'xhs',
+  redbook: 'xhs',
+  douyin: 'douyin',
+  tiktok_cn: 'douyin',
+  wechat: 'wechat-mp',
+  wechat_mp: 'wechat-mp',
+  wechatmp: 'wechat-mp',
+  gzh: 'wechat-mp',
+  '\u516c\u4f17\u53f7': 'wechat-mp',
+  all: 'all',
+});
+
+const PLATFORM_HINTS = Object.freeze({
+  all: ['\u8d8b\u52bf', '\u6848\u4f8b', '\u6a21\u677f'],
+  xhs: ['\u5c0f\u7ea2\u4e66\u7b14\u8bb0', '\u6807\u9898\u5199\u6cd5', '\u5c01\u9762\u7b56\u7565'],
+  douyin: ['\u77ed\u89c6\u9891\u811a\u672c', '\u5b8c\u64ad\u7387', '\u9996\u5c4f\u5f00\u573a'],
+  'wechat-mp': ['\u516c\u4f17\u53f7\u957f\u6587', '\u8f6c\u5316\u6f0f\u6597', '\u79c1\u57df\u627f\u63a5'],
+});
+
+const INTENT_BRANCHES = Object.freeze([
+  {
+    id: 'pain_point',
+    suffix: '\u75db\u70b9',
+    weight: 1.0,
+    child_templates: ['{seed} \u5e38\u89c1\u95ee\u9898', '{seed} \u4e3a\u4ec0\u4e48\u6ca1\u6548\u679c', '{seed} \u8bef\u533a'],
+  },
+  {
+    id: 'tutorial',
+    suffix: '\u6559\u7a0b',
+    weight: 0.94,
+    child_templates: ['{seed} \u5165\u95e8', '{seed} \u64cd\u4f5c\u6b65\u9aa4', '{seed} \u6267\u884c\u6e05\u5355'],
+  },
+  {
+    id: 'template',
+    suffix: '\u6a21\u677f',
+    weight: 0.9,
+    child_templates: ['{seed} \u6587\u6848\u6a21\u677f', '{seed} \u9009\u9898\u6a21\u677f', '{seed} \u8868\u683c\u6a21\u677f'],
+  },
+  {
+    id: 'case_study',
+    suffix: '\u6848\u4f8b',
+    weight: 0.88,
+    child_templates: ['{seed} \u6210\u529f\u6848\u4f8b', '{seed} \u5931\u8d25\u590d\u76d8', '{seed} A/B \u6d4b\u8bd5'],
+  },
+  {
+    id: 'comparison',
+    suffix: '\u5bf9\u6bd4',
+    weight: 0.84,
+    child_templates: ['{seed} \u5de5\u5177\u5bf9\u6bd4', '{seed} \u65b9\u6cd5\u5bf9\u6bd4', '{seed} \u54ea\u4e2a\u66f4\u597d'],
+  },
+]);
+
+function normalizePlatform(value) {
+  const raw = String(value ?? '').trim().toLowerCase();
+  if (!raw) return 'all';
+  return PLATFORM_ALIAS[raw] ?? raw;
+}
+
+function clampInt(value, min, max, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(min, Math.min(max, Math.trunc(n)));
+}
+
+function deterministicRatio(seed, salt) {
+  const text = `${seed}#${salt}`;
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967295;
+}
+
+function computeMetrics({ keyword, seedKeyword, depth, intentWeight }) {
+  const base = deterministicRatio(keyword, seedKeyword);
+  const searchVolume = Math.round((2200 + base * 8200) * (1 - depth * 0.18) * intentWeight);
+  const competitionRaw = 0.28 + deterministicRatio(seedKeyword, keyword) * 0.58 + depth * 0.06;
+  const competition = Math.max(0.1, Math.min(0.95, Number(competitionRaw.toFixed(2))));
+  const relevanceRaw = 0.62 + deterministicRatio(`${seedKeyword}:${keyword}`, depth) * 0.33 - depth * 0.05;
+  const relevance = Math.max(0.4, Math.min(1, Number(relevanceRaw.toFixed(2))));
+
+  return {
+    search_volume: Math.max(120, searchVolume),
+    competition,
+    relevance,
+  };
+}
+
+function computePriority(metrics) {
+  const volumeScore = Math.min(100, 20 + metrics.search_volume / 120);
+  const competitionScore = (1 - metrics.competition) * 100;
+  const relevanceScore = metrics.relevance * 100;
+  const score = Math.round(volumeScore * 0.45 + competitionScore * 0.35 + relevanceScore * 0.2);
+
+  let tier = 'P4';
+  if (score >= 82) tier = 'P1';
+  else if (score >= 68) tier = 'P2';
+  else if (score >= 55) tier = 'P3';
+
+  return { score, tier };
+}
+
+function buildNode({ keyword, seedKeyword, depth, intent, intentWeight }) {
+  const metrics = computeMetrics({ keyword, seedKeyword, depth, intentWeight });
+  const priority = computePriority(metrics);
+  return {
+    keyword,
+    depth,
+    intent,
+    metrics,
+    priority_score: priority.score,
+    priority_tier: priority.tier,
+    children: [],
+  };
+}
+
+function renderTemplate(template, seedKeyword) {
+  return String(template ?? '').replaceAll('{seed}', seedKeyword);
+}
+
+function uniqueKeywords(items) {
+  const seen = new Set();
+  const output = [];
+  for (const item of items) {
+    const key = String(item ?? '').trim();
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    output.push(key);
+  }
+  return output;
+}
+
+function flattenTree(root) {
+  const output = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    output.push(current);
+    for (let i = current.children.length - 1; i >= 0; i -= 1) {
+      stack.push(current.children[i]);
+    }
+  }
+  return output;
+}
+
+function buildKeywordTree({ seedKeyword, platform, maxDepth, branchLimit }) {
+  const normalizedSeed = String(seedKeyword).trim();
+  const hints = PLATFORM_HINTS[platform] ?? PLATFORM_HINTS.all;
+
+  const root = buildNode({
+    keyword: normalizedSeed,
+    seedKeyword: normalizedSeed,
+    depth: 0,
+    intent: 'seed',
+    intentWeight: 1.04,
+  });
+
+  if (maxDepth < 1) return root;
+
+  const selectedBranches = INTENT_BRANCHES.slice(0, branchLimit);
+
+  for (const branch of selectedBranches) {
+    const branchKeyword = `${normalizedSeed} ${branch.suffix}`;
+    const branchNode = buildNode({
+      keyword: branchKeyword,
+      seedKeyword: normalizedSeed,
+      depth: 1,
+      intent: branch.id,
+      intentWeight: branch.weight,
+    });
+
+    if (maxDepth >= 2) {
+      const baseChildren = branch.child_templates.map((template) => renderTemplate(template, normalizedSeed));
+      const hintChildren = hints.map((hint) => `${normalizedSeed} ${hint}`);
+      const childKeywords = uniqueKeywords([...baseChildren, ...hintChildren]).slice(0, 3);
+
+      for (const childKeyword of childKeywords) {
+        branchNode.children.push(buildNode({
+          keyword: childKeyword,
+          seedKeyword: normalizedSeed,
+          depth: 2,
+          intent: `${branch.id}_longtail`,
+          intentWeight: Math.max(0.65, branch.weight - 0.1),
+        }));
+      }
+    }
+
+    root.children.push(branchNode);
+  }
+
+  return root;
+}
+
+await startFixtureServer({
+  serverId: 'keyword-research',
+  serverName: 'official-keyword-research',
+  toolName: 'keyword_research',
+  toolDescription: 'Generate fixture-mode keyword tree with priority ranking using seed keyword and platform context.',
+  inputSchema: {
+    seed_keyword: z.string().min(1).describe('Seed keyword/topic, e.g. \"\u5c0f\u7ea2\u4e66\u8d77\u53f7\".'),
+    platform: z.enum(['all', 'xhs', 'douyin', 'wechat-mp']).optional()
+      .describe('Optional platform hint for long-tail expansion.'),
+    locale: z.string().optional().describe('Locale hint, default zh-CN.'),
+    max_depth: z.number().int().min(1).max(2).optional()
+      .describe('Tree depth, default 2.'),
+    branch_limit: z.number().int().min(2).max(5).optional()
+      .describe('Max first-level branches, default 4.'),
+    top_k: z.number().int().min(3).max(30).optional()
+      .describe('Top K keywords in priority ranking, default 12.'),
+  },
+  handler: ({
+    seed_keyword,
+    platform = 'all',
+    locale = 'zh-CN',
+    max_depth = 2,
+    branch_limit = 4,
+    top_k = 12,
+  }) => {
+    const seedKeyword = String(seed_keyword ?? '').trim();
+    if (!seedKeyword) throw new Error('seed_keyword_required');
+
+    const normalizedPlatform = normalizePlatform(platform);
+    const normalizedLocale = String(locale ?? 'zh-CN').trim() || 'zh-CN';
+    const safeDepth = clampInt(max_depth, 1, 2, 2);
+    const safeBranchLimit = clampInt(branch_limit, 2, 5, 4);
+    const safeTopK = clampInt(top_k, 3, 30, 12);
+
+    const keywordTree = buildKeywordTree({
+      seedKeyword,
+      platform: normalizedPlatform,
+      maxDepth: safeDepth,
+      branchLimit: safeBranchLimit,
+    });
+
+    const flatNodes = flattenTree(keywordTree);
+    const ranked = flatNodes
+      .map((node) => ({
+        keyword: node.keyword,
+        depth: node.depth,
+        intent: node.intent,
+        priority_score: node.priority_score,
+        priority_tier: node.priority_tier,
+        search_volume: node.metrics.search_volume,
+        competition: node.metrics.competition,
+        relevance: node.metrics.relevance,
+      }))
+      .sort((a, b) => {
+        if (b.priority_score !== a.priority_score) return b.priority_score - a.priority_score;
+        if (b.search_volume !== a.search_volume) return b.search_volume - a.search_volume;
+        return a.keyword.localeCompare(b.keyword, 'zh-Hans-CN');
+      });
+
+    const priorityRanking = ranked.slice(0, safeTopK);
+
+    return {
+      ...FIXTURE_META,
+      seed_keyword: seedKeyword,
+      platform: normalizedPlatform,
+      locale: normalizedLocale,
+      priority_model: {
+        score_formula: '0.45*volume + 0.35*(1-competition) + 0.20*relevance',
+        tiers: {
+          P1: 'score >= 82',
+          P2: '68-81',
+          P3: '55-67',
+          P4: '< 55',
+        },
+      },
+      node_count: ranked.length,
+      keyword_tree: keywordTree,
+      priority_ranking: priorityRanking,
+      related_keywords: priorityRanking
+        .map((item) => item.keyword)
+        .filter((item) => item !== seedKeyword)
+        .slice(0, 12),
+      generated_at: new Date().toISOString(),
+    };
+  },
+});

package/mcp-servers/official/keyword-research/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "keyword-research",
+  "name": "Official Keyword Research MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "keyword_research", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "keyword_research",
+    "arguments": {
+      "seed_keyword": "\u5c0f\u7ea2\u4e66\u8d77\u53f7",
+      "platform": "xhs",
+      "branch_limit": 3,
+      "top_k": 8
+    }
+  }
+}