@kak4343/scholar-mcp 0.3.0

package/dist/sources/semantic_scholar.d.ts

@@ -0,0 +1,7 @@
+import type { SearchParams, SearchResult, SourceSearcher } from "../types.js";
+export declare class SemanticScholarSearcher implements SourceSearcher {
+    private apiKey?;
+    constructor(apiKey?: string);
+    search(params: SearchParams): Promise<SearchResult[]>;
+    private parsePaper;
+}

package/dist/sources/semantic_scholar.js

@@ -0,0 +1,61 @@
+const BASE_URL = "https://api.semanticscholar.org/graph/v1";
+const USER_AGENT = "scholar-mcp/0.2.1 (https://github.com/kak4343/scholar-mcp)";
+const FIELDS = "title,authors,abstract,year,publicationDate,externalIds,citationCount,venue,url";
+export class SemanticScholarSearcher {
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async search(params) {
+        const url = new URL(`${BASE_URL}/paper/search`);
+        url.searchParams.set("query", params.query);
+        url.searchParams.set("limit", String(params.max_results ?? 10));
+        url.searchParams.set("fields", FIELDS);
+        if (params.date_from || params.date_to) {
+            const from = params.date_from ?? "1900-01-01";
+            const to = params.date_to ?? new Date().toISOString().substring(0, 10);
+            url.searchParams.set("publicationDateOrYear", `${from}:${to}`);
+        }
+        const headers = { "User-Agent": USER_AGENT };
+        if (this.apiKey)
+            headers["x-api-key"] = this.apiKey;
+        const r = await fetch(url, { headers });
+        if (!r.ok) {
+            if (r.status === 429)
+                throw new Error("Semantic Scholar rate limit exceeded");
+            throw new Error(`Semantic Scholar search failed: ${r.status}`);
+        }
+        const data = await r.json();
+        return (data.data ?? []).map((p) => this.parsePaper(p)).filter((r) => r !== null);
+    }
+    parsePaper(paper) {
+        const id = String(paper.paperId ?? "");
+        if (!id)
+            return null;
+        const title = String(paper.title ?? "").trim();
+        const abstract = String(paper.abstract ?? "").trim();
+        const authors = (paper.authors ?? []).map((a) => String(a.name ?? "")).filter(Boolean);
+        const published_date = String(paper.publicationDate ?? (paper.year ? `${paper.year}-01-01` : ""));
+        const doi = paper.externalIds?.DOI ? String(paper.externalIds.DOI) : undefined;
+        const pmid = paper.externalIds?.PubMed ? String(paper.externalIds.PubMed) : undefined;
+        const arxiv_id = paper.externalIds?.ArXiv ? String(paper.externalIds.ArXiv) : undefined;
+        const venue = String(paper.venue ?? "");
+        const citation_count = typeof paper.citationCount === "number" ? paper.citationCount : undefined;
+        const url = String(paper.url ?? `https://www.semanticscholar.org/paper/${id}`);
+        return {
+            source: "semantic_scholar",
+            title,
+            authors,
+            abstract,
+            doi,
+            pmid,
+            arxiv_id,
+            semantic_scholar_id: id,
+            published_date,
+            venue,
+            citation_count,
+            url,
+        };
+    }
+}
+//# sourceMappingURL=semantic_scholar.js.map

