---
name: scholion-research
description: >
  Conduct deep academic literature research, novelty assessment, journal
  selection, reviewer/editor recommendation using the Scholion.ai Public API (v1),
  which indexes 220,000+ papers from 60+ leading business journals (FT50).
  Use when the user needs literature review, novelty check, journal matching,
  or peer reviewer/editor suggestions for academic manuscripts.
---

# Scholion.ai Deep Research Skill

Conduct deep academic literature research, novelty assessment, journal selection,
reviewer/editor recommendation using the Scholion.ai Public API (v1), which
indexes 220,000+ papers from 60+ leading business journals (FT50).

## Quick Reference

### Search & Discovery

| Endpoint | Cost | Purpose |
|---|---|---|
| `GET /api/v1/search/keyword` | 1 credit | Full-text search over title/abstract/authors |
| `GET /api/v1/search/semantic` | 2 credits | Vector similarity search over abstracts |
| `GET /api/v1/papers` | 1 credit | Structured query by author/journal/year/title |
| `GET /api/v1/papers/by-doi` | 1 credit | Exact lookup by DOI — full metadata |

### Authors & Network

| Endpoint | Cost | Purpose |
|---|---|---|
| `GET /api/v1/authors/search` | 1 credit | Find authors by name substring |
| `GET /api/v1/authors/coauthors` | 1 credit | Co-author network for a given author |

### Journals & Stats

| Endpoint | Cost | Purpose |
|---|---|---|
| `GET /api/v1/journals/lookup` | 1 credit | Look up journals by name/ISSN/field/publisher |
| `GET /api/v1/journals/editors` | 1 credit | List editorial board by role |
| `GET /api/v1/journals/review-cycle` | 1 credit | Review cycle time statistics |
| `GET /api/v1/stats` | 1 credit | Aggregate database statistics |

### Recommendation (POST)

| Endpoint | Cost | Purpose |
|---|---|---|
| `POST /api/v1/recommend/journals` | 3 credits | Recommend target journals for a manuscript |
| `POST /api/v1/recommend/reviewers` | 3 credits | Suggest peer reviewers by semantic match |
| `POST /api/v1/recommend/editors` | 3 credits | Suggest handling editors from top journals |

- **Auth**: `Authorization: Bearer YOUR_API_KEY` (or `X-API-Key` header)
- **Quota**: 100 free credits/day, resets UTC midnight
- **Rate limiting**: `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset`, `X-Credits-Cost` headers
- **Exceeding quota**: HTTP 429 with `Retry-After` header
- **Base URL**: `https://scholion.ai`
- **POST endpoints**: Content-Type `application/json`

Full OpenAPI spec at `references/api_spec.md`. Use `scripts/scholion_api.py` for
deterministic API calls.

## Prerequisites

Before using this skill, ask the user for their Scholion.ai API key. If they
haven't registered, direct them to `https://scholion.ai/account/api` after
logging in. Store the key as `SCHOLION_API_KEY` env var, or pass it explicitly.

## Core Workflow 1: Deep Research

When the user describes a research need, follow this iterative workflow:

### Phase 1: Understand & Plan

1. Parse the user's research question/need. Identify:
   - Core concepts and keywords
   - Scope constraints (journals, time range, methodology)
   - Angle (theoretical, empirical, practitioner-oriented, etc.)

2. Present a **research plan** to the user before executing:
   - 2–5 keyword search queries (for `search/keyword`)
   - 2–3 semantic search queries (for `search/semantic`)
   - Optional: 1–2 structured queries (for `papers`) to narrow by author/journal/year
   - Logical execution order (broad → narrow, or conceptual → applied)
   - Estimated credit cost

Wait for user confirmation before proceeding, unless they've opted for full-auto.

### Phase 2: Execute Searches

Execute the planned searches in order. For each search:

1. Call the endpoint with `limit=20` (default) or higher for broad searches
2. Record the response: paper ID, title, abstract snippet, journal, year, similarity
3. Deduplicate results across queries (by `paper_id` and `doi`)

