convez.ai
MCP ServerAutomaçãoAvançado
user7401

GenomeOps

user7401/GenomeOps

Executa pipelines nf-core via IA com aprovação humana em cada etapa

Ver no GitHub
InicialPluginScore · de 0 a 100

MCP server que integra pipelines de bioinformática nf-core/Nextflow com agentes de IA, permitindo descoberta, configuração e execução de análises genômicas com controle humano em cada etapa. Converte o ecossistema nf-core em ferramentas estruturadas consumíveis por Claude e outros agentes, eliminando alucinações sobre conhecimento específico de bioinformática.

Instalação

$npx convez-ai user7401/GenomeOps

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
2

Casos de uso

  • Descoberta automática de pipelines nf-core adequados para análises genômicas
  • Geração e validação de samplesheets sem conhecimento prévio de bioinformática
  • Execução de análises Nextflow com interface amigável via agentes de IA
  • Automação de workflows bioinformáticos complexos com segurança

Veredito

Ferramenta especializada e bem-arquitetada para democratizar pipelines nf-core via IA, com modelo HITL robusto que mantém controle humano sobre execução real. Ainda em desenvolvimento pré-release, mas resolve um nicho crítico: análises genômicas reproducíveis sem expertise técnica prévia.

README

A tradução para o português deste README ainda está na fila.

GenomeOps

⚠️ Status: developmental / pre-release. This project is under active development. Tool names, schemas, and behavior may change without notice. Execution tools run real subprocesses (Nextflow, container engines) and can consume real compute — review every gated output carefully before approving anything, and expect rough edges.

Unofficial, community-built project. Not affiliated with, endorsed by, or maintained by the nf-core community or Seqera/Nextflow.

GenomeOps is an MCP (Model Context Protocol) server that exposes the nf-core / Nextflow bioinformatics pipeline ecosystem as structured, agent-consumable tools. Any AI agent — Claude, GPT, Cursor — can go from "I have these files and this goal" all the way through pipeline discovery, samplesheet generation, parameter configuration, and launching and monitoring an actual analysis run, without hallucinating nf-core-specific knowledge.

The server is built around a human-in-the-loop (HITL) model: every step that involves a judgment call, a cost, or an irreversible action returns a structured "review required" signal so a human stays in control of what actually runs.

Quickstart

# Run directly with uvx (no install required)
uvx genomeops-mcp

# Or install with uv
uv pip install genomeops-mcp
genomeops-mcp

Add to Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "genomeops": {
      "command": "uvx",
      "args": ["genomeops-mcp"]
    }
  }
}

Add to Claude Code (CLI)

claude mcp add genomeops -- uvx genomeops-mcp

Or add to .claude/mcp.json in your project:

{
  "mcpServers": {
    "genomeops": {
      "command": "uvx",
      "args": ["genomeops-mcp"]
    }
  }
}

Enable AI parameter suggestions

export ANTHROPIC_API_KEY=sk-ant-...
uvx genomeops-mcp

Tool Reference

Discovery & matching

ToolInputsOutputs
check_feasibilitygoal: str, file_paths: list[str]Reads actual file content (magic bytes, gzip, first lines) via an LLM to identify formats — even with scrambled filenames — and matches them + the stated goal against candidate pipelines, surfacing gaps
list_pipelinestopic?: strList of pipelines with name, description, version
get_pipeline_infopipeline_name: str, version?: strFull metadata, profiles, schema URLs
get_latest_versionpipeline_name: strLatest stable release tag; flags dev/pre-releases (is_dev) so agents stop and ask before using one

Samplesheet

ToolInputsOutputs
get_samplesheet_schemapipeline_name: str, version?: strColumn definitions, types, allowed values
generate_samplesheetpipeline_name: str, file_paths: list[str]CSV string + review warnings
validate_samplesheetpipeline_name: str, samplesheet_content: strvalid: bool, plain-English errors with row numbers

Parameters

ToolInputsOutputs
analyze_pipeline_schemapipeline_name: str, version: strMaps the pipeline's full decision tree — every branch point and parameter classified by an LLM into tiers (provided_input → expert_required), with extracted expert guidance and conditional dependencies. Cached 24h per version.
configure_parameterspipeline_name, version, data_summary?, experiment_description?, user_choices?, mode?Resolves non-obvious parameters: auto-derives what it can, lets the user set any subset themselves via user_choices, and (in mode="expert") uses an LLM to propose context-dependent values — while always escalating expert_required parameters back to the human rather than guessing
get_parameterspipeline_name: str, version?: str, group?: strGrouped parameter definitions
suggest_parameterspipeline_name: str, experiment_description: strAI-suggested params + justifications

Launch & execution

