gbanyan/novelty-seeking
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: save local changes

Browse Source
This commit is contained in:
gbanyan
2026-01-05 22:32:08 +08:00
parent bc281b8e0a
commit ec48709755
42 changed files with 5576 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
backend/app/prompts/attribute_prompt.py
View File

@@ -1,21 +1,37 @@
from typing import List, Optional, Dict
import json
DEFAULT_CATEGORIES = ["材料", "功能", "用途", "使用族群", "特性"]
CATEGORY_DESCRIPTIONS = {
"材料": "物件由什麼材料組成",
"功能": "物件能做什麼",
"用途": "物件在什麼場景使用",
"使用族群": "誰會使用這個物件",
"特性": "物件有什麼特徵",
}
from .language_config import (
LanguageType,
DEFAULT_CATEGORIES,
CATEGORY_DESCRIPTIONS,
)
def get_attribute_prompt(query: str, categories: Optional[List[str]] = None) -> str:
def get_default_categories(lang: LanguageType = "zh") -> List[str]:
return DEFAULT_CATEGORIES.get(lang, DEFAULT_CATEGORIES["zh"])
def get_category_descriptions(lang: LanguageType = "zh") -> Dict[str, str]:
return CATEGORY_DESCRIPTIONS.get(lang, CATEGORY_DESCRIPTIONS["zh"])
def get_attribute_prompt(
query: str,
categories: Optional[List[str]] = None,
lang: LanguageType = "zh"
) -> str:
"""Generate prompt with causal chain structure."""
if lang == "en":
prompt = f"""Analyze the attributes of "{query}" in a causal chain format: Materials→Functions→Usages→User Groups.
prompt = f"""分析「{query}」的屬性，以因果鏈方式呈現：材料→功能→用途→使用族群。
List 3-5 types of materials, each extending into a complete causal chain.
JSON format:
{{"name": "{query}", "children": [{{"name": "Material Name", "category": "Materials", "children": [{{"name": "Function Name", "category": "Functions", "children": [{{"name": "Usage Name", "category": "Usages", "children": [{{"name": "User Group Name", "category": "User Groups"}}]}}]}}]}}]}}
Return JSON only."""
else:
prompt = f"""分析「{query}」的屬性，以因果鏈方式呈現：材料→功能→用途→使用族群。
請列出 3-5 種材料，每種材料延伸出完整因果鏈。
@@ -27,9 +43,18 @@ JSON 格式：
return prompt
def get_step1_attributes_prompt(query: str) -> str:
"""Step 1: 生成各類別的屬性列表（平行結構）"""
return f"""/no_think
def get_step1_attributes_prompt(query: str, lang: LanguageType = "zh") -> str:
"""Step 1: Generate attribute list for each category (parallel structure)"""
if lang == "en":
return f"""/no_think
Analyze "{query}" and list attributes for the following four categories. List 3-5 common attributes for each category.
Return JSON only, in the following format:
{{"materials": ["material1", "material2", "material3"], "functions": ["function1", "function2", "function3"], "usages": ["usage1", "usage2", "usage3"], "users": ["user group1", "user group2", "user group3"]}}
Object: {query}"""
else:
return f"""/no_think
分析「{query}」，列出以下四個類別的屬性。每個類別列出 3-5 個常見屬性。
只回傳 JSON，格式如下：
@@ -45,21 +70,48 @@ def get_step2_causal_chain_prompt(
usages: List[str],
users: List[str],
existing_chains: List[dict],
chain_index: int
chain_index: int,
lang: LanguageType = "zh"
) -> str:
"""Step 2: 生成單條因果鏈"""
"""Step 2: Generate a single causal chain"""
existing_chains_text = ""
if existing_chains:
chains_list = [
f"- {c['material']} → {c['function']} → {c['usage']} → {c['user']}"
for c in existing_chains
]
existing_chains_text = f"""
if lang == "en":
if existing_chains:
chains_list = [
f"- {c['material']} → {c['function']} → {c['usage']} → {c['user']}"
for c in existing_chains
]
existing_chains_text = f"""
[Already generated causal chains, do not repeat]
{chr(10).join(chains_list)}
"""
return f"""/no_think
Generate causal chain #{chain_index} for "{query}".
[Available Materials] {', '.join(materials)}
[Available Functions] {', '.join(functions)}
[Available Usages] {', '.join(usages)}
[Available User Groups] {', '.join(users)}
{existing_chains_text}
[Rules]
1. Select one attribute from each category to form a logical causal chain
2. The causal relationship must be logical (materials determine functions, functions determine usages, usages determine user groups)
3. Do not repeat existing causal chains
Return JSON only:
{{"material": "selected material", "function": "selected function", "usage": "selected usage", "user": "selected user group"}}"""
else:
if existing_chains:
chains_list = [
f"- {c['material']} → {c['function']} → {c['usage']} → {c['user']}"
for c in existing_chains
]
existing_chains_text = f"""
【已生成的因果鏈，請勿重複】
{chr(10).join(chains_list)}
"""
return f"""/no_think
return f"""/no_think
為「{query}」生成第 {chain_index} 條因果鏈。
【可選材料】{', '.join(materials)}
@@ -76,19 +128,52 @@ def get_step2_causal_chain_prompt(
{{"material": "選擇的材料", "function": "選擇的功能", "usage": "選擇的用途", "user": "選擇的族群"}}"""
def get_flat_attribute_prompt(query: str, categories: Optional[List[str]] = None) -> str:
def get_flat_attribute_prompt(
query: str,
categories: Optional[List[str]] = None,
lang: LanguageType = "zh"
) -> str:
"""Generate prompt with flat/parallel categories (original design)."""
cats = categories if categories else DEFAULT_CATEGORIES
cats = categories if categories else get_default_categories(lang)
cat_descs = get_category_descriptions(lang)
# Build category list
category_lines = []
for cat in cats:
desc = CATEGORY_DESCRIPTIONS.get(cat, f"{cat}的相關屬性")
category_lines.append(f"- {cat}：{desc}")
desc = cat_descs.get(cat, f"Related attributes of {cat}" if lang == "en" else f"{cat}的相關屬性")
category_lines.append(f"- {cat}: {desc}")
categories_text = "\n".join(category_lines)
prompt = f"""/no_think
if lang == "en":
prompt = f"""/no_think
You are an object attribute analysis expert. Please break down the user's input object into the following attribute categories.
[Required Categories]
{categories_text}
[Important] The return format must be valid JSON, and each node must have a "name" field:
```json
{{
"name": "Object Name",
"children": [
{{
"name": "Category Name",
"children": [
{{"name": "Attribute 1"}},
{{"name": "Attribute 2"}}
]
}}
]
}}
```
Return JSON only, no other text.
User input: {query}"""
else:
prompt = f"""/no_think
你是一個物件屬性分析專家。請將用戶輸入的物件拆解成以下屬性類別。
【必須包含的類別】
@@ -123,14 +208,42 @@ def get_flat_attribute_prompt(query: str, categories: Optional[List[str]] = None
def get_step0_category_analysis_prompt(
query: str,
suggested_count: int = 3,
exclude_categories: List[str] | None = None
exclude_categories: List[str] | None = None,
lang: LanguageType = "zh"
) -> str:
"""Step 0: LLM 分析建議類別"""
exclude_text = ""
if exclude_categories:
exclude_text = f"\n【禁止使用的類別】{', '.join(exclude_categories)}（這些已經是固定類別，不要重複建議）\n"
"""Step 0: LLM analyzes and suggests categories"""
return f"""/no_think
if lang == "en":
exclude_text = ""
if exclude_categories:
exclude_text = f"\n[Forbidden Categories] {', '.join(exclude_categories)} (These are already fixed categories, do not suggest duplicates)\n"
return f"""/no_think
Analyze "{query}" and suggest {suggested_count} most suitable attribute categories to describe it.
[Common Category References] Characteristics, Shape, Color, Size, Brand, Price Range, Weight, Style, Occasion, Season, Technical Specifications
{exclude_text}
[Important]
1. Choose categories that best describe the essence of this object
2. Categories should have logical relationships
3. Do not choose overly abstract or duplicate categories
4. Must suggest creative categories different from the reference list
Return JSON only:
{{
"categories": [
{{"name": "Category1", "description": "Description1", "order": 0}},
{{"name": "Category2", "description": "Description2", "order": 1}}
]
}}
Object: {query}"""
else:
exclude_text = ""
if exclude_categories:
exclude_text = f"\n【禁止使用的類別】{', '.join(exclude_categories)}（這些已經是固定類別，不要重複建議）\n"
return f"""/no_think
分析「{query}」，建議 {suggested_count} 個最適合的屬性類別來描述它。
【常見類別參考】特性、形狀、顏色、尺寸、品牌、價格區間、重量、風格、場合、季節、技術規格
@@ -154,21 +267,35 @@ def get_step0_category_analysis_prompt(
def get_step1_dynamic_attributes_prompt(
query: str,
categories: List # List[CategoryDefinition]
categories: List, # List[CategoryDefinition]
lang: LanguageType = "zh"
) -> str:
"""動態 Step 1 - 根據類別列表生成屬性"""
# 按 order 排序並構建描述
"""Dynamic Step 1 - Generate attributes based on category list"""
# Sort by order and build description
sorted_cats = sorted(categories, key=lambda x: x.order if hasattr(x, 'order') else x.get('order', 0))
category_desc = "\n".join([
f"- {cat.name if hasattr(cat, 'name') else cat['name']}: {cat.description if hasattr(cat, 'description') else cat.get('description', '相關屬性')}"
f"- {cat.name if hasattr(cat, 'name') else cat['name']}: {cat.description if hasattr(cat, 'description') else cat.get('description', 'Related attributes' if lang == 'en' else '相關屬性')}"
for cat in sorted_cats
])
category_keys = [cat.name if hasattr(cat, 'name') else cat['name'] for cat in sorted_cats]
json_template = {cat: ["屬性1", "屬性2", "屬性3"] for cat in category_keys}
return f"""/no_think
if lang == "en":
json_template = {cat: ["attribute1", "attribute2", "attribute3"] for cat in category_keys}
return f"""/no_think
Analyze "{query}" and list attributes for the following categories. List 3-5 common attributes for each category.
[Category List]
{category_desc}
Return JSON only:
{json.dumps(json_template, ensure_ascii=False, indent=2)}
Object: {query}"""
else:
json_template = {cat: ["屬性1", "屬性2", "屬性3"] for cat in category_keys}
return f"""/no_think
分析「{query}」，列出以下類別的屬性。每個類別列出 3-5 個常見屬性。
【類別列表】
@@ -185,30 +312,59 @@ def get_step2_dynamic_causal_chain_prompt(
categories: List, # List[CategoryDefinition]
attributes_by_category: Dict[str, List[str]],
existing_chains: List[Dict[str, str]],
chain_index: int
chain_index: int,
lang: LanguageType = "zh"
) -> str:
"""動態 Step 2 - 生成動態類別的因果鏈"""
"""Dynamic Step 2 - Generate causal chains for dynamic categories"""
sorted_cats = sorted(categories, key=lambda x: x.order if hasattr(x, 'order') else x.get('order', 0))
# 構建可選屬性
# Build available attributes
available_attrs = "\n".join([
f"【{cat.name if hasattr(cat, 'name') else cat['name']}】{', '.join(attributes_by_category.get(cat.name if hasattr(cat, 'name') else cat['name'], []))}"
f"[{cat.name if hasattr(cat, 'name') else cat['name']}] {', '.join(attributes_by_category.get(cat.name if hasattr(cat, 'name') else cat['name'], []))}"
for cat in sorted_cats
])
# 已生成的因果鏈
existing_text = ""
if existing_chains:
chains_list = [
" → ".join([chain.get(cat.name if hasattr(cat, 'name') else cat['name'], '?') for cat in sorted_cats])
for chain in existing_chains
]
existing_text = f"\n【已生成，請勿重複】\n" + "\n".join([f"- {c}" for c in chains_list])
if lang == "en":
# Already generated causal chains
existing_text = ""
if existing_chains:
chains_list = [
" → ".join([chain.get(cat.name if hasattr(cat, 'name') else cat['name'], '?') for cat in sorted_cats])
for chain in existing_chains
]
existing_text = "\n[Already generated, do not repeat]\n" + "\n".join([f"- {c}" for c in chains_list])
# JSON 模板
json_template = {cat.name if hasattr(cat, 'name') else cat['name']: f"選擇的{cat.name if hasattr(cat, 'name') else cat['name']}" for cat in sorted_cats}
# JSON template
json_template = {cat.name if hasattr(cat, 'name') else cat['name']: f"selected {cat.name if hasattr(cat, 'name') else cat['name']}" for cat in sorted_cats}
return f"""/no_think
return f"""/no_think
Generate causal chain #{chain_index} for "{query}".
[Available Attributes]
{available_attrs}
{existing_text}
[Rules]
1. Select one attribute from each category
2. Causal relationships must be logical
3. Do not repeat
Return JSON only:
{json.dumps(json_template, ensure_ascii=False, indent=2)}"""
else:
# 已生成的因果鏈
existing_text = ""
if existing_chains:
chains_list = [
" → ".join([chain.get(cat.name if hasattr(cat, 'name') else cat['name'], '?') for cat in sorted_cats])
for chain in existing_chains
]
existing_text = "\n【已生成，請勿重複】\n" + "\n".join([f"- {c}" for c in chains_list])
# JSON 模板
json_template = {cat.name if hasattr(cat, 'name') else cat['name']: f"選擇的{cat.name if hasattr(cat, 'name') else cat['name']}" for cat in sorted_cats}
return f"""/no_think
為「{query}」生成第 {chain_index} 條因果鏈。
【可選屬性】
@@ -230,20 +386,46 @@ def get_step2_dag_relationships_prompt(
query: str,
categories: List, # List[CategoryDefinition]
attributes_by_category: Dict[str, List[str]],
lang: LanguageType = "zh"
) -> str:
"""生成相鄰類別之間的自然關係"""
"""Generate natural relationships between adjacent categories"""
sorted_cats = sorted(categories, key=lambda x: x.order if hasattr(x, 'order') else x.get('order', 0))
# Build attribute listing
attr_listing = "\n".join([
f"【{cat.name if hasattr(cat, 'name') else cat['name']}】{', '.join(attributes_by_category.get(cat.name if hasattr(cat, 'name') else cat['name'], []))}"
f"[{cat.name if hasattr(cat, 'name') else cat['name']}] {', '.join(attributes_by_category.get(cat.name if hasattr(cat, 'name') else cat['name'], []))}"
for cat in sorted_cats
])
# Build direction hints
direction_hints = " → ".join([cat.name if hasattr(cat, 'name') else cat['name'] for cat in sorted_cats])
return f"""/no_think
if lang == "en":
return f"""/no_think
Analyze the attribute relationships of "{query}".
{attr_listing}
[Relationship Direction] {direction_hints}
[Rules]
1. Only establish relationships between adjacent categories (e.g., Materials→Functions, Functions→Usages)
2. Only output pairs that have true causal or associative relationships
3. An attribute can connect to multiple downstream attributes, or none at all
4. Not every attribute needs to have connections
5. Relationships should be reasonable and meaningful
Return JSON:
{{
"relationships": [
{{"source_category": "CategoryA", "source": "attribute name", "target_category": "CategoryB", "target": "attribute name"}},
...
]
}}
Return JSON only."""
else:
return f"""/no_think
分析「{query}」的屬性關係。
{attr_listing}

128
backend/app/prompts/expert_transformation_prompt.py
View File

@@ -1,34 +1,68 @@
"""Expert Transformation Agent 提示詞模組"""
"""Expert Transformation Agent prompts module - Bilingual support"""
from typing import List, Optional
from .language_config import LanguageType
def get_expert_generation_prompt(
query: str,
categories: List[str],
expert_count: int,
custom_experts: Optional[List[str]] = None
custom_experts: Optional[List[str]] = None,
lang: LanguageType = "zh"
) -> str:
"""Step 0: 生成專家團隊（不依賴主題，純隨機多元）"""
"""Step 0: Generate expert team (not dependent on topic, purely random and diverse)"""
import time
import random
custom_text = ""
if custom_experts and len(custom_experts) > 0:
custom_text = f"（已指定：{', '.join(custom_experts[:expert_count])}）"
# 加入時間戳和隨機數來增加多樣性
# Add timestamp and random number for diversity
seed = int(time.time() * 1000) % 10000
diversity_hints = [
"冷門、非主流、跨領域",
"罕見職業、新興領域、邊緣學科",
"非傳統、創新、小眾專業",
"未來趨向、實驗性、非常規",
"跨文化、混合領域、獨特視角"
]
hint = random.choice(diversity_hints)
return f"""/no_think
if lang == "en":
custom_text = ""
if custom_experts and len(custom_experts) > 0:
custom_text = f" (Specified: {', '.join(custom_experts[:expert_count])})"
diversity_hints = [
"obscure, non-mainstream, cross-disciplinary",
"rare occupations, emerging fields, fringe disciplines",
"unconventional, innovative, niche specialties",
"future-oriented, experimental, non-traditional",
"cross-cultural, hybrid fields, unique perspectives"
]
hint = random.choice(diversity_hints)
return f"""/no_think
Randomly assemble a team of {expert_count} experts from completely different fields{custom_text}.
[Innovation Requirements] (Random seed: {seed})
- Prioritize {hint} experts
- Avoid common professions (such as doctors, engineers, teachers, lawyers, etc.)
- Each expert must be from a completely unrelated field
- The rarer and more innovative, the better
Return JSON:
{{"experts": [{{"id": "expert-0", "name": "profession", "domain": "field", "perspective": "viewpoint"}}, ...]}}
Rules:
- id should be expert-0 to expert-{expert_count - 1}
- name is the profession name (not a person's name), 2-5 words
- domain should be specific and unique, no duplicate types"""
else:
custom_text = ""
if custom_experts and len(custom_experts) > 0:
custom_text = f"（已指定：{', '.join(custom_experts[:expert_count])}）"
diversity_hints = [
"冷門、非主流、跨領域",
"罕見職業、新興領域、邊緣學科",
"非傳統、創新、小眾專業",
"未來趨向、實驗性、非常規",
"跨文化、混合領域、獨特視角"
]
hint = random.choice(diversity_hints)
return f"""/no_think
隨機組建 {expert_count} 個來自完全不同領域的專家團隊{custom_text}。
【創新要求】（隨機種子:{seed}）
@@ -50,13 +84,39 @@ def get_expert_keyword_generation_prompt(
category: str,
attribute: str,
experts: List[dict], # List[ExpertProfile]
keywords_per_expert: int = 1
keywords_per_expert: int = 1,
lang: LanguageType = "zh"
) -> str:
"""Step 1: 專家視角關鍵字生成"""
# 建立專家列表，格式更清晰
"""Step 1: Expert perspective keyword generation"""
# Build expert list in clearer format
experts_list = "\n".join([f"- {exp['id']}: {exp['name']}" for exp in experts])
return f"""/no_think
if lang == "en":
return f"""/no_think
You need to play the role of the following experts to generate innovative keywords for an attribute:
[Expert List]
{experts_list}
[Task]
Attribute: "{attribute}" (Category: {category})
For each expert, please:
1. First understand the professional background, knowledge domain, and work content of that profession
2. Think about "{attribute}" from that profession's unique perspective
3. Generate {keywords_per_expert} innovative keyword(s) related to that specialty (2-6 words)
Keywords must reflect that expert's professional thinking style, for example:
- Accountant viewing "movement" → "cash flow", "cost-benefit"
- Architect viewing "movement" → "circulation design", "spatial flow"
- Psychologist viewing "movement" → "behavioral motivation", "emotional transition"
Return JSON:
{{"keywords": [{{"keyword": "term", "expert_id": "expert-X", "expert_name": "name"}}, ...]}}
Total of {len(experts) * keywords_per_expert} keywords needed, each keyword must be clearly related to the corresponding expert's professional field."""
else:
return f"""/no_think
你需要扮演以下專家，為屬性生成創新關鍵字：
【專家名單】
@@ -86,13 +146,29 @@ def get_single_description_prompt(
keyword: str,
expert_id: str,
expert_name: str,
expert_domain: str
expert_domain: str,
lang: LanguageType = "zh"
) -> str:
"""Step 2: 為單一關鍵字生成描述"""
# 如果 domain 是通用的，就只用職業名稱
domain_text = f"（{expert_domain}領域）" if expert_domain and expert_domain != "Professional Field" else ""
"""Step 2: Generate description for a single keyword"""
if lang == "en":
# If domain is generic, just use profession name
domain_text = f" ({expert_domain} field)" if expert_domain and expert_domain != "Professional Field" else ""
return f"""/no_think
return f"""/no_think
You are a {expert_name}{domain_text}.
Task: Generate an innovative application description for "{query}".
Keyword: {keyword}
From your professional perspective, explain how to apply the concept of "{keyword}" to "{query}". The description should be specific, creative, 15-30 words.
Return JSON only, no other text:
{{"description": "your innovative application description"}}"""
else:
# 如果 domain 是通用的，就只用職業名稱
domain_text = f"（{expert_domain}領域）" if expert_domain and expert_domain != "Professional Field" else ""
return f"""/no_think
你是一位{expert_name}{domain_text}。
任務：為「{query}」生成一段創新應用描述。

51
backend/app/prompts/language_config.py Normal file
View File

@@ -0,0 +1,51 @@
"""Language configuration for prompts"""
from enum import Enum
from typing import Literal
class Language(str, Enum):
CHINESE = "zh"
ENGLISH = "en"
LanguageType = Literal["zh", "en"]
# Default categories for each language
DEFAULT_CATEGORIES = {
"zh": ["材料", "功能", "用途", "使用族群", "特性"],
"en": ["Materials", "Functions", "Usages", "User Groups", "Characteristics"],
}
CATEGORY_DESCRIPTIONS = {
"zh": {
"材料": "物件由什麼材料組成",
"功能": "物件能做什麼",
"用途": "物件在什麼場景使用",
"使用族群": "誰會使用這個物件",
"特性": "物件有什麼特徵",
},
"en": {
"Materials": "What materials the object is made of",
"Functions": "What the object can do",
"Usages": "In what scenarios the object is used",
"User Groups": "Who uses this object",
"Characteristics": "What features the object has",
},
}
# Category name mappings between languages
CATEGORY_MAPPING = {
"zh_to_en": {
"材料": "Materials",
"功能": "Functions",
"用途": "Usages",
"使用族群": "User Groups",
"特性": "Characteristics",
},
"en_to_zh": {
"Materials": "材料",
"Functions": "功能",
"Usages": "用途",
"User Groups": "使用族群",
"Characteristics": "特性",
},
}

95
backend/app/prompts/transformation_prompt.py
View File

@@ -1,22 +1,43 @@
"""Transformation Agent 提示詞模組"""
"""Transformation Agent prompts module - Bilingual support"""
from typing import List
from .language_config import LanguageType
def get_keyword_generation_prompt(
category: str,
attributes: List[str],
keyword_count: int = 3
keyword_count: int = 3,
lang: LanguageType = "zh"
) -> str:
"""
Step 1: 生成新關鍵字
Step 1: Generate new keywords
給定類別和現有屬性，生成全新的、有創意的關鍵字。
不考慮原始查詢，只專注於類別本身可能的延伸。
Given a category and existing attributes, generate new, creative keywords.
Don't consider the original query, focus only on possible extensions of the category itself.
"""
attrs_text = "、".join(attributes)
attrs_text = ", ".join(attributes) if lang == "en" else "、".join(attributes)
return f"""/no_think
if lang == "en":
return f"""/no_think
You are a creative brainstorming expert. Given a category and its existing attributes, please generate new, creative keywords or descriptive phrases.
[Category] {category}
[Existing Attributes] {attrs_text}
[Important Rules]
1. Generate {keyword_count} completely new keywords
2. Keywords must fit within the scope of "{category}" category
3. Keywords should be creative and not duplicate or be too similar to existing attributes
4. Don't consider any specific object, focus only on possible extensions of this category
5. Each keyword should be 2-6 words
Return JSON only:
{{
"keywords": ["keyword1", "keyword2", "keyword3"]
}}"""
else:
return f"""/no_think
你是一個創意發想專家。給定一個類別和該類別下的現有屬性，請生成全新的、有創意的關鍵字或描述片段。
【類別】{category}
@@ -38,14 +59,36 @@ def get_keyword_generation_prompt(
def get_description_generation_prompt(
query: str,
category: str,
keyword: str
keyword: str,
lang: LanguageType = "zh"
) -> str:
"""
Step 2: 結合原始查詢生成描述
Step 2: Combine with original query to generate description
用新關鍵字創造一個與原始查詢相關的創新應用描述。
Use new keyword to create an innovative application description related to the original query.
"""
return f"""/no_think
if lang == "en":
return f"""/no_think
You are an innovation application expert. Please apply a new keyword concept to a specific object to create an innovative application description.
[Object] {query}
[Category] {category}
[New Keyword] {keyword}
[Task]
Using the concept of "{keyword}", create an innovative application description for "{query}".
The description should be a complete sentence or phrase explaining how to apply this new concept to the object.
[Example Format]
- If the object is "bicycle" and keyword is "monitor", you could generate "bicycle monitors the rider's health status"
- If the object is "umbrella" and keyword is "generate power", you could generate "umbrella generates electricity using raindrop impacts"
Return JSON only:
{{
"description": "innovative application description"
}}"""
else:
return f"""/no_think
你是一個創新應用專家。請將一個新的關鍵字概念應用到特定物件上，創造出創新的應用描述。
【物件】{query}
@@ -69,15 +112,35 @@ def get_description_generation_prompt(
def get_batch_description_prompt(
query: str,
category: str,
keywords: List[str]
keywords: List[str],
lang: LanguageType = "zh"
) -> str:
"""
批次生成描述（可選的優化版本，一次處理多個關鍵字）
Batch description generation (optional optimized version, process multiple keywords at once)
"""
keywords_text = "、".join(keywords)
keywords_json = ", ".join([f'"{k}"' for k in keywords])
keywords_text = ", ".join(keywords) if lang == "en" else "、".join(keywords)
return f"""/no_think
if lang == "en":
return f"""/no_think
You are an innovation application expert. Please apply multiple new keyword concepts to a specific object, creating an innovative application description for each keyword.
[Object] {query}
[Category] {category}
[New Keywords] {keywords_text}
[Task]
Create an innovative application description related to "{query}" for each keyword.
Each description should be a complete sentence or phrase.
Return JSON only:
{{
"descriptions": [
{{"keyword": "keyword1", "description": "description1"}},
{{"keyword": "keyword2", "description": "description2"}}
]
}}"""
else:
return f"""/no_think
你是一個創新應用專家。請將多個新的關鍵字概念應用到特定物件上，為每個關鍵字創造創新的應用描述。
【物件】{query}