After the initial round, decide whether a **second iteration** is needed:
- Are there obvious gaps? (seminal papers not found, competing theories missing)
- Does a specific paper's authors suggest a new author search or coauthor exploration?
- Should a narrower sub-topic get its own focused search?

If expanding, execute follow-up queries (with user notice if credit consumption is high).

### Phase 3: Deep Dive

For the most relevant 5–15 papers from Phase 2:

1. Retrieve full metadata via `papers/by-doi` if DOI is available
2. Optionally search for works by key first/last authors via `authors/search`
3. Explore co-author networks via `authors/coauthors` to discover related scholars
4. Note the journal, year, and publisher for quality assessment

### Phase 4: Synthesize & Report

Produce a structured research report covering:

1. **Executive Summary** — 2–3 paragraphs on the state of research
2. **Key Papers** — Top 5–10 papers ranked by relevance, each with:
   - Full citation (authors, title, journal, year)
   - Abstract summary
   - Why it matters to the research question
3. **Thematic Clusters** — Group papers into 2–4 themes/approaches
4. **Research Gaps** — What questions remain unanswered
5. **Bibliography** — Full reference list with DOIs and URLs

Output as a single-file HTML (styles inlined) or a structured Markdown doc,
according to user preference.

### Phase 5 (Optional): Iterate

Ask the user if they want to dig deeper into any theme, exclude certain angles,
or adjust scope. Run additional searches as needed.

## Core Workflow 2: Novelty Check

When the user provides an abstract, manuscript excerpt, or research question and
asks "is this novel?" or "has this been done before?":

### Phase 1: Parse the Input

Extract from the input:
- The core research question or hypothesis
- Key constructs/variables
- Methodology (if stated)
- Domain and theoretical framing

### Phase 2: Multi-Strategy Search

Run 3–5 searches in parallel to maximize coverage:

| Strategy | Endpoint | Query derived from... |
|---|---|---|
| Semantic 1 | `search/semantic` | The full abstract text |
| Semantic 2 | `search/semantic` | Rephrased summary focusing on RQ |
| Keyword 1 | `search/keyword` | Core constructs (2–3 key terms) |
| Keyword 2 | `search/keyword` | Methodology + domain terms |
| Structured | `papers` | Narrow by relevant journals or authors |
| Author (optional) | `authors/search` | If specific authors are cited as competitors |

### Phase 3: Assess Overlap

For each retrieved paper (up to top 30 across all searches):

1. Compare the **research question** — same question answered?
2. Compare the **methodology** — same approach applied?
3. Compare the **context** — same industry/setting/population?
4. Compare the **contribution** — same theoretical or practical claim?

Classify each paper as:
- **Direct overlap** (same question + same approach — high threat to novelty)
- **Partial overlap** (similar question OR similar method — needs positioning)
- **Adjacent work** (related domain but different question — can be cited as context)
- **No overlap** (irrelevant, filter out)

### Phase 4: Report

Produce a novelty assessment report:

1. **Novelty Verdict** — Clear statement: "Novel" / "Partially Novel — needs positioning" / "Not Novel — prior art exists"
2. **Closest Prior Art** — Top 3–5 most overlapping papers with detailed comparison
3. **Differentiation Space** — What makes this work different (if anything)
4. **Positioning Advice** — How to frame the contribution given existing work
5. **Complete List** — All papers considered, with overlap classification

Use the `similarity` field from semantic search results as a quantitative signal,
but do not treat it as definitive — LLM qualitative judgment is the final arbiter.

## Core Workflow 3: Journal Recommendation

When the user has a manuscript (abstract or description) and wants to find the
best target journal:

### Phase 1: Gather Manuscript Details

Collect from the user:
- Abstract or description of the manuscript
- Research field/discipline
- Any preferences (e.g., FT50 only, specific methodology fit, fast review cycle)

### Phase 2: Call Recommendation API

