flonat-research 0.1.0

package/packages/mcp-bibliography/tools/opencitations.py

@@ -0,0 +1,102 @@
+"""OpenCitations tools (2 tools, always available)."""
+
+from mcp.types import Tool, TextContent
+
+from _app import _opencitations_client
+from tools._registry import register
+
+
+# ---------- Handlers ----------
+
+
+async def _handle_opencitations_citations(args: dict) -> list[TextContent]:
+    doi = args["doi"]
+    limit = args.get("limit")
+
+    citations = await _opencitations_client.get_citations(doi, limit=limit)
+
+    if not citations:
+        return [TextContent(type="text", text=f"No citations found in OpenCitations for: {doi}")]
+
+    count = await _opencitations_client.get_citation_count(doi)
+
+    lines = [f"## OpenCitations: Papers citing {doi}\n"]
+    lines.append(f"**Total citations:** {count}\n")
+    lines.append("| # | Citing DOI | Date |")
+    lines.append("|---|-----------|------|")
+
+    for i, c in enumerate(citations[:50], 1):
+        citing_doi = c.citing
+        date = c.creation or "—"
+        lines.append(f"| {i} | [{citing_doi}](https://doi.org/{citing_doi}) | {date} |")
+
+    if len(citations) > 50:
+        lines.append(f"\n*Showing 50 of {len(citations)} citations*")
+
+    lines.append(f"\n*Source: OpenCitations COCI (fully open citation index)*")
+    return [TextContent(type="text", text="\n".join(lines))]
+
+
+async def _handle_opencitations_references(args: dict) -> list[TextContent]:
+    doi = args["doi"]
+    limit = args.get("limit")
+
+    references = await _opencitations_client.get_references(doi, limit=limit)
+
+    if not references:
+        return [TextContent(type="text", text=f"No references found in OpenCitations for: {doi}")]
+
+    lines = [f"## OpenCitations: References of {doi}\n"]
+    lines.append("| # | Referenced DOI | Date |")
+    lines.append("|---|--------------|------|")
+
+    for i, r in enumerate(references, 1):
+        cited_doi = r.cited
+        date = r.creation or "—"
+        lines.append(f"| {i} | [{cited_doi}](https://doi.org/{cited_doi}) | {date} |")
+
+    lines.append(f"\n*{len(references)} references (Source: OpenCitations COCI)*")
+    return [TextContent(type="text", text="\n".join(lines))]
+
+
+# ---------- Registration ----------
+
+_TOOLS = [
+    (
+        Tool(
+            name="opencitations_citations",
+            description=(
+                "Get papers that cite a given DOI using the fully open COCI citation index. "
+                "Returns citing DOIs with dates. Complements Semantic Scholar citations with "
+                "a fully open, non-proprietary citation graph."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "doi": {"type": "string", "description": "DOI to find citations for (with or without prefix)"},
+                    "limit": {"type": "integer", "description": "Max results (default: all citations)"},
+                },
+                "required": ["doi"],
+            },
+        ),
+        _handle_opencitations_citations,
+    ),
+    (
+        Tool(
+            name="opencitations_references",
+            description="Get papers referenced by a given DOI (backward citations / bibliography). Returns cited DOIs. Use for tracing intellectual lineage.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "doi": {"type": "string", "description": "DOI to find references for"},
+                    "limit": {"type": "integer", "description": "Max results (default: all references)"},
+                },
+                "required": ["doi"],
+            },
+        ),
+        _handle_opencitations_references,
+    ),
+]
+
+for tool, handler in _TOOLS:
+    register(tool, handler)

package/packages/mcp-bibliography/tools/openreview.py

