@wentorai/research-plugins 1.1.0 → 1.2.0

package/skills/domains/biomedical/genotex-benchmark-guide/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: genotex-benchmark-guide
+description: "Benchmark for LLM agents on gene expression data analysis"
+metadata:
+  openclaw:
+    emoji: "🧫"
+    category: "domains"
+    subcategory: "biomedical"
+    keywords: ["GenoTEX", "gene expression", "benchmark", "LLM agent", "bioinformatics", "GEO"]
+    source: "https://github.com/Liu-Hy/GenoTEX"
+---
+
+# GenoTEX Benchmark Guide
+
+## Overview
+
+GenoTEX is a benchmark for evaluating LLM-based agents on gene expression data analysis tasks. It provides curated datasets from GEO (Gene Expression Omnibus) with ground-truth analysis pipelines, testing agents on data preprocessing, differential expression, enrichment analysis, and biological interpretation. Published at MLCB 2025 as an oral presentation.
+
+## Benchmark Structure
+
+```
+GenoTEX Benchmark
+├── Data Collection
+│   └── Curated GEO datasets with ground truth
+├── Task Categories
+│   ├── Data preprocessing (QC, normalization)
+│   ├── Differential expression analysis
+│   ├── Gene set enrichment analysis
+│   ├── Clustering and classification
+│   └── Biological interpretation
+├── Evaluation
+│   ├── Code correctness (executes without error)
+│   ├── Statistical validity (appropriate tests)
+│   ├── Result accuracy (vs ground truth)
+│   └── Interpretation quality (biological insight)
+└── Baselines
+    ├── GPT-4 agent
+    ├── Claude agent
+    └── Domain-specific fine-tuned models
+```
+
+## Usage
+
+```python
+from genotex import GenoTEXBenchmark
+
+bench = GenoTEXBenchmark()
+
+# List available tasks
+tasks = bench.list_tasks()
+for task in tasks[:5]:
+    print(f"Task: {task.id}")
+    print(f"  Dataset: {task.geo_accession}")
+    print(f"  Category: {task.category}")
+    print(f"  Difficulty: {task.difficulty}")
+
+# Get a specific task
+task = bench.get_task("GSE12345_DEG")
+print(f"Description: {task.description}")
+print(f"Input files: {task.input_files}")
+print(f"Expected output: {task.expected_output_type}")
+```
+
+## Running Evaluations
+
+```python
+# Evaluate an agent on GenoTEX
+from genotex import evaluate_agent
+
+results = evaluate_agent(
+    agent_fn=my_agent_function,
+    tasks="all",            # or specific task IDs
+    timeout_per_task=300,   # seconds
+)
+
+print(f"Tasks completed: {results.completed}/{results.total}")
+print(f"Code correctness: {results.code_correct_rate:.1%}")
+print(f"Statistical validity: {results.stats_valid_rate:.1%}")
+print(f"Result accuracy: {results.accuracy:.3f}")
+```
+
+## Task Examples
+
+```python
+# Example: Differential Expression Analysis
+task = {
+    "id": "GSE12345_DEG",
+    "description": "Identify differentially expressed genes "
+                   "between treatment and control groups in "
+                   "this RNA-seq dataset.",
+    "input": "GSE12345_counts.csv",  # Raw count matrix
+    "metadata": "GSE12345_metadata.csv",  # Sample info
+    "expected": {
+        "method": "DESeq2 or limma-voom",
+        "output": "DEG table with log2FC, p-value, adj.p",
+        "ground_truth": "GSE12345_deg_truth.csv",
+    },
+}
+
+# Example: Gene Set Enrichment
+task = {
+    "id": "GSE12345_GSEA",
+    "description": "Perform gene set enrichment analysis on "
+                   "the DEGs and identify enriched pathways.",
+    "input": "GSE12345_deg_results.csv",
+    "expected": {
+        "method": "fgsea, clusterProfiler, or enrichR",
+        "output": "Enriched pathways with NES and FDR",
+    },
+}
+```
+
+## Use Cases
+
+1. **Agent evaluation**: Test bioinformatics agents on real tasks
+2. **Method comparison**: Compare LLM agents on genomics
+3. **Benchmark development**: Extend with new GEO datasets
+4. **Teaching**: Standard tasks for bioinformatics education
+5. **Tool development**: Test new analysis pipelines
+
+## References
+
+- [GenoTEX GitHub](https://github.com/Liu-Hy/GenoTEX)
+- [GEO Database](https://www.ncbi.nlm.nih.gov/geo/)
+- [MLCB 2025](https://mlcb.github.io/)

package/skills/domains/biomedical/med-researcher-guide/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: med-researcher-guide
+description: "Multi-agent system for biomedical literature review and synthesis"
+metadata:
+  openclaw:
+    emoji: "🏥"
+    category: "domains"
+    subcategory: "biomedical"
+    keywords: ["medical research", "biomedical agent", "clinical literature", "PubMed agent", "medical AI", "evidence synthesis"]
+    source: "https://github.com/mao1207/Med-Researcher"
+---
+
+# Med-Researcher Guide
+
+## Overview
+
+Med-Researcher is a multi-agent system designed specifically for biomedical literature review. It orchestrates specialized agents for searching PubMed and other medical databases, extracting structured evidence from clinical papers, and synthesizing findings into evidence-graded summaries. Particularly useful for clinical evidence reviews, drug interaction research, and systematic reviews in medicine.
+
+## Architecture
+
+### Agent Roles
+
+```
+Query → Planning Agent (decomposes clinical question)
+            ↓
+      Search Agent (PubMed, PMC, clinical trials)
+            ↓
+      Extraction Agent (PICO, outcomes, evidence grade)
+            ↓
+      Synthesis Agent (evidence summary, contradictions)
+            ↓
+      Report Agent (structured review output)
+```
+
+### Agent Descriptions
+
+| Agent | Role |
+|-------|------|
+| **Planner** | Converts clinical question to PICO format, generates sub-queries |
+| **Searcher** | Queries PubMed, PMC, ClinicalTrials.gov |
+| **Extractor** | Extracts structured data: population, intervention, outcomes |
+| **Synthesizer** | Grades evidence, identifies consensus and contradictions |
+| **Reporter** | Generates formatted review with citations |
+
+## Usage
+
+```python
+from med_researcher import MedResearcher
+
+researcher = MedResearcher(
+    llm_provider="anthropic",
+    search_backends=["pubmed", "pmc", "clinical_trials"],
+)
+
+# Clinical question
+result = researcher.review(
+    question="What is the comparative efficacy of SGLT2 inhibitors "
+             "versus GLP-1 receptor agonists for cardiovascular "
+             "outcomes in type 2 diabetes?",
+    max_papers=50,
+    evidence_grading=True,
+)
+
+print(result.summary)
+print(f"Papers analyzed: {len(result.papers)}")
+print(f"Evidence grade: {result.overall_grade}")
+```
+
+## PICO Framework Integration
+
+```python
+# Automatic PICO extraction from clinical question
+pico = researcher.extract_pico(
+    "Does metformin reduce cancer incidence in diabetic patients?"
+)
+# P: patients with diabetes
+# I: metformin treatment
+# C: no metformin / other antidiabetics
+# O: cancer incidence
+
+# Search with PICO components
+result = researcher.review_pico(
+    population="type 2 diabetes patients",
+    intervention="metformin",
+    comparison="placebo or other antidiabetics",
+    outcome="cancer incidence",
+)
+```
+
+## Evidence Grading
+
+```python
+# Evidence levels following GRADE methodology
+for paper in result.papers:
+    print(f"{paper.title}")
+    print(f"  Study type: {paper.study_type}")  # RCT, cohort, case-control
+    print(f"  Evidence level: {paper.evidence_level}")  # High/Moderate/Low/Very Low
+    print(f"  Risk of bias: {paper.bias_risk}")
+    print(f"  Sample size: {paper.sample_size}")
+
+# Aggregate evidence summary
+print(f"\nOverall certainty: {result.certainty}")
+print(f"Recommendation strength: {result.recommendation}")
+```
+
+## Search Configuration
+
+```python
+researcher = MedResearcher(
+    search_config={
+        "pubmed": {
+            "max_results": 100,
+            "date_range": ("2020-01-01", "2025-12-31"),
+            "article_types": ["Clinical Trial", "Meta-Analysis",
+                              "Randomized Controlled Trial"],
+        },
+        "clinical_trials": {
+            "status": ["Completed", "Active"],
+            "phase": ["Phase 3", "Phase 4"],
+        },
+    },
+    extraction_config={
+        "fields": ["population", "intervention", "comparator",
+                   "primary_outcome", "secondary_outcomes",
+                   "adverse_events", "sample_size", "follow_up"],
+    },
+)
+```
+
+## Output Formats
+
+```python
+# Structured evidence table
+result.export_evidence_table("evidence_table.csv")
+
+# PRISMA flow diagram data
+prisma = result.prisma_flow()
+print(f"Identified: {prisma['identified']}")
+print(f"Screened: {prisma['screened']}")
+print(f"Included: {prisma['included']}")
+
+# Bibliography
+result.export_bibtex("references.bib")
+
+# Full report
+result.export_report("review.md", format="markdown")
+```
+
+## Clinical Use Cases
+
+1. **Drug comparison reviews**: Head-to-head efficacy analysis
+2. **Safety signal detection**: Adverse event pattern identification
+3. **Guideline evidence**: Supporting clinical guideline development
+4. **Grant proposals**: Rapid evidence landscape assessment
+5. **Journal clubs**: Structured paper discussion preparation
+
+## References
+
+- [Med-Researcher GitHub](https://github.com/mao1207/Med-Researcher)
+- [GRADE Handbook](https://gdt.gradepro.org/app/handbook/handbook.html)
+- [PubMed API (E-utilities)](https://www.ncbi.nlm.nih.gov/books/NBK25501/)

package/skills/domains/biomedical/med-researcher-r1-guide/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: med-researcher-r1-guide
+description: "Medical deep research agent with reasoning chain analysis"
+metadata:
+  openclaw:
+    emoji: "🩺"
+    category: "domains"
+    subcategory: "biomedical"
+    keywords: ["medical research", "deep research", "clinical reasoning", "PubMed", "medical agent", "evidence-based"]
+    source: "https://github.com/AQ-MedAI/MedResearcher-R1"
+---
+
+# MedResearcher-R1 Guide
+
+## Overview
+
+MedResearcher-R1 is a medical deep research agent that combines clinical reasoning chains with iterative literature search to answer complex medical questions. Unlike general research agents, it is specialized for medical evidence — understanding clinical trial designs, PICO frameworks, evidence hierarchies, and medical terminology. Uses reasoning chain analysis (R1) to decompose clinical questions and systematically gather evidence.
+
+## Architecture
+
+```
+Clinical Question
+      ↓
+  R1 Reasoning Chain (decompose into sub-questions)
+      ↓
+  Medical Search Agent
+  ├── PubMed (MeSH terms)
+  ├── ClinicalTrials.gov
+  ├── Cochrane Library
+  └── WHO ICTRP
+      ↓
+  Evidence Extraction Agent
+  ├── PICO extraction
+  ├── Study design classification
+  ├── Outcome extraction
+  └── Risk of bias assessment
+      ↓
+  Synthesis Agent (evidence grading)
+      ↓
+  Clinical Answer + Evidence Report
+```
+
+## Usage
+
+```python
+from med_researcher_r1 import MedResearcherR1
+
+researcher = MedResearcherR1(
+    llm_provider="anthropic",
+    search_backends=["pubmed", "clinical_trials", "cochrane"],
+)
+
+# Complex clinical question
+result = researcher.research(
+    question="In patients with treatment-resistant depression, "
+             "how does psilocybin-assisted therapy compare to "
+             "esketamine in terms of remission rates and "
+             "long-term outcomes?",
+    evidence_level="systematic",  # systematic, rapid, scoping
+    max_papers=50,
+)
+
+print(result.summary)
+print(f"\nEvidence quality: {result.evidence_grade}")
+print(f"Papers analyzed: {len(result.papers)}")
+```
+
+## Reasoning Chain
+
+```python
+# Inspect the R1 reasoning chain
+for step in result.reasoning_chain:
+    print(f"\nStep {step.number}: {step.type}")
+    print(f"  Question: {step.question}")
+    print(f"  Strategy: {step.search_strategy}")
+    print(f"  Findings: {step.key_finding}")
+    print(f"  Next: {step.next_action}")
+
+# Example chain:
+# Step 1: DECOMPOSE — Split into psilocybin efficacy,
+#          esketamine efficacy, head-to-head comparisons
+# Step 2: SEARCH — PubMed: psilocybin depression RCT
+# Step 3: EXTRACT — 3 RCTs found, extract PICO + outcomes
+# Step 4: SEARCH — PubMed: esketamine depression outcomes
+# Step 5: SYNTHESIZE — Compare evidence, note no direct
+#          head-to-head trials exist
+# Step 6: CONCLUDE — Indirect comparison with caveats
+```
+
+## Evidence Grading
+
+```python
+# GRADE methodology for evidence quality
+for paper in result.papers[:5]:
+    print(f"\n{paper.title} ({paper.year})")
+    print(f"  Design: {paper.study_design}")
+    print(f"  Sample: {paper.sample_size}")
+    print(f"  Grade: {paper.evidence_grade}")
+    print(f"  Risk of bias: {paper.risk_of_bias}")
+
+# Aggregate evidence
+print(f"\nOverall certainty: {result.certainty}")
+# HIGH / MODERATE / LOW / VERY LOW
+print(f"Recommendation: {result.recommendation}")
+```
+
+## Medical Search Configuration
+
+```python
+researcher = MedResearcherR1(
+    search_config={
+        "pubmed": {
+            "use_mesh": True,
+            "date_range": "2019/01/01:2025/12/31",
+            "article_types": [
+                "Randomized Controlled Trial",
+                "Meta-Analysis",
+                "Systematic Review",
+            ],
+        },
+        "clinical_trials": {
+            "status": ["Completed", "Active, not recruiting"],
+            "phase": ["Phase 3", "Phase 4"],
+        },
+    },
+    reasoning_config={
+        "max_chain_length": 10,
+        "reflection_enabled": True,
+        "uncertainty_explicit": True,
+    },
+)
+```
+
+## Clinical Use Cases
+
+1. **Clinical queries**: Evidence-based answers to medical questions
+2. **Drug comparison**: Indirect comparison when no head-to-head data
+3. **Guideline review**: Check evidence supporting clinical guidelines
+4. **Case analysis**: Literature context for unusual presentations
+5. **Grant proposals**: Evidence landscape for research funding
+
+## References
+
+- [MedResearcher-R1 GitHub](https://github.com/AQ-MedAI/MedResearcher-R1)
+- [PubMed E-utilities](https://www.ncbi.nlm.nih.gov/books/NBK25501/)
+- [GRADE Handbook](https://gdt.gradepro.org/app/handbook/handbook.html)

package/skills/domains/biomedical/ncbi-blast-api/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: ncbi-blast-api
+description: "Run sequence similarity searches via the NCBI BLAST REST API"
+metadata:
+  openclaw:
+    emoji: "🧪"
+    category: "domains"
+    subcategory: "biomedical"
+    keywords: ["BLAST", "sequence alignment", "NCBI", "homology search", "protein similarity", "nucleotide search"]
+    source: "https://blast.ncbi.nlm.nih.gov/"
+---
+
+# NCBI BLAST REST API
+
+## Overview
+
+BLAST (Basic Local Alignment Search Tool) is the most widely used bioinformatics tool, comparing nucleotide or protein sequences against databases to find regions of similarity. The NCBI BLAST REST API enables programmatic submission of searches, status polling, and result retrieval. Free, no authentication required (but rate-limited).
+
+## API Workflow
+
+BLAST searches are asynchronous: submit → poll → retrieve.
+
+### Step 1: Submit Search
+
+```bash
+# Nucleotide BLAST (blastn)
+curl -X POST "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi" \
+  -d "CMD=Put&PROGRAM=blastn&DATABASE=nt&QUERY=ATGCGATCGATCG..."
+
+# Protein BLAST (blastp)
+curl -X POST "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi" \
+  -d "CMD=Put&PROGRAM=blastp&DATABASE=nr&QUERY=MKTLLLTLVVVTIVCL..."
+
+# BLAST with specific parameters
+curl -X POST "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi" \
+  -d "CMD=Put&PROGRAM=blastn&DATABASE=nt&QUERY=SEQUENCE&\
+EXPECT=0.001&WORD_SIZE=11&HITLIST_SIZE=50"
+```
+
+### Step 2: Check Status
+
+```bash
+# Poll for completion (returns XML with Status field)
+curl "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi?CMD=Get&FORMAT_OBJECT=SearchInfo&RID=YOUR_RID"
+```
+
+### Step 3: Retrieve Results
+
+```bash
+# Get results in XML
+curl "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi?CMD=Get&FORMAT_TYPE=XML&RID=YOUR_RID"
+
+# Get results in JSON
+curl "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi?CMD=Get&FORMAT_TYPE=JSON2_S&RID=YOUR_RID"
+
+# Get results in tabular format
+curl "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi?CMD=Get&FORMAT_TYPE=Tabular&RID=YOUR_RID"
+```
+
+### BLAST Programs
+
+| Program | Query → Database | Use case |
+|---------|-----------------|----------|
+| `blastn` | Nucleotide → Nucleotide | DNA/RNA similarity |
+| `blastp` | Protein → Protein | Protein homology |
+| `blastx` | Translated nuc → Protein | Find protein homologs of DNA |
+| `tblastn` | Protein → Translated nuc | Find DNA encoding similar protein |
+| `tblastx` | Translated nuc → Translated nuc | Compare at protein level |
+
+### Common Databases
+
+| Database | Content |
+|----------|---------|
+| `nt` | All GenBank nucleotide sequences |
+| `nr` | Non-redundant protein sequences |
+| `refseq_rna` | RefSeq RNA sequences |
+| `refseq_protein` | RefSeq protein sequences |
+| `swissprot` | UniProtKB/Swiss-Prot (curated) |
+| `pdb` | Protein Data Bank sequences |
+
+### Key Parameters
+
+| Parameter | Description | Default |
+|-----------|-------------|---------|
+| `PROGRAM` | BLAST program | Required |
+| `DATABASE` | Target database | Required |
+| `QUERY` | Sequence or accession | Required |
+| `EXPECT` | E-value threshold | `10` |
+| `WORD_SIZE` | Word size | `11` (blastn), `6` (blastp) |
+| `HITLIST_SIZE` | Max results | `100` |
+| `MATRIX` | Scoring matrix (protein) | `BLOSUM62` |
+| `FILTER` | Low complexity filter | `L` |
+| `ENTREZ_QUERY` | Restrict to organism | `Homo sapiens[ORGN]` |
+
+## Python Usage
+
+```python
+import time
+import requests
+from xml.etree import ElementTree
+
+BLAST_URL = "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi"
+
+
+def submit_blast(sequence: str, program: str = "blastn",
+                 database: str = "nt",
+                 evalue: float = 0.001) -> str:
+    """Submit a BLAST search, return Request ID."""
+    resp = requests.post(BLAST_URL, data={
+        "CMD": "Put",
+        "PROGRAM": program,
+        "DATABASE": database,
+        "QUERY": sequence,
+        "EXPECT": evalue,
+        "HITLIST_SIZE": 50,
+    })
+    resp.raise_for_status()
+
+    for line in resp.text.split("\n"):
+        if "RID = " in line:
+            return line.split("=")[1].strip()
+    raise ValueError("No RID in response")
+
+
+def wait_for_results(rid: str, poll_interval: int = 15,
+                     max_wait: int = 300) -> bool:
+    """Poll until BLAST search completes."""
+    elapsed = 0
+    while elapsed < max_wait:
+        resp = requests.get(BLAST_URL, params={
+            "CMD": "Get",
+            "FORMAT_OBJECT": "SearchInfo",
+            "RID": rid,
+        })
+        if "Status=READY" in resp.text:
+            return True
+        if "Status=FAILED" in resp.text:
+            raise RuntimeError("BLAST search failed")
+        time.sleep(poll_interval)
+        elapsed += poll_interval
+    raise TimeoutError(f"BLAST timed out after {max_wait}s")
+
+
+def get_results(rid: str) -> list:
+    """Retrieve BLAST results as parsed hits."""
+    resp = requests.get(BLAST_URL, params={
+        "CMD": "Get",
+        "FORMAT_TYPE": "XML",
+        "RID": rid,
+    })
+    resp.raise_for_status()
+
+    root = ElementTree.fromstring(resp.text)
+    ns = ""
+    hits = []
+    for hit in root.iter(f"{ns}Hit"):
+        hsps = hit.find(f"{ns}Hit_hsps")
+        hsp = hsps.find(f"{ns}Hsp") if hsps is not None else None
+        hits.append({
+            "accession": hit.findtext(f"{ns}Hit_accession", ""),
+            "description": hit.findtext(f"{ns}Hit_def", ""),
+            "length": int(hit.findtext(f"{ns}Hit_len", "0")),
+            "evalue": float(hsp.findtext(f"{ns}Hsp_evalue", "999"))
+                     if hsp is not None else 999,
+            "identity": float(hsp.findtext(f"{ns}Hsp_identity", "0"))
+                       if hsp is not None else 0,
+            "score": float(hsp.findtext(f"{ns}Hsp_bit-score", "0"))
+                    if hsp is not None else 0,
+        })
+    return hits
+
+
+# Example: BLAST a short DNA sequence
+rid = submit_blast("ATGCGATCGATCGATCGATCGATCG", program="blastn")
+print(f"Submitted BLAST search: {rid}")
+
+wait_for_results(rid)
+hits = get_results(rid)
+for h in hits[:5]:
+    print(f"{h['accession']}: {h['description'][:60]}...")
+    print(f"  E-value: {h['evalue']:.2e} | Identity: {h['identity']}")
+```
+
+## Rate Limits
+
+- Max 1 request per 10 seconds for search submission
+- Max concurrent searches: varies by load
+- NCBI requests a contact email in User-Agent header
+
+## References
+
+- [NCBI BLAST](https://blast.ncbi.nlm.nih.gov/)
+- [BLAST URL API Guide](https://blast.ncbi.nlm.nih.gov/doc/blast-help/developerinfo.html)
+- [BLAST Command Line](https://www.ncbi.nlm.nih.gov/books/NBK279690/)
+- Altschul, S.F. et al. (1990). "Basic local alignment search tool." *J. Mol. Biol.* 215(3).