Skip to main content
Glama

Scholar Agent

Python 3.10+ License: MIT MCP Ready

中文

Allzweck-LLMs sind in spezialisierten Bereichen oft ungenau und veraltet. Scholar Agent kombiniert Online-Recherche + lokale Wissensansammlung zu einem nachhaltigen Wissens-Schwungrad, das Ihre KI mit der Zeit in Ihrem Fachgebiet intelligenter macht. Zudem erstellt es eine für Menschen lesbare Wissensdatenbank für schnelles Lernen. Lässt sich nahtlos über MCP in Claude Code und VS Code Copilot integrieren.

Was es tut

Your question
    │
    ▼
Online research (LLM web search + academic APIs)
    │
    ▼
Structured synthesis (with citations, confidence, uncertainty)
    │
    ▼
Local accumulation (Markdown knowledge cards + BM25 index)
    │
    ▼
Next question: AI checks local first ── hit? ──► use directly, fast & accurate
    │ miss
    ▼
Research again → accumulate → reindex ──► knowledge base keeps growing

Jede Runde verstärkt sich selbst. Wissenskarten verfügen über ein vollständiges Lebenszyklusmanagement: Entwurf → geprüft → vertrauenswürdig → veraltet → abgekündigt.

Related MCP server: codememory

Akademische Recherche-Pipeline

Scholar Agent enthält eine umfassende Pipeline für die Recherche akademischer Arbeiten:

  • Papersuche — Durchsuchen Sie Arbeiten von arXiv, DBLP und Semantic Scholar. Filtern Sie nach Top-Konferenzen (CVPR, ICCV, ECCV, ICLR, AAAI, NeurIPS, ICML, ACL, EMNLP, MICCAI)

  • Intelligente Bewertung — Eine vierdimensionale Bewertungs-Engine (Relevanz, Aktualität, Popularität, Qualität) sortiert Arbeiten nach Ihren Forschungsinteressen

  • Detaillierte Analyse-Notizen — Automatische Generierung von Obsidian-artigen Markdown-Notizen mit über 20 Abschnitten und <!-- LLM: -->-Platzhaltern für KI-gestützte Vervollständigung

  • Figurenextraktion — Extrahieren Sie Bilder aus arXiv-Quellarchiven und PDFs (via PyMuPDF)

  • Tägliche Empfehlungen — Automatisierte tägliche Papersuche, Bewertung, Deduplizierung und Generierung von Empfehlungsnotizen

  • Paper → Wissenskarte — Konvertieren Sie Paper-Analysen in Wissenskarten, die zurück in das Wissens-Schwungrad fließen

  • Automatische Schlagwort-Verlinkung — Scannen Sie Notizen nach Fachbegriffen und erstellen Sie automatisch [[wiki-links]]

Schnelleinstieg

In ein bestehendes Projekt einbetten

cd my-project && git clone https://github.com/zfy465914233/scholar-agent.git
bash scholar-agent/setup.sh
# Restart Claude Code to activate

Dies erstellt die Verzeichnisstruktur, kopiert Konfigurationsvorlagen, installiert Skills und baut den Wissensindex auf.

Als eigenständiges Projekt verwenden

# Clone and install
git clone https://github.com/zfy465914233/scholar-agent.git
cd scholar-agent
pip install -r requirements.txt

# Build the knowledge index
python scripts/local_index.py --output indexes/local/index.json

MCP-Konfigurationen sind vorkonfiguriert:

  • Claude Code: .mcp.json ist bereit. cd in das Projekt und starten Sie Claude Code.

  • VS Code Copilot: .vscode/mcp.json ist bereit. Öffnen Sie das Projekt, aktivieren Sie den Agent-Modus.

MCP-Tools

Kern-Tools (immer verfügbar)

Tool

Beschreibung

query_knowledge

Lokale Wissensdatenbank durchsuchen

save_research

Strukturierte Forschungsergebnisse als Wissenskarte speichern

list_knowledge

Alle Wissenskarten durchsuchen

capture_answer

Ein Q&A-Paar schnell als Entwurfskarte erfassen

ingest_source

Eine URL oder Rohtext in die Wissensdatenbank aufnehmen

build_graph

Einen interaktiven Wissensgraphen generieren (vis.js)