package/dist/sources/semantic_scholar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic_scholar.js","sourceRoot":"","sources":["../../src/sources/semantic_scholar.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+export type Source = "pubmed" | "arxiv" | "semantic_scholar";
+export interface SearchResult {
+    source: Source;
+    title: string;
+    authors: string[];
+    abstract: string;
+    doi?: string;
+    arxiv_id?: string;
+    pmid?: string;
+    semantic_scholar_id?: string;
+    published_date: string;
+    venue?: string;
+    citation_count?: number;
+    url: string;
+}
+export interface SearchParams {
+    query: string;
+    sources?: Source[];
+    max_results?: number;
+    date_from?: string;
+    date_to?: string;
+}
+export interface SourceSearcher {
+    search(params: SearchParams): Promise<SearchResult[]>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@kak4343/scholar-mcp",
+  "version": "0.3.0",
+  "description": "Unified MCP server for PubMed + arXiv + Semantic Scholar scholarly search, with two-tier caching and Notion export.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "scholar-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "test": "node --test dist/tests/*.test.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "pubmed",
+    "arxiv",
+    "semantic-scholar",
+    "scholarly-search",
+    "claude",
+    "anthropic"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@notionhq/client": "^2.3.0",
+    "better-sqlite3": "^12.10.0",
+    "fast-xml-parser": "^4.5.0",
+    "lru-cache": "^11.5.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/smoke_test.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * scholar-mcp v0.2 smoke test.
+ *
+ * Validates:
+ *   1. SearchCache: first lookup is a miss, second lookup is a hit, hit rate
+ *      reflects the 1-of-2 ratio.
+ *   2. Cache key determinism: same inputs in different order produce the
+ *      same sha256 key.
+ *   3. exportResultsToNotion dry-run: builds the expected Notion property
+ *      payload without touching the network.
+ *
+ * Run: `npm run build && node scripts/smoke_test.mjs`
+ */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { SearchCache, buildCacheKey } from "../dist/cache/index.js";
+import { exportResultsToNotion } from "../dist/notion/push.js";
+
+const tmp = mkdtempSync(join(tmpdir(), "scholar-mcp-smoke-"));
+const dbPath = join(tmp, "scholar_cache.db");
+
+let failures = 0;
+function assert(cond, msg) {
+  if (!cond) {
+    console.error(`  FAIL: ${msg}`);
+    failures++;
+  } else {
+    console.error(`  ok  : ${msg}`);
+  }
+}
+
+console.error("[1/3] Cache key determinism");
+const k1 = buildCacheKey({
+  tool: "scholar_search",
+  query: "diabetic retinopathy",
+  sources: ["pubmed", "arxiv", "semantic_scholar"],
+  max_results: 10,
+});
+const k2 = buildCacheKey({
+  tool: "scholar_search",
+  query: "DIABETIC RETINOPATHY",
+  sources: ["semantic_scholar", "arxiv", "pubmed"],
+  max_results: 10,
+});
+assert(k1 === k2, "same inputs (different case/order) hash to same key");
+assert(k1.length === 64, "sha256 produces 64-hex-char digest");
+
+console.error("[2/3] SearchCache hit/miss");
+const cache = new SearchCache({ diskPath: dbPath });
+const key = buildCacheKey({
+  tool: "scholar_search",
+  query: "test query",
+  sources: ["pubmed"],
+  max_results: 5,
+});
+const hit0 = cache.get(key);
+assert(hit0 === undefined, "first lookup is a miss");
+cache.set(key, { results: [{ source: "pubmed", title: "Test Paper" }] });
+const hit1 = cache.get(key);
+assert(hit1 !== undefined, "second lookup is a hit");
+assert(cache.hitRate() === 0.5, `hit rate is 0.5 (got ${cache.hitRate()})`);
+
+// disk persistence: new in-memory cache, same disk path -> still hits
+const cache2 = new SearchCache({ diskPath: dbPath });
+const hit2 = cache2.get(key);
+assert(hit2 !== undefined, "disk cache persists across SearchCache instances");
+cache.close();
+cache2.close();
+
+console.error("[3/3] exportResultsToNotion dry-run schema");
+const sampleResult = {
+  source: "pubmed",
+  title: "Sample paper on diabetic retinopathy",
+  authors: ["Yamada T", "Suzuki K"],
+  abstract: "Background. Methods. Results. Conclusions.",
+  doi: "10.1000/example.2026.001",
+  pmid: "12345678",
+  published_date: "2026-01-15",
+  venue: "JAMA Ophthalmology",
+  citation_count: 42,
+  url: "https://pubmed.ncbi.nlm.nih.gov/12345678/",
+};
+const dry = await exportResultsToNotion({
+  results: [sampleResult],
+  notion_database_id: "0a489d15-83e8-471d-ba1e-f04030473967",
+  include_japanese_summary: false,
+  dry_run: true,
+});
+
+assert(dry.dry_run === true, "dry_run flag echoed in output");
+assert(dry.total === 1, "total = 1");
+assert(dry.created === 0, "created = 0 in dry run");
+assert(dry.pages.length === 1, "one page payload returned");
+const p = dry.pages[0];
+assert(p.status === "dry_run", "page status = dry_run");
+assert(p.properties.Title !== undefined, "Title property present");
+assert(p.properties.Authors !== undefined, "Authors property present");
+assert(p.properties.DOI !== undefined && p.properties.DOI.url.includes("doi.org"), "DOI normalised to URL");
+assert(p.properties.Source.select.name === "pubmed", "Source select = pubmed");
+assert(p.properties.Published.date.start === "2026-01-15", "Published date passed through");
+assert(p.properties.Venue !== undefined, "Venue rich_text present");
+assert(p.properties["Citation Count"].number === 42, "Citation Count = 42");
+assert(p.properties.Abstract !== undefined, "Abstract rich_text present");
+assert(p.properties.Status.select.name === "To Read", "Status defaults to 'To Read'");
+assert(p.properties["Japanese Summary"] === undefined, "Japanese Summary omitted when not requested");
+
+// teardown
+rmSync(tmp, { recursive: true, force: true });
+
+if (failures === 0) {
+  console.error("\nAll smoke checks passed.");
+  process.exit(0);
+} else {
+  console.error(`\n${failures} check(s) failed.`);
+  process.exit(1);
+}

package/src/cache/disk_cache.ts

@@ -0,0 +1,94 @@
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+/**
+ * Persistent SQLite-backed cache for scholar_search results.
+ *
+ * Default location: ~/.scholar-mcp/cache/scholar_cache.db
+ * Default TTL: 7 days
+ *
+ * Schema:
+ *   key      TEXT PRIMARY KEY  -- sha256 of the canonical request
+ *   value    TEXT NOT NULL     -- JSON-serialised payload
+ *   created  INTEGER NOT NULL  -- epoch ms of insertion
+ *   expires  INTEGER NOT NULL  -- epoch ms after which the row is stale
+ */
+export class DiskCache<T extends object = object> {
+  private db: Database.Database;
+  private ttlMs: number;
+
+  constructor(dbPath?: string, ttlMs = 7 * 24 * 60 * 60 * 1000) {
+    const resolved = dbPath ?? join(homedir(), ".scholar-mcp", "cache", "scholar_cache.db");
+    mkdirSync(dirname(resolved), { recursive: true });
+    this.db = new Database(resolved);
+    this.ttlMs = ttlMs;
+    this.init();
+  }
+
+  private init(): void {
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS cache (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        created INTEGER NOT NULL,
+        expires INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_cache_expires ON cache(expires);
+    `);
+  }
+
+  get(key: string): T | undefined {
+    const row = this.db
+      .prepare<[string, number], { value: string }>(
+        "SELECT value FROM cache WHERE key = ? AND expires > ?"
+      )
+      .get(key, Date.now());
+    if (!row) return undefined;
+    try {
+      return JSON.parse(row.value) as T;
+    } catch {
+      return undefined;
+    }
+  }
+
+  set(key: string, value: T): void {
+    const now = Date.now();
+    this.db
+      .prepare(
+        "INSERT OR REPLACE INTO cache (key, value, created, expires) VALUES (?, ?, ?, ?)"
+      )
+      .run(key, JSON.stringify(value), now, now + this.ttlMs);
+  }
+
+  has(key: string): boolean {
+    return this.get(key) !== undefined;
+  }
+
+  delete(key: string): void {
+    this.db.prepare("DELETE FROM cache WHERE key = ?").run(key);
+  }
+
+  /** Remove all expired rows. Call periodically to keep the DB small. */
+  prune(): number {
+    const result = this.db.prepare("DELETE FROM cache WHERE expires <= ?").run(Date.now());
+    return Number(result.changes);
+  }
+
+  clear(): void {
+    this.db.exec("DELETE FROM cache");
+  }
+
+  get size(): number {
+    const row = this.db
+      .prepare<[number], { c: number }>("SELECT COUNT(*) AS c FROM cache WHERE expires > ?")
+      .get(Date.now());
+    return row?.c ?? 0;
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/cache/index.ts

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import type { Source } from "../types.js";
+import { MemoryCache } from "./memory_cache.js";
+import { DiskCache } from "./disk_cache.js";
+
+export { MemoryCache } from "./memory_cache.js";
+export { DiskCache } from "./disk_cache.js";
+
+/**
+ * Canonical key inputs. `sources` is sorted before hashing so that
+ * ["arxiv", "pubmed"] and ["pubmed", "arxiv"] map to the same cache entry.
+ */
+export interface CacheKeyInput {
+  tool: string;
+  query: string;
+  sources: Source[];
+  date_from?: string;
+  date_to?: string;
+  max_results?: number;
+}
+
+export function buildCacheKey(input: CacheKeyInput): string {
+  const canonical = {
+    tool: input.tool,
+    query: input.query.trim().toLowerCase(),
+    sources: [...input.sources].sort(),
+    date_from: input.date_from ?? null,
+    date_to: input.date_to ?? null,
+    max_results: input.max_results ?? null,
+  };
+  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+
+/**
+ * Two-tier cache helper: memory first, then disk. On a disk hit the
+ * value is promoted back into memory so subsequent lookups are fast.
+ *
+ * Stats lets the caller report a cache_hit_rate metric.
+ */
+export class SearchCache<T extends object = object> {
+  readonly memory: MemoryCache<T>;
+  readonly disk: DiskCache<T>;
+  private hits = 0;
+  private misses = 0;
+
+  constructor(opts: {
+    memoryMaxEntries?: number;
+    memoryTtlMs?: number;
+    diskPath?: string;
+    diskTtlMs?: number;
+  } = {}) {
+    this.memory = new MemoryCache<T>(opts.memoryMaxEntries, opts.memoryTtlMs);
+    this.disk = new DiskCache<T>(opts.diskPath, opts.diskTtlMs);
+  }
+
+  get(key: string): T | undefined {
+    const m = this.memory.get(key);
+    if (m !== undefined) {
+      this.hits++;
+      return m;
+    }
+    const d = this.disk.get(key);
+    if (d !== undefined) {
+      this.memory.set(key, d);
+      this.hits++;
+      return d;
+    }
+    this.misses++;
+    return undefined;
+  }
+
+  set(key: string, value: T): void {
+    this.memory.set(key, value);
+    this.disk.set(key, value);
+  }
+
+  /** Hit rate over the lifetime of this cache instance. */
+  hitRate(): number {
+    const total = this.hits + this.misses;
+    return total === 0 ? 0 : this.hits / total;
+  }
+
+  stats(): { hits: number; misses: number; rate: number } {
+    return { hits: this.hits, misses: this.misses, rate: this.hitRate() };
+  }
+
+  resetStats(): void {
+    this.hits = 0;
+    this.misses = 0;
+  }
+
+  close(): void {
+    this.disk.close();
+  }
+}

package/src/cache/memory_cache.ts

@@ -0,0 +1,43 @@
+import { LRUCache } from "lru-cache";
+
+/**
+ * In-process LRU cache for scholar_search results.
+ *
+ * - Capacity: 1000 entries
+ * - TTL: 1 hour
+ * - Stores arbitrary JSON-serialisable values keyed by sha256 hash
+ */
+export class MemoryCache<T extends object = object> {
+  private cache: LRUCache<string, T>;
+
+  constructor(maxEntries = 1000, ttlMs = 60 * 60 * 1000) {
+    this.cache = new LRUCache<string, T>({
+      max: maxEntries,
+      ttl: ttlMs,
+    });
+  }
+
+  get(key: string): T | undefined {
+    return this.cache.get(key);
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, value);
+  }
+
+  has(key: string): boolean {
+    return this.cache.has(key);
+  }
+
+  delete(key: string): boolean {
+    return this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  get size(): number {
+    return this.cache.size;
+  }
+}