@wentorai/research-plugins 1.1.0 → 1.2.0

package/skills/tools/knowledge-graph/openspg-guide/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: openspg-guide
+description: "Ant Group knowledge graph engine with SPG and KAG framework"
+metadata:
+  openclaw:
+    emoji: "🕸️"
+    category: "tools"
+    subcategory: "knowledge-graph"
+    keywords: ["OpenSPG", "knowledge graph", "SPG", "KAG", "Ant Group", "semantic reasoning"]
+    source: "https://github.com/OpenSPG/openspg"
+---
+
+# OpenSPG Knowledge Graph Guide
+
+## Overview
+
+OpenSPG is Ant Group's open-source knowledge graph engine based on the Semantic-enhanced Programmable Graph (SPG) framework. It combines property graphs with semantic reasoning, enabling knowledge extraction, representation, reasoning, and question answering. The KAG (Knowledge Augmented Generation) module integrates with LLMs for RAG over knowledge graphs. Suited for building domain-specific knowledge bases for research.
+
+## Installation
+
+```bash
+# Docker deployment
+git clone https://github.com/OpenSPG/openspg.git
+cd openspg
+docker-compose up -d
+
+# Python SDK
+pip install openspg
+
+# Access KG Studio at http://localhost:8887
+```
+
+## Core Concepts
+
+```
+SPG Framework
+├── Schema Layer (define types and relations)
+│   ├── Entity types (Person, Paper, Concept)
+│   ├── Properties (typed, constrained)
+│   └── Relations (directed, typed edges)
+├── Knowledge Layer (populate with data)
+│   ├── Entity extraction (NER + linking)
+│   ├── Relation extraction
+│   └── Property filling
+├── Reasoning Layer (infer new knowledge)
+│   ├── Rule-based reasoning
+│   ├── Statistical reasoning
+│   └── LLM-augmented reasoning
+└── Application Layer (query and use)
+    ├── Graph queries (SPARQL-like)
+    ├── Question answering
+    └── Knowledge-augmented generation
+```
+
+## Schema Definition
+
+```python
+from openspg import Schema, EntityType, RelationType
+
+# Define a research knowledge graph schema
+schema = Schema("research_kg")
+
+# Entity types
+paper = EntityType("Paper", properties={
+    "title": "Text",
+    "abstract": "Text",
+    "year": "Integer",
+    "venue": "Text",
+    "doi": "Text",
+    "citation_count": "Integer",
+})
+
+author = EntityType("Author", properties={
+    "name": "Text",
+    "affiliation": "Text",
+    "h_index": "Integer",
+})
+
+concept = EntityType("Concept", properties={
+    "name": "Text",
+    "definition": "Text",
+    "domain": "Text",
+})
+
+# Relations
+schema.add_relation(RelationType(
+    "authored_by", source=paper, target=author
+))
+schema.add_relation(RelationType(
+    "cites", source=paper, target=paper
+))
+schema.add_relation(RelationType(
+    "discusses", source=paper, target=concept
+))
+schema.add_relation(RelationType(
+    "related_to", source=concept, target=concept
+))
+
+schema.deploy()
+```
+
+## Knowledge Population
+
+```python
+from openspg import KnowledgeBuilder
+
+builder = KnowledgeBuilder(schema="research_kg")
+
+# Add entities
+builder.add_entity("Paper", {
+    "title": "Attention Is All You Need",
+    "year": 2017,
+    "venue": "NeurIPS",
+    "doi": "10.48550/arXiv.1706.03762",
+})
+
+# Automatic extraction from text
+builder.extract_from_text(
+    "Vaswani et al. proposed the Transformer architecture "
+    "which uses self-attention mechanisms to replace "
+    "recurrence. The model achieved state-of-the-art on "
+    "WMT 2014 English-to-German translation.",
+    entity_types=["Paper", "Author", "Concept"],
+    relation_types=["authored_by", "discusses"],
+)
+
+# Batch import from structured data
+builder.import_csv(
+    "papers.csv",
+    entity_type="Paper",
+    column_mapping={"title": "title", "year": "year"},
+)
+
+builder.commit()
+```
+
+## KAG: Knowledge-Augmented Generation
+
+```python
+from openspg.kag import KAGPipeline
+
+kag = KAGPipeline(
+    knowledge_graph="research_kg",
+    llm_provider="anthropic",
+)
+
+# Question answering over knowledge graph
+answer = kag.ask(
+    "What are the key papers on attention mechanisms "
+    "and how are they related?"
+)
+
+print(answer.text)
+for source in answer.sources:
+    print(f"  [{source.type}] {source.name}: {source.evidence}")
+
+# The KAG pipeline:
+# 1. Parses question to identify relevant entities/relations
+# 2. Queries knowledge graph for subgraph
+# 3. Augments LLM context with structured knowledge
+# 4. Generates grounded answer with provenance
+```
+
+## Graph Queries
+
+```python
+from openspg import GraphQuery
+
+gq = GraphQuery("research_kg")
+
+# Find papers by concept
+papers = gq.query("""
+    MATCH (p:Paper)-[:discusses]->(c:Concept)
+    WHERE c.name = 'self-attention'
+    RETURN p.title, p.year, p.citation_count
+    ORDER BY p.citation_count DESC
+    LIMIT 10
+""")
+
+# Find co-author network
+coauthors = gq.query("""
+    MATCH (a1:Author)<-[:authored_by]-(p:Paper)
+          -[:authored_by]->(a2:Author)
+    WHERE a1.name = 'Ashish Vaswani'
+    RETURN DISTINCT a2.name, COUNT(p) as papers
+    ORDER BY papers DESC
+""")
+
+# Citation chain
+chain = gq.query("""
+    MATCH path = (p1:Paper)-[:cites*1..3]->(p2:Paper)
+    WHERE p1.title CONTAINS 'GPT-4'
+    RETURN path
+    LIMIT 20
+""")
+```
+
+## Use Cases
+
+1. **Research KG**: Build knowledge graphs from paper collections
+2. **Literature QA**: Grounded question answering over research
+3. **Concept mapping**: Visualize research concept relationships
+4. **Citation analysis**: Graph-based citation network analysis
+5. **Domain ontology**: Build and maintain domain-specific schemas
+
+## References
+
+- [OpenSPG GitHub](https://github.com/OpenSPG/openspg)
+- [KAG Framework](https://github.com/OpenSPG/KAG)
+- [SPG White Paper](https://arxiv.org/abs/2302.09560)

package/skills/tools/knowledge-graph/paperpile-notion-guide/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: paperpile-notion-guide
+description: "Sync Paperpile references and annotations to Notion"
+metadata:
+  openclaw:
+    emoji: "📋"
+    category: "tools"
+    subcategory: "knowledge-graph"
+    keywords: ["Paperpile", "Notion", "sync", "reference management", "annotations", "integration"]
+    source: "https://github.com/gsarti/paperpile-notion"
+---
+
+# Paperpile-Notion Integration Guide
+
+## Overview
+
+Paperpile-Notion is a tool that syncs your Paperpile reference library to a Notion database. It exports paper metadata (title, authors, year, DOI, abstract), reading status, labels, and annotations to Notion pages, enabling you to combine reference management with Notion's rich knowledge management features.
+
+## Setup
+
+```bash
+# Install from source
+git clone https://github.com/gsarti/paperpile-notion.git
+cd paperpile-notion
+pip install -e .
+
+# Configuration
+# 1. Export Paperpile library as BibTeX/JSON
+# 2. Create Notion integration and get token
+# 3. Create Notion database with required properties
+# 4. Run sync script
+```
+
+## Notion Database Properties
+
+```markdown
+### Required Properties
+| Property | Type | Source |
+|----------|------|--------|
+| Title | Title | Paper title |
+| Authors | Rich text | Author names |
+| Year | Number | Publication year |
+| DOI | URL | Digital Object Identifier |
+| Abstract | Rich text | Paper abstract |
+| Labels | Multi-select | Paperpile labels/folders |
+| Status | Select | Read / Unread / Reading |
+| Added | Date | Date added to Paperpile |
+| Journal | Rich text | Publication venue |
+| Notes | Rich text | Paperpile notes |
+```
+
+## Sync Workflow
+
+```python
+from paperpile_notion import PaperpileSync
+
+sync = PaperpileSync(
+    paperpile_export="library.bib",    # BibTeX export
+    notion_database_id="your_db_id",
+)
+
+# Full sync
+result = sync.run()
+print(f"Synced: {result.created} new, "
+      f"{result.updated} updated, "
+      f"{result.skipped} unchanged")
+
+# Incremental sync (only new/modified)
+result = sync.run(incremental=True)
+```
+
+## Use Cases
+
+1. **Knowledge management**: Paperpile references in Notion
+2. **Reading tracking**: Kanban board for paper reading status
+3. **Team collaboration**: Shared reference database in Notion
+4. **Research notes**: Rich notes alongside paper metadata
+5. **Project organization**: Tag papers by research project
+
+## References
+
+- [paperpile-notion GitHub](https://github.com/gsarti/paperpile-notion)
+- [Paperpile](https://paperpile.com/)
+- [Notion API](https://developers.notion.com/)

package/skills/tools/knowledge-graph/zotero-markdb-connect-guide/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: zotero-markdb-connect-guide
+description: "Sync Zotero references to Obsidian and Logseq markdown"
+metadata:
+  openclaw:
+    emoji: "🔗"
+    category: "tools"
+    subcategory: "knowledge-graph"
+    keywords: ["Zotero", "Obsidian", "Logseq", "markdown", "PKM", "literature notes"]
+    source: "https://github.com/daeh/zotero-markdb-connect"
+---
+
+# Zotero MarkDB-Connect Guide
+
+## Overview
+
+Zotero MarkDB-Connect bridges Zotero with Markdown-based knowledge management tools (Obsidian, Logseq). It creates and maintains bidirectional links between Zotero items and their corresponding Markdown literature notes, enabling seamless navigation between your reference manager and PKM system. Syncs metadata, annotations, and tags.
+
+## Installation
+
+```bash
+# Download .xpi from GitHub releases
+# Zotero 7: Tools → Add-ons → Install Add-on From File
+```
+
+## Configuration
+
+```markdown
+### Settings (Edit → Preferences → MarkDB-Connect)
+
+**Markdown Vault Path:**
+- Point to your Obsidian vault or Logseq directory
+- Example: ~/Documents/ObsidianVault/Literature/
+
+**Note Template:**
+- Customize the Markdown template for new literature notes
+- Uses Zotero item fields as variables
+
+**Sync Options:**
+- Auto-create notes for new items
+- Sync annotations to Markdown
+- Bidirectional tag sync
+- Update existing notes on item change
+```
+
+## Note Template
+
+```markdown
+<!-- Template for literature notes -->
+---
+title: "{{title}}"
+authors: [{{authors}}]
+year: {{year}}
+doi: {{doi}}
+citekey: {{citekey}}
+tags: [{{tags}}]
+zotero: {{zoteroSelectURI}}
+---
+
+# {{title}}
+
+**Authors:** {{authors}}
+**Year:** {{year}}
+**Venue:** {{publicationTitle}}
+**DOI:** [{{doi}}](https://doi.org/{{doi}})
+
+## Abstract
+{{abstractNote}}
+
+## Annotations
+{{annotations}}
+
+## Key Takeaways
+-
+
+## Notes
+-
+
+## Connections
+- Related: [[]]
+- Builds on: [[]]
+- Contradicts: [[]]
+```
+
+## Obsidian Integration
+
+```markdown
+### Folder Structure
+ObsidianVault/
+├── Literature/          # Auto-generated literature notes
+│   ├── vaswani2017.md
+│   ├── devlin2019.md
+│   └── brown2020.md
+├── Concepts/            # Your concept notes
+│   ├── Attention.md     # Links to [[vaswani2017]]
+│   └── Pre-training.md  # Links to [[devlin2019]]
+└── Projects/            # Project notes referencing papers
+
+### Workflow
+1. Import paper in Zotero (via browser connector)
+2. MarkDB-Connect auto-creates Literature/citekey.md
+3. In Obsidian: open literature note, add your thoughts
+4. Link to concept notes using [[wikilinks]]
+5. Annotations sync from Zotero PDF reader
+```
+
+## Annotation Sync
+
+```markdown
+### Zotero PDF Annotations → Markdown
+
+When you highlight or annotate in Zotero's PDF reader:
+
+> [!quote] Highlight (Yellow)
+> "The attention mechanism allows focusing on relevant parts"
+> — p. 3
+
+> [!note] Note
+> This is the key insight — attention replaces recurrence
+> — p. 3, linked to highlight above
+
+> [!important] Red Highlight
+> "Our model achieves 28.4 BLEU on WMT 2014"
+> — p. 7
+
+Annotations auto-sync to the Markdown note when updated.
+```
+
+## Logseq Integration
+
+```markdown
+### Logseq-Specific Setup
+- Set vault path to your Logseq pages directory
+- Notes created as Logseq pages with properties block
+- Uses Logseq property syntax instead of YAML frontmatter
+
+### Logseq Note Format
+title:: Attention Is All You Need
+authors:: [[Vaswani]], [[Shazeer]]
+year:: 2017
+doi:: 10.48550/arXiv.1706.03762
+tags:: #transformer #attention
+zotero:: zotero://select/items/...
+
+- Key contributions
+  - Self-attention mechanism replacing recurrence
+  - Multi-head attention for different representation subspaces
+```
+
+## Use Cases
+
+1. **Literature management**: Seamless Zotero ↔ Obsidian workflow
+2. **Knowledge building**: Link papers to concept notes
+3. **Annotation workflow**: PDF annotations in Markdown
+4. **Research writing**: Quick access to notes while writing
+5. **Zettelkasten**: Literature notes as part of note network
+
+## References
+
+- [MarkDB-Connect GitHub](https://github.com/daeh/zotero-markdb-connect)
+- [Obsidian](https://obsidian.md/)
+- [Logseq](https://logseq.com/)

package/skills/tools/ocr-translate/latex-translation-guide/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: latex-translation-guide
+description: "Translate LaTeX documents preserving math formulas and structure"
+metadata:
+  openclaw:
+    emoji: "🌐"
+    category: "tools"
+    subcategory: "ocr-translate"
+    keywords: ["LaTeX translation", "document translation", "multilingual", "math preservation", "academic translation"]
+    source: "https://github.com/SUSYUSTC/MathTranslate"
+---
+
+# LaTeX Document Translation Guide
+
+## Overview
+
+Translating LaTeX academic documents requires preserving mathematical formulas, cross-references, citations, and formatting while converting the text between languages. This guide covers tools and techniques for translating LaTeX papers — from command-line utilities to full document pipelines. Particularly useful for making research accessible across language barriers.
+
+## LaTeXTrans Approach
+
+```bash
+# Install LaTeXTrans
+pip install latextrans
+
+# Translate a LaTeX file
+latextrans translate paper.tex --from en --to zh --output paper_zh.tex
+```
+
+### How It Works
+
+1. **Parse**: Extract text segments while preserving LaTeX commands
+2. **Protect**: Shield math environments (`$...$`, `\[...\]`, equations)
+3. **Translate**: Send text segments to translation API
+4. **Reconstruct**: Reassemble with original LaTeX structure
+
+### Python Usage
+
+```python
+from latextrans import LatexTranslator
+
+translator = LatexTranslator(
+    source_lang="en",
+    target_lang="zh",
+    engine="google",  # or "deepl", "openai"
+)
+
+# Translate a file
+translator.translate_file("paper.tex", "paper_zh.tex")
+
+# Translate a string
+result = translator.translate(
+    r"The loss function $\mathcal{L}(\theta)$ is minimized "
+    r"using gradient descent with learning rate $\eta$."
+)
+# Output preserves $\mathcal{L}(\theta)$ and $\eta$ untouched
+```
+
+## MathTranslate Tool
+
+```bash
+# Install MathTranslate (specialized for math-heavy papers)
+pip install mathtranslate
+
+# Translate arXiv paper directly
+translate_arxiv 2301.00001 -o translated.tex
+
+# Translate local file
+translate_tex paper.tex -o paper_translated.tex
+```
+
+### MathTranslate Features
+
+```python
+# Configuration
+import mathtranslate
+
+# Set translation backend
+mathtranslate.config.set_translator("google")  # free
+mathtranslate.config.set_translator("openai")  # higher quality
+
+# Translate with customization
+mathtranslate.translate(
+    input_file="paper.tex",
+    output_file="paper_zh.tex",
+    source_lang="en",
+    target_lang="zh-CN",
+    threads=4,  # parallel translation
+)
+```
+
+## Manual Translation Tips
+
+### Protecting Math Environments
+
+```python
+import re
+
+def extract_and_protect(latex_text: str) -> tuple:
+    """Extract math environments before translation."""
+    math_pattern = r'(\$\$[\s\S]*?\$\$|\$[^$]+\$|\\begin\{equation\}[\s\S]*?\\end\{equation\}|\\begin\{align\}[\s\S]*?\\end\{align\})'
+
+    placeholders = {}
+    counter = [0]
+
+    def replace_math(match):
+        key = f"__MATH_{counter[0]}__"
+        placeholders[key] = match.group(0)
+        counter[0] += 1
+        return key
+
+    protected = re.sub(math_pattern, replace_math, latex_text)
+    return protected, placeholders
+
+
+def restore_math(translated: str, placeholders: dict) -> str:
+    """Restore math environments after translation."""
+    for key, value in placeholders.items():
+        translated = translated.replace(key, value)
+    return translated
+```
+
+### Commands to Protect
+
+```latex
+% Always protect these:
+\ref{...}      % Cross-references
+\cite{...}     % Citations
+\label{...}    % Labels
+\eqref{...}    % Equation references
+\url{...}      % URLs
+\texttt{...}   % Code/monospace
+
+% Math environments to protect:
+$...$          % Inline math
+$$...$$        % Display math
+\[...\]        % Display math
+\begin{equation}...\end{equation}
+\begin{align}...\end{align}
+\begin{theorem}...\end{theorem}  % Custom environments
+```
+
+## Bilingual Output
+
+```latex
+% Create side-by-side bilingual document
+\usepackage{paracol}
+
+\begin{paracol}{2}
+\switchcolumn[0]
+The transformer architecture has become...
+
+\switchcolumn[1]
+Transformer架构已经成为...
+
+\switchcolumn[0]
+Self-attention computes $\text{Attention}(Q,K,V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V$
+
+\switchcolumn[1]
+自注意力计算 $\text{Attention}(Q,K,V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V$
+\end{paracol}
+```
+
+## Translation Backends
+
+| Backend | Quality | Cost | Speed |
+|---------|---------|------|-------|
+| Google Translate | Good | Free | Fast |
+| DeepL | Better | Freemium | Fast |
+| OpenAI GPT-4 | Best | Paid | Slower |
+| Claude | Best | Paid | Slower |
+
+## References
+
+- [LaTeXTrans](https://github.com/SUSYUSTC/MathTranslate)
+- [PDFMathTranslate](https://github.com/Byaidu/PDFMathTranslate)
+- [arXiv LaTeX Cleaner](https://github.com/google-research/arxiv-latex-cleaner)