Japanese NLP Resource Search

Search the awesome-japanese-nlp-resources database for: "$ARGUMENTS"

Instructions

Step 0 — Validate input

If $ARGUMENTS is empty or blank, stop immediately and output:

Usage: /awesome-japanese-nlp-resources:search <query>

Examples:
 /awesome-japanese-nlp-resources:search morphological analysis
 /awesome-japanese-nlp-resources:search BERT
 /awesome-japanese-nlp-resources:search named entity recognition
 /awesome-japanese-nlp-resources:search text classification dataset
 /awesome-japanese-nlp-resources:search sentence embedding

Please pass the keyword(s) you want to search for as the argument.

---

: /awesome-japanese-nlp-resources:search <query>

:
 /awesome-japanese-nlp-resources:search 
 /awesome-japanese-nlp-resources:search BERT
 /awesome-japanese-nlp-resources:search 
 /awesome-japanese-nlp-resources:search 
 /awesome-japanese-nlp-resources:search 

Do not proceed to Step 1 if $ARGUMENTS is empty.

Step 1 — Interpret the query

The user's query is: "$ARGUMENTS"

The data descriptions are in English, so always convert the query intent to English keywords before searching.

Keyword rules — read before choosing keywords:

1. Use stems, not full words. Substring match is used, so morpholog catches "morphology", "morphological", "morphological analyzer". Other examples: embed → embedding/embeddings, classif → classification/classifier, translat → translation/translate, generat → generation/generative, segment → segmentation/segmenter, recogni → recognition/recognizer, extract → extraction/extractor, retriev → retrieval/retrieve.
2. Add domain-specific tool names. When the query maps to a known NLP domain, include the well-known tool names present in the database:

3. Aim for 4–6 keywords. Fewer miss items; more than 6 inflates low-quality partial matches.
4. If none of the above domains fit, translate the query intent literally to English stems.

Step 2 — Locate the data file

The data file ships with the plugin. Resolve its path via ${CLAUDE_PLUGIN_ROOT} (Claude Code substitutes this inline in skill content), falling back to a scoped search only if the install is unusual:

RESOURCES_PATH="${CLAUDE_PLUGIN_ROOT}/data/resources.json"
[ -f "$RESOURCES_PATH" ] || RESOURCES_PATH="$(find "${HOME}/.claude/plugins" -type f -name resources.json 2>/dev/null | grep "awesome-japanese-nlp-resources/" | head -1)"
echo "RESOURCES_PATH=$RESOURCES_PATH"

Use the resulting absolute RESOURCES_PATH wherever Step 3 opens the data file.

Step 3 — Search and score via Bash

Do NOT use the Read tool — the file exceeds the Read tool's size limit and would consume ~64K tokens unnecessarily. Instead, run the scoring in a single Bash call using Python.

Each item in the JSON array has:

• u: GitHub or Hugging Face URL
• n: repository/model name
• d: description (English for most items; some Japanese-only items have Japanese descriptions)
• c: category (e.g. Python library, HuggingFace Model (Text Generation), Corpus, Tutorial, ...)
• s: subcategory / semantic labels (comma-separated)
• st: GitHub star count (GitHub items only; absent or 0 otherwise)
• ns: normalized star score 0–10 (log-scaled, GitHub items only)
• dl: Hugging Face download count (HF items only; absent or 0 otherwise)
• nd: normalized download score 0–10 (log-scaled, HF items only)
• sc: pre-computed quality score (higher = more popular/active)

Run the following, substituting KEYWORDS with your English keywords list from Step 1:

python3 << 'EOF'
import json

with open("RESOURCES_PATH") as f: # absolute path from Step 2
 data = json.load(f)

keywords = ["keyword1", "keyword2", "keyword3"] # from Step 1

results = 
for item in data:
 n = item.get("n", "").lower
 d = item.get("d", "").lower
 s = item.get("s", "").lower
 c = item.get("c", "").lower

 text_score = 0
 for kw in keywords:
 kw = kw.lower
 if n == kw: text_score += 20
 elif kw in n: text_score += 10
 if kw in d: text_score += 5
 if kw in s: text_score += 3
 if kw in c: text_score += 2

 if text_score < 8:
 continue

 ns = item.get("ns") or 0
 nd = item.get("nd") or 0
 sc = item.get("sc") or 0
 pop = (ns if ns else nd) * 2.5
 qual = min(5, sc * 5 / 21)
 combined = text_score + pop + qual

 results.append((combined, text_score, item))

results.sort(key=lambda x: -x[0])
seen = {item['n'] for _, _, item in results}