Akademische Tools (setzen Sie SCHOLAR_ACADEMIC=1 zur Aktivierung)

Tool

Beschreibung

search_papers

arXiv + Semantic Scholar mit 4-dimensionaler Bewertung durchsuchen

search_conf_papers

Konferenzbeiträge via DBLP + S2-Anreicherung durchsuchen

analyze_paper

Detaillierte Analyse-Markdown-Notizen generieren (20+ Abschnitte)

extract_paper_images

Abbildungen aus arXiv-Quelle / PDF extrahieren

paper_to_card

Paper-Analyse in eine Wissenskarte konvertieren

daily_recommend

Täglicher Paper-Empfehlungs-Workflow

link_paper_keywords

Schlagworte automatisch als [[wikilinks]] in Notizen verlinken

Empfohlener Workflow

Für die beste Analysequalität folgen Sie dieser Reihenfolge:

  1. Paper herunterladen: download_paper("2510.24701", title="Paper Title", domain="LLM")

  2. Bilder extrahieren: extract_paper_images("2510.24701") (erkennt lokales PDF automatisch)

  3. Detaillierte Analyse: analyze_paper(paper_json) (erkennt lokales PDF automatisch, extrahiert Volltext)

Tipp: Das Herunterladen des PDFs vor der Analyse ermöglicht eine Volltext-Extraktion, was zu qualitativ hochwertigen Notizen mit spezifischen Daten, Formeln und experimentellen Ergebnissen führt. Ohne lokales PDF basiert die Analyse nur auf dem Abstract.

Konfiguration

.scholar.json

Die Datei .scholar.json konfiguriert Wissenspfade und akademische Forschungseinstellungen. Siehe .scholar.example.json für ein vollständiges Beispiel mit Kommentaren.

Schlüsselbereiche:

  • knowledge_dir — Pfad zum Verzeichnis der Wissenskarten

  • index_path — Pfad zum BM25-Suchindex

  • academic.research_interests — Ihre Forschungsbereiche, Schlagworte und arXiv-Kategorien

  • academic.scoring — Bewertungsgewichtungen und Dimensionen für Paper

Umgebungsvariablen

Kopieren Sie .env.example nach .env und konfigurieren Sie:

Variable

Erforderlich

Beschreibung

SCHOLAR_ACADEMIC

Nein

Auf 1 setzen, um akademische Tools zu aktivieren

S2_API_KEY

Nein

Semantic Scholar API-Schlüssel (hier kostenlos erhalten)

LLM_API_KEY

Nein

LLM API-Schlüssel für die fortgeschrittene Synthese-Pipeline

Projektstruktur

scholar-agent/
├── mcp_server.py              # MCP server (13 tools)
├── setup_mcp.py               # Embed into existing projects
├── pyproject.toml             # Package configuration
├── .scholar.json               # Project & academic configuration
├── schemas/                   # Answer + evidence JSON schemas
├── scripts/
│   ├── academic/              # Academic research modules
│   │   ├── arxiv_search.py    # arXiv + Semantic Scholar search
│   │   ├── conf_search.py     # Conference paper search (DBLP)
│   │   ├── paper_analyzer.py  # Deep-analysis note generation
│   │   ├── scoring.py         # 4-dim paper scoring engine
│   │   ├── image_extractor.py # Figure extraction from PDFs
│   │   ├── note_linker.py     # Wiki-link discovery + keyword linking
│   │   └── daily_workflow.py  # Daily recommendation pipeline
│   ├── scholar_config.py       # Configuration reader
│   ├── local_index.py         # BM25 index builder
│   ├── local_retrieve.py      # Knowledge retrieval
│   ├── close_knowledge_loop.py # Knowledge card builder
│   └── ...                    # Research, synthesis, governance, graph
├── knowledge/                 # Knowledge cards (gitignored, user-generated)
├── indexes/                   # Generated indexes (gitignored)
└── tests/                     # 247 tests

Weitere Funktionen

  • Multi-Perspektiven-Recherche — Parallele Recherche aus 5 Perspektiven (akademisch, technisch, angewandt, konträr, historisch)

  • Obsidian-kompatibel — Standard-Markdown + YAML-Frontmatter + [[wiki-links]]

  • Wissens-Governance-CLI — Frontmatter validieren, verwaiste Karten erkennen, Duplikate finden, Lebenszyklus verwalten

  • Anbieter-Fehlertoleranz — Jede Suchquelle fällt unabhängig aus; greift bei Offline-Status auf lokale Abfrage zurück

