wu-yc/labclaw/academic-literature-search

Tool: pubmed_search_articles
Parameters:
  queryTerm: "large language model bioinformatics"
  maxResults: 20
  sortBy: "relevance"                       ← 或 "pub_date"
  fetchBriefSummaries: 10                   ← 返回前10篇摘要
  dateRange:                                ← 可选
    minDate: "2022"
    maxDate: "2026"
    dateType: "pdat"
  filterByPublicationTypes: ["Review"]      ← 可选

queryTerm: "(large language model agent) AND (biorxiv[journal] OR medrxiv[journal])"

Tool: pubmed_fetch_contents
Parameters:
  pmids: ["39361263", "38768397", "36869294"]
  detailLevel: "abstract_plus"              ← 推荐，解析后的结构化数据
  includeMeshTerms: true

Tool: pubmed_article_connections
Parameters:
  sourcePmid: "39361263"
  relationshipType: "pubmed_similar_articles"   ← 或 citedin / references / citation_formats
  maxRelatedResults: 15

Tool: pubmed_article_connections
Parameters:
  sourcePmid: "39361263"
  relationshipType: "citation_formats"
  citationStyles: ["ris", "bibtex", "apa_string"]

import urllib.request, urllib.parse, xml.etree.ElementTree as ET, re
def _parse_author_name(full_name):
    """Convert 'Shunyu Yao' → 'Yao S' (GB/T 7714: surname first, initials)."""
    parts = full_name.strip().split()
    if not parts:
        return full_name
    if len(parts) == 1:
        return parts[0]
    surname = parts[-1]
    initials = "".join(p[0].upper() for p in parts[:-1])
    return f"{surname} {initials}"
def search_arxiv(query, max_results=10):
    """Search arXiv. Free API, no key needed. Uses only stdlib."""
    params = urllib.parse.urlencode({
        "search_query": f"all:{query}", "start": 0,
        "max_results": max_results, "sortBy": "relevance",
        "sortOrder": "descending"
    })
    url = f"https://export.arxiv.org/api/query?{params}"
    with urllib.request.urlopen(url, timeout=30) as resp:
        xml_text = resp.read().decode("utf-8")
    ns = {"atom": "http://www.w3.org/2005/Atom",
          "arxiv": "http://arxiv.org/schemas/atom"}
    root = ET.fromstring(xml_text)
    articles = []
    for entry in root.findall("atom:entry", ns):
        title = (entry.findtext("atom:title", "", ns) or "").replace("\n", " ").strip()
        abstract = (entry.findtext("atom:summary", "", ns) or "").replace("\n", " ").strip()
        raw_authors = [a.findtext("atom:name", "", ns).strip()
                       for a in entry.findall("atom:author", ns)]
        authors_gbt = [_parse_author_name(a) for a in raw_authors]
        published = entry.findtext("atom:published", "", ns)[:10]
        id_url = entry.findtext("atom:id", "", ns) or ""
        arxiv_id = id_url.split("/abs/")[-1] if "/abs/" in id_url else ""
        doi_e = entry.find("arxiv:doi", ns)
        doi = doi_e.text.strip() if doi_e is not None and doi_e.text else ""
        cat_e = entry.find("arxiv:primary_category", ns)
        cat = cat_e.get("term", "") if cat_e is not None else ""
        articles.append({
            "source": "arxiv", "pmid": "", "doi": doi, "arxiv_id": arxiv_id,
            "title": title, "authors": authors_gbt,
            "journal": f"arXiv:{arxiv_id}",
            "year": published[:4] if published else "",
            "volume": "", "issue": "", "pages": "",
            "abstract": abstract,
            "url": f"https://arxiv.org/abs/{arxiv_id}",
            "category": cat,
            "venue": "",  # populated manually for published conference papers
        })
    return articles