Call `POST /api/v1/recommend/journals` with:
- `description`: manuscript abstract/summary (max 5000 chars)
- `field`: research field (optional, for filtering)
- `limit`: 10–15 (default 15, max 30)
- `restrict_to_field`: whether to restrict results to the specified field

### Phase 3: Augment with Journal Intel

For the top 3–5 recommended journals, enrich with:
1. `journals/lookup` — get journal details (ISSN, publisher, FT50/UTD24 status)
2. `journals/review-cycle` — check typical review turnaround times
3. `journals/editors` — identify relevant editors in the research area

### Phase 4: Report

Present a ranked journal recommendation with:
1. **Top Picks** — Top 3–5 journals with fit scores and rationale
2. **Fit Analysis** — Why each journal matches the manuscript's topic/method
3. **Practical Intel** — Review cycle times, editorial board expertise
4. **Strategy** — Suggested submission order with rationale

## Core Workflow 4: Reviewer Recommendation

When the user needs to identify peer reviewers for their manuscript:

### Phase 1: Gather Context

Collect:
- Abstract/description of the manuscript (required)
- Research field
- Authors to exclude (the manuscript's own authors)
- Institutions to exclude (conflict of interest)
- Preferred journal (to bias toward its typical reviewer pool)

### Phase 2: Call Recommendation API

Call `POST /api/v1/recommend/reviewers` with:
- `description`: manuscript description (required, max 5000 chars)
- `field`: research field (optional)
- `limit`: up to 50 (default 20)
- `exclude_authors`: list of author names to exclude (max 100)
- `exclude_institution`: institution to exclude (max 300 chars)
- `journal_name`: bias toward reviewers familiar with this journal
- `restrict_to_field`: true = only consider authors from journals in the specified field

### Phase 3: Verify and Augment

For top candidates:
1. `authors/search` — verify publication record
2. `authors/coauthors` — check for indirect conflicts via co-author networks

### Phase 4: Report

Present ranked reviewers with:
1. **Top Candidates** — Ranked by semantic fit to the manuscript
2. **Publication Record** — Paper counts, recency, relevant work
3. **Conflict Check** — Any co-authorship or institutional ties noted
4. **Recommendation** — Suggested shortlist of 3–6 reviewers

## Core Workflow 5: Editor Recommendation

When the user wants to identify suitable handling editors:

### Phase 1: Gather Context

Collect:
- Abstract/description (required)
- Research field
- Target journal (optional — restricts to that journal's editorial board)
- How many top journals to consider (default 5, max 15)

### Phase 2: Call Recommendation API

Call `POST /api/v1/recommend/editors` with:
- `description`: manuscript description (required, max 5000 chars)
- `field`: research field (optional)
- `journal_name`: restrict to a specific journal's board (optional)
- `top_journals_limit`: number of top journals to consider (default 5, max 15)
- `editors_per_role`: editors to return per role (default 2, max 5)

### Phase 3: Report

Present editor recommendations grouped by role:
1. **Editor-in-Chief / Senior Editors** — Top-level fit
2. **Associate / Department Editors** — Most likely handling editors
3. **Fit Rationale** — Why each editor's expertise matches the manuscript
4. **Journal Context** — Which journal each editor is affiliated with

## Supplementary Tools

These endpoints are useful standalone or to enrich other workflows:

### Co-Author Network

`GET /api/v1/authors/coauthors?name=...&limit=50` (1 credit, max 200)

Discover an author's research network. `name` must be the exact standardized full name (not a substring). Useful for:
- Finding competing research groups
- Identifying potential collaborators
- Tracing the intellectual lineage of a research stream

### Database Statistics

`GET /api/v1/stats?type=...` (1 credit)

Get aggregate insights:
- `total_papers`, `total_authors` — catalog size
- `list_journals` — all indexed journals
- `year_range` — earliest/latest publication years
- `papers_by_year`, `papers_by_field`, `papers_by_field_by_year` — temporal/domain breakdowns

Optional filters: `author`, `journal`, `field`, `year_start`, `year_end`.

### Journal Lookup

`GET /api/v1/journals/lookup?journal_name=...` (1 credit, max 200 results)

Find journals by name, abbreviation, field, ISSN, or publisher. Filter by
`ft50_only` or `utd24_only`. At least one search parameter required.

### Journal Editors

`GET /api/v1/journals/editors?journal_name=...` (1 credit)

List editorial board grouped by role. Set `current_only=false` for historical
editors. Filter by `role` for specific positions.

### Review Cycle Statistics

`GET /api/v1/journals/review-cycle?journal_name=...` (1 credit)

Review turnaround stats: first decision time, acceptance time. Filter by journal
or field (not both). `breakdown` by `journal` (default) or `journal_year`.

## API Usage Patterns

### Keyword Search

```
GET /api/v1/search/keyword?q=platform+strategy&limit=20&offset=0&journals=Management+Science,Marketing+Science&year_from=2020&sort=relevance
```

**New parameters** (since v1.0):
- `journals` — comma-separated journal names to restrict results
- `year_from` / `year_to` — publication year range (inclusive)
- `sort` — `relevance` (default), `year_asc`, or `year_desc`

Query syntax for `q`:
- Space-separated terms are ANDed — every term must match.
- `|` between terms means OR: `robotics|blockchain` matches papers with either term.
- `|` binds tighter than the implicit AND: `platform robotics|blockchain` means platform AND (robotics OR blockchain).
- Double quotes match an exact phrase: `"digital platform"`.
- Multiple quoted phrases require co-occurrence: `"machine learning" "supply chain"` returns papers containing both phrases, each of which may appear in the title or the abstract independently.
- OR grouping applies to queries with fewer than 6 words; longer queries treat every word as required.

Search covers title, abstract, and author names.

Response includes `relaxed` boolean: when strict matching yields too few results
and the matcher falls back to a looser OR query, `relaxed` is `true`.

Response also includes `applied_filters` — an echo of the journal/year/sort
filters the server actually applied (after abbreviation resolution). Check it
to confirm your filters took effect. Unknown query parameters and out-of-range
values (e.g. `limit` above 50) return a 400 error naming the parameter —
nothing is silently ignored or capped.

### Semantic Search

```
GET /api/v1/search/semantic?q=how+do+two-sided+platforms+price&limit=20&offset=0&journals=Management+Science&year_from=2018&year_to=2025&min_similarity=0.4
```

**New parameters**: `journals`, `year_from`, `year_to`, `min_similarity`.
Results remain sorted by similarity score even when year/journals filters are
applied.

Natural language queries work best. The API returns `similarity` scores (0–1)
in each `PaperSummary`.

**Response counts**: `count` is the number of results on this page.
`index_size` is the size of the filtered searchable pool (every embedded paper
matching your journal/year filters) — it is NOT a relevance count. Pass
`min_similarity` (0–1) to also get `matched_count`: the number of papers whose
similarity meets that cutoff. Omit `min_similarity` and no relevance count is
returned (no default threshold is applied).

The response also echoes `applied_filters` (journals/year_from/year_to/
min_similarity actually applied) so you can confirm filters took effect.

### Structured Paper Query (NEW)

```
GET /api/v1/papers?author_name=Porter&journal_name=Strategic+Management+Journal&year_start=2015&year_end=2025&limit=50
```

Filter by structured fields rather than free-text relevance. At least one filter
required. Max 100 results per page. Parameters: `author_name`, `journal_name`,
`year`, `year_start`, `year_end`, `title_contains`.

### DOI Lookup

```
GET /api/v1/papers/by-doi?doi=10.1287/mnsc.2021.4205
```

Returns full `PaperDetail` with keywords, article type, page range, online pub date.

### Author Search

```
GET /api/v1/authors/search?name=Shen&limit=20&offset=0
```

Case-insensitive substring match on first/last/full name. Returns paper counts
per author. `limit` max 50, `offset` max 300.

### Co-Author Network (NEW)

```
GET /api/v1/authors/coauthors?name=Porter&limit=100
```

Lists most frequent co-authors, ranked by number of co-authored papers.
`limit` max 200. **Note**: `name` uses standardized exact match, not substring—pass the full author name.

### Journal Recommendation (NEW, POST)

```
POST /api/v1/recommend/journals
Content-Type: application/json

{
  "description": "This paper examines how digital platforms...",
  "field": "Information Systems",
  "limit": 15,
  "restrict_to_field": false
}
```

Recommends target journals by semantic similarity and journal quality ranking.
`description` max 5000 chars, `limit` 1–30.

### Reviewer Recommendation (NEW, POST)

```
POST /api/v1/recommend/reviewers
Content-Type: application/json

{
  "description": "This paper examines how digital platforms...",
  "field": "Information Systems",
  "limit": 20,
  "exclude_authors": ["Smith, John", "Chen, Li"],
  "exclude_institution": "Harvard University",
  "journal_name": "MIS Quarterly",
  "restrict_to_field": false
}
```

Recommends peer reviewers by semantic match to published work. Use
`exclude_authors` / `exclude_institution` for conflict-of-interest management.

### Editor Recommendation (NEW, POST)

```
POST /api/v1/recommend/editors
Content-Type: application/json

{
  "description": "This paper examines how digital platforms...",
  "field": "Information Systems",
  "journal_name": "Information Systems Research",
  "top_journals_limit": 5,
  "editors_per_role": 2
}
```

Matches editorial boards to manuscript. Can restrict to a specific journal or
search across top journals. `top_journals_limit` 1–15, `editors_per_role` 1–5.

## Tips

- **Journal abbreviations**: Any journal parameter (`journals` on search
  endpoints; `journal_name` / `journal` elsewhere) accepts standard
  abbreviations, e.g. `ISR` = *Information Systems Research*, `JMIS` = *Journal
  of Management Information Systems* (`MISQ`, `JAIS`, etc. work too). Common
  name variants also resolve — `MIS Quarterly` matches the stored name
  *Management Information Systems Quarterly*, and `M&SOM` / `POMS` map to their
  canonical journals. They resolve to the full journal name, so you can pass
  whichever the user provides.
- **Strict validation — read the 400s**: Endpoints reject query parameters they
  don't accept (the error lists the accepted ones) and out-of-range values
  (e.g. `limit=60` on search endpoints is an error, not a silent cap at 50).
  If you get a 400, fix the named parameter and retry. On search endpoints,
  verify `applied_filters` in the response to confirm journal/year filters
  actually landed.
- **Credit budget**: 100 credits/day. Deep Research Phase 2+3 typically costs
  10–30 credits. Novelty Check costs 5–10 credits. Recommendation workflows
  cost 5–15 credits each. Always report credits consumed to the user.
- **Semantic vs Keyword**: Semantic is better for "finding similar ideas";
  keyword is better for comprehensive coverage of a construct. Use both.
- **Structured queries** (`/papers`): Use when you know specific authors or
  journals to search within — more precise, lower noise than keyword search.
- **Dedup aggressively**: Papers may appear across multiple queries. Merge results
  by `paper_id` and prefer the entry with the higher `similarity` score.
- **Quality signal**: Prefer papers from FT50 journals (all indexed). The
  `journal_name` and `publisher` fields help assess prestige. Use
  `journals/lookup` with `ft50_only=true` to verify.
- **New filters on search endpoints**: Use `journals`, `year_from`, `year_to`
  to narrow results before searching, saving credits on broad queries.
- **When credits are low**: Prioritize the most critical queries. Semantic search
  often gives higher signal per credit. Skip supplementary enrichment.
- **Recommendation workflows are POST**: These accept JSON request bodies, not
  query parameters. Cost 3 credits each — fewer calls, richer output.
- **Conflict management**: Always use `exclude_authors` and `exclude_institution`
  in reviewer recommendations to avoid COI.

## Files

- `scripts/scholion_api.py` — Python helper for calling all 15 API endpoints
  with retry logic and rate limit handling
- `references/api_spec.md` — Full OpenAPI specification for reference