ToolInputsOutputs
generate_launch_commandpipeline_name, version, profile, samplesheet_path, outdir, params?Validated nextflow run command string
check_execution_environmentprofile?: strProbes for Nextflow, Java, and container/conda engines (Docker, Singularity, Apptainer, Podman, Conda, Mamba), checks the Docker daemon, recommends a viable -profile, and reports what's missing with install hints
setup_environmentpipeline_name, version, profileRuns nextflow pull + nextflow config to cache the pipeline and resolve its configuration as a dry run, before any compute is spent
estimate_resourcespipeline_name, version, samplesheet_path?, file_paths?, data_summary?, profile?Sizes the job against this machine before launch: derives the workload (sample count + input size) and, with the pipeline's resource profile, proposes CPU/memory/disk/walltime, returns a verdict (sufficient/marginal/insufficient), and suggests --max_* overrides. LLM-refined when ANTHROPIC_API_KEY is set; otherwise heuristic + raw signals returned for the host agent to reason over
run_pipelinepipeline_name, version, profile, samplesheet_path, outdir, params?, run_name?, confirm: boolGated. With confirm=false (default) it only previews the validated command and changes nothing. It launches a detached background nextflow run only when called with confirm=true — which must follow explicit human approval of the preview. Parameters are written to a -params-file (more robust than inline flags), and a full provenance manifest is recorded
get_run_statusrun_name: strPolls a launched run: process liveness, log tail, and a parsed status (running / completed / failed / unknown) with suggested next steps
list_runs—Lists every run launched through the server (newest first), refreshing liveness and resolving terminal status from the log
stop_pipelinerun_name, confirm: boolGated like run_pipeline: previews unless confirm=true, then sends SIGTERM to the detached process group. The run can be continued later with resume=true

Diagnostics & provenance

ToolInputsOutputs
diagnose_run_failurerun_name: strFor a failed run, locates the failed process and its work dir, reads .command.err/.command.sh/.exitcode, classifies the root cause (out of memory, time limit, disk, container/engine, missing input, tool error) and proposes concrete fixes. LLM-refined when ANTHROPIC_API_KEY is set, heuristic otherwise
diagnose_resumerun_name: strPredicts whether -resume will actually reuse cached work: checks the .nextflow cache and work/ dir exist and whether any recorded input file changed (path/mtime/size) since launch — the common silent causes of a full re-run
generate_methods_noterun_name: strDrafts a citable Methods paragraph from the recorded provenance (pipeline, pinned version, profile, exact non-default parameters, tool versions) with canonical nf-core + Nextflow citations and a pipeline Zenodo DOI pointer. Deterministic and auditable

Results

ToolInputsOutputs
inventory_resultsresults_dir: strWalks the output tree and classifies every file by format and semantic role (alignment, variants, gene_counts, qc_report, provenance, …) into a structured manifest grouped as primary_outputs, qc, provenance, indices, and unclassified. LLM-refined with one-sentence downstream hints when ANTHROPIC_API_KEY is set; heuristic otherwise
parse_run_summaryresults_dir: strPer-sample QC (from MultiQC), flagged samples with reasons, and overall run status

Typical Agent Workflow

check_feasibility(goal, file_paths)              # match files+goal → candidate pipeline(s)
  → get_pipeline_info("rnaseq")
  → get_latest_version("rnaseq")                  # pin to a stable tag, never "master"
  → analyze_pipeline_schema("rnaseq", "3.14.0")   # map every decision point & parameter
  → get_samplesheet_schema("rnaseq")
  → generate_samplesheet("rnaseq", ["/data/sample_R1.fastq.gz", ...])
  → validate_samplesheet("rnaseq", <csv>)         # fix any errors
  → configure_parameters(...)                     # resolve params; ask human for expert_required
  → generate_launch_command("rnaseq", ...)        # human reviews the command
  → check_execution_environment()                 # confirm Nextflow + a container engine
  → setup_environment("rnaseq", "3.14.0", "docker")
  → estimate_resources("rnaseq", "3.14.0", ...)   # will this machine cope? size CPU/mem/disk/time
  → run_pipeline(..., confirm=False)              # preview command + params
  → run_pipeline(..., confirm=True)               # human has approved — launch for real
  → get_run_status("myrun")                       # poll until completed/failed
  → diagnose_run_failure("myrun")                 # IF failed: root cause + fixes
  → diagnose_resume("myrun")                       # before re-running with resume=true
  → inventory_results("./results")                # what files were produced + downstream hints
  → parse_run_summary("./results")                # QC once completed
  → generate_methods_note("myrun")                # citable Methods paragraph

Human-in-the-Loop (HITL)

Tools that generate executable content, propose AI-derived values, or gate compute always signal that a human should be in the loop — via review_required: true, requires_confirmation: true, or an explicit confirm parameter:

  • check_feasibility — pipeline match is a recommendation, not a decision
  • get_latest_version — if the latest release is a dev/pre-release, the agent must stop and ask before using it
  • analyze_pipeline_schema — surfaces decision points (e.g. aligner choice) for the human to choose, or to delegate to expert mode
  • generate_samplesheet — strandedness and similar fields cannot be inferred reliably
  • configure_parameters — expert_required parameters are never silently set; they're always returned for a human decision
  • suggest_parameters — AI suggestions need domain expert review
  • generate_launch_command — pipelines consume real compute resources
  • estimate_resources — a planning estimate, never a guarantee; an insufficient/marginal verdict should be raised with the user before launching
  • run_pipeline — hard-gated behind confirm=true; with confirm=false it only previews and launches nothing
  • stop_pipeline — hard-gated behind confirm=true; previews what would be terminated otherwise
  • diagnose_run_failure / diagnose_resume / generate_methods_note — return findings for human review, not automatic action

These are not blocking terminal prompts — they're structured signals in the JSON response. The calling agent is expected to surface them to the human, wait for a reply, and only then proceed.

Development

git clone https://github.com/user7401/nfcore-for-agents
cd nfcore-for-agents
uv sync --extra dev
uv run pytest -v

License

MIT

Ver o original no GitHub

Bom para

Relacionados