# Supplemental pass: surface high-popularity items from matching categories
# that may have been missed because their descriptions are in Japanese.
# Keys are stems to match against user keywords; values are category prefixes
# (prefix match covers "HuggingFace Model (Text Generation)" etc.).
CATEGORY_KEYWORDS = {
 "tutorial": "Tutorial", "introduc": "Tutorial", "learn": "Tutorial",
 "morpholog": "Python library", "segment": "Python library",
 "mecab": "Python library", "janome": "Python library", "sudachi": "Python library",
 "spacy": "Python library", "ginza": "Python library",
 "corpus": "Corpus", "dataset": "Corpus",
 "bert": "HuggingFace Model", "gpt": "HuggingFace Model",
 "llm": "HuggingFace Model", "llama": "HuggingFace Model",
 "pretrain": "HuggingFace Model", "embed": "HuggingFace Model",
 "model": "Pretrained model",
}
supplement_cats = set
for kw in keywords:
 for ck, cat in CATEGORY_KEYWORDS.items:
 if ck in kw.lower:
 supplement_cats.add(cat)

if supplement_cats:
 def cat_match(c):
 return any(c == cat or c.startswith(cat + " ") for cat in supplement_cats)
 extras = [
 item for item in data
 if cat_match(item.get("c", ""))
 and (item.get("st", 0) or item.get("dl", 0))
 and item["n"] not in seen
 ]
 extras.sort(key=lambda x: -max(x.get("ns") or 0, x.get("nd") or 0))
 for item in extras[:5]:
 ns = item.get("ns") or 0
 nd = item.get("nd") or 0
 sc = item.get("sc") or 0
 # base 8 = category-match credit (same as the text_score threshold)
 combined = 8 + max(ns, nd) * 2.5 + min(5, sc * 5 / 21)
 results.append((combined, 0, item))
 seen.add(item["n"])

results.sort(key=lambda x: -x[0])
for combined, text_score, item in results[:20]:
 st = item.get("st", 0) or 0
 dl = item.get("dl", 0) or 0
 flag = " [supplemental]" if text_score == 0 else ""
 print(f"score={combined:.1f} text={text_score} st={st} dl={dl}{flag}")
 print(f" n={item['n']}")
 print(f" u={item['u']}")
 print(f" c={item['c']}")
 print(f" s={item.get('s','')}")
 print(f" d={item.get('d','')[:120]}")
 print
EOF

This returns up to 20 candidates. Items marked [supplemental] were added by the category-based pass to recover high-star resources whose descriptions are in Japanese. In Step 4, evaluate supplemental items on semantic fit before including them in the final list.

Step 4 — Re-rank with your judgment

You now have up to 20 candidates. Apply your semantic judgment to produce the final ordered list of up to 10 results.

Re-rank by evaluating each candidate on:

1. Semantic centrality — how directly does this resource address the query's core intent? A BERT model is more central to "BERT fine-tuning" than a generic transformer library.
2. Popularity as a proxy for quality — high stars/downloads generally signal battle-tested, well-documented tools. Prefer them when candidates are otherwise equivalent.
3. Category fit — match the resource type to the implied need:

• "how to learn / " → prefer Tutorial, Research summary
• "I need a model" → prefer Pretrained model, HuggingFace Model
• "find a dataset / " → prefer Corpus, HuggingFace Dataset
• "build an app / " → prefer Python library, language-specific libs

4. Specificity — a resource specialized for the exact task beats a general one.
5. Recency signal — when sc is significantly higher among otherwise-similar items, it usually reflects more recent activity; prefer those.

Do not mechanically follow the combined score from Step 3 — use it as a starting point, then move items up or down based on the criteria above.

Step 5 — Format the output

Language detection rule (apply before writing any output):

• $ARGUMENTS contains Japanese characters (hiragana / katakana / kanji) → Japanese
• Otherwise → English (default)

Apply the detected language to all headings and prose.

Present the final re-ranked results:

## Search results for "$ARGUMENTS"

*(Searched for: keyword1, keyword2, ...)*

Found N result(s).

### 1. [repository-name](url)
**Category:** category > subcategory
**Popularity:** ⭐ {st} stars (or 📥 {dl} downloads for HF)
Description text here.

### 2. ...

If no results, suggest alternate keywords and link to: https://github.com/taishi-i/awesome-japanese-nlp-resources

Step 6 — Output use-case selection guide table

After the search results list, append a guide table that helps the user pick the right resource for their specific situation.

Match the section heading and table language to the query language — translate the heading and column headers into the query language (e.g. Japanese query → Japanese heading and headers).

## Use-case Selection Guide

| Use case | Recommended | Popularity | Why |
|---|---|---|---|
| ... | [name](url) | ⭐N or 📥N | short reason |

Rules:

• List 3–6 distinct use cases derived from the top 10 results. Each row should represent a meaningfully different scenario (e.g., "fine-tune an LLM" vs "evaluate an LLM"), not just a restatement of the search query.
• For each row, select the single best resource from the top 10 results.
• Popularity column: use ⭐{st} for GitHub stars, 📥{dl} for HuggingFace downloads. If both are 0, omit.
• Why: write a 10–15 word reason in the query language explaining why this resource is the best fit for that use case. Do not copy the description verbatim. Focus on the practical benefit.
• If two use cases would map to the same resource, merge them into one row or drop the weaker one.
• If there are fewer than 3 meaningfully distinct use cases in the results, output as many rows as make sense (minimum 1).