@@ -0,0 +1,179 @@
+"""OpenReview tools (3 tools, always available)."""
+
+from mcp.types import Tool, TextContent
+
+from _app import _openreview_client, format_papers_table
+from tools._registry import register
+
+
+# ---------- Handlers ----------
+
+
+async def _handle_openreview_venue(args: dict) -> list[TextContent]:
+    venue_id = args["venue_id"]
+    limit = min(args.get("limit", 25), 1000)
+
+    papers = await _openreview_client.get_venue_submissions(venue_id, limit=limit)
+
+    if not papers:
+        return [TextContent(type="text", text=f"No submissions found for venue: {venue_id}")]
+
+    lines = [f"## OpenReview: {venue_id}\n"]
+    lines.append("| # | Title | Authors | Keywords | Area | Forum ID |")
+    lines.append("|---|-------|---------|----------|------|----------|")
+
+    for i, p in enumerate(papers, 1):
+        title = p.title[:60] + ("..." if len(p.title) > 60 else "")
+        authors = ", ".join(p.authors[:3]) + ("..." if len(p.authors) > 3 else "")
+        kw = ", ".join(p.keywords[:3]) if p.keywords else "—"
+        area = p.primary_area or "—"
+        if len(area) > 30:
+            area = area[:30] + "..."
+        lines.append(f"| {i} | [{title}](https://openreview.net/forum?id={p.forum_id}) | {authors} | {kw} | {area} | `{p.forum_id}` |")
+
+    lines.append(f"\n*{len(papers)} submissions from OpenReview*")
+    return [TextContent(type="text", text="\n".join(lines))]
+
+
+async def _handle_openreview_reviews(args: dict) -> list[TextContent]:
+    forum_id = args["forum_id"]
+
+    paper = await _openreview_client.get_paper_with_reviews(forum_id)
+
+    if not paper:
+        return [TextContent(type="text", text=f"Paper not found: {forum_id}")]
+
+    lines = [f"## {paper.title}\n"]
+    lines.append(f"**Forum:** [openreview.net/forum?id={forum_id}](https://openreview.net/forum?id={forum_id})")
+    if paper.authors:
+        lines.append(f"**Authors:** {', '.join(paper.authors[:5])}")
+    if paper.venue:
+        lines.append(f"**Venue:** {paper.venue}")
+    if paper.primary_area:
+        lines.append(f"**Area:** {paper.primary_area}")
+    if paper.keywords:
+        lines.append(f"**Keywords:** {', '.join(paper.keywords)}")
+    if paper.tldr:
+        lines.append(f"**TLDR:** {paper.tldr}")
+    if paper.abstract:
+        lines.append(f"\n**Abstract:** {paper.abstract[:500]}{'...' if len(paper.abstract or '') > 500 else ''}")
+
+    if paper.reviews:
+        lines.append(f"\n### Reviews ({len(paper.reviews)})\n")
+        for i, r in enumerate(paper.reviews, 1):
+            lines.append(f"#### Reviewer {i}")
+            if r.rating:
+                lines.append(f"- **Rating:** {r.rating}")
+            if r.soundness:
+                lines.append(f"- **Soundness:** {r.soundness}")
+            if r.presentation:
+                lines.append(f"- **Presentation:** {r.presentation}")
+            if r.contribution:
+                lines.append(f"- **Contribution:** {r.contribution}")
+            if r.confidence:
+                lines.append(f"- **Confidence:** {r.confidence}")
+            if r.strengths:
+                lines.append(f"- **Strengths:** {r.strengths}")
+            if r.weaknesses:
+                lines.append(f"- **Weaknesses:** {r.weaknesses}")
+            lines.append("")
+    else:
+        lines.append("\n*No reviews available.*")
+
+    lines.append(f"\n*Source: OpenReview API v2*")
+    return [TextContent(type="text", text="\n".join(lines))]
+
+
+async def _handle_openreview_search(args: dict) -> list[TextContent]:
+    query = args["query"]
+    venue_id = args.get("venue_id")
+    limit = min(args.get("limit", 25), 100)
+
+    papers = await _openreview_client.search(query, venue_id=venue_id, limit=limit)
+
+    if not papers:
+        return [TextContent(type="text", text=f"No OpenReview results for: {query}")]
+
+    lines = [f"## OpenReview Search: {query}\n"]
+    if venue_id:
+        lines[0] = f"## OpenReview Search: {query} (venue: {venue_id})\n"
+
+    lines.append("| # | Title | Authors | Venue | Forum ID |")
+    lines.append("|---|-------|---------|-------|----------|")
+
+    for i, p in enumerate(papers, 1):
+        title = p.title[:60] + ("..." if len(p.title) > 60 else "")
+        authors = ", ".join(p.authors[:2]) + ("..." if len(p.authors) > 2 else "")
+        venue = p.venue or p.venue_id or "—"
+        if len(venue) > 30:
+            venue = venue[:30] + "..."
+        lines.append(f"| {i} | [{title}](https://openreview.net/forum?id={p.forum_id}) | {authors} | {venue} | `{p.forum_id}` |")
+
+    lines.append(f"\n*{len(papers)} results from OpenReview*")
+    return [TextContent(type="text", text="\n".join(lines))]
+
+
+# ---------- Tool definitions + registration ----------
+
+_TOOLS = [
+    (
+        Tool(
+            name="openreview_venue_submissions",
+            description=(
+                "Get submissions for an AI/ML conference from OpenReview. Returns titles, abstracts, "
+                "authors, keywords, and primary areas. Supports: NeurIPS, ICLR, ICML, ACL, EMNLP, "
+                "AISTATS, UAI, CoRL, AAAI. Use shorthand like 'neurips/2024' or full ID."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "venue_id": {"type": "string", "description": "Venue ID: shorthand (neurips/2024, iclr/2025) or full (NeurIPS.cc/2024/Conference)"},
+                    "limit": {"type": "integer", "description": "Max results (default 25, max 1000)"},
+                },
+                "required": ["venue_id"],
+            },
+        ),
+        _handle_openreview_venue,
+    ),
+    (
+        Tool(
+            name="openreview_paper_reviews",
+            description=(
+                "Get a paper and all its reviews from OpenReview. Returns the submission plus "
+                "reviewer ratings, soundness, strengths, weaknesses, and questions. "
+                "Provide the forum ID (from openreview_venue_submissions results)."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "forum_id": {"type": "string", "description": "OpenReview forum ID for the paper"},
+                },
+                "required": ["forum_id"],
+            },
+        ),
+        _handle_openreview_reviews,
+    ),
+    (
+        Tool(
+            name="openreview_search",
+            description=(
+                "Search OpenReview for papers by text query. Optionally filter by venue. "
+                "Returns submissions matching the query. Use for finding specific papers "
+                "or exploring what's been submitted to a conference on a topic."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query (keywords, title fragment)"},
+                    "venue_id": {"type": "string", "description": "Optional venue filter (e.g. neurips/2024)"},
+                    "limit": {"type": "integer", "description": "Max results (default 25)"},
+                },
+                "required": ["query"],
+            },
+        ),
+        _handle_openreview_search,
+    ),
+]
+
+for tool, handler in _TOOLS:
+    register(tool, handler)

package/packages/mcp-bibliography/tools/orcid.py

@@ -0,0 +1,131 @@
+"""ORCID tools (2 tools, conditional on credentials)."""
+
+from mcp.types import Tool, TextContent
+
+from _app import _orcid_client
+from tools._registry import register
+
+
+# ---------- Handlers ----------
+
+
+async def _handle_orcid_search(args: dict) -> list[TextContent]:
+    if not _orcid_client:
+        return [TextContent(type="text", text="**Error:** ORCID not configured (set ORCID_CLIENT_ID + ORCID_CLIENT_SECRET)")]
+
+    query = args["query"]
+    limit = min(args.get("limit", 10), 100)
+
+    results = await _orcid_client.search(query, limit=limit)
+
+    if not results:
+        return [TextContent(type="text", text=f"No ORCID profiles found for: {query}")]
+
+    lines = [f"## ORCID Search: {query}\n"]
+    lines.append(f"| # | ORCID iD | Name | Affiliations |")
+    lines.append(f"|---|----------|------|-------------|")
+
+    for i, r in enumerate(results, 1):
+        name = r.credit_name or f"{r.given_names} {r.family_name}"
+        institutions = ", ".join(r.institutions[:3]) if r.institutions else "—"
+        lines.append(f"| {i} | [{r.orcid_id}](https://orcid.org/{r.orcid_id}) | {name} | {institutions} |")
+
+    lines.append(f"\n*{len(results)} result(s) from ORCID registry*")
+    return [TextContent(type="text", text="\n".join(lines))]
+
+
+async def _handle_orcid_get_researcher(args: dict) -> list[TextContent]:
+    if not _orcid_client:
+        return [TextContent(type="text", text="**Error:** ORCID not configured (set ORCID_CLIENT_ID + ORCID_CLIENT_SECRET)")]
+
+    orcid_id = args["orcid_id"]
+    include_works = args.get("include_works", True)
+    max_works = min(args.get("max_works", 50), 200)
+
+    researcher = await _orcid_client.get_researcher(
+        orcid_id,
+        include_works=include_works,
+        max_works=max_works,
+    )
+
+    if not researcher:
+        return [TextContent(type="text", text=f"ORCID profile not found: {orcid_id}")]
+
+    lines = [f"## {researcher.display_name}\n"]
+    lines.append(f"**ORCID:** [{researcher.orcid_id}]({researcher.profile_url})")
+
+    if researcher.affiliations:
+        lines.append(f"**Affiliations:** {', '.join(researcher.affiliations)}")
+
+    if researcher.biography:
+        bio = researcher.biography[:500]
+        if len(researcher.biography) > 500:
+            bio += "..."
+        lines.append(f"\n**Biography:** {bio}")
+
+    if researcher.keywords:
+        lines.append(f"**Keywords:** {', '.join(researcher.keywords)}")
+
+    if researcher.urls:
+        url_parts = [f"[{name}]({url})" for name, url in list(researcher.urls.items())[:5]]
+        lines.append(f"**Links:** {' · '.join(url_parts)}")
+
+    if researcher.works:
+        lines.append(f"\n### Publications ({researcher.works_count} total, showing {len(researcher.works)})\n")
+        lines.append("| Year | Title | DOI | Type |")
+        lines.append("|------|-------|-----|------|")
+
+        for w in sorted(researcher.works, key=lambda x: x.year or 0, reverse=True):
+            year = str(w.year) if w.year else "—"
+            title = w.title[:80] + ("..." if len(w.title) > 80 else "")
+            doi_link = f"[{w.doi}](https://doi.org/{w.doi})" if w.doi else "—"
+            wtype = (w.work_type or "—").replace("-", " ")
+            lines.append(f"| {year} | {title} | {doi_link} | {wtype} |")
+
+    lines.append(f"\n*Source: ORCID Public API v3.0*")
+    return [TextContent(type="text", text="\n".join(lines))]
+
+
+# ---------- Registration (conditional) ----------
+
+if _orcid_client:
+    register(
+        Tool(
+            name="orcid_search_researchers",
+            description=(
+                "Search the ORCID registry for researchers by name, affiliation, or keyword. "
+                "Returns ORCID iDs with names and institutional affiliations. "
+                "Query syntax: family-name:Smith, given-names:John, affiliation-org-name:Warwick, keyword:MCDM. "
+                "Combine with AND/OR. Use this to find a researcher's ORCID iD for disambiguation."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "ORCID search query (Lucene syntax: family-name:X AND affiliation-org-name:Y)"},
+                    "limit": {"type": "integer", "description": "Max results (default 10, max 100)"},
+                },
+                "required": ["query"],
+            },
+        ),
+        _handle_orcid_search,
+    )
+    register(
+        Tool(
+            name="orcid_get_researcher",
+            description=(
+                "Get a researcher's full ORCID profile: name, biography, affiliations, keywords, "
+                "URLs, and publication list with DOIs. Provide an ORCID iD (e.g. 0000-0001-2345-6789). "
+                "Use orcid_search_researchers first to find the iD if you only have a name."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "orcid_id": {"type": "string", "description": "ORCID identifier (e.g. 0000-0001-2345-6789 or https://orcid.org/0000-0001-2345-6789)"},
+                    "include_works": {"type": "boolean", "description": "Include publication list (default true)"},
+                    "max_works": {"type": "integer", "description": "Max works to return (default 50)"},
+                },
+                "required": ["orcid_id"],
+            },
+        ),
+        _handle_orcid_get_researcher,
+    )