@wentorai/research-plugins 1.1.0 → 1.2.1

package/skills/research/automation/coexist-ai-guide/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: coexist-ai-guide
+description: "Modular MCP-based research assistant framework"
+metadata:
+  openclaw:
+    emoji: "🧩"
+    category: "research"
+    subcategory: "automation"
+    keywords: ["CoexistAI", "MCP", "research assistant", "modular agents", "academic workflow", "framework"]
+    source: "https://github.com/SPThole/CoexistAI"
+---
+
+# CoexistAI Research Assistant Guide
+
+## Overview
+
+CoexistAI is a modular research assistant framework built on MCP (Model Context Protocol) that provides composable academic research capabilities. It offers MCP servers for paper search, citation management, data analysis, and writing assistance that can be mixed and matched with any MCP-compatible LLM client. Designed for researchers who want customizable, extensible AI research tooling.
+
+## Architecture
+
+```
+LLM Client (Claude Code / Open WebUI / etc.)
+      ↓ MCP Protocol
+  CoexistAI MCP Servers
+  ├── paper-search     (arXiv, S2, PubMed)
+  ├── citation-manager (BibTeX, formatting)
+  ├── data-analysis    (Python execution)
+  ├── writing-assist   (drafting, revision)
+  ├── note-taker       (structured notes)
+  └── custom modules   (extend as needed)
+```
+
+## Installation
+
+```bash
+# Install CoexistAI
+npm install -g @coexistai/mcp-servers
+
+# Or individual modules
+npm install -g @coexistai/paper-search
+npm install -g @coexistai/citation-manager
+npm install -g @coexistai/data-analysis
+```
+
+## MCP Configuration
+
+```json
+{
+  "mcpServers": {
+    "coexist-paper-search": {
+      "command": "npx",
+      "args": ["@coexistai/paper-search"],
+      "env": {}
+    },
+    "coexist-citation": {
+      "command": "npx",
+      "args": ["@coexistai/citation-manager"],
+      "env": {
+        "BIB_FILE": "./references.bib"
+      }
+    },
+    "coexist-analysis": {
+      "command": "npx",
+      "args": ["@coexistai/data-analysis"],
+      "env": {
+        "SANDBOX": "true"
+      }
+    }
+  }
+}
+```
+
+## Module: Paper Search
+
+```markdown
+### Available Tools
+- `search_papers(query, source, limit)` — Search academic DBs
+- `get_paper_details(id)` — Fetch full metadata
+- `find_related(id, limit)` — Find related papers
+- `get_citations(id)` — List citing papers
+- `get_references(id)` — List referenced papers
+
+### Example Usage
+"Search for papers on contrastive learning in NLP from 2023"
+→ Returns top results with title, authors, abstract, DOI
+```
+
+## Module: Citation Manager
+
+```markdown
+### Available Tools
+- `add_citation(doi)` — Add to .bib file from DOI
+- `format_citation(id, style)` — Format in APA/MLA/etc
+- `search_bib(query)` — Search existing bibliography
+- `check_duplicates()` — Find duplicate entries
+- `export_bib(format)` — Export in various formats
+
+### Example Usage
+"Add the BERT paper to my bibliography"
+→ Fetches metadata, generates BibTeX, appends to refs.bib
+```
+
+## Module: Data Analysis
+
+```markdown
+### Available Tools
+- `run_python(code)` — Execute Python in sandbox
+- `analyze_csv(path, task)` — Auto-analyze data file
+- `generate_plot(data, type)` — Create visualizations
+- `run_statistics(data, test)` — Statistical tests
+
+### Example Usage
+"Run a t-test comparing groups A and B in experiment.csv"
+→ Loads data, runs scipy.stats.ttest_ind, returns results
+```
+
+## Custom Module Development
+
+```typescript
+// Create a custom MCP module
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+const server = new McpServer({
+  name: "my-research-tool",
+  version: "1.0.0",
+});
+
+server.tool(
+  "custom_analysis",
+  { description: "Run custom research analysis" },
+  async (args) => {
+    // Your custom logic
+    return { result: "Analysis complete" };
+  }
+);
+```
+
+## Use Cases
+
+1. **Modular research**: Pick-and-choose research capabilities
+2. **Custom pipelines**: Build tailored research workflows
+3. **Tool integration**: Connect to existing research infrastructure
+4. **Team standardization**: Shared MCP modules across lab
+5. **Extension**: Add domain-specific research tools
+
+## References
+
+- [CoexistAI GitHub](https://github.com/SPThole/CoexistAI)
+- [MCP Specification](https://modelcontextprotocol.io/)

package/skills/research/automation/datagen-research-guide/SKILL.md

@@ -6,8 +6,8 @@ author: wentor-community
 source: https://github.com/DATAGEN-AI/DATAGEN
 metadata:
   openclaw:
-    category: research
-    subcategory: automation
+    category: "research"
+    subcategory: "automation"
     keywords:
       - multi-agent
       - research-assistant

package/skills/research/automation/foam-agent-guide/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: foam-agent-guide
+description: "Agent for automated knowledge graph building from research notes"
+metadata:
+  openclaw:
+    emoji: "🫧"
+    category: "research"
+    subcategory: "automation"
+    keywords: ["Foam", "knowledge graph", "Zettelkasten", "research notes", "linked notes", "PKM agent"]
+    source: "https://github.com/foambubble/foam"
+---
+
+# Foam Agent Guide
+
+## Overview
+
+Foam is a personal knowledge management and note-sharing system built on VS Code, inspired by Roam Research. This guide covers using AI agents to automate Foam-based research workflows — extracting concepts from papers, building knowledge graphs, discovering connections between notes, and maintaining a Zettelkasten-style research knowledge base. Particularly useful for researchers managing large literature collections.
+
+## Foam Basics
+
+### Workspace Structure
+
+```
+research-foam/
+├── .foam/
+│   └── config.json          # Foam configuration
+├── .vscode/
+│   └── settings.json        # VS Code settings
+├── inbox/                   # Unprocessed notes
+├── literature/              # Paper notes (one per paper)
+├── concepts/                # Concept/topic notes
+├── projects/                # Project-specific notes
+├── daily/                   # Daily research journal
+└── README.md                # Graph entry point
+```
+
+### Note Format
+
+```markdown
+# Attention Mechanism
+
+Tags: #transformer #nlp #deep-learning
+
+## Summary
+The attention mechanism allows models to focus on relevant parts
+of the input sequence when producing output.
+
+## Key Concepts
+- [[self-attention]] computes relationships within a sequence
+- [[cross-attention]] relates two different sequences
+- [[multi-head-attention]] runs parallel attention functions
+
+## References
+- [[vaswani-2017-attention]] — original Transformer paper
+- [[bahdanau-2015-attention]] — attention for NMT
+
+## Related
+- [[transformer-architecture]]
+- [[positional-encoding]]
+```
+
+## Automated Note Generation
+
+```python
+from foam_agent import FoamAgent
+
+agent = FoamAgent(
+    workspace="./research-foam",
+    llm_provider="anthropic",
+)
+
+# Generate literature note from PDF
+note = agent.process_paper(
+    pdf_path="papers/vaswani2017attention.pdf",
+    template="literature",
+)
+# Creates: literature/vaswani-2017-attention.md
+# - Extracts title, authors, year, venue
+# - Summarizes key contributions
+# - Identifies main concepts → [[wikilinks]]
+# - Adds BibTeX reference
+
+# Batch process papers directory
+agent.process_papers_batch(
+    input_dir="papers/",
+    output_dir="literature/",
+    skip_existing=True,
+)
+```
+
+## Knowledge Graph Building
+
+```python
+# Discover connections between notes
+connections = agent.discover_connections(
+    scope="literature/",
+    min_similarity=0.7,
+)
+
+for conn in connections:
+    print(f"{conn.source} ↔ {conn.target}")
+    print(f"  Reason: {conn.reason}")
+    print(f"  Similarity: {conn.score:.2f}")
+
+# Auto-insert wikilinks for discovered connections
+agent.link_notes(connections, mode="suggest")
+# Adds [[suggested-link]] with <!-- foam:auto --> comment
+
+# Build concept map from literature notes
+concept_map = agent.build_concept_map(
+    scope="literature/",
+    min_mentions=3,
+)
+for concept in concept_map.nodes:
+    print(f"{concept.name}: mentioned in {concept.count} papers")
+```
+
+## Daily Research Journal
+
+```python
+# Generate daily note with research context
+agent.create_daily_note(
+    include=[
+        "recent_papers",        # Papers read recently
+        "open_questions",       # Unresolved questions from notes
+        "stale_notes",          # Notes not updated in 30+ days
+        "orphan_notes",         # Notes with no incoming links
+        "suggested_reading",    # Papers related to recent work
+    ],
+)
+
+# Output: daily/2025-03-10.md
+# ## Recently Added
+# - [[vaswani-2017-attention]] (added yesterday)
+#
+# ## Open Questions
+# - How does [[rotary-position-embedding]] compare to [[alibi]]?
+#
+# ## Suggested Reading
+# Based on recent notes on [[flash-attention]], consider:
+# - "FlashAttention-2: Faster Attention" (Dao, 2023)
+```
+
+## Graph Analysis
+
+```python
+# Analyze knowledge graph structure
+stats = agent.analyze_graph()
+
+print(f"Total notes: {stats.total_notes}")
+print(f"Total links: {stats.total_links}")
+print(f"Orphan notes: {stats.orphan_count}")
+print(f"Most connected: {stats.top_nodes[:5]}")
+print(f"Clusters: {stats.cluster_count}")
+
+# Identify research gaps
+gaps = agent.find_gaps()
+for gap in gaps:
+    print(f"Gap: {gap.description}")
+    print(f"  Between clusters: {gap.cluster_a} ↔ {gap.cluster_b}")
+    print(f"  Suggested topics: {gap.suggested_topics}")
+```
+
+## Configuration
+
+```json
+{
+  "foam.agent": {
+    "llm_provider": "anthropic",
+    "templates": {
+      "literature": "templates/literature.md",
+      "concept": "templates/concept.md",
+      "daily": "templates/daily.md"
+    },
+    "auto_link": {
+      "enabled": true,
+      "min_similarity": 0.75,
+      "max_suggestions_per_note": 5
+    },
+    "graph": {
+      "exclude_patterns": ["daily/*", "templates/*"],
+      "tag_colors": {
+        "transformer": "#3B82F6",
+        "nlp": "#10B981"
+      }
+    }
+  }
+}
+```
+
+## Use Cases
+
+1. **Literature management**: Auto-generate linked notes from papers
+2. **Concept mapping**: Build and visualize research concept graphs
+3. **Research journaling**: AI-assisted daily research summaries
+4. **Gap discovery**: Find under-explored connections between topics
+5. **Collaborative wikis**: Shared team research knowledge bases
+
+## References
+
+- [Foam GitHub](https://github.com/foambubble/foam)
+- [Foam Documentation](https://foambubble.github.io/foam/)
+- [Zettelkasten Method](https://zettelkasten.de/introduction/)

package/skills/research/automation/kedro-pipeline-guide/SKILL.md

@@ -4,8 +4,8 @@ description: "Build reproducible data science pipelines with Kedro for research
 metadata:
   openclaw:
     emoji: "🔧"
-    category: research
-    subcategory: automation
+    category: "research"
+    subcategory: "automation"
     keywords: ["pipeline", "reproducibility", "data-science", "workflow", "automation", "mlops"]
     source: "https://github.com/kedro-org/kedro"
 ---

package/skills/research/automation/mle-agent-guide/SKILL.md

@@ -6,8 +6,8 @@ author: wentor-community
 source: https://github.com/MLSys-Tools/MLE-agent
 metadata:
   openclaw:
-    category: research
-    subcategory: automation
+    category: "research"
+    subcategory: "automation"
     keywords:
       - machine-learning
       - ml-engineering

package/skills/research/automation/paper-to-agent-guide/SKILL.md

@@ -6,8 +6,8 @@ author: wentor-community
 source: https://github.com/paper2agent/Paper2Agent
 metadata:
   openclaw:
-    category: research
-    subcategory: automation
+    category: "research"
+    subcategory: "automation"
     keywords:
       - paper-parsing
       - agent-generation

package/skills/research/deep-research/auto-deep-research-guide/SKILL.md

@@ -6,8 +6,8 @@ author: wentor-community
 source: https://github.com/Auto-Deep-Research/Auto-Deep-Research
 metadata:
   openclaw:
-    category: research
-    subcategory: deep-research
+    category: "research"
+    subcategory: "deep-research"
     keywords:
       - deep-research
       - automated-investigation

package/skills/research/deep-research/cognitive-kernel-guide/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: cognitive-kernel-guide
+description: "Autonomous agent with long-term memory for deep research tasks"
+metadata:
+  openclaw:
+    emoji: "🧠"
+    category: "research"
+    subcategory: "deep-research"
+    keywords: ["Cognitive Kernel", "autonomous agent", "long-term memory", "deep research", "reasoning", "knowledge accumulation"]
+    source: "https://github.com/Cognitive-Kernel/cognitive-kernel"
+---
+
+# Cognitive Kernel Guide
+
+## Overview
+
+Cognitive Kernel is an autonomous agent framework designed for deep research tasks that require sustained reasoning over long horizons. Unlike single-shot agents, it maintains long-term memory across research sessions, builds incremental knowledge representations, and uses structured planning to decompose complex research questions. The system combines web search, paper reading, and code execution with persistent memory for accumulating expertise over time.
+
+## Architecture
+
+### Core Components
+
+```
+Research Question
+      ↓
+  Planning Module (decomposes into subtasks)
+      ↓
+  Execution Engine
+  ├── Web Search Tool
+  ├── Paper Reader Tool
+  ├── Code Executor Tool
+  └── Calculator Tool
+      ↓
+  Working Memory (session state)
+      ↓
+  Long-term Memory (cross-session persistence)
+      ↓
+  Reflection Module (evaluate + revise)
+      ↓
+  Synthesized Answer
+```
+
+### Memory System
+
+| Memory Type | Scope | Purpose |
+|-------------|-------|---------|
+| **Working** | Current task | Active reasoning context |
+| **Episodic** | Cross-session | Past research experiences |
+| **Semantic** | Permanent | Accumulated domain knowledge |
+| **Procedural** | Permanent | Learned research strategies |
+
+## Usage
+
+```python
+from cognitive_kernel import CognitiveKernel
+
+kernel = CognitiveKernel(
+    llm_provider="anthropic",
+    memory_backend="chromadb",
+    tools=["web_search", "paper_reader", "code_executor"],
+)
+
+# Deep research with persistent memory
+result = kernel.research(
+    question="What are the theoretical limits of in-context learning "
+             "in transformer architectures, and how do recent results "
+             "on looped transformers change our understanding?",
+    max_iterations=10,
+    allow_code_execution=True,
+)
+
+print(result.answer)
+print(f"Sources consulted: {len(result.sources)}")
+print(f"Memory entries created: {result.new_memories}")
+```
+
+## Planning and Decomposition
+
+```python
+# The kernel automatically decomposes complex questions
+plan = kernel.plan(
+    "Compare the sample efficiency of model-based vs model-free "
+    "reinforcement learning in robotics manipulation tasks"
+)
+
+for step in plan.steps:
+    print(f"Step {step.id}: {step.description}")
+    print(f"  Tool: {step.tool}")
+    print(f"  Dependencies: {step.depends_on}")
+
+# Execute plan with monitoring
+result = kernel.execute_plan(plan, verbose=True)
+```
+
+## Long-term Memory
+
+```python
+# Memory persists across sessions
+kernel = CognitiveKernel(memory_path="./research_memory")
+
+# First session: research transformers
+kernel.research("What is the attention mechanism in transformers?")
+
+# Later session: builds on prior knowledge automatically
+result = kernel.research(
+    "How does flash attention improve transformer efficiency?"
+)
+# Kernel recalls prior attention mechanism knowledge
+
+# Query accumulated knowledge
+memories = kernel.memory.search(
+    "attention mechanism efficiency",
+    top_k=10,
+)
+for mem in memories:
+    print(f"[{mem.timestamp}] {mem.content[:100]}...")
+```
+
+## Reflection and Self-Correction
+
+```python
+# Built-in reflection after each research step
+kernel = CognitiveKernel(
+    reflection_config={
+        "enabled": True,
+        "frequency": "every_step",   # or "end_only"
+        "criteria": [
+            "factual_accuracy",
+            "completeness",
+            "logical_consistency",
+        ],
+        "max_revisions": 3,
+    }
+)
+
+# Access reflection log
+for entry in result.reflections:
+    print(f"Step {entry.step}: {entry.assessment}")
+    if entry.revision:
+        print(f"  Revised: {entry.revision_reason}")
+```
+
+## Tool Integration
+
+```python
+# Custom tool registration
+from cognitive_kernel import Tool
+
+@Tool(name="arxiv_search", description="Search arXiv papers")
+def search_arxiv(query: str, max_results: int = 10) -> list:
+    import arxiv
+    search = arxiv.Search(query=query, max_results=max_results)
+    return [{"title": r.title, "abstract": r.summary}
+            for r in search.results()]
+
+kernel.register_tool(search_arxiv)
+
+# Code execution for data analysis
+result = kernel.research(
+    "Analyze the publication trend of LLM papers on arXiv "
+    "from 2020 to 2025",
+    allow_code_execution=True,  # enables matplotlib, pandas
+)
+```
+
+## Configuration
+
+```python
+kernel = CognitiveKernel(
+    llm_provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    memory_config={
+        "backend": "chromadb",
+        "embedding_model": "all-MiniLM-L6-v2",
+        "max_memories": 10000,
+        "similarity_threshold": 0.7,
+    },
+    planning_config={
+        "max_depth": 3,          # Subtask nesting depth
+        "max_steps": 20,         # Max steps per plan
+        "allow_replanning": True,
+    },
+    execution_config={
+        "timeout_per_step": 120,   # seconds
+        "max_retries": 2,
+    },
+)
+```
+
+## Use Cases
+
+1. **Multi-session literature reviews**: Build expertise incrementally
+2. **Technical deep dives**: Complex questions requiring code + search
+3. **Research planning**: Decompose and explore research directions
+4. **Knowledge base building**: Accumulate domain expertise over time
+
+## References
+
+- [Cognitive Kernel GitHub](https://github.com/Cognitive-Kernel/cognitive-kernel)
+- [Cognitive Kernel Paper](https://arxiv.org/abs/2409.10925)