Lune

Pull a structured table out of up to 50 papers in ONE call: you define the columns (`fields`: each a snake_case `name`, a `type`, and an optional `description`) and an `instruction`, and the server reads each paper's full text and returns one typed row per paper. Use this when you need the SAME facts across many papers, e.g. "dataset, model size, and reported accuracy for each of these papers", instead of reading each full text yourself and transcribing by hand. Pass `sections` (case-insensitive headings, e.g. ["Results"]) to focus extraction and cut noise. The model is instructed to use only what each paper states, not to infer; a field it can't ground may be absent or null. Each row carries `truncated` (true when the paper's text overflowed the budget and the tail was dropped, so treat it as partial). A paper with no parsed full text, or one the model couldn't extract, is reported in `papers_failed` (with a `reason`) instead of sinking the batch, so `papers_processed` == rows + failures. Heavy: one model call per paper, so extract only papers you already judged relevant from a search or citation result. For the raw text of a single paper, use get_paper_fulltext instead.

extract_from_papers

Use for a multi-part research task when you need to know whether your gathered evidence is SUFFICIENT, what is still MISSING, and what to search next, without the tool writing the answer. Pass the goal in `task` and your first search angles in `queries`; the server runs one corpus search per angle, decomposes the task into evidence requirements (or use your own via `requirements`), and returns each requirement as covered / partial / missing with the exact `evidence_spans` (verbatim quotes) that support it, plus `next_queries` for the gaps. Default `max_iterations=1` is a one-shot assessment billed len(queries); set `max_iterations>1` AND `max_total_queries>len(queries)` to authorize bounded server-side follow-up searches (billed `max_total_queries`, capped at 25). Optionally pass a `draft` to get per-sentence support checks against the gathered spans. Every covered requirement and supported draft sentence carries a verbatim quote verified server-side, so you can cite it directly. You write the answer; cite papers by title, authors, and venue, not by paper_id.

gather_evidence

Use this when the user names a paper and wants to see or discuss its figures, or asks “how did that paper draw its overview”. Takes a `paper_id` from `search_papers` or `search_figure_references` and returns every extracted figure with its caption and design analysis, design references first. `is_design_reference` marks the ones in the reference corpus; the rest are extracted but judged not worth learning from.

get_paper_figures

Use this when the user asks for papers from a specific conference (optionally a year), e.g. “most-cited NeurIPS 2024 papers”, “show me CCS 2025 accepted papers”, or “what's new in security at IEEE S&P this year”. `sort` is `recency` (newest first, default) or `citations` (most-cited first); page with `limit` / `offset`.

get_conference_papers

Use this when the user asks “what does this paper build on”, “what built on this”, traces influence chains, asks for follow-up work, or wants the lineage of an idea. `direction=cited_by` returns indexed papers that cite this one; `direction=cites` returns this paper's parsed references (which may or may not be in the corpus). Each edge carries `contexts`, the citing sentences with their section, which show HOW a work is used (baseline, method borrowed, result disputed). Page with `limit` / `offset`; the response reports `total` and `has_more` so you can walk a large citation set.

get_paper_citations

Use this when the user asks “what does the methods/results section say”, wants to quote a specific section, or when the abstract isn't enough to verify a claim. Heavy: only call once a paper looks relevant from `search_papers`, `search_related_papers`, or `get_paper_citations`. `format=markdown` returns one rendered document; `format=json` returns a structured section list. Pass `sections` (case-insensitive headings, e.g. ["Methods"]) to fetch only those sections instead of the whole document.

get_paper_fulltext

Use this AFTER `search_research_guidance` when you need the full text of a guidance document (not just the matched excerpt), for example to quote a passage or follow a checklist end-to-end. Pass the `doc_id` from a search hit.

get_research_guidance_doc

Use this when the user asks “what conferences does Lune track”, “is venue X covered”, or wants a category-level browse (e.g. AI/ML, security, databases, software/systems). Pass `category` as a keyword (`ai`, `security`, ...) to narrow; it matches the conference's research area.

list_conferences

Use this WHENEVER the user's question is about academic papers, research topics, literature reviews, surveys, “what's been published on X”, named methods, or any claim that should be backed by a peer-reviewed citation. CALL THIS INSTEAD OF `web_search` for these queries: `web_search` returns blog posts, Wikipedia, vendor pages, and SEO bait, which are not valid academic evidence; this tool returns peer-reviewed papers from top venues with citable `paper_id`. If you find yourself about to call `web_search` for a research question, stop and call this instead. Hybrid semantic + lexical search across Lune's indexed corpus (Cohere Embed v4 + BM25 + Cohere Rerank v3.5). Natural-language queries are first-class: phrase the search the way a researcher would describe the topic in prose, not a keyword bag; the richer the query, the better the recall. Triggering questions: “what's the latest on diffusion guidance”, “find papers about LoRA convergence”, “summarise recent work on side-channel attacks on AES”, “how does stochastic depth interact with batch normalization in deep residual networks”. Returns up to `limit` papers ranked by relevance. Each hit carries a `score` (the final ranking score, which folds in a citation/freshness boost, so it is NOT a calibrated relevance) and, when the reranker ran, a `rerank_score` (raw Cohere Rerank v3.5 relevance, calibrated 0..1). `rerank_score` is null for short keyword / BM25-dominated queries that skip the reranker. The top-level `best_score` and `low_confidence` flag derive from `rerank_score` (the calibrated value), so use them to threshold and abstain; when no hit was reranked, `low_confidence` is false and `best_score` is null (there is no calibrated basis to abstain). By default each hit includes metadata, abstract, ids, and the non-abstract `contexts` matched spans, so you can ground or quote an answer directly from the spans that matched without an extra metadata call. Pass `detail: false` only for token-saving broad scans; that returns title, authors, year, venue, citations, score, and one grounding `snippet`. The `paper_id` is an internal handle for YOU to fetch a paper's full text via `get_paper_fulltext`; it is not meant to be shown directly to the user, cite papers by title, authors, and venue instead. Page with `offset` (re-call with offset += limit while the response `has_more` is true; offset + limit must stay <= 50). Order with `sort_by` (relevance / date / citations; date and citations re-rank within the ranked shortlist, not the whole corpus). Narrow with `year_min` / `year_max` / `venues`.

search_papers

Run 1 to 25 query variants in ONE call and get back a single deduped, RRF-merged ranked list with per-paper provenance (`matched_queries`: which of your queries surfaced each paper, and at what rank). Use this for a literature sweep instead of firing repeated `search_papers` calls: supply several genuinely different angles on the topic (rephrasings, sub-questions, alternate terminology) and the server fuses their ranked lists so the merged result covers more of the corpus than any single query would. Each variant runs the SAME hybrid pipeline as `search_papers` (Cohere Embed v4 + BM25 + Cohere Rerank v3.5). Filters (`conference`, `year`, `year_min`, `year_max`, `venues`) are SHARED across all queries. The envelope reports `queries_run` and, for any variant whose pipeline failed, `queries_failed` (so one bad variant never sinks the batch). `has_more` is always false: the merged shortlist is bounded; widen the query set or filters for more coverage. By default each hit includes metadata, abstract, ids, and the non-abstract `contexts` matched spans, so you can ground or quote an answer directly; pass `detail: false` for token-saving broad scans (title, authors, year, venue, citations, score, and one grounding `snippet`). `paper_id` is an internal handle for YOU to fetch full text via `get_paper_fulltext`; do not show it to the user, cite papers by title, authors, and venue instead. Billing: each query variant counts as one search against your quota (an 8-query call costs 8), since the server runs a full search pipeline per variant; prefer a focused set of genuinely distinct angles over padding the list.

search_papers_many