Testen

python -m pytest tests/ -v

247 Tests, ~13s. Keine externen Dienste erforderlich.

Lizenz

MIT — siehe LICENSE.

Available Tools

12 tools
build_graphA

Build an interactive knowledge graph visualization.

Generates a self-contained HTML file showing all knowledge cards as nodes and their wiki-links as edges. Open the output file in a browser to explore the knowledge graph visually. Compatible with Obsidian vaults.

Returns the path to the generated graph.html file.

Inputs: no named parameters. Returns: result

capture_answerA

Capture a useful Q&A answer as a draft knowledge card.

Use this ONLY when a conversation produces a SUBSTANTIVE answer that is worth persisting — meaning it provides genuine technical insight, a non-obvious explanation, or actionable knowledge that cannot be found in standard references.

DO NOT use this tool for:

  • Single-sentence answers or brief definitions

  • Answers that could be found in any standard reference (Wikipedia, docs)

  • Trivial facts, simple yes/no responses, or content shorter than 150 characters

  • Paper or topic-level knowledge that requires source verification

If you have structured evidence and claims, prefer save_research instead — it produces higher-quality cards with proper source attribution.

The answer text MUST be at least 150 characters. Write a thorough explanation covering the key insight, context, and practical implications.

Inputs: query (required), answer (required), tags, language. Returns: result

fetch_urlA

Fetch a web URL and return its main content as markdown — first-hand retrieval (G5).

抓取网页正文(已做 HTML→正文提取)返回给调用方,用于在 save_research 之前把 knowledge card 建立在一手出处之上,而非凭记忆或摘要。同时把完整正文存本地 快照 knowledge/_snapshots/<sha1(url)>.md(含 captured_at),防止原链接失效 (招聘 JD、网页易下架)后无法回溯(G2)。

典型用法:fetch_url 抓一手 → 基于正文写带具体数字/机制的深度 answer → save_research 存卡。

Inputs: url (required), max_chars. Returns: result

import_paperpulse_noteA

Import a distilled paper note from PaperPulse SaaS directly into the local Scholar Agent knowledge base.

Inputs: paper_id (required), api_token. Returns: result

ingest_sourceA

Ingest a URL or raw text into the knowledge base as a draft card.

For URLs: fetches the page content, extracts text, and saves as a card. For text: saves the provided text directly as a card.

Use this when you want to add external documents, articles, or notes to the knowledge base without requiring structured JSON.

Inputs: source (required), tags, title, language. Returns: result

lint_knowledgeA

Run read-only content health checks over the local knowledge base.

Reports orphan cards, broken wiki-links, cards not updated within stale_days, and highly overlapping titles. This tool never edits files.

Inputs: stale_days. Returns: result

list_knowledgeA

List all knowledge cards in the local knowledge base.

Returns card metadata (id, title, topic, type) for browsing and discovery.

Inputs: topic. Returns: result

query_knowledgeA

Search the local knowledge base for relevant information.

Returns top-k knowledge cards matching the query, with scores and content. Use this to find existing knowledge before doing web research.

Inputs: query (required), limit, rerank. Returns: result

save_researchA

Save structured research results as a knowledge card in the local knowledge base.

The answer_json must conform to schemas/answer.schema.json: { "answer": "detailed answer text", "supporting_claims": [{"claim": "...", "evidence_ids": ["..."], "confidence": "high|medium|low"}], "inferences": ["..."], "uncertainty": ["..."], "missing_evidence": ["..."], "suggested_next_steps": ["..."], "sources": ["https://example.com/source1", "https://example.com/source2"], "visual_aids": [{"type": "mermaid|image_url|image_path", "content": "...", "caption": "...", "alt_text": "..."}] }

