@wentorai/research-plugins 1.0.0 → 1.2.0

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

@@ -0,0 +1,187 @@
+---
+name: notero-zotero-notion-guide
+description: "Sync Zotero references and annotations to Notion databases"
+metadata:
+  openclaw:
+    emoji: "🔗"
+    category: "tools"
+    subcategory: "knowledge-graph"
+    keywords: ["Zotero", "Notion", "sync", "reference management", "knowledge base", "annotations"]
+    source: "https://github.com/dvanoni/notero"
+---
+
+# Notero: Zotero-Notion Sync Guide
+
+## Overview
+
+Notero is a Zotero plugin that syncs your reference library to a Notion database. When you add or update items in Zotero, Notero automatically creates or updates corresponding Notion pages with metadata (title, authors, DOI, tags), annotations, and notes. Bridges the gap between reference management and knowledge management workflows.
+
+## Installation
+
+```bash
+# 1. Download .xpi from GitHub releases
+# 2. In Zotero: Tools → Add-ons → Install Add-on From File
+
+# Prerequisites:
+# - Zotero 7
+# - Notion account with a database for papers
+# - Notion integration token
+```
+
+## Notion Database Setup
+
+```markdown
+### Required Properties
+Create a Notion database with these properties:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| Title | Title | Paper title (auto-filled) |
+| Authors | Rich text | Author names |
+| Year | Number | Publication year |
+| DOI | URL | Digital Object Identifier |
+| URL | URL | Paper link |
+| Abstract | Rich text | Paper abstract |
+| Tags | Multi-select | Zotero tags |
+| Item Type | Select | Article, book, etc. |
+| Zotero URI | URL | Link back to Zotero item |
+| Date Added | Date | When added to Zotero |
+| Publication | Rich text | Journal/conference name |
+```
+
+## Configuration
+
+```
+# In Zotero: Tools → Notero Preferences
+
+# 1. Notion Integration Token:
+#    - Go to notion.so/my-integrations
+#    - Create new integration
+#    - Copy the token
+#    - Share your database with the integration
+
+# 2. Database ID:
+#    - Open your Notion database
+#    - Copy the ID from the URL
+#    - Format: notion.so/<workspace>/<database_id>?v=...
+
+# 3. Property Mapping:
+#    - Map Zotero fields to Notion properties
+#    - Configure which fields to sync
+
+# 4. Sync Settings:
+#    - Auto-sync on add/modify
+#    - Sync annotations (highlights + notes)
+#    - Sync attachments (link to PDF)
+```
+
+## Sync Workflow
+
+```markdown
+### Automatic Sync
+1. Add paper to Zotero (via browser connector, DOI, etc.)
+2. Notero detects new item
+3. Creates Notion page with metadata
+4. Updates on subsequent edits
+
+### Manual Sync
+1. Select items in Zotero
+2. Right-click → "Sync to Notion"
+3. Bulk sync supported
+
+### Annotation Sync
+1. Annotate PDF in Zotero reader
+2. Highlights and notes sync to Notion page
+3. Page references and colors preserved
+```
+
+## Advanced Configuration
+
+```json
+{
+  "notion": {
+    "propertyMapping": {
+      "title": "Title",
+      "creators": "Authors",
+      "date": "Year",
+      "DOI": "DOI",
+      "url": "URL",
+      "abstractNote": "Abstract",
+      "tags": "Tags",
+      "itemType": "Item Type",
+      "publicationTitle": "Publication"
+    },
+    "syncOptions": {
+      "syncOnModify": true,
+      "syncAnnotations": true,
+      "syncNotes": true,
+      "createBacklink": true,
+      "pageIcon": "📄"
+    },
+    "formatting": {
+      "authorsFormat": "Last, F.",
+      "maxAuthors": 5,
+      "tagPrefix": ""
+    }
+  }
+}
+```
+
+## Notion Templates
+
+```markdown
+### Paper Review Template
+When a paper syncs, Notero can use a Notion template:
+
+## Summary
+<!-- Auto-filled abstract -->
+
+## Key Contributions
+- [ ] Contribution 1
+- [ ] Contribution 2
+
+## Methodology
+<!-- Your notes -->
+
+## Results
+<!-- Your notes -->
+
+## Relevance to My Research
+<!-- Your notes -->
+
+## Questions / Follow-ups
+- [ ] Question 1
+
+## Rating: ⭐⭐⭐⭐☆
+```
+
+## Integration Stack
+
+```markdown
+### Recommended Workflow
+Zotero (collect) → Notero → Notion (organize + notes)
+                                ↓
+                         Notion AI (summarize)
+                                ↓
+                         Writing tool (cite)
+
+### Complementary Plugins
+- **Zotero Better BibTeX** — Citation keys in Notion
+- **Zotero Style** — Visual organization in Zotero
+- **Zotero Sci-Hub** — PDF retrieval before annotation
+- **Notion Web Clipper** — Save web pages alongside papers
+```
+
+## Use Cases
+
+1. **Knowledge management**: Unified paper + notes database
+2. **Research tracking**: Notion views for project-based paper lists
+3. **Team collaboration**: Shared Notion databases for lab groups
+4. **Literature review**: Tag and categorize papers with Notion filters
+5. **Reading workflow**: Kanban board (To Read → Reading → Done)
+
+## References
+
+- [Notero GitHub](https://github.com/dvanoni/notero)
+- [Notion API](https://developers.notion.com/)
+- [Zotero Plugin Development](https://www.zotero.org/support/dev/)

package/skills/tools/knowledge-graph/open-webui-tools-guide/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: open-webui-tools-guide
+description: "Academic research tools for Open WebUI chat interface"
+metadata:
+  openclaw:
+    emoji: "🌐"
+    category: "tools"
+    subcategory: "knowledge-graph"
+    keywords: ["Open WebUI", "research tools", "chat interface", "paper search", "academic tools", "LLM UI"]
+    source: "https://github.com/Haervwe/open-webui-tools"
+---
+
+# Open WebUI Academic Tools Guide
+
+## Overview
+
+A collection of academic research tools designed for Open WebUI, the popular self-hosted LLM chat interface. These tools add paper search, citation lookup, and research capabilities directly into chat conversations — search arXiv, PubMed, and Semantic Scholar; fetch paper details; generate citations; and analyze documents, all within the familiar chat UI.
+
+## Installation
+
+```bash
+# In Open WebUI: Admin → Tools → Add Tool
+# Import from the tools collection
+
+# Or manually add tool functions
+# Copy tool JSON definitions to Open WebUI config
+```
+
+## Available Tools
+
+### Paper Search Tool
+
+```python
+# Searches arXiv, Semantic Scholar, PubMed
+# Usage in chat: "Search for papers on attention mechanisms"
+
+def search_papers(query: str, source: str = "all",
+                  max_results: int = 10) -> str:
+    """Search academic databases for papers.
+
+    Args:
+        query: Search query
+        source: "arxiv", "semantic_scholar", "pubmed", or "all"
+        max_results: Maximum results to return
+    """
+    results = []
+
+    if source in ("all", "arxiv"):
+        # Search arXiv
+        arxiv_results = search_arxiv(query, max_results)
+        results.extend(arxiv_results)
+
+    if source in ("all", "semantic_scholar"):
+        # Search Semantic Scholar
+        s2_results = search_s2(query, max_results)
+        results.extend(s2_results)
+
+    return format_results(results)
+```
+
+### Citation Generator Tool
+
+```python
+# Generate formatted citations from DOI or title
+# Usage: "Get BibTeX for DOI 10.48550/arXiv.1706.03762"
+
+def get_citation(identifier: str,
+                 style: str = "bibtex") -> str:
+    """Get formatted citation for a paper.
+
+    Args:
+        identifier: DOI, arXiv ID, or paper title
+        style: "bibtex", "apa", "mla", "chicago"
+    """
+    paper = resolve_paper(identifier)
+    return format_citation(paper, style)
+```
+
+### Paper Summary Tool
+
+```python
+# Fetch and summarize paper abstract + key points
+# Usage: "Summarize arxiv:2401.12345"
+
+def summarize_paper(paper_id: str) -> str:
+    """Fetch paper metadata and generate summary.
+
+    Args:
+        paper_id: arXiv ID, DOI, or Semantic Scholar ID
+    """
+    paper = fetch_paper_details(paper_id)
+    return {
+        "title": paper.title,
+        "authors": paper.authors,
+        "abstract": paper.abstract,
+        "year": paper.year,
+        "citations": paper.citation_count,
+    }
+```
+
+## Tool Configuration
+
+```json
+{
+  "tools": {
+    "paper_search": {
+      "enabled": true,
+      "default_source": "semantic_scholar",
+      "max_results": 10,
+      "include_abstract": true
+    },
+    "citation_generator": {
+      "enabled": true,
+      "default_style": "bibtex"
+    },
+    "paper_summary": {
+      "enabled": true,
+      "include_related": true
+    }
+  }
+}
+```
+
+## Chat Workflow Examples
+
+```markdown
+### Research Discovery
+User: "Find recent papers on retrieval-augmented generation"
+Bot: [Uses paper_search tool] Here are 10 recent papers on RAG...
+
+### Citation Workflow
+User: "Get BibTeX for the BERT paper"
+Bot: [Uses citation_generator] @article{devlin2019bert, ...}
+
+### Paper Analysis
+User: "Tell me about arxiv:2404.19756"
+Bot: [Uses paper_summary] This paper introduces KAN...
+
+### Literature Review
+User: "Compare attention mechanisms in the top-5 cited
+       transformer papers from 2023"
+Bot: [Uses multiple tools] Searching... Here's a comparison...
+```
+
+## Use Cases
+
+1. **Chat-based research**: Search papers while chatting with LLM
+2. **Quick citations**: Generate BibTeX without leaving chat
+3. **Paper discovery**: Find related work through conversation
+4. **Team research**: Shared research chat with embedded tools
+5. **Teaching**: Interactive paper exploration in classroom
+
+## References
+
+- [open-webui-tools GitHub](https://github.com/Haervwe/open-webui-tools)
+- [Open WebUI](https://github.com/open-webui/open-webui)

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/)