def format_gbt7714(article, seq_num):
    """Format one article as GB/T 7714-2015 sequential reference.
    Handles: MCP article dicts (authors as list of dicts, journalInfo as nested dict),
             Python-parsed dicts (flat fields), and arXiv dicts.
    Supports: [J] journal, [Z/OL] preprint, [C] conference, [M] book, [D] dissertation.
    """
    # ── Author parsing (handles 4 input formats) ──
    authors_raw = article.get("authors") or []
    if isinstance(authors_raw, str):
        authors = [a.strip() for a in authors_raw.split(",") if a.strip()]
    elif authors_raw and isinstance(authors_raw[0], dict):
        authors = []
        for a in authors_raw:
            last = a.get("lastName") or ""
            ini = a.get("initials") or (a.get("firstName") or "")[:1]
            if last:
                authors.append(f"{last} {ini}".strip())
    else:
        authors = [str(a) for a in authors_raw if a]
    if len(authors) > 3:
        author_str = ", ".join(authors[:3]) + ", et al"
    elif authors:
        author_str = ", ".join(authors)
    else:
        author_str = "Anonymous"
    title = (article.get("title") or "Untitled").rstrip(".")
    source = article.get("source") or "pubmed"
    doi = (article.get("doi") or "").strip()
    # ── Journal info (MCP nested dict vs flat fields) ──
    journal_info = article.get("journalInfo")
    if journal_info and isinstance(journal_info, dict):
        journal = journal_info.get("title") or journal_info.get("isoAbbreviation") or ""
        volume = journal_info.get("volume") or ""
        issue = journal_info.get("issue") or ""
        pages = journal_info.get("pages") or ""
        pub_date = journal_info.get("publicationDate") or {}
        year = pub_date.get("year", "") if isinstance(pub_date, dict) else str(pub_date)[:4]
    else:
        journal = article.get("journal") or ""
        volume = article.get("volume") or ""
        issue = article.get("issue") or ""
        pages = article.get("pages") or ""
        year = article.get("year") or ""
    venue = article.get("venue") or ""  # for conference papers
    # ── Detect document type ──
    doc_type = article.get("doc_type") or ""  # explicit override
    if not doc_type:
        jl = (journal or "").lower()
        if source in ("biorxiv", "medrxiv") or "biorxiv" in jl or "medrxiv" in jl:
            doc_type = "preprint"
        elif source == "arxiv":
            if venue:
                doc_type = "conference"
            else:
                doc_type = "preprint"
        elif venue:
            doc_type = "conference"
        else:
            doc_type = "journal"
    # ── Format by document type ──
    if doc_type == "preprint":
        platform = "bioRxiv" if "biorxiv" in (journal or "").lower() else \
                   "medRxiv" if "medrxiv" in (journal or "").lower() else \
                   f"arXiv:{article.get('arxiv_id', '')}" if source == "arxiv" else \
                   journal or "Preprint"
        ref = f"[{seq_num}] {author_str}. {title}[Z/OL]. {platform}, {year}"
        if doi:
            ref += f". DOI: {doi}"
        ref += "."
    elif doc_type == "conference":
        # [C]//Conference Name. City: Publisher, Year: Pages.
        # Simplified: if venue is known, use it; otherwise fall back
        ref = f"[{seq_num}] {author_str}. {title}[C]//{venue}"
        if year:
            ref += f", {year}"
        if pages:
            ref += f": {pages}"
        ref += "."
        if doi:
            ref += f" DOI: {doi}."
    elif doc_type == "book":
        publisher = article.get("publisher") or ""
        city = article.get("city") or ""
        ref = f"[{seq_num}] {author_str}. {title}[M]"
        if city or publisher:
            ref += f". {city}: {publisher}" if city else f". {publisher}"
        if year:
            ref += f", {year}"
        ref += "."
    elif doc_type == "dissertation":
        institution = article.get("institution") or ""
        city = article.get("city") or ""
        ref = f"[{seq_num}] {author_str}. {title}[D]"
        if city or institution:
            ref += f". {city}: {institution}" if city else f". {institution}"
        if year:
            ref += f", {year}"
        ref += "."
    else:
        # Default: [J] journal article
        ref = f"[{seq_num}] {author_str}. {title}[J]. {journal}, {year}"
        if volume:
            ref += f", {volume}"
        if issue:
            ref += f"({issue})"
        if pages:
            ref += f": {pages}"
        ref += "."
        if doi:
            ref += f" DOI: {doi}."
    return ref
def format_reference_list(articles):
    """Batch format articles into numbered GB/T 7714 reference list."""
    return "\n".join(format_gbt7714(a, i) for i, a in enumerate(articles, 1))

[N] Yao S, Zhao J, Yu D, et al. ReAct: synergizing reasoning and acting in language models[C]//International Conference on Learning Representations (ICLR), 2023.
[N] Wei J, Wang X, Schuurmans D, et al. Chain-of-thought prompting elicits reasoning in large language models[C]//Advances in Neural Information Processing Systems (NeurIPS), 2022.

article["venue"] = "International Conference on Learning Representations (ICLR)"
article["doc_type"] = "conference"

import re
def process_citations(body, sources):
    """Post-process LLM-written text:
    1. Expand [1,2,3] → [1][2][3]
    2. Collect cited IDs in order of first appearance
    3. Remap to sequential numbering
    4. Remove phantom citations (IDs not in sources)
    """
    # Step 1: Expand multi-citations
    body = re.sub(
        r"\[(\d+(?:\s*,\s*\d+)+)\]",
        lambda m: "".join(f"[{n.strip()}]" for n in m.group(1).split(",")),
        body
    )