IMPORTANT quality requirements:

  • The "answer" field MUST be at least 200 characters of substantive content.

  • You MUST include at least 1 supporting_claim with evidence_ids and confidence.

  • Each claim text MUST be at least 20 characters — vague one-word claims are rejected.

  • DO NOT create cards with empty supporting_claims — every card needs evidence-backed claims.

  • Aim for 3+ supporting claims, inferences, uncertainty, and suggested_next_steps for high-quality cards.

  • DO NOT use this tool for trivial facts or one-sentence answers — those are not worth persisting.

  • ALWAYS include a "sources" array with the URLs you referenced during research. These are written to the card's frontmatter source_refs for provenance tracking.

  • evidence_ids in supporting_claims SHOULD cite the source URL (from "sources") — the card renders them as clickable [host](url) source links. Opaque ids like "s1" stay as bare text and lose the link.

  • For first-hand depth: call fetch_url on key sources BEFORE writing the answer, so it cites concrete numbers/mechanisms from the actual page (not memory). fetch_url also archives a local snapshot (knowledge/_snapshots/) so dead links stay traceable. save_research best-effort snapshots any listed sources in the background even without an explicit fetch_url.

  • When language="zh" (default), the entire answer field MUST be written in Chinese (中文). When language="en", write in English.

When to include visual_aids (auto-judge by topic):

  • Processes / workflows / data flow → mermaid flowchart or sequence diagram

  • Architecture / system design → mermaid graph or class diagram

  • Comparisons or hierarchies → mermaid diagram or table

  • Spatial / geometric concepts → image_url or mermaid

  • Pure definitions or simple facts → omit visual_aids

When sources contain useful images (charts, diagrams, figures):

  • If a source page has a relevant diagram/chart with clear explanatory value, include it as visual_aids with type "image_url" and the image's absolute URL

  • Judge relevance: prefer diagrams explaining mechanisms, architecture overviews, comparison charts, result plots — skip decorative screenshots or generic stock photos

  • Always provide a descriptive caption explaining what the image shows

For method/procedural content (how-to, implementation, deployment, etc.), also include:

  • expected_output: Description of what a successful result looks like — output format, shape, key metrics, or acceptance criteria. Synthesize from the answer if sources don't explicitly provide this.

  • example: A minimal worked example (sample input → processing steps → expected output). Construct synthetically based on the answer if sources lack one. Write '[insufficient data — needs supplementation]' only if impossible to construct.

Visual aids placement (optional after_section field):

  • "answer" — insert after the main answer paragraph (default for architecture/pipeline diagrams)

  • "supporting_claims" — insert after claims (default for evidence figures/charts)

  • "inferences", "uncertainty", "missing_evidence", "suggested_next_steps" — after respective sections

  • Omit after_section to place at the end of the card (backward compatible)

Inputs: query (required), answer_json (required), domain, language, +1 more. Returns: result

scan_stale_knowledgeA

Report knowledge cards whose source freshness exceeds domain thresholds.

Unlike lint_knowledge's updated_at check, this uses source_date/captured year with the domain-specific freshness policy used by card validation. This tool is read-only.

Inputs: no named parameters. Returns: result

validate_knowledgeA

Validate local knowledge cards without modifying files.

Runs card frontmatter validation plus body-density/source-freshness checks. Use this before relying on a knowledge base or after bulk imports.

Inputs: verbose. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 12 tools

    Disambiguation4/5

    Most tools have distinct purposes (query, save, ingest, validate, fetch, list, lint, scan, build, import). However, save_research, capture_answer, and ingest_source all persist knowledge cards with different input formats, which could cause confusion despite detailed descriptions.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with snake_case (e.g., query_knowledge, save_research, fetch_url). Verbs are descriptive and the pattern is predictable across all 12 tools.

    Tool Count5/5

    12 tools is well-scoped for a knowledge management server. The set covers querying, saving, ingesting, validating, listing, linting, scanning dead links, building graphs, and importing notes—no bloat or deficiency.

    Completeness3/5

    The tool surface covers create (save, capture, ingest), read (query, list), and checking tools, but lacks update and delete operations for knowledge cards. This is a notable gap that could hinder full life cycle management.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI coding agents to retrieve and manage code context with hybrid search, project memory, and observability via MCP tools.
      30
      MIT
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables AI coding agents to persistently store, semantically search, and recall project-specific and cross-project knowledge across sessions, with everything kept local in SQLite. It also exposes project context, guidelines, and preferences as MCP resources for agents to read and write directly.
      -