@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/research/methodology/research-pipeline-units-guide/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: research-pipeline-units-guide
+description: "Evidence-first semantic research pipeline methodology"
+metadata:
+  openclaw:
+    emoji: "🔬"
+    category: "research"
+    subcategory: "methodology"
+    keywords: ["research pipeline", "evidence-first", "semantic units", "methodology", "research workflow", "structured inquiry"]
+    source: "https://github.com/WILLOSCAR/research-units-pipeline-skills"
+---
+
+# Research Pipeline Units Guide
+
+## Overview
+
+Research Pipeline Units is a methodology for structuring research as composable, evidence-first semantic units. Instead of monolithic literature reviews, it decomposes research into atomic claims, evidence units, and reasoning chains that can be independently verified, combined, and reused. Each unit has clear provenance, confidence levels, and connections to other units. Suited for systematic reviews and evidence synthesis.
+
+## Core Concepts
+
+```
+Research Pipeline
+├── Claim Unit
+│   ├── Statement (falsifiable assertion)
+│   ├── Evidence (supporting sources)
+│   ├── Confidence (high/medium/low)
+│   └── Counter-evidence (opposing sources)
+├── Evidence Unit
+│   ├── Source (paper, dataset, experiment)
+│   ├── Extraction (quote, data point, figure)
+│   ├── Quality (study design, bias risk)
+│   └── Relevance (to claim)
+├── Reasoning Chain
+│   ├── Premises (claim units)
+│   ├── Logic (deductive, inductive, abductive)
+│   └── Conclusion (derived claim)
+└── Knowledge Map
+    ├── Clusters (related claims)
+    ├── Contradictions (conflicting evidence)
+    └── Gaps (missing evidence)
+```
+
+## Building Claim Units
+
+```python
+from research_units import ClaimUnit, EvidenceUnit
+
+# Create an evidence-backed claim
+claim = ClaimUnit(
+    statement="Retrieval-augmented generation reduces "
+              "hallucination in LLMs by 40-60%",
+    confidence="medium",
+    evidence=[
+        EvidenceUnit(
+            source="Lewis et al., 2020",
+            doi="10.48550/arXiv.2005.11401",
+            extraction="RAG reduces factual errors by 43% "
+                       "on Natural Questions",
+            quality="high",  # Peer-reviewed, strong methodology
+        ),
+        EvidenceUnit(
+            source="Shuster et al., 2021",
+            doi="10.48550/arXiv.2104.07567",
+            extraction="Knowledge-grounded dialogue 54% fewer "
+                       "hallucinated facts",
+            quality="medium",
+        ),
+    ],
+    counter_evidence=[
+        EvidenceUnit(
+            source="Mallen et al., 2023",
+            extraction="RAG helps less for popular knowledge "
+                       "that LLMs already encode",
+            quality="high",
+        ),
+    ],
+)
+
+print(f"Claim: {claim.statement}")
+print(f"Confidence: {claim.confidence}")
+print(f"Supporting: {len(claim.evidence)} sources")
+print(f"Opposing: {len(claim.counter_evidence)} sources")
+```
+
+## Reasoning Chains
+
+```python
+from research_units import ReasoningChain
+
+chain = ReasoningChain(
+    premises=[
+        ClaimUnit("RAG reduces hallucination (Lewis 2020)"),
+        ClaimUnit("Knowledge conflicts degrade RAG quality "
+                  "(Chen 2022)"),
+        ClaimUnit("Adaptive retrieval mitigates conflicts "
+                  "(Jiang 2023)"),
+    ],
+    logic="inductive",
+    conclusion=ClaimUnit(
+        statement="Adaptive retrieval-augmented generation "
+                  "with conflict resolution is the most "
+                  "promising approach to LLM factuality",
+        confidence="medium",
+    ),
+)
+
+# Validate chain
+validation = chain.validate()
+print(f"Valid: {validation.is_valid}")
+print(f"Gaps: {validation.gaps}")
+print(f"Strength: {validation.strength}")
+```
+
+## Knowledge Maps
+
+```python
+from research_units import KnowledgeMap
+
+kmap = KnowledgeMap("RAG for Factuality")
+
+# Add clusters of related claims
+kmap.add_cluster("retrieval_methods", [claim1, claim2, claim3])
+kmap.add_cluster("conflict_resolution", [claim4, claim5])
+kmap.add_cluster("evaluation", [claim6, claim7])
+
+# Identify contradictions
+contradictions = kmap.find_contradictions()
+for c in contradictions:
+    print(f"Conflict: {c.claim_a.statement[:50]}...")
+    print(f"  vs: {c.claim_b.statement[:50]}...")
+    print(f"  Resolution: {c.suggested_resolution}")
+
+# Identify gaps
+gaps = kmap.find_gaps()
+for g in gaps:
+    print(f"Gap: {g.description}")
+    print(f"  Between: {g.cluster_a} ↔ {g.cluster_b}")
+    print(f"  Suggested research: {g.suggestion}")
+
+# Export
+kmap.export("knowledge_map.json")
+kmap.visualize("knowledge_map.html")
+```
+
+## Pipeline Workflow
+
+```markdown
+### Step-by-Step Research Pipeline
+1. **Define scope**: Research question → decomposed sub-questions
+2. **Search**: Literature search per sub-question
+3. **Extract**: Create evidence units from each paper
+4. **Claim**: Formulate claims supported by evidence
+5. **Chain**: Build reasoning chains linking claims
+6. **Map**: Assemble knowledge map showing landscape
+7. **Synthesize**: Write narrative from structured units
+8. **Validate**: Peer review individual units + chains
+```
+
+## Use Cases
+
+1. **Systematic reviews**: Structured evidence synthesis
+2. **Research proposals**: Evidence-backed argument construction
+3. **Collaborative research**: Shared, verifiable claim units
+4. **Teaching**: Demonstrate evidence-based reasoning
+5. **Knowledge management**: Reusable research building blocks
+
+## References
+
+- [research-units-pipeline-skills](https://github.com/WILLOSCAR/research-units-pipeline-skills)

package/skills/research/methodology/research-town-guide/SKILL.md

@@ -0,0 +1,263 @@
+---
+name: research-town-guide
+description: "Simulate human research communities with multi-agent AI collaboration"
+metadata:
+  openclaw:
+    emoji: "town"
+    category: "research"
+    subcategory: "methodology"
+    keywords: ["multi-agent", "simulation", "research community", "AI agents", "peer review", "collaboration"]
+    source: "https://github.com/hiyouga/ResearchTown"
+---
+
+# Research Town Guide
+
+Simulate human research communities using multi-agent AI systems. Research Town creates virtual research environments where AI agents take on the roles of researchers, reviewers, editors, and collaborators to generate, critique, refine, and peer-review research ideas through structured multi-agent interaction.
+
+## Overview
+
+Research Town is an open-source framework for simulating the social dynamics of academic research communities. Rather than using a single AI model for idea generation or paper writing, Research Town instantiates multiple specialized agents -- each with a defined expertise profile, publication history, and behavioral model -- that interact through the same social structures as human researchers: lab meetings, peer review, conference discussions, and collaborative writing.
+
+The key insight behind Research Town is that research quality emerges from the social process of science, not just individual brilliance. Peer review, adversarial critique, iterative refinement through rebuttal, and cross-disciplinary fertilization are all processes that can be simulated with multi-agent systems. By modeling these interactions, Research Town produces research outputs that have been stress-tested through simulated peer review before a human researcher ever sees them.
+
+This approach is particularly valuable for three research tasks: (1) generating novel research ideas by simulating brainstorming sessions between agents with diverse expertise, (2) stress-testing research proposals by subjecting them to simulated peer review, and (3) identifying gaps in the literature by having agents independently survey and then synthesize findings from different subfields.
+
+## Architecture
+
+### Agent Types
+
+| Agent Role | Expertise | Behavior |
+|------------|-----------|----------|
+| Principal Investigator | Broad domain knowledge, research vision | Sets research direction, evaluates proposals |
+| Domain Expert | Deep knowledge in a specific area | Provides technical depth, identifies related work |
+| Methodologist | Statistical and experimental design expertise | Critiques methods, suggests improvements |
+| Reviewer | Journal review experience, quality standards | Evaluates novelty, significance, rigor |
+| Devil's Advocate | Critical thinking, identifying weaknesses | Challenges assumptions, finds counterexamples |
+| Synthesizer | Cross-disciplinary knowledge | Connects ideas across fields, identifies patterns |
+
+### Interaction Protocols
+
+```python
+# Research Town interaction structure
+class ResearchTownSession:
+    def __init__(self, agents, topic):
+        self.agents = agents
+        self.topic = topic
+        self.rounds = []
+
+    def run_brainstorming(self, num_rounds=3):
+        """Structured brainstorming with multiple agents."""
+        ideas = []
+        for round_num in range(num_rounds):
+            round_ideas = []
+            for agent in self.agents:
+                # Each agent generates ideas given prior context
+                idea = agent.generate_idea(
+                    topic=self.topic,
+                    prior_ideas=ideas,
+                    round=round_num
+                )
+                round_ideas.append(idea)
+
+            # Cross-pollination: agents react to each other's ideas
+            for agent in self.agents:
+                reactions = agent.react_to_ideas(round_ideas)
+                ideas.extend(reactions)
+
+            self.rounds.append(round_ideas)
+        return ideas
+
+    def run_peer_review(self, paper_draft):
+        """Simulate peer review with multiple reviewers."""
+        reviews = []
+        for reviewer in self.agents:
+            if reviewer.role == "reviewer":
+                review = reviewer.review_paper(
+                    paper_draft,
+                    criteria=["novelty", "significance",
+                             "methodology", "clarity", "reproducibility"]
+                )
+                reviews.append(review)
+
+        # Meta-review: aggregate and identify consensus
+        meta_review = self.aggregate_reviews(reviews)
+        return meta_review
+```
+
+## Setting Up a Research Town Session
+
+### Defining Agent Profiles
+
+```yaml
+# agents.yaml - Agent configuration
+agents:
+  - name: "Prof. ML Expert"
+    role: principal_investigator
+    expertise: ["machine learning", "deep learning", "optimization"]
+    style: "rigorous, quantitative, focused on scalability"
+    publication_venues: ["NeurIPS", "ICML", "JMLR"]
+    h_index: 45
+
+  - name: "Dr. Biology Specialist"
+    role: domain_expert
+    expertise: ["structural biology", "protein engineering", "bioinformatics"]
+    style: "experimental, emphasizes biological validity"
+    publication_venues: ["Nature", "Cell", "PNAS"]
+    h_index: 32
+
+  - name: "Dr. Statistics"
+    role: methodologist
+    expertise: ["causal inference", "experimental design", "Bayesian methods"]
+    style: "rigorous, demands proper statistical justification"
+    publication_venues: ["JASA", "Biometrika", "Statistical Science"]
+    h_index: 28
+
+  - name: "Reviewer Alpha"
+    role: reviewer
+    expertise: ["interdisciplinary research", "computational biology"]
+    style: "constructive but demanding, focuses on reproducibility"
+    review_experience: 200
+
+  - name: "Skeptic"
+    role: devils_advocate
+    expertise: ["philosophy of science", "replication crisis", "research methods"]
+    style: "challenges assumptions, demands strong evidence"
+```
+
+### Running an Idea Generation Session
+
+```python
+from research_town import ResearchTown, Agent
+
+# Initialize agents from profiles
+town = ResearchTown.from_config("agents.yaml")
+
+# Define research topic
+topic = {
+    "area": "AI for Drug Discovery",
+    "question": "How can we improve the efficiency of virtual screening "
+                "for novel antibiotics using foundation models?",
+    "constraints": [
+        "Must work with limited labeled data (<1000 compounds)",
+        "Must generalize across bacterial species",
+        "Should produce interpretable predictions"
+    ]
+}
+
+# Run brainstorming (3 rounds of idea generation and critique)
+session = town.create_session(topic)
+ideas = session.run_brainstorming(num_rounds=3)
+
+# Rank ideas by multi-agent consensus
+ranked = session.rank_ideas(ideas, criteria=[
+    "novelty",       # How different from existing approaches
+    "feasibility",   # Can it be implemented with current resources
+    "impact",        # Potential significance if successful
+    "rigor"          # Methodological soundness
+])
+
+# Output top ideas with supporting analysis
+for i, idea in enumerate(ranked[:5]):
+    print(f"\n=== Idea {i+1} (Score: {idea.score:.2f}) ===")
+    print(f"Title: {idea.title}")
+    print(f"Summary: {idea.summary}")
+    print(f"Proposed by: {idea.proposer.name}")
+    print(f"Endorsed by: {[a.name for a in idea.endorsers]}")
+    print(f"Critiques: {idea.critiques}")
+```
+
+## Simulated Peer Review
+
+### Review Protocol
+
+The simulated peer review follows a structured protocol modeled on top-venue review processes:
+
+```python
+review_criteria = {
+    "novelty": {
+        "description": "Does this paper present genuinely new ideas?",
+        "scale": "1-10",
+        "weight": 0.25
+    },
+    "significance": {
+        "description": "How important is the contribution to the field?",
+        "scale": "1-10",
+        "weight": 0.20
+    },
+    "soundness": {
+        "description": "Are the methods and analysis technically correct?",
+        "scale": "1-10",
+        "weight": 0.25
+    },
+    "clarity": {
+        "description": "Is the paper well-written and easy to follow?",
+        "scale": "1-10",
+        "weight": 0.15
+    },
+    "reproducibility": {
+        "description": "Could another researcher replicate the results?",
+        "scale": "1-10",
+        "weight": 0.15
+    }
+}
+```
+
+### Review Output Format
+
+```markdown
+## Review Summary
+
+**Overall Score**: 6.5/10
+**Recommendation**: Minor Revision
+
+### Strengths
+1. Novel application of contrastive learning to molecular fingerprints
+2. Comprehensive ablation study across 4 benchmark datasets
+3. Clear explanation of the biological motivation
+
+### Weaknesses
+1. Limited comparison with recent graph neural network baselines (2024+)
+2. Statistical significance not reported for main results
+3. Interpretability analysis is superficial
+
+### Questions for Authors
+1. How does performance scale with dataset size? The smallest dataset has 5000 compounds.
+2. What is the computational cost compared to traditional docking methods?
+
+### Minor Issues
+- Table 3 formatting is inconsistent
+- Reference [24] appears to be a preprint; has it been published?
+```
+
+## Use Cases for Researchers
+
+### 1. Idea Stress-Testing
+
+Before investing months in a research direction, run your idea through a simulated review panel to identify weaknesses early.
+
+### 2. Literature Gap Discovery
+
+Deploy agents with different domain expertise to independently survey a topic, then synthesize their findings to identify under-explored intersections.
+
+### 3. Writing Feedback
+
+Submit draft sections to simulated reviewers for constructive criticism on clarity, argumentation, and missing references.
+
+### 4. Proposal Refinement
+
+Iterate on grant proposals by having agents role-play as review panel members with different priorities (novelty, feasibility, broader impact).
+
+## Limitations and Ethics
+
+- **AI-generated ideas are starting points, not final outputs**: All ideas require human validation, domain expertise, and ethical review before pursuit.
+- **Simulated review is not a substitute for real peer review**: It can catch obvious issues but cannot replicate the full depth of expert human review.
+- **Bias inheritance**: Agent behaviors are shaped by their training data, which may reproduce biases in existing research communities.
+- **Attribution**: When using multi-agent idea generation, researchers should document the AI's role in the ideation process per their institution's guidelines.
+
+## References
+
+- Research Town: https://github.com/hiyouga/ResearchTown
+- The AI Scientist (Sakana AI): https://github.com/SakanaAI/AI-Scientist
+- AutoGen multi-agent framework: https://github.com/microsoft/autogen
+- CrewAI agent framework: https://github.com/joaomdmoura/crewAI
+- Park et al., "Generative Agents: Interactive Simulacra of Human Behavior" (2023)

package/skills/research/methodology/slr-automation-guide/SKILL.md

@@ -0,0 +1,235 @@
+---
+name: slr-automation-guide
+description: "Tools and pipelines for automating systematic literature reviews"
+metadata:
+  openclaw:
+    emoji: "📋"
+    category: "research"
+    subcategory: "methodology"
+    keywords: ["systematic review", "SLR", "automation", "screening", "PRISMA", "evidence synthesis"]
+    source: "https://github.com/asreview/asreview"
+---
+
+# Systematic Literature Review Automation Guide
+
+## Overview
+
+Systematic Literature Reviews (SLRs) are rigorous, reproducible surveys of research evidence following protocols like PRISMA and Cochrane. This guide covers tools that automate the most time-consuming steps — deduplication, title/abstract screening, full-text assessment, and data extraction — using active learning, NLP, and AI agents. Key tools include ASReview, Rayyan, and custom pipelines.
+
+## SLR Pipeline
+
+```
+Protocol Definition (PICO, inclusion/exclusion criteria)
+         ↓
+   Database Search (PubMed, Scopus, Web of Science)
+         ↓
+   Deduplication (ASReview, Rayyan, or custom)
+         ↓
+   Title/Abstract Screening (AI-assisted prioritization)
+         ↓
+   Full-text Assessment (relevance + quality)
+         ↓
+   Data Extraction (structured tables)
+         ↓
+   Quality Assessment (risk of bias)
+         ↓
+   Synthesis + PRISMA Report
+```
+
+## ASReview (Active Learning)
+
+```bash
+# Install ASReview
+pip install asreview
+
+# Launch web interface
+asreview lab
+
+# CLI screening
+asreview simulate benchmark:van_de_Schoot_2017 \
+  -m nb -e tfidf \
+  --n_prior_included 5 --n_prior_excluded 5 \
+  -o results/simulation.asreview
+```
+
+### Python API
+
+```python
+import asreview
+from asreview import ASReviewData, ReviewSimulate
+
+# Load dataset (RIS, CSV, or Excel)
+data = ASReviewData.from_file("search_results.ris")
+print(f"Records: {len(data)}")
+
+# Active learning simulation
+sim = ReviewSimulate(
+    data,
+    model="nb",              # Naive Bayes classifier
+    feature_extraction="tfidf",
+    query_strategy="max",     # Show most likely relevant first
+    n_prior_included=5,
+    n_prior_excluded=5,
+)
+sim.review()
+
+# Results: screening order optimized by relevance
+print(f"Work saved: {sim.work_saved():.1%}")
+# Typically 80-95% of irrelevant papers screened out early
+```
+
+## Deduplication
+
+```python
+# ASReview deduplication
+from asreview.data import ASReviewData
+
+# Merge results from multiple databases
+datasets = [
+    ASReviewData.from_file("pubmed_results.ris"),
+    ASReviewData.from_file("scopus_results.ris"),
+    ASReviewData.from_file("wos_results.ris"),
+]
+
+merged = ASReviewData.from_dataframe(
+    pd.concat([d.df for d in datasets])
+)
+print(f"Before dedup: {len(merged)}")
+
+# Fuzzy matching on title + DOI
+deduplicated = merged.deduplicate()
+print(f"After dedup: {len(deduplicated)}")
+```
+
+## AI-Assisted Screening
+
+```python
+# Custom LLM screening pipeline
+from slr_tools import LLMScreener
+
+screener = LLMScreener(
+    llm_provider="anthropic",
+    criteria={
+        "population": "Adults with type 2 diabetes",
+        "intervention": "SGLT2 inhibitors",
+        "outcomes": "Cardiovascular events",
+        "study_types": ["RCT", "cohort", "meta-analysis"],
+        "exclusions": ["animal studies", "in vitro", "pediatric"],
+    },
+)
+
+# Screen abstracts
+results = screener.screen_batch(
+    records=search_results,
+    fields=["title", "abstract"],
+    threshold=0.5,  # Include if P(relevant) > 0.5
+)
+
+for r in results:
+    print(f"[{'INCLUDE' if r.include else 'EXCLUDE'}] "
+          f"(p={r.confidence:.2f}) {r.title[:60]}...")
+    print(f"  Reason: {r.reason}")
+```
+
+## Data Extraction
+
+```python
+# Structured data extraction from full-text papers
+from slr_tools import DataExtractor
+
+extractor = DataExtractor(
+    llm_provider="anthropic",
+    schema={
+        "study_design": "str",
+        "sample_size": "int",
+        "population_description": "str",
+        "intervention_details": "str",
+        "primary_outcome": "str",
+        "effect_size": "float",
+        "confidence_interval": "str",
+        "p_value": "float",
+        "follow_up_duration": "str",
+        "risk_of_bias": "str",
+    },
+)
+
+# Extract from PDF
+extracted = extractor.extract("paper.pdf")
+print(extracted.to_dict())
+
+# Batch extraction
+results_df = extractor.extract_batch("fulltext_papers/")
+results_df.to_csv("extraction_table.csv")
+```
+
+## PRISMA Flow Diagram
+
+```python
+# Generate PRISMA 2020 flow diagram
+from slr_tools import PRISMAFlow
+
+flow = PRISMAFlow(
+    identification={
+        "databases": {"PubMed": 1200, "Scopus": 890, "WoS": 650},
+        "other_sources": {"citation_search": 45},
+    },
+    screening={
+        "after_dedup": 1850,
+        "excluded_title_abstract": 1620,
+        "sought_fulltext": 230,
+        "not_retrieved": 12,
+    },
+    included={
+        "assessed_fulltext": 218,
+        "excluded_fulltext": {
+            "wrong_population": 45,
+            "wrong_intervention": 32,
+            "wrong_outcome": 28,
+            "wrong_study_type": 15,
+        },
+        "final_included": 98,
+    },
+)
+
+flow.save_svg("prisma_flow.svg")
+flow.save_latex("prisma_flow.tex")
+```
+
+## Quality Assessment
+
+```python
+# Risk of Bias assessment (Cochrane RoB 2)
+from slr_tools import RiskOfBias
+
+rob = RiskOfBias(tool="rob2")  # or "robins_i" for non-RCTs
+
+assessment = rob.assess(
+    paper="paper.pdf",
+    domains=[
+        "randomization_process",
+        "deviations_from_intervention",
+        "missing_outcome_data",
+        "outcome_measurement",
+        "selection_of_reported_result",
+    ],
+)
+
+print(f"Overall: {assessment.overall_judgment}")
+for domain, judgment in assessment.domain_judgments.items():
+    print(f"  {domain}: {judgment}")
+```
+
+## Use Cases
+
+1. **Medical SLRs**: Cochrane-style evidence reviews
+2. **CS surveys**: Comprehensive literature mapping
+3. **Policy reviews**: Evidence synthesis for policy decisions
+4. **Thesis literature chapters**: Structured review sections
+5. **Grant applications**: Rapid evidence landscape scans
+
+## References
+
+- [ASReview](https://asreview.nl/) — Active learning for systematic reviews
+- [PRISMA 2020](http://www.prisma-statement.org/) — Reporting guidelines
+- [Cochrane Handbook](https://training.cochrane.org/handbook)
+- [Rayyan](https://www.rayyan.ai/) — Collaborative screening platform