Add files using upload-large-folder tool

.env.example

@@ -0,0 +1,22 @@
+# Biomni Environment Configuration
+# Copy this file to .env and fill in your actual API keys
+
+# Required: Anthropic API Key for Claude models
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional: OpenAI API Key (if using OpenAI models)
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Optional: AWS Bedrock Configuration (if using AWS Bedrock models)
+AWS_BEARER_TOKEN_BEDROCK=your_bedrock_api_key_here
+AWS_REGION=us-east-1
+
+# Optional: Custom model serving configuration
+# CUSTOM_MODEL_BASE_URL=http://localhost:8000/v1
+# CUSTOM_MODEL_API_KEY=your_custom_api_key_here
+
+# Optional: Biomni data path (defaults to ./data)
+# BIOMNI_DATA_PATH=/path/to/your/data
+
+# Optional: Timeout settings
+# BIOMNI_TIMEOUT_SECONDS=600

.gitignore

@@ -0,0 +1,234 @@
+.gitignore
+.buildplan
+.env
+debug*
+.*
+# Byte-compiled / optimized / DLL files
+biomni_release/biomni_env/biomni_tools/
+open_source_process.ipynb
+biomni_env/biomni_tools/*
+.gradio/
+*xlsx
+scripts/*.png
+notebooks/figures/*
+notebooks/tmp_dir/*
+notebooks/tmp_directory/*
+notebooks/save_folder/*
+notebooks/cache
+notebooks/\[draft*
+notebooks/\[scratch*
+notebooks/labbench/*
+scripts/save_folder/*
+scripts/\[draft*
+scripts/tmp_dir/*
+scripts/tmp_directory/*
+scripts/figures/*
+*/scripts/outputs/*
+*/scripts/wandb/*
+*/results/*
+bioagentos/agent/popper_agent.py
+bioagentos/scripts/biorxiv_results
+bioagentos/tool/data_tool/old_data_tool/*
+examples/*.png
+examples/*.csv
+examples/*.fa
+scratch/
+packages/
+data
+dataset
+logs
+scripts/gradio
+data_lake
+__pycache__/
+*.py[cod]
+*$py.class
+res/
+examples/tmp*
+bioagentos/task/lab_bench.py
+*database/
+.history/
+
+temp.*
+
+scripts/analysis/all_tools.txt
+
+BIOMNI_GRADIO/biomni/tool/files/*
+
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+test.ipynb
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.envrc
+uv.lock
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+*.jsonl
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# macOS system files
+.DS_Store
+**/.DS_Store
+
+# DDInter data files
+biomni/tool/schema_db/ddinter_*.pkl
+data/ddinter_raw/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# VSCode
+/.vscode
+
+# Sphinx build
+/docs/build/
+/docs/source/api/

.pre-commit-config.yaml

@@ -0,0 +1,41 @@
+fail_fast: false
+default_language_version:
+    python: python3
+default_stages:
+    - pre-commit
+    - pre-push
+minimum_pre_commit_version: 2.16.0
+repos:
+    - repo: https://github.com/biomejs/pre-commit
+      rev: v2.3.10
+      hooks:
+          - id: biome-format
+    - repo: https://github.com/astral-sh/ruff-pre-commit
+      rev: v0.14.11
+      hooks:
+          - id: ruff-check
+            args: [--fix, --exit-non-zero-on-fix, --unsafe-fixes]
+          - id: ruff-format
+    - repo: https://github.com/pre-commit/pre-commit-hooks
+      rev: v6.0.0
+      hooks:
+          - id: detect-private-key
+          - id: check-ast
+          - id: end-of-file-fixer
+          - id: mixed-line-ending
+            args: [--fix=lf]
+          - id: trailing-whitespace
+          - id: check-case-conflict
+          - id: check-added-large-files
+          - id: check-toml
+          - id: check-yaml
+          - id: check-merge-conflict
+          - id: no-commit-to-branch
+            args: ["--branch=main"]
+    #- repo: https://github.com/pre-commit/mirrors-mypy
+    # rev: v1.16.1
+    #  hooks:
+    #      - id: mypy
+    #        args: [--no-strict-optional, --ignore-missing-imports]
+    #        additional_dependencies:
+    #            ["types-setuptools", "types-requests", "types-attrs"]

CONTRIBUTION.md

@@ -0,0 +1,129 @@
+# Contributing to Biomni
+
+Thank you for your interest in contributing to Biomni! We're building the infrastructure layer for biomedical AI agents, and we welcome contributions from the community. Contributors with significant contributions will be invited to co-author publications in top-tier journals and conferences.
+
+## Getting Started
+
+Before contributing, please ensure you:
+- Have tested your changes locally
+- Follow the existing code style and conventions
+- Include appropriate documentation
+
+## Types of Contributions
+
+### 🛠️ Adding a New Tool
+
+Tools are implemented as Python functions in `biomni/tool/XXX.py`, organized by subject area.
+
+**Steps:**
+1. **Implement and test** your function locally. If it requires additional software, create installation script and append it into `biomni_env/new_software_{VERSION}.sh`
+
+2. **Choose the appropriate subject** category (e.g. database, biochemistry, etc.)
+
+3. **Create a tool description** in `biomni/tool/tool_description/XXX.py` following the existing format
+
+   *Tip: Use this helper to auto-generate descriptions:*
+   ```python
+   from biomni.utils import function_to_api_schema
+   from biomni.llm import get_llm
+
+   llm = get_llm('claude-sonnet-4-20250514')
+   desc = function_to_api_schema(function_code, llm)
+   ```
+4. **Create a test prompt** that uses your tool and verify the agent works correctly
+5. **Submit a pull request** for review, don't forget to include your test prompt as well
+
+### 📊 Adding New Data
+
+If the data source has web API, follow this process:
+
+**Steps:**
+1. **Verify uniqueness** - ensure no overlap with existing data
+2. **Add a new query_XX function** to `biomni/tool/database.py`, follow the format from the other functions.
+3. **Create a tool description** in `biomni/tool/tool_description/database.py` following the existing format
+
+If the data source has no API access, follow the process below:
+
+**Steps:**
+1. **Verify uniqueness** - ensure no overlap with existing data
+2. **Prepare download link** with verified redistribution rights
+3. **Add entry** to `data_lake_dict` in `biomni/env_desc.py`
+4. **Submit a pull request** with the download link
+
+Then, make a PR.
+
+### 💻 Adding New Software
+
+**Steps:**
+1. **Test locally** to ensure no conflicts with existing environments
+2. **Create installation script** and append it into `biomni_env/new_software_{VERSION}.sh`
+3. **Add entry** to `library_content_dict` in `biomni/env_desc.py`
+4. **Submit a pull request** including:
+   - Installation bash script
+   - Screenshot demonstrating no environment conflicts
+
+### 🎯 Adding a New Benchmark
+
+Create benchmarks in the `biomni/task/` folder.
+
+**Required implementation:**
+```python
+class YourBenchmark:
+    def __init__(self):
+        # Initialize benchmark
+        pass
+
+    def __len__(self):
+        # Return dataset size
+        pass
+
+    def get_example(self, index):
+        # Return dataset item at index
+        pass
+
+    def evaluate(self):
+        # Evaluation logic (flexible input format)
+        pass
+
+    def output_class(self):
+        # Return expected agent output format
+        pass
+```
+
+**Steps:**
+1. **Create benchmark file** in `biomni/task/[benchmark_name].py`
+2. **Implement required methods** as shown above
+3. **Provide data download link** for associated datasets
+4. **Submit a pull request**
+
+### 🐛 Bug Fixes & Enhancements
+
+We welcome all bug fixes and enhancements to the existing codebase!
+
+**Create an issue to discuss with the Biomni team first.**
+
+**Guidelines:**
+- Clearly describe the issue or enhancement
+- Include tests when applicable
+- Follow existing code patterns
+- Update documentation if needed
+
+## Submission Process
+
+1. **Fork** the repository
+2. **Create a feature branch** from `main`
+3. **Make your changes** following the guidelines above
+4. **Test thoroughly** in your local environment
+5. **Submit a pull request** with a clear description
+
+## Review Process
+
+The Biomni team will review all pull requests promptly. We may request changes or provide feedback to ensure code quality and consistency.
+
+## Questions?
+
+If you have questions about contributing, please open an issue or reach out to the maintainers.
+
+---
+
+*Together, let's build the future of biomedical AI agents!*

DETAILS.md

@@ -0,0 +1,364 @@
+# DETAILS.md
+
+🔍 **Powered by [Detailer](https://detailer.ginylil.com)** - Context-aware codebase analysis
+
+
+
+---
+
+## 1. Project Overview
+
+### Project Purpose & Domain
+
+This project is a comprehensive **biomedical AI toolkit and research platform** designed to facilitate **biomedical data analysis, knowledge extraction, and AI-driven reasoning**. It integrates large language models (LLMs), domain-specific bioinformatics tools, and scientific data processing pipelines to enable:
+
+- Automated extraction of biomedical knowledge from literature (e.g., bioRxiv papers)
+- Querying and integration of diverse biomedical databases and APIs
+- Execution of domain-specific computational biology and physiology analyses
+- AI agent orchestration for complex biomedical reasoning and tool invocation
+- Benchmarking and evaluation of biomedical tasks and datasets
+
+### Target Users and Use Cases
+
+- **Biomedical researchers and data scientists** seeking to automate literature mining, data retrieval, and analysis workflows.
+- **Bioinformaticians** requiring integrated access to multiple biological databases and computational tools.
+- **AI researchers** interested in applying LLMs and autonomous agents to biomedical problem solving.
+- **Developers and integrators** building domain-specific AI pipelines and scientific workflows.
+- Use cases include:
+  - Extracting structured biomedical tasks and entities from scientific papers
+  - Querying gene, protein, disease, and pathway databases via natural language prompts
+  - Running computational models of biological systems (e.g., metabolic networks, signaling)
+  - Performing image analysis and quantitative pathology workflows
+  - Orchestrating multi-step AI reasoning with tool use and self-criticism
+
+### Core Business Logic and Domain Models
+
+- **Biomedical domain models**: gene IDs, protein structures, pathways, disease ontologies, experimental assays.
+- **Task abstractions**: benchmark tasks with prompt/response evaluation (e.g., humanity last exam, lab bench).
+- **Tool metadata schemas**: declarative descriptions of biomedical tools and APIs for dynamic invocation.
+- **AI agent workflows**: ReAct-style reasoning graphs integrating LLMs, tool calls, retrieval, and self-critique.
+- **Data models**: structured JSON, pandas DataFrames, numpy arrays representing biological data and analysis results.
+
+---
+
+## 2. Architecture and Structure
+
+### High-Level Architecture
+
+The system is organized into modular layers and components:
+
+- **Core Library (`biomni/`)**: Contains main application logic, including:
+  - **Agent framework (`biomni/agent/`)**: Implements autonomous AI agents using LLMs and workflow graphs.
+  - **Task definitions (`biomni/task/`)**: Abstract base and concrete biomedical benchmark tasks.
+  - **Tool implementations (`biomni/tool/`)**: Domain-specific analysis functions, API clients, and computational biology workflows.
+  - **Tool metadata (`biomni/tool/tool_description/`)**: Declarative schemas describing tool APIs and parameters.
+  - **Model components (`biomni/model/`)**: AI-driven resource retriever for selecting relevant tools and data.
+  - **Utility modules (`biomni/utils.py`, `biomni/llm.py`, `biomni/env_desc.py`)**: Helpers for LLM instantiation, system commands, environment descriptions.
+  - **Versioning (`biomni/version.py`)**: Package version management.
+
+- **Environment Setup (`biomni_env/`)**: Scripts and configuration files for reproducible environment provisioning, including:
+  - Conda environment YAMLs (`environment.yml`, `bio_env.yml`)
+  - R package specifications (`r_packages.yml`)
+  - CLI tools installer (`install_cli_tools.sh`)
+  - Shell scripts for environment setup (`setup.sh`, `setup_path.sh`)
+
+- **Scripts (`biomni/biorxiv_scripts/`)**: Data processing pipelines for literature mining and task extraction.
+
+- **Documentation and Configuration**:
+  - Root-level files: `README.md`, `CONTRIBUTION.md`, `pyproject.toml`, `.pre-commit-config.yaml`.
+
+---
+
+### Complete Repository Structure
+
+```
+.
+├── biomni/ (90 items)
+│   ├── agent/
+│   │   ├── __init__.py
+│   │   ├── a1.py
+│   │   ├── env_collection.py
+│   │   ├── qa_llm.py
+│   │   └── react.py
+│   ├── biorxiv_scripts/
+│   │   ├── extract_biorxiv_tasks.py
+│   │   ├── generate_function.py
+│   │   └── process_all_subjects.py
+│   ├── model/
+│   │   ├── __init__.py
+│   │   └── retriever.py
+│   ├── task/
+│   │   ├── __init__.py
+│   │   ├── base_task.py
+│   │   ├── hle.py
+│   │   └── lab_bench.py
+│   ├── tool/ (65 items)
+│   │   ├── schema_db/ (25 items)
+│   │   │   ├── cbioportal.pkl
+│   │   │   ├── clinvar.pkl
+│   │   │   ├── dbsnp.pkl
+│   │   │   ├── emdb.pkl
+│   │   │   ├── ensembl.pkl
+│   │   │   ├── geo.pkl
+│   │   │   ├── gnomad.pkl
+│   │   │   ├── gtopdb.pkl
+│   │   │   ├── gwas_catalog.pkl
+│   │   │   ├── interpro.pkl
+│   │   │   └── ... (15 more files)
+│   │   ├── tool_description/ (18 items)
+│   │   │   ├── biochemistry.py
+│   │   │   ├── bioengineering.py
+│   │   │   ├── biophysics.py
+│   │   │   ├── cancer_biology.py
+│   │   │   ├── cell_biology.py
+│   │   │   ├── database.py
+│   │   │   ├── genetics.py
+│   │   │   ├── genomics.py
+│   │   │   ├── immunology.py
+│   │   │   ├── literature.py
+│   │   │   ├── microbiology.py
+│   │   │   ├── molecular_biology.py
+│   │   │   ├── pathology.py
+│   │   │   ├── pharmacology.py
+│   │   │   ├── physiology.py
+│   │   │   ├── support_tools.py
+│   │   │   ├── synthetic_biology.py
+│   │   │   └── systems_biology.py
+│   │   ├── __init__.py
+│   │   ├── biochemistry.py
+│   │   ├── bioengineering.py
+│   │   ├── biophysics.py
+│   │   ├── cancer_biology.py
+│   │   ├── cell_biology.py
+│   │   ├── database.py
+│   │   ├── genetics.py
+│   │   └── ... (12 more files)
+│   ├── __init__.py
+│   ├── env_desc.py
+│   ├── llm.py
+│   ├── utils.py
+│   └── version.py
+├── biomni_env/ (9 items)
+│   ├── README.md
+│   ├── bio_env.yml
+│   ├── cli_tools_config.json
+│   ├── environment.yml
+│   ├── install_cli_tools.sh
+│   ├── install_r_packages.R
+│   ├── r_packages.yml
+│   ├── setup.sh
+│   └── setup_path.sh
+├── figs/
+│   └── biomni_logo.png
+├── tutorials/
+│   ├── examples/
+│   │   └── cloning.ipynb
+│   ├── 101_biomni.ipynb
+│   └── biomni_101.ipynb
+├── .gitignore
+├── .pre-commit-config.yaml
+├── CONTRIBUTION.md
+├── LICENSE
+├── README.md
+└── pyproject.toml
+```
+
+---
+
+## 3. Technical Implementation Details
+
+### Core Modules and Their Roles
+
+#### `biomni/agent/`
+
+- Implements autonomous AI agents using the **ReAct paradigm**:
+  - `react.py`: Main ReAct agent class managing reasoning, tool invocation, retrieval, and self-criticism workflows.
+  - `env_collection.py`: Environment and data retrieval utilities.
+  - `qa_llm.py`: Question-answering LLM wrappers.
+  - `a1.py`: Possibly experimental or auxiliary agent code.
+
+- Uses **langgraph** for workflow graph orchestration and **langchain** for LLM integration.
+
+#### `biomni/task/`
+
+- Defines **benchmark tasks** with a common interface:
+  - `base_task.py`: Abstract base class specifying methods like `get_example()`, `evaluate()`, `output_class()`.
+  - `hle.py`: "Humanity Last Exam" task implementation.
+  - `lab_bench.py`: Lab bench dataset task.
+
+- Tasks load data (e.g., parquet files), generate prompts, and evaluate LLM responses.
+
+#### `biomni/tool/`
+
+- Contains **domain-specific scientific analysis functions** organized by subdomains:
+  - `biochemistry.py`, `bioengineering.py`, `biophysics.py`, `cancer_biology.py`, `cell_biology.py`, `genetics.py`, `pathology.py`, `physiology.py`, `systems_biology.py`, etc.
+  - Each file implements multiple functions performing analyses, simulations, or data processing workflows.
+  - Functions accept input files/parameters and return detailed textual logs and output files.
+
+- **API client modules** (e.g., `database.py`) provide facade functions to query external biomedical databases (UniProt, GWAS Catalog, Ensembl, etc.) via REST or GraphQL APIs, often using LLMs to generate query payloads from natural language prompts.
+
+- **Tool registry (`tool_registry.py`)** manages metadata about available tools, supporting dynamic registration and lookup.
+
+#### `biomni/tool/tool_description/`
+
+- Contains **declarative metadata schemas** describing tool APIs:
+  - Each file exports a `description` list of dictionaries defining tool names, descriptions, required and optional parameters with types and defaults.
+  - Supports **dynamic API generation, validation, and documentation**.
+  - Organized by biological domain (e.g., genetics, immunology, pathology).
+
+#### `biomni/model/retriever.py`
+
+- Implements `ToolRetriever` class for **AI-driven resource selection**:
+  - Uses LLMs (OpenAI or Anthropic) to parse user queries and select relevant tools, datasets, and libraries.
+  - Encapsulates prompt formatting and response parsing logic.
+
+#### `biomni/utils.py` and `biomni/llm.py`
+
+- `utils.py`: Utility functions for running system commands (R, Bash), file operations, schema generation, logging, and colorized printing.
+- `llm.py`: Factory functions to instantiate LLMs (OpenAI, Anthropic) with configurable parameters.
+
+#### `biomni/env_desc.py`
+
+- Contains **environment and dataset descriptions**, acting as a centralized metadata repository for datasets and experimental environments.
+
+---
+
+### Environment Setup (`biomni_env/`)
+
+- `setup.sh`: Main shell script to create conda environment, install R packages, and CLI bioinformatics tools.
+- `install_cli_tools.sh`: Automates downloading, compiling, and installing external bioinformatics command-line tools, managing PATH and verification.
+- `r_packages.yml`: Lists R packages required.
+- `environment.yml` and `bio_env.yml`: Conda environment specifications.
+- `setup_path.sh`: Shell script to update environment variables for CLI tools.
+
+---
+
+### Entry Points and Execution Flow
+
+- **Agent usage**: Instantiate `react` agent from `biomni.agent.react`, configure with tools and retrieval, then call `go(prompt)` to run reasoning workflows.
+- **Task evaluation**: Use classes in `biomni.task` to load datasets, generate prompts, and evaluate LLM outputs.
+- **Tool invocation**: Call functions in `biomni.tool` modules or use API facades in `database.py` to query external resources.
+- **Metadata-driven tool discovery**: Use `tool_registry.py` and `tool_description` schemas to dynamically discover and validate tools.
+- **Environment setup**: Run `biomni_env/setup.sh` to provision environment and install dependencies.
+
+---
+
+## 4. Development Patterns and Standards
+
+### Code Organization Principles
+
+- **Modular design**: Clear separation of concerns by domain and functionality (agent, task, tool, model).
+- **Functional programming style**: Most analysis modules use standalone functions with explicit inputs and outputs.
+- **Declarative metadata**: Tool descriptions and schemas are separated from implementation, enabling dynamic validation and UI generation.
+- **Abstract base classes**: Used in `biomni.task.base_task` to enforce consistent task interfaces.
+- **Factory pattern**: Used in `llm.py` to instantiate LLMs based on configuration.
+- **Strategy pattern**: Task implementations and tool retrieval use interchangeable strategies.
+
+### Testing and Coverage
+
+- No explicit test files detected; testing likely manual or via notebooks (`tutorials/`).
+- Tasks and tools return detailed logs suitable for manual verification.
+- Metadata schemas facilitate automated validation of inputs.
+
+### Error Handling and Logging
+
+- Use of try-except blocks around external calls and subprocesses.
+- Logging via custom callback handlers (`PromptLogger`, `NodeLogger`) in LLM interactions.
+- Utilities provide colorized printing and error wrappers for robustness.
+
+### Configuration Management
+
+- Environment variables for API keys (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`).
+- YAML and JSON files for environment and tool configuration.
+- Dynamic loading of schemas from pickle files for API request generation.
+- CLI tools and R packages installed via scripted environment setup.
+
+---
+
+## 5. Integration and Dependencies
+
+### External Libraries
+
+- **LLM & AI Frameworks**: `langchain_core`, `langchain_openai`, `langchain_anthropic`
+- **Scientific Computing**: `numpy`, `pandas`, `scipy`, `scikit-image`, `matplotlib`, `BioPython`, `cobra`, `sklearn`
+- **Data Processing**: `pickle`, `json`, `requests`, `PyPDF2`
+- **System and OS**: `subprocess`, `os`, `sys`, `tempfile`, `multiprocessing`
+- **Others**: `tqdm` (progress bars), `enum`, `ast` (code introspection)
+
+### External APIs and Data Sources
+
+- Biomedical databases: UniProt, GWAS Catalog, Ensembl, ClinVar, dbSNP, EMDB, GEO, GnomAD, InterPro, etc.
+- Bioinformatics tools: PLINK, IQ-TREE, GCTA, MACS2, samtools, LUMPY, installed via CLI tools installer.
+- R packages for statistical and bioinformatics analyses.
+
+### Build and Deployment Dependencies
+
+- Python 3 environment managed via Conda (`environment.yml`).
+- R environment with specified packages (`r_packages.yml`).
+- Shell scripts for CLI tool installation and environment setup.
+- Pre-commit hooks for code quality and security.
+
+---
+
+## 6. Usage and Operational Guidance
+
+### Getting Started
+
+1. **Environment Setup**
+   - Run `biomni_env/setup.sh` to create the Conda environment, install R packages, and CLI tools.
+   - Source `biomni_env/setup_path.sh` or add it to your shell profile to configure PATH.
+
+2. **API Keys**
+   - Set environment variables `OPENAI_API_KEY` and/or `ANTHROPIC_API_KEY` for LLM access.
+
+3. **Running Agents**
+   - Import and instantiate the `react` agent from `biomni.agent.react`.
+   - Configure with desired tools and retrieval options.
+   - Call `go(prompt)` to execute reasoning workflows.
+
+4. **Executing Tasks**
+   - Use classes in `biomni.task` to load datasets and evaluate LLM responses.
+   - Implement new tasks by subclassing `base_task` and following the interface.
+
+5. **Querying Databases**
+   - Use `biomni.tool.database` functions (e.g., `query_uniprot`, `query_gwas_catalog`) to retrieve data via natural language or direct parameters.
+
+6. **Extending Tools**
+   - Add new tool metadata in `biomni/tool/tool_description/` as structured dictionaries.
+   - Implement corresponding analysis functions in `biomni/tool/`.
+   - Register tools in `tool_registry.py` for discovery.
+
+### Monitoring and Debugging
+
+- Use logging callbacks (`PromptLogger`, `NodeLogger`) to trace LLM interactions.
+- Check output logs returned by analysis functions for detailed execution info.
+- Use pre-commit hooks to maintain code quality.
+
+### Performance and Scalability
+
+- Modular design allows parallel execution of tasks and tools.
+- Timeout wrappers in agent tools prevent hanging executions.
+- Use of efficient numerical libraries (`numpy`, `scipy`) for computational tasks.
+- Large data handled via streaming and chunking (e.g., PDF text extraction).
+
+### Security Considerations
+
+- API keys managed via environment variables, not hardcoded.
+- Pre-commit hooks include security checks.
+- External tool installations verified via version commands.
+
+### Observability
+
+- Progress bars (`tqdm`) used in data processing scripts.
+- Structured logs and JSON outputs facilitate downstream analysis.
+- Agent workflows produce detailed message histories for audit.
+
+---
+
+## Summary
+
+This project is a **modular, extensible biomedical AI platform** integrating **LLM-powered agents**, **domain-specific scientific tools**, and **metadata-driven APIs** to automate complex biomedical research workflows. It emphasizes **declarative tool descriptions**, **dynamic resource retrieval**, and **robust environment provisioning** to enable researchers and developers to build, evaluate, and extend AI-driven biomedical applications efficiently.
+
+---
+
+# End of DETAILS.md

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.in

@@ -0,0 +1,27 @@
+# MANIFEST.in
+
+# Include all python files from the biomni package
+recursive-include biomni *.py
+
+# Include the .pkl database files
+recursive-include biomni/tool/schema_db *.pkl
+
+# Include specific files from biomni_env, but not the biomni_tools subdirectory
+recursive-include biomni_env *.py *.sh *.yml *.yaml *.txt *.md *.json *.R
+
+# Exclude specific directories that are not part of the package
+prune tutorials/data
+prune biomni_env/biomni_tools
+
+# Exclude build artifacts and caches
+global-exclude *.py[co]
+global-exclude __pycache__
+global-exclude .ruff_cache
+prune build
+prune dist
+prune *.egg-info
+
+# Include other necessary files
+include README.md
+include LICENSE
+include pyproject.toml

README.md

@@ -0,0 +1,420 @@
+<p align="center">
+  <img src="./figs/biomni_logo.png" alt="Biomni Logo" width="600px" />
+</p>
+
+<p align="center">
+<a href="https://join.slack.com/t/biomnigroup/shared_invite/zt-3avks4913-dotMBt8D_apQnJ3mG~ak6Q">
+<img src="https://img.shields.io/badge/Join-Slack-4A154B?style=for-the-badge&logo=slack" alt="Join Slack" />
+</a>
+<a href="https://biomni.stanford.edu">
+<img src="https://img.shields.io/badge/Try-Web%20UI-blue?style=for-the-badge" alt="Web UI" />
+</a>
+<a href="https://x.com/ProjectBiomni">
+<img src="https://img.shields.io/badge/Follow-on%20X-black?style=for-the-badge&logo=x" alt="Follow on X" />
+</a>
+<a href="https://www.linkedin.com/company/project-biomni">
+<img src="https://img.shields.io/badge/Follow-LinkedIn-0077B5?style=for-the-badge&logo=linkedin" alt="Follow on LinkedIn" />
+</a>
+<a href="https://www.biorxiv.org/content/10.1101/2025.05.30.656746v1">
+<img src="https://img.shields.io/badge/Read-Paper-green?style=for-the-badge" alt="Paper" />
+</a>
+</p>
+
+
+
+# Biomni: A General-Purpose Biomedical AI Agent
+
+## Overview
+
+
+Biomni is a general-purpose biomedical AI agent designed to autonomously execute a wide range of research tasks across diverse biomedical subfields. By integrating cutting-edge large language model (LLM) reasoning with retrieval-augmented planning and code-based execution, Biomni helps scientists dramatically enhance research productivity and generate testable hypotheses.
+
+
+## Quick Start
+
+### Installation
+
+Our software environment is massive and we provide a single setup.sh script to setup.
+Follow this [file](biomni_env/README.md) to setup the env first.
+
+Then activate the environment E1:
+
+```bash
+conda activate biomni_e1
+```
+
+then install the biomni official pip package:
+
+```bash
+pip install biomni --upgrade
+```
+
+For the latest update, install from the github source version, or do:
+
+```bash
+pip install git+https://github.com/snap-stanford/Biomni.git@main
+```
+
+Lastly, configure your API keys using one of the following methods:
+
+<details>
+<summary>Click to expand</summary>
+
+#### Option 1: Using .env file (Recommended)
+
+Create a `.env` file in your project directory:
+
+```bash
+# Copy the example file
+cp .env.example .env
+
+# Edit the .env file with your actual API keys
+```
+
+Your `.env` file should look like:
+
+```env
+# Required: Anthropic API Key for Claude models
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional: OpenAI API Key (if using OpenAI models)
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Optional: Azure OpenAI API Key (if using Azure OpenAI models)
+OPENAI_API_KEY=your_azure_openai_api_key
+OPENAI_ENDPOINT=https://your-resource-name.openai.azure.com/
+
+# Optional: AI Studio Gemini API Key (if using Gemini models)
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# Optional: groq API Key (if using groq as model provider)
+GROQ_API_KEY=your_groq_api_key_here
+
+# Optional: Set the source of your LLM for example:
+#"OpenAI", "AzureOpenAI", "Anthropic", "Ollama", "Gemini", "Bedrock", "Groq", "Custom"
+LLM_SOURCE=your_LLM_source_here
+
+# Optional: AWS Bedrock Configuration (if using AWS Bedrock models)
+AWS_BEARER_TOKEN_BEDROCK=your_bedrock_api_key_here
+AWS_REGION=us-east-1
+
+# Optional: Custom model serving configuration
+# CUSTOM_MODEL_BASE_URL=http://localhost:8000/v1
+# CUSTOM_MODEL_API_KEY=your_custom_api_key_here
+
+# Optional: Biomni data path (defaults to ./data)
+# BIOMNI_DATA_PATH=/path/to/your/data
+
+# Optional: Timeout settings (defaults to 600 seconds)
+# BIOMNI_TIMEOUT_SECONDS=600
+```
+
+#### Option 2: Using shell environment variables
+
+Alternatively, configure your API keys in bash profile `~/.bashrc`:
+
+```bash
+export ANTHROPIC_API_KEY="YOUR_API_KEY"
+export OPENAI_API_KEY="YOUR_API_KEY" # optional if you just use Claude
+export OPENAI_ENDPOINT="https://your-resource-name.openai.azure.com/" # optional unless you are using Azure
+export AWS_BEARER_TOKEN_BEDROCK="YOUR_BEDROCK_API_KEY" # optional for AWS Bedrock models
+export AWS_REGION="us-east-1" # optional, defaults to us-east-1 for Bedrock
+export GEMINI_API_KEY="YOUR_GEMINI_API_KEY" #optional if you want to use a gemini model
+export GROQ_API_KEY="YOUR_GROQ_API_KEY" # Optional: set this to use models served by Groq
+export LLM_SOURCE="Groq" # Optional: set this to use models served by Groq
+
+
+```
+</details>
+
+
+#### ⚠️ Known Package Conflicts
+
+Some Python packages are not installed by default in the Biomni environment due to dependency conflicts. If you need these features, you must install the packages manually and may need to uncomment relevant code in the codebase. See the up-to-date list and details in [docs/known_conflicts.md](./docs/known_conflicts.md).
+
+### Basic Usage
+
+Once inside the environment, you can start using Biomni:
+
+```python
+from biomni.agent import A1
+
+# Initialize the agent with data path, Data lake will be automatically downloaded on first run (~11GB)
+agent = A1(path='./data', llm='claude-sonnet-4-20250514')
+
+# Execute biomedical tasks using natural language
+agent.go("Plan a CRISPR screen to identify genes that regulate T cell exhaustion, generate 32 genes that maximize the perturbation effect.")
+agent.go("Perform scRNA-seq annotation at [PATH] and generate meaningful hypothesis")
+agent.go("Predict ADMET properties for this compound: CC(C)CC1=CC=C(C=C1)C(C)C(=O)O")
+```
+
+#### Controlling Datalake Loading
+
+By default, Biomni automatically downloads the datalake files (~11GB) when you create an agent. You can control this behavior:
+
+```python
+# Skip automatic datalake download (faster initialization)
+agent = A1(path='./data', llm='claude-sonnet-4-20250514', expected_data_lake_files = [])
+```
+
+This is useful for:
+- Faster testing and development
+- Environments with limited storage or bandwidth
+- Cases where you only need specific tools that don't require datalake files
+If you plan on using Azure for your model, always prefix the model name with azure- (e.g. llm='azure-gpt-4o').
+
+### Gradio Interface
+
+Launch an interactive web UI for Biomni:
+
+```python
+from biomni.agent import A1
+
+agent = A1(path='./data', llm='claude-sonnet-4-20250514')
+agent.launch_gradio_demo()
+```
+
+**Installation:**
+```bash
+pip install "gradio>=5.0,<6.0"
+```
+
+**Note:** Biomni's Gradio interface currently requires Gradio 5.x due to API changes in Gradio 6.0. If you have Gradio 6.x installed, you may need to downgrade.
+
+**Options:**
+- `share=True` - Create a public shareable link
+- `server_name="127.0.0.1"` - Localhost only (default: "0.0.0.0")
+- `require_verification=True` - Require access code (default code: "Biomni2025")
+
+The interface will be available at `http://localhost:7860`
+
+### Configuration Management
+
+Biomni includes a centralized configuration system that provides flexible ways to manage settings. You can configure Biomni through environment variables, runtime modifications, or direct parameters.
+
+```python
+from biomni.config import default_config
+from biomni.agent import A1
+
+# RECOMMENDED: Modify global defaults for consistency
+default_config.llm = "gpt-4"
+default_config.timeout_seconds = 1200
+
+# All agents AND database queries use these defaults
+agent = A1()  # Everything uses gpt-4, 1200s timeout
+```
+
+**Note**: Direct parameters to `A1()` only affect that agent's reasoning, not database queries. For consistent configuration across all operations, use `default_config` or environment variables.
+
+For detailed configuration options, see the **[Configuration Guide](docs/configuration.md)**.
+
+### PDF Generation
+
+Generate PDF reports of execution traces:
+
+```python
+from biomni.agent import A1
+
+# Initialize agent
+agent = A1(path='./data', llm='claude-sonnet-4-20250514')
+
+# Run your task
+agent.go("Your biomedical task here")
+
+# Save conversation history as PDF
+agent.save_conversation_history("my_analysis_results.pdf")
+```
+
+**PDF Generation Dependencies:**
+<details>
+<summary>Click to expand</summary>
+For optimal PDF generation, install one of these packages:
+
+```bash
+# Option 1: WeasyPrint (recommended for best layout control)
+# Conda environment (recommended)
+conda install weasyprint
+
+# System installation
+brew install weasyprint  # macOS
+apt install weasyprint   # Linux
+
+# See [WeasyPrint Installation Guide](https://doc.courtbouillon.org/weasyprint/stable/first_steps.html) for detailed instructions.
+
+# Option 2: markdown2pdf (Rust-based, fast and reliable)
+# macOS:
+brew install theiskaa/tap/markdown2pdf
+
+# Windows/Linux (using Cargo):
+cargo install markdown2pdf
+
+# Or download prebuilt binaries from:
+# https://github.com/theiskaa/markdown2pdf/releases/latest
+
+# Option 3: Pandoc (pip installation)
+pip install pandoc
+```
+</details>
+
+## MCP (Model Context Protocol) Support
+
+Biomni supports MCP servers for external tool integration:
+
+```python
+from biomni.agent import A1
+
+agent = A1()
+agent.add_mcp(config_path="./mcp_config.yaml")
+agent.go("Find FDA active ingredient information for ibuprofen")
+```
+
+**Built-in MCP Servers:**
+For usage and implementation details, see the [MCP Integration Documentation](docs/mcp_integration.md) and examples in [`tutorials/examples/add_mcp_server/`](tutorials/examples/add_mcp_server/) and [`tutorials/examples/expose_biomni_server/`](tutorials/examples/expose_biomni_server/).
+
+
+## Biomni-R0
+
+**Biomni-R0** is our first reasoning model for biology, built on Qwen-32B with reinforcement learning from agent interaction data. It's designed to excel at tool use, multi-step reasoning, and complex biological problem-solving through iterative self-correction.
+
+- 🤗 Model: [biomni/Biomni-R0-32B-Preview](https://huggingface.co/biomni/Biomni-R0-32B-Preview)
+- 📝 Technical Report: [biomni.stanford.edu/blog/biomni-r0-technical-report](https://biomni.stanford.edu/blog/biomni-r0-technical-report)
+
+To use Biomni-R0 for agent reasoning while keeping database queries on your usual provider (recommended), run a local SGLang server and pass the model to `A1()` directly.
+
+1) Launch SGLang with Biomni-R0:
+
+```bash
+python -m sglang.launch_server --model-path RyanLi0802/Biomni-R0-Preview --port 30000 --host 0.0.0.0 --mem-fraction-static 0.8 --tp 2 --trust-remote-code --json-model-override-args '{"rope_scaling":{"rope_type":"yarn","factor":1.0,"original_max_position_embeddings":32768}, "max_position_embeddings": 131072}'
+```
+
+2) Point the agent to your SGLang endpoint for reasoning:
+
+```python
+from biomni.config import default_config
+from biomni.agent import A1
+
+# Database queries (indexes, retrieval, etc.) use default_config
+default_config.llm = "claude-3-5-sonnet-20241022"
+default_config.source = "Anthropic"
+
+# Agent reasoning uses Biomni-R0 served via SGLang (OpenAI-compatible API)
+agent = A1(
+    llm="biomni/Biomni-R0-32B-Preview",
+    source="Custom",
+    base_url="http://localhost:30000/v1",
+    api_key="EMPTY",
+)
+
+agent.go("Plan a CRISPR screen to identify genes regulating T cell exhaustion")
+```
+
+## Biomni-Eval1
+
+**Biomni-Eval1** is a comprehensive evaluation benchmark for assessing biological reasoning capabilities across diverse tasks. It contains **433 instances** spanning **10 biological reasoning tasks**, from gene identification to disease diagnosis.
+
+**Tasks Included:**
+- GWAS causal gene identification (3 variants)
+- Lab bench Q&A (2 variants)
+- Patient gene detection
+- Screen gene retrieval
+- GWAS variant prioritization
+- Rare disease diagnosis
+- CRISPR delivery method selection
+
+**Resources:**
+- 🤗 Dataset: [biomni/Eval1](https://huggingface.co/datasets/biomni/Eval1)
+- 💻 Quick Start:
+```python
+from biomni.eval import BiomniEval1
+
+evaluator = BiomniEval1()
+score = evaluator.evaluate('gwas_causal_gene_opentargets', 0, 'BRCA1')
+```
+
+
+## 📚 Know-How Library
+
+Biomni includes a **Know-How Library** — a curated collection of best practices, protocols, and troubleshooting guides for biomedical techniques. These documents are automatically retrieved by the A1 agent when relevant to provide domain expertise and practical knowledge.
+
+**Features:**
+- Automatic retrieval based on query relevance
+- Metadata tracking (authors, affiliations, licensing, commercial use)
+- Compatible with commercial mode (filters non-commercial content)
+
+### 📝 Contributing Know-How Documents
+
+We're actively seeking community contributions to expand our Know-How Library! Share your expertise by contributing:
+
+- **Lab protocols** (cell culture, flow cytometry, western blotting, etc.)
+- **Analysis best practices** (NGS workflows, microscopy techniques, etc.)
+- **Troubleshooting guides** (common issues and solutions)
+- **Experimental design guidelines** (sample size, controls, validation)
+- **Domain-specific knowledge** (drug formulation, animal models, clinical trials, etc.)
+
+Know-how documents should be practical, succinct, and include proper attribution. Use [this know-how](know_how/single_cell_annotation.md) as an example.
+
+**To contribute:** Create a markdown file following our template and submit a pull request.
+
+## 🤝 Contributing to Biomni
+
+Biomni is an open-science initiative that thrives on community contributions. We welcome:
+
+- **🔧 New Tools**: Specialized analysis functions and algorithms
+- **📊 Datasets**: Curated biomedical data and knowledge bases
+- **💻 Software**: Integration of existing biomedical software packages
+- **📋 Benchmarks**: Evaluation datasets and performance metrics
+- **📚 Know-How**: Best practices, protocols, and domain expertise
+- **📚 Misc**: Tutorials, examples, and use cases
+- **🔧 Update existing tools**: many current tools are not optimized - fix and replacements are welcome!
+
+Check out this **[Contributing Guide](CONTRIBUTION.md)** on how to contribute to the Biomni ecosystem.
+
+If you have particular tool/database/software in mind that you want to add, you can also submit to [this form](https://forms.gle/nu2n1unzAYodTLVj6) and the biomni team will implement them.
+
+## 🔬 Call for Contributors: Help Build Biomni-E2
+
+Biomni-E1 only scratches the surface of what’s possible in the biomedical action space.
+
+Now, we’re building **Biomni-E2** — a next-generation environment developed **with and for the community**.
+
+We believe that by collaboratively defining and curating a shared library of standard biomedical actions, we can accelerate science for everyone.
+
+**Join us in shaping the future of biomedical AI agent.**
+
+- **Contributors with significant impact** (e.g., 10+ significant & integrated tool contributions or equivalent) will be **invited as co-authors** on our upcoming paper in a top-tier journal or conference.
+- **All contributors** will be acknowledged in our publications.
+- More contributor perks...
+
+Let’s build it together.
+
+
+## Tutorials and Examples
+
+**[Biomni 101](./tutorials/biomni_101.ipynb)** - Basic concepts and first steps
+
+More to come!
+
+## 🌐 Web Interface
+
+Experience Biomni through our no-code web interface at **[biomni.stanford.edu](https://biomni.stanford.edu)**.
+
+[![Watch the video](https://img.youtube.com/vi/E0BRvl23hLs/maxresdefault.jpg)](https://youtu.be/E0BRvl23hLs)
+
+
+## Important Note
+- Security warning: Currently, Biomni executes LLM-generated code with full system privileges. If you want to use it in production, please use in isolated/sandboxed environments. The agent can access files, network, and system commands. Be careful with sensitive data or credentials.
+- This release was frozen as of April 15 2025, so it differs from the current web platform.
+- Biomni itself is Apache 2.0-licensed, but certain integrated tools, databases, or software may carry more restrictive commercial licenses. Review each component carefully before any commercial use.
+
+## Cite Us
+
+```
+@article{huang2025biomni,
+  title={Biomni: A General-Purpose Biomedical AI Agent},
+  author={Huang, Kexin and Zhang, Serena and Wang, Hanchen and Qu, Yuanhao and Lu, Yingzhou and Roohani, Yusuf and Li, Ryan and Qiu, Lin and Zhang, Junze and Di, Yin and others},
+  journal={bioRxiv},
+  pages={2025--05},
+  year={2025},
+  publisher={Cold Spring Harbor Laboratory}
+}
+```

biomni/__init__.py

@@ -0,0 +1,3 @@
+from .version import __version__
+
+__all__ = ["__version__"]

biomni/config.py

@@ -0,0 +1,99 @@
+"""
+Biomni Configuration Management
+
+Simple configuration class for centralizing common settings.
+Maintains full backward compatibility with existing code.
+"""
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class BiomniConfig:
+    """Central configuration for Biomni agent.
+
+    All settings are optional and have sensible defaults.
+    API keys are still read from environment variables to maintain
+    compatibility with existing .env file structure.
+
+    Usage:
+        # Create config with defaults
+        config = BiomniConfig()
+
+        # Override specific settings
+        config = BiomniConfig(llm="gpt-4", timeout_seconds=1200)
+
+        # Modify after creation
+        config.path = "./custom_data"
+    """
+
+    # Data and execution settings
+    path: str = "./data"
+    timeout_seconds: int = 600
+
+    # LLM settings (API keys still from environment)
+    llm: str = "claude-sonnet-4-5"
+    temperature: float = 0.7
+
+    # Tool settings
+    use_tool_retriever: bool = True
+
+    # Data licensing settings
+    commercial_mode: bool = False  # If True, excludes non-commercial datasets
+
+    # Custom model settings (for custom LLM serving)
+    base_url: str | None = None
+    api_key: str | None = None  # Only for custom models, not provider API keys
+
+    # LLM source (auto-detected if None)
+    source: str | None = None
+
+    # Third-party integrations
+    protocols_io_access_token: str | None = None
+
+    def __post_init__(self):
+        """Load any environment variable overrides if they exist."""
+        # Check for environment variable overrides (optional)
+        # Support both old and new names for backwards compatibility
+        if os.getenv("BIOMNI_PATH") or os.getenv("BIOMNI_DATA_PATH"):
+            self.path = os.getenv("BIOMNI_PATH") or os.getenv("BIOMNI_DATA_PATH")
+        if os.getenv("BIOMNI_TIMEOUT_SECONDS"):
+            self.timeout_seconds = int(os.getenv("BIOMNI_TIMEOUT_SECONDS"))
+        if os.getenv("BIOMNI_LLM") or os.getenv("BIOMNI_LLM_MODEL"):
+            self.llm = os.getenv("BIOMNI_LLM") or os.getenv("BIOMNI_LLM_MODEL")
+        if os.getenv("BIOMNI_USE_TOOL_RETRIEVER"):
+            self.use_tool_retriever = os.getenv("BIOMNI_USE_TOOL_RETRIEVER").lower() == "true"
+        if os.getenv("BIOMNI_COMMERCIAL_MODE"):
+            self.commercial_mode = os.getenv("BIOMNI_COMMERCIAL_MODE").lower() == "true"
+        if os.getenv("BIOMNI_TEMPERATURE"):
+            self.temperature = float(os.getenv("BIOMNI_TEMPERATURE"))
+        if os.getenv("BIOMNI_CUSTOM_BASE_URL"):
+            self.base_url = os.getenv("BIOMNI_CUSTOM_BASE_URL")
+        if os.getenv("BIOMNI_CUSTOM_API_KEY"):
+            self.api_key = os.getenv("BIOMNI_CUSTOM_API_KEY")
+        if os.getenv("BIOMNI_SOURCE"):
+            self.source = os.getenv("BIOMNI_SOURCE")
+
+        # Protocols.io access token (prefer specific env vars)
+        env_token = os.getenv("PROTOCOLS_IO_ACCESS_TOKEN") or os.getenv("BIOMNI_PROTOCOLS_IO_ACCESS_TOKEN")
+        if env_token:
+            self.protocols_io_access_token = env_token
+
+    def to_dict(self) -> dict:
+        """Convert config to dictionary for easy access."""
+        return {
+            "path": self.path,
+            "timeout_seconds": self.timeout_seconds,
+            "llm": self.llm,
+            "temperature": self.temperature,
+            "use_tool_retriever": self.use_tool_retriever,
+            "commercial_mode": self.commercial_mode,
+            "base_url": self.base_url,
+            "api_key": self.api_key,
+            "source": self.source,
+        }
+
+
+# Global default config instance (optional, for convenience)
+default_config = BiomniConfig()

biomni/env_desc.py

@@ -0,0 +1,221 @@
+# Data lake dictionary with detailed descriptions
+data_lake_dict = {
+    "affinity_capture-ms.parquet": "Protein-protein interactions detected via affinity capture and mass spectrometry.",
+    "affinity_capture-rna.parquet": "Protein-RNA interactions detected by affinity capture.",
+    "BindingDB_All_202409.tsv": "Measured binding affinities between proteins and small molecules for drug discovery.",
+    "broad_repurposing_hub_molecule_with_smiles.parquet": "Molecules from Broad Institute's Drug Repurposing Hub with SMILES annotations.",
+    "broad_repurposing_hub_phase_moa_target_info.parquet": "Drug phases, mechanisms of action, and target information from Broad Institute.",
+    "co-fractionation.parquet": "Protein-protein interactions from co-fractionation experiments.",
+    "czi_census_datasets_v4.parquet": "Datasets from the Chan Zuckerberg Initiative's Cell Census.",
+    "DepMap_CRISPRGeneDependency.csv": "Gene dependency probability estimates for cancer cell lines, including all DepMap models.",
+    "DepMap_CRISPRGeneEffect.csv": "Genome-wide CRISPR gene effect estimates for cancer cell lines, including all DepMap models.",
+    "DepMap_Model.csv": "Metadata describing all cancer models/cell lines which are referenced by a dataset contained within the DepMap portal.",
+    "DepMap_OmicsExpressionProteinCodingGenesTPMLogp1.csv": "Gene expression in TPMs for cancer cell lines, including all DepMap models.",
+    "ddinter_alimentary_tract_metabolism.csv": "Drug-drug interactions for alimentary tract and metabolism drugs from DDInter 2.0 database.",
+    "ddinter_antineoplastic.csv": "Drug-drug interactions for antineoplastic and immunomodulating agents from DDInter 2.0 database.",
+    "ddinter_antiparasitic.csv": "Drug-drug interactions for antiparasitic products from DDInter 2.0 database.",
+    "ddinter_blood_organs.csv": "Drug-drug interactions for blood and blood forming organs drugs from DDInter 2.0 database.",
+    "ddinter_dermatological.csv": "Drug-drug interactions for dermatological drugs from DDInter 2.0 database.",
+    "ddinter_hormonal.csv": "Drug-drug interactions for systemic hormonal preparations from DDInter 2.0 database.",
+    "ddinter_respiratory.csv": "Drug-drug interactions for respiratory system drugs from DDInter 2.0 database.",
+    "ddinter_various.csv": "Drug-drug interactions for various drugs from DDInter 2.0 database.",
+    "DisGeNET.parquet": "Gene-disease associations from multiple sources.",
+    "dosage_growth_defect.parquet": "Gene dosage changes affecting growth.",
+    "enamine_cloud_library_smiles.pkl": "Compounds from Enamine REAL library with SMILES annotations.",
+    "evebio_assay_table.csv": "Assay metadata with one row per assay from EveBio pharmome mapping.",
+    "evebio_bundle_table.csv": "Target subfamily bundles used for screening-to-profiling progression.",
+    "evebio_compound_table.csv": "Compound metadata with common identifiers from EveBio screening.",
+    "evebio_control_table.csv": "Control datapoints for all screening and profiling plates.",
+    "evebio_detailed_result_table.csv": "Expanded results on evebio_summary_result_table with curve fit parameters and phase categories.",
+    "evebio_observed_points_table.csv": "Raw observed datapoints from all screening and profiling experiments.",
+    "evebio_summary_result_table.csv": "Succinct summary of results for each assay-compound combination.",
+    "evebio_target_table.csv": "Target metadata with common identifiers from EveBio screening.",
+    "genebass_missense_LC_filtered.pkl": "Filtered missense variants from GeneBass.",
+    "genebass_pLoF_filtered.pkl": "Predicted loss-of-function variants from GeneBass.",
+    "genebass_synonymous_filtered.pkl": "Filtered synonymous variants from GeneBass.",
+    "gene_info.parquet": "Comprehensive gene information.",
+    "genetic_interaction.parquet": "Genetic interactions between genes.",
+    "go-plus.json": "Gene ontology data for functional gene annotations.",
+    "gtex_tissue_gene_tpm.parquet": "Gene expression (TPM) across human tissues from GTEx.",
+    "gwas_catalog.pkl": "Genome-wide association studies (GWAS) results.",
+    "hp.obo": "Official HPO release in obographs format",
+    "kg.csv": "Precision medicine knowledge graph with 17,080 diseases and 4+ million relationships across biological scales.",
+    "marker_celltype.parquet": "Cell type marker genes for identification.",
+    "McPAS-TCR.parquet": "T-cell receptor sequences and specificity data from McPAS database.",
+    "miRDB_v6.0_results.parquet": "Predicted microRNA targets from miRDB.",
+    "miRTarBase_microRNA_target_interaction.parquet": "Experimentally validated microRNA-target interactions from miRTarBase.",
+    "miRTarBase_microRNA_target_interaction_pubmed_abtract.txt": "PubMed abstracts for microRNA-target interactions in miRTarBase.",
+    "miRTarBase_MicroRNA_Target_Sites.parquet": "Binding sites of microRNAs on target genes from miRTarBase.",
+    "mousemine_m1_positional_geneset.parquet": "Positional gene sets from MouseMine.",
+    "mousemine_m2_curated_geneset.parquet": "Curated gene sets from MouseMine.",
+    "mousemine_m3_regulatory_target_geneset.parquet": "Regulatory target gene sets from MouseMine.",
+    "mousemine_m5_ontology_geneset.parquet": "Ontology-based gene sets from MouseMine.",
+    "mousemine_m8_celltype_signature_geneset.parquet": "Cell type signature gene sets from MouseMine.",
+    "mousemine_mh_hallmark_geneset.parquet": "Hallmark gene sets from MouseMine.",
+    "msigdb_human_c1_positional_geneset.parquet": "Human positional gene sets from MSigDB.",
+    "msigdb_human_c2_curated_geneset.parquet": "Curated human gene sets from MSigDB.",
+    "msigdb_human_c3_regulatory_target_geneset.parquet": "Regulatory target gene sets from MSigDB.",
+    "msigdb_human_c3_subset_transcription_factor_targets_from_GTRD.parquet": "Transcription factor targets from GTRD/MSigDB.",
+    "msigdb_human_c4_computational_geneset.parquet": "Computationally derived gene sets from MSigDB.",
+    "msigdb_human_c5_ontology_geneset.parquet": "Ontology-based gene sets from MSigDB.",
+    "msigdb_human_c6_oncogenic_signature_geneset.parquet": "Oncogenic signatures from MSigDB.",
+    "msigdb_human_c7_immunologic_signature_geneset.parquet": "Immunologic signatures from MSigDB.",
+    "msigdb_human_c8_celltype_signature_geneset.parquet": "Cell type signatures from MSigDB.",
+    "msigdb_human_h_hallmark_geneset.parquet": "Hallmark gene sets from MSigDB.",
+    "omim.parquet": "Genetic disorders and associated genes from OMIM.",
+    "proteinatlas.tsv": "Protein expression data from Human Protein Atlas.",
+    "proximity_label-ms.parquet": "Protein interactions via proximity labeling and mass spectrometry.",
+    "reconstituted_complex.parquet": "Protein complexes reconstituted in vitro.",
+    "sgRNA_KO_SP_mouse.txt": "sgRNA knockout data for mouse.",
+    "sgRNA_KO_SP_human.txt": "sgRNA knockout data for human.",
+    "synthetic_growth_defect.parquet": "Synthetic growth defects from genetic interactions.",
+    "synthetic_lethality.parquet": "Synthetic lethal interactions.",
+    "synthetic_rescue.parquet": "Genetic interactions rescuing phenotypes.",
+    "two-hybrid.parquet": "Protein-protein interactions detected by yeast two-hybrid assays.",
+    "variant_table.parquet": "Annotated genetic variants table.",
+    "Virus-Host_PPI_P-HIPSTER_2020.parquet": "Virus-host protein-protein interactions from P-HIPSTER.",
+    "txgnn_name_mapping.pkl": "Name mapping for TXGNN.",
+    "txgnn_prediction.pkl": "Prediction data for TXGNN.",
+}
+
+# Updated library_content as a dictionary with detailed descriptions
+library_content_dict = {
+    # === PYTHON PACKAGES ===
+    # Core Bioinformatics Libraries (Python)
+    "biopython": "[Python Package] A set of tools for biological computation including parsers for bioinformatics files, access to online services, and interfaces to common bioinformatics programs.",
+    "biom-format": "[Python Package] The Biological Observation Matrix (BIOM) format is designed for representing biological sample by observation contingency tables with associated metadata.",
+    "scanpy": "[Python Package] A scalable toolkit for analyzing single-cell gene expression data, specifically designed for large datasets using AnnData.",
+    "scikit-bio": "[Python Package] Data structures, algorithms, and educational resources for bioinformatics, including sequence analysis, phylogenetics, and ordination methods.",
+    "anndata": "[Python Package] A Python package for handling annotated data matrices in memory and on disk, primarily used for single-cell genomics data.",
+    "mudata": "[Python Package] A Python package for multimodal data storage and manipulation, extending AnnData to handle multiple modalities.",
+    "pyliftover": "[Python Package] A Python implementation of UCSC liftOver tool for converting genomic coordinates between genome assemblies.",
+    "biopandas": "[Python Package] A package that provides pandas DataFrames for working with molecular structures and biological data.",
+    "biotite": "[Python Package] A comprehensive library for computational molecular biology, providing tools for sequence analysis, structure analysis, and more.",
+    "lazyslide": "[Python Package] A Python framework that brings interoperable, reproducible whole slide image analysis, enabling seamless histopathology workflows from preprocessing to deep learning.",
+    # Genomics & Variant Analysis (Python)
+    "gget": "[Python Package] A toolkit for accessing genomic databases and retrieving sequences, annotations, and other genomic data.",
+    "lifelines": "[Python Package] A complete survival analysis library for fitting models, plotting, and statistical tests.",
+    # "scvi-tools": "[Python Package] A package for probabilistic modeling of single-cell omics data, including deep generative models.",
+    "gseapy": "[Python Package] A Python wrapper for Gene Set Enrichment Analysis (GSEA) and visualization.",
+    "scrublet": "[Python Package] A tool for detecting doublets in single-cell RNA-seq data.",
+    "cellxgene-census": "[Python Package] A tool for accessing and analyzing the CellxGene Census, a collection of single-cell datasets. To download a dataset, use the download_source_h5ad function with the dataset id as the argument (856c1b98-5727-49da-bf0f-151bdb8cb056, no .h5ad extension).",
+    "hyperopt": "[Python Package] A Python library for optimizing hyperparameters of machine learning algorithms.",
+    "scvelo": "[Python Package] A tool for RNA velocity analysis in single cells using dynamical models.",
+    "pysam": "[Python Package] A Python module for reading, manipulating and writing genomic data sets in SAM/BAM/VCF/BCF formats.",
+    "pyfaidx": "[Python Package] A Python package for efficient random access to FASTA files.",
+    "pyranges": "[Python Package] A Python package for interval manipulation with a pandas-like interface.",
+    "pybedtools": "[Python Package] A Python wrapper for Aaron Quinlan's BEDTools programs.",
+    # "panhumanpy": "A Python package for hierarchical, cross-tissue cell type annotation of human single-cell RNA-seq data",
+    # Structural Biology & Drug Discovery (Python)
+    "rdkit": "[Python Package] A collection of cheminformatics and machine learning tools for working with chemical structures and drug discovery.",
+    "deeppurpose": "[Python Package] A deep learning library for drug-target interaction prediction and virtual screening.",
+    "pyscreener": "[Python Package] A Python package for virtual screening of chemical compounds.",
+    "openbabel": "[Python Package] A chemical toolbox designed to speak the many languages of chemical data, supporting file format conversion and molecular modeling.",
+    "descriptastorus": "[Python Package] A library for computing molecular descriptors for machine learning applications in drug discovery.",
+    # "pymol": "[Python Package] A molecular visualization system for rendering and animating 3D molecular structures.",
+    "openmm": "[Python Package] A toolkit for molecular simulation using high-performance GPU computing.",
+    "pytdc": "[Python Package] A Python package for Therapeutics Data Commons, providing access to machine learning datasets for drug discovery.",
+    # Data Science & Statistical Analysis (Python)
+    "pandas": "[Python Package] A fast, powerful, and flexible data analysis and manipulation library for Python.",
+    "numpy": "[Python Package] The fundamental package for scientific computing with Python, providing support for arrays, matrices, and mathematical functions.",
+    "scipy": "[Python Package] A Python library for scientific and technical computing, including modules for optimization, linear algebra, integration, and statistics.",
+    "scikit-learn": "[Python Package] A machine learning library featuring various classification, regression, and clustering algorithms.",
+    "matplotlib": "[Python Package] A comprehensive library for creating static, animated, and interactive visualizations in Python.",
+    "seaborn": "[Python Package] A statistical data visualization library based on matplotlib with a high-level interface for drawing attractive statistical graphics.",
+    "statsmodels": "[Python Package] A Python module for statistical modeling and econometrics, including descriptive statistics and estimation of statistical models.",
+    "pymc3": "[Python Package] A Python package for Bayesian statistical modeling and probabilistic machine learning.",
+    # "pystan": "[Python Package] A Python interface to Stan, a platform for statistical modeling and high-performance statistical computation.",
+    "umap-learn": "[Python Package] Uniform Manifold Approximation and Projection, a dimension reduction technique.",
+    "faiss-cpu": "[Python Package] A library for efficient similarity search and clustering of dense vectors.",
+    "harmony-pytorch": "[Python Package] A PyTorch implementation of the Harmony algorithm for integrating single-cell data.",
+    # General Bioinformatics & Computational Utilities (Python)
+    "tiledb": "[Python Package] A powerful engine for storing and analyzing large-scale genomic data.",
+    "tiledbsoma": "[Python Package] A library for working with the SOMA (Stack of Matrices) format using TileDB.",
+    "h5py": "[Python Package] A Python interface to the HDF5 binary data format, allowing storage of large amounts of numerical data.",
+    "tqdm": "[Python Package] A fast, extensible progress bar for loops and CLI applications.",
+    "joblib": "[Python Package] A set of tools to provide lightweight pipelining in Python, including transparent disk-caching and parallel computing.",
+    "opencv-python": "[Python Package] OpenCV library for computer vision tasks, useful for image analysis in biological contexts.",
+    "PyPDF2": "[Python Package] A library for working with PDF files, useful for extracting text from scientific papers.",
+    "googlesearch-python": "[Python Package] A library for performing Google searches programmatically.",
+    "scikit-image": "[Python Package] A collection of algorithms for image processing in Python.",
+    "pymed": "[Python Package] A Python library for accessing PubMed articles.",
+    "arxiv": "[Python Package] A Python wrapper for the arXiv API, allowing access to scientific papers.",
+    "scholarly": "[Python Package] A module to retrieve author and publication information from Google Scholar.",
+    "cryosparc-tools": "[Python Package] Tools for working with cryoSPARC, a platform for cryo-EM data processing.",
+    "mageck": "[Python Package] Analysis of CRISPR screen data.",
+    "igraph": "[Python Package] Network analysis and visualization.",
+    "pyscenic": "[Python Package] Analysis of single-cell RNA-seq data and gene regulatory networks.",
+    "cooler": "[Python Package] Storage and analysis of Hi-C data.",
+    "trackpy": "[Python Package] Particle tracking in images and video.",
+    "nnunet": "[Python Package] A deep learning framework for biomedical image segmentation, providing a standardized approach to training and inference.",
+    # "flowcytometrytools": "[Python Package] Analysis and visualization of flow cytometry data.",
+    "cellpose": "[Python Package] Cell segmentation in microscopy images.",
+    "viennarna": "[Python Package] RNA secondary structure prediction.",
+    "PyMassSpec": "[Python Package] Mass spectrometry data analysis.",
+    "python-libsbml": "[Python Package] Working with SBML files for computational biology.",
+    "cobra": "[Python Package] Constraint-based modeling of metabolic networks.",
+    "reportlab": "[Python Package] Creation of PDF documents.",
+    "flowkit": "[Python Package] Toolkit for processing flow cytometry data.",
+    "hmmlearn": "[Python Package] Hidden Markov model analysis.",
+    "msprime": "[Python Package] Simulation of genetic variation.",
+    "tskit": "[Python Package] Handling tree sequences and population genetics data.",
+    "cyvcf2": "[Python Package] Fast parsing of VCF files.",
+    "pykalman": "[Python Package] Kalman filter and smoother implementation.",
+    "fanc": "[Python Package] Analysis of chromatin conformation data.",
+    "loompy": "A Python implementation of the Loom file format for efficiently storing and working with large omics datasets.",
+    "pyBigWig": "A Python library for accessing bigWig and bigBed files for genome browser track data.",
+    "pymzml": "A Python module for high-throughput bioinformatics analysis of mass spectrometry data.",
+    "optlang": "A Python package for modeling optimization problems symbolically.",
+    "FlowIO": "A Python package for reading and writing flow cytometry data files.",
+    "FlowUtils": "Utilities for processing and analyzing flow cytometry data.",
+    "arboreto": "A Python package for inferring gene regulatory networks from single-cell RNA-seq data.",
+    "pdbfixer": "A Python package for fixing problems in PDB files in preparation for molecular simulations.",
+    # === R PACKAGES ===
+    # Core R Packages for Data Analysis
+    "ggplot2": "[R Package] A system for declaratively creating graphics, based on The Grammar of Graphics. Use with subprocess.run(['Rscript', '-e', 'library(ggplot2); ...']).",
+    "dplyr": "[R Package] A grammar of data manipulation, providing a consistent set of verbs that help you solve the most common data manipulation challenges. Use with subprocess.",
+    "tidyr": "[R Package] A package that helps you create tidy data, where each column is a variable, each row is an observation, and each cell is a single value. Use with subprocess.",
+    "readr": "[R Package] A fast and friendly way to read rectangular data like CSV, TSV, and FWF. Use with subprocess.run(['Rscript', '-e', 'library(readr); ...']).",
+    "stringr": "[R Package] A cohesive set of functions designed to make working with strings as easy as possible. Use with subprocess calls.",
+    "Matrix": "[R Package] A package that provides classes and methods for dense and sparse matrices. Required for Seurat. Use with subprocess calls.",
+    # "Rcpp": "[R Package] Seamless R and C++ Integration, allowing R functions to call compiled C++ code. Use with subprocess calls.",
+    # "devtools": "[R Package] Tools to make developing R packages easier, including functions to install packages from GitHub. Use with subprocess calls.",
+    # "remotes": "[R Package] Install R packages from GitHub, GitLab, Bitbucket, or other remote repositories. Use with subprocess calls.",
+    # Bioinformatics R Packages
+    "DESeq2": "[R Package] Differential gene expression analysis based on the negative binomial distribution. Use with subprocess.run(['Rscript', '-e', 'library(DESeq2); ...']).",
+    "clusterProfiler": "[R Package] A package for statistical analysis and visualization of functional profiles for genes and gene clusters. Use with subprocess calls.",
+    # "DADA2": "[R Package] A package for modeling and correcting Illumina-sequenced amplicon errors. Use with subprocess calls.",
+    # "xcms": "[R Package] A package for processing and visualization of LC-MS and GC-MS data. Use with subprocess calls.",
+    # "FlowCore": "[R Package] Basic infrastructure for flow cytometry data. Use with subprocess calls.",
+    "edgeR": "[R Package] Empirical Analysis of Digital Gene Expression Data in R, for differential expression analysis. Use with subprocess calls.",
+    "limma": "[R Package] Linear Models for Microarray Data, for differential expression analysis. Use with subprocess calls.",
+    "harmony": "[R Package] A method for integrating and analyzing single-cell data across datasets. Use with subprocess calls.",
+    "WGCNA": "[R Package] Weighted Correlation Network Analysis for studying biological networks. Use with subprocess calls.",
+    # === CLI TOOLS ===
+    # Sequence Analysis Tools
+    "samtools": "[CLI Tool] A suite of programs for interacting with high-throughput sequencing data. Use with subprocess.run(['samtools', ...]).",
+    "bowtie2": "[CLI Tool] An ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences. Use with subprocess.run(['bowtie2', ...]).",
+    "bwa": "[CLI Tool] Burrows-Wheeler Aligner for mapping low-divergent sequences against a large reference genome. Use with subprocess.run(['bwa', ...]).",
+    "bedtools": "[CLI Tool] A powerful toolset for genome arithmetic, allowing operations like intersect, merge, count, and complement on genomic features. Use with subprocess.run(['bedtools', ...]).",
+    "macs2": "[CLI Tool] Model-based Analysis of ChIP-Seq data, a tool for identifying transcript factor binding sites.",
+    # Quality Control and Processing Tools
+    "fastqc": "[CLI Tool] A quality control tool for high throughput sequence data. Use with subprocess.run(['fastqc', ...]).",
+    "trimmomatic": "[CLI Tool] A flexible read trimming tool for Illumina NGS data. Use with subprocess.run(['trimmomatic', ...]).",
+    # Multiple Sequence Alignment and Phylogenetics
+    "mafft": "[CLI Tool] A multiple sequence alignment program for unix-like operating systems. Use with subprocess.run(['mafft', ...]).",
+    "Homer": "[CLI Tool] Motif discovery and next-gen sequencing analysis.",
+    "FastTree": "[CLI Tool] Phylogenetic trees from sequence alignments.",
+    "muscle": "[CLI Tool] Multiple sequence alignment tool.",
+    # Genetic Analysis Tools
+    "plink": "[CLI Tool] A comprehensive toolkit for genome association studies that can perform a range of large-scale analyses in a computationally efficient manner. Use with subprocess.run(['plink', ...]).",
+    "plink2": "[CLI Tool] A comprehensive toolkit for genome association studies that can perform a range of large-scale analyses in a computationally efficient manner. Use with subprocess.run(['plink2', ...]).",
+    "gcta64": "[CLI Tool] Genome-wide Complex Trait Analysis (GCTA) tool for estimating the proportion of phenotypic variance explained by genome-wide SNPs and analyzing genetic relationships. Use with subprocess.run(['gcta64', ...]).",
+    "iqtree2": "[CLI Tool] An efficient phylogenetic software for maximum likelihood analysis with built-in model selection and ultrafast bootstrap. Use with subprocess.run(['iqtree2', ...]).",
+    "ADFR": "AutoDock for Receptors suite for molecular docking and virtual screening. ",
+    "diamond": "A sequence aligner for protein and translated DNA searches, designed for high performance analysis of big sequence data. ",
+    "fcsparser": "A command-line tool for parsing and analyzing flow cytometry standard (FCS) files. ",
+    "plannotate": "[CLI Tool] A tool for annotating plasmid sequences with common features. ",
+    "vina": "[CLI Tool] An open-source program for molecular docking and virtual screening, known for its speed and accuracy improvements over AutoDock 4.",
+    "autosite": "[CLI Tool] A binding site detection tool used to identify potential ligand binding pockets on protein structures for molecular docking.",
+    "PyLabRobot": "[Python Package] A Python package for controlling liquid-handling robots and other lab automation equipment.",
+}

biomni/env_desc_cm.py

@@ -0,0 +1,219 @@
+# Data lake dictionary with detailed descriptions (Commercial Mode - Non-commercial datasets commented out)
+data_lake_dict = {
+    "affinity_capture-ms.parquet": "Protein-protein interactions detected via affinity capture and mass spectrometry.",
+    "affinity_capture-rna.parquet": "Protein-RNA interactions detected by affinity capture.",
+    # "BindingDB_All_202409.tsv": "Measured binding affinities between proteins and small molecules for drug discovery.",  # Requires commercial license
+    "broad_repurposing_hub_molecule_with_smiles.parquet": "Molecules from Broad Institute's Drug Repurposing Hub with SMILES annotations.",
+    "broad_repurposing_hub_phase_moa_target_info.parquet": "Drug phases, mechanisms of action, and target information from Broad Institute.",
+    "co-fractionation.parquet": "Protein-protein interactions from co-fractionation experiments.",
+    "czi_census_datasets_v4.parquet": "Datasets from the Chan Zuckerberg Initiative's Cell Census.",
+    "DepMap_CRISPRGeneDependency.csv": "Gene dependency probability estimates for cancer cell lines, including all DepMap models.",
+    "DepMap_CRISPRGeneEffect.csv": "Genome-wide CRISPR gene effect estimates for cancer cell lines, including all DepMap models.",
+    "DepMap_Model.csv": "Metadata describing all cancer models/cell lines which are referenced by a dataset contained within the DepMap portal.",
+    "DepMap_OmicsExpressionProteinCodingGenesTPMLogp1.csv": "Gene expression in TPMs for cancer cell lines, including all DepMap models.",
+    # "ddinter_alimentary_tract_metabolism.csv": "Drug-drug interactions for alimentary tract and metabolism drugs from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "ddinter_antineoplastic.csv": "Drug-drug interactions for antineoplastic and immunomodulating agents from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "ddinter_antiparasitic.csv": "Drug-drug interactions for antiparasitic products from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "ddinter_blood_organs.csv": "Drug-drug interactions for blood and blood forming organs drugs from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "ddinter_dermatological.csv": "Drug-drug interactions for dermatological drugs from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "ddinter_hormonal.csv": "Drug-drug interactions for systemic hormonal preparations from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "ddinter_respiratory.csv": "Drug-drug interactions for respiratory system drugs from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "ddinter_various.csv": "Drug-drug interactions for various drugs from DDInter 2.0 database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "DisGeNET.parquet": "Gene-disease associations from multiple sources.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    "dosage_growth_defect.parquet": "Gene dosage changes affecting growth.",
+    # "enamine_cloud_library_smiles.pkl": "Compounds from Enamine REAL library with SMILES annotations.",  # Proprietary - Requires license
+    # "evebio_assay_table.csv": "Assay metadata with one row per assay from EveBio pharmome mapping.",  # Proprietary - Requires permission
+    # "evebio_bundle_table.csv": "Target subfamily bundles used for screening-to-profiling progression.",  # Proprietary - Requires permission
+    # "evebio_compound_table.csv": "Compound metadata with common identifiers from EveBio screening.",  # Proprietary - Requires permission
+    # "evebio_control_table.csv": "Control datapoints for all screening and profiling plates.",  # Proprietary - Requires permission
+    # "evebio_detailed_result_table.csv": "Expanded results on evebio_summary_result_table with curve fit parameters and phase categories.",  # Proprietary - Requires permission
+    # "evebio_observed_points_table.csv": "Raw observed datapoints from all screening and profiling experiments.",  # Proprietary - Requires permission
+    # "evebio_summary_result_table.csv": "Succinct summary of results for each assay-compound combination.",  # Proprietary - Requires permission
+    # "evebio_target_table.csv": "Target metadata with common identifiers from EveBio screening.",  # Proprietary - Requires permission
+    "genebass_missense_LC_filtered.pkl": "Filtered missense variants from GeneBass.",
+    "genebass_pLoF_filtered.pkl": "Predicted loss-of-function variants from GeneBass.",
+    "genebass_synonymous_filtered.pkl": "Filtered synonymous variants from GeneBass.",
+    "gene_info.parquet": "Comprehensive gene information.",
+    "genetic_interaction.parquet": "Genetic interactions between genes.",
+    "go-plus.json": "Gene ontology data for functional gene annotations.",
+    "gtex_tissue_gene_tpm.parquet": "Gene expression (TPM) across human tissues from GTEx.",
+    "gwas_catalog.pkl": "Genome-wide association studies (GWAS) results.",
+    "hp.obo": "Official HPO release in obographs format",
+    "kg.csv": "Precision medicine knowledge graph with 17,080 diseases and 4+ million relationships across biological scales.",
+    "marker_celltype.parquet": "Cell type marker genes for identification.",
+    # "McPAS-TCR.parquet": "T-cell receptor sequences and specificity data from McPAS database.",  # CC BY-NC-SA 4.0 - Non-commercial only
+    # "miRDB_v6.0_results.parquet": "Predicted microRNA targets from miRDB.",  # Non-commercial use only
+    # "miRTarBase_microRNA_target_interaction.parquet": "Experimentally validated microRNA-target interactions from miRTarBase.",  # CC BY-NC 4.0 - Non-commercial only
+    # "miRTarBase_microRNA_target_interaction_pubmed_abtract.txt": "PubMed abstracts for microRNA-target interactions in miRTarBase.",  # CC BY-NC 4.0 - Non-commercial only
+    # "miRTarBase_MicroRNA_Target_Sites.parquet": "Binding sites of microRNAs on target genes from miRTarBase.",  # CC BY-NC 4.0 - Non-commercial only
+    "mousemine_m1_positional_geneset.parquet": "Positional gene sets from MouseMine.",
+    "mousemine_m2_curated_geneset.parquet": "Curated gene sets from MouseMine.",
+    "mousemine_m3_regulatory_target_geneset.parquet": "Regulatory target gene sets from MouseMine.",
+    "mousemine_m5_ontology_geneset.parquet": "Ontology-based gene sets from MouseMine.",
+    "mousemine_m8_celltype_signature_geneset.parquet": "Cell type signature gene sets from MouseMine.",
+    "mousemine_mh_hallmark_geneset.parquet": "Hallmark gene sets from MouseMine.",
+    # "msigdb_human_c1_positional_geneset.parquet": "Human positional gene sets from MSigDB.",  # Requires commercial license
+    # "msigdb_human_c2_curated_geneset.parquet": "Curated human gene sets from MSigDB.",  # Requires commercial license
+    # "msigdb_human_c3_regulatory_target_geneset.parquet": "Regulatory target gene sets from MSigDB.",  # Requires commercial license
+    # "msigdb_human_c3_subset_transcription_factor_targets_from_GTRD.parquet": "Transcription factor targets from GTRD/MSigDB.",  # Requires commercial license
+    # "msigdb_human_c4_computational_geneset.parquet": "Computationally derived gene sets from MSigDB.",  # Requires commercial license
+    # "msigdb_human_c5_ontology_geneset.parquet": "Ontology-based gene sets from MSigDB.",  # Requires commercial license
+    # "msigdb_human_c6_oncogenic_signature_geneset.parquet": "Oncogenic signatures from MSigDB.",  # Requires commercial license
+    # "msigdb_human_c7_immunologic_signature_geneset.parquet": "Immunologic signatures from MSigDB.",  # Requires commercial license
+    # "msigdb_human_c8_celltype_signature_geneset.parquet": "Cell type signatures from MSigDB.",  # Requires commercial license
+    # "msigdb_human_h_hallmark_geneset.parquet": "Hallmark gene sets from MSigDB.",  # Requires commercial license
+    # "omim.parquet": "Genetic disorders and associated genes from OMIM.",  # Requires commercial license
+    "proteinatlas.tsv": "Protein expression data from Human Protein Atlas.",
+    "proximity_label-ms.parquet": "Protein interactions via proximity labeling and mass spectrometry.",
+    "reconstituted_complex.parquet": "Protein complexes reconstituted in vitro.",
+    "sgRNA_KO_SP_mouse.txt": "sgRNA knockout data for mouse.",
+    "sgRNA_KO_SP_human.txt": "sgRNA knockout data for human.",
+    "synthetic_growth_defect.parquet": "Synthetic growth defects from genetic interactions.",
+    "synthetic_lethality.parquet": "Synthetic lethal interactions.",
+    "synthetic_rescue.parquet": "Genetic interactions rescuing phenotypes.",
+    "two-hybrid.parquet": "Protein-protein interactions detected by yeast two-hybrid assays.",
+    "variant_table.parquet": "Annotated genetic variants table.",
+    "Virus-Host_PPI_P-HIPSTER_2020.parquet": "Virus-host protein-protein interactions from P-HIPSTER.",
+    "txgnn_name_mapping.pkl": "Name mapping for TXGNN.",
+    "txgnn_prediction.pkl": "Prediction data for TXGNN.",
+}
+
+# Updated library_content as a dictionary with detailed descriptions
+library_content_dict = {
+    # === PYTHON PACKAGES ===
+    # Core Bioinformatics Libraries (Python)
+    "biopython": "[Python Package] A set of tools for biological computation including parsers for bioinformatics files, access to online services, and interfaces to common bioinformatics programs.",
+    "biom-format": "[Python Package] The Biological Observation Matrix (BIOM) format is designed for representing biological sample by observation contingency tables with associated metadata.",
+    "scanpy": "[Python Package] A scalable toolkit for analyzing single-cell gene expression data, specifically designed for large datasets using AnnData.",
+    "scikit-bio": "[Python Package] Data structures, algorithms, and educational resources for bioinformatics, including sequence analysis, phylogenetics, and ordination methods.",
+    "anndata": "[Python Package] A Python package for handling annotated data matrices in memory and on disk, primarily used for single-cell genomics data.",
+    "mudata": "[Python Package] A Python package for multimodal data storage and manipulation, extending AnnData to handle multiple modalities.",
+    "pyliftover": "[Python Package] A Python implementation of UCSC liftOver tool for converting genomic coordinates between genome assemblies.",
+    "biopandas": "[Python Package] A package that provides pandas DataFrames for working with molecular structures and biological data.",
+    "biotite": "[Python Package] A comprehensive library for computational molecular biology, providing tools for sequence analysis, structure analysis, and more.",
+    "lazyslide": "[Python Package] A Python framework that brings interoperable, reproducible whole slide image analysis, enabling seamless histopathology workflows from preprocessing to deep learning.",
+    # Genomics & Variant Analysis (Python)
+    "gget": "[Python Package] A toolkit for accessing genomic databases and retrieving sequences, annotations, and other genomic data.",
+    "lifelines": "[Python Package] A complete survival analysis library for fitting models, plotting, and statistical tests.",
+    # "scvi-tools": "[Python Package] A package for probabilistic modeling of single-cell omics data, including deep generative models.",
+    "gseapy": "[Python Package] A Python wrapper for Gene Set Enrichment Analysis (GSEA) and visualization.",
+    "scrublet": "[Python Package] A tool for detecting doublets in single-cell RNA-seq data.",
+    "cellxgene-census": "[Python Package] A tool for accessing and analyzing the CellxGene Census, a collection of single-cell datasets. To download a dataset, use the download_source_h5ad function with the dataset id as the argument (856c1b98-5727-49da-bf0f-151bdb8cb056, no .h5ad extension).",
+    "hyperopt": "[Python Package] A Python library for optimizing hyperparameters of machine learning algorithms.",
+    "scvelo": "[Python Package] A tool for RNA velocity analysis in single cells using dynamical models.",
+    "pysam": "[Python Package] A Python module for reading, manipulating and writing genomic data sets in SAM/BAM/VCF/BCF formats.",
+    "pyfaidx": "[Python Package] A Python package for efficient random access to FASTA files.",
+    "pyranges": "[Python Package] A Python package for interval manipulation with a pandas-like interface.",
+    "pybedtools": "[Python Package] A Python wrapper for Aaron Quinlan's BEDTools programs.",
+    # "panhumanpy": "A Python package for hierarchical, cross-tissue cell type annotation of human single-cell RNA-seq data",
+    # Structural Biology & Drug Discovery (Python)
+    "rdkit": "[Python Package] A collection of cheminformatics and machine learning tools for working with chemical structures and drug discovery.",
+    "deeppurpose": "[Python Package] A deep learning library for drug-target interaction prediction and virtual screening.",
+    "pyscreener": "[Python Package] A Python package for virtual screening of chemical compounds.",
+    "openbabel": "[Python Package] A chemical toolbox designed to speak the many languages of chemical data, supporting file format conversion and molecular modeling.",
+    "descriptastorus": "[Python Package] A library for computing molecular descriptors for machine learning applications in drug discovery.",
+    # "pymol": "[Python Package] A molecular visualization system for rendering and animating 3D molecular structures.",
+    "openmm": "[Python Package] A toolkit for molecular simulation using high-performance GPU computing.",
+    "pytdc": "[Python Package] A Python package for Therapeutics Data Commons, providing access to machine learning datasets for drug discovery.",
+    # Data Science & Statistical Analysis (Python)
+    "pandas": "[Python Package] A fast, powerful, and flexible data analysis and manipulation library for Python.",
+    "numpy": "[Python Package] The fundamental package for scientific computing with Python, providing support for arrays, matrices, and mathematical functions.",
+    "scipy": "[Python Package] A Python library for scientific and technical computing, including modules for optimization, linear algebra, integration, and statistics.",
+    "scikit-learn": "[Python Package] A machine learning library featuring various classification, regression, and clustering algorithms.",
+    "matplotlib": "[Python Package] A comprehensive library for creating static, animated, and interactive visualizations in Python.",
+    "seaborn": "[Python Package] A statistical data visualization library based on matplotlib with a high-level interface for drawing attractive statistical graphics.",
+    "statsmodels": "[Python Package] A Python module for statistical modeling and econometrics, including descriptive statistics and estimation of statistical models.",
+    "pymc3": "[Python Package] A Python package for Bayesian statistical modeling and probabilistic machine learning.",
+    # "pystan": "[Python Package] A Python interface to Stan, a platform for statistical modeling and high-performance statistical computation.",
+    "umap-learn": "[Python Package] Uniform Manifold Approximation and Projection, a dimension reduction technique.",
+    "faiss-cpu": "[Python Package] A library for efficient similarity search and clustering of dense vectors.",
+    "harmony-pytorch": "[Python Package] A PyTorch implementation of the Harmony algorithm for integrating single-cell data.",
+    # General Bioinformatics & Computational Utilities (Python)
+    "tiledb": "[Python Package] A powerful engine for storing and analyzing large-scale genomic data.",
+    "tiledbsoma": "[Python Package] A library for working with the SOMA (Stack of Matrices) format using TileDB.",
+    "h5py": "[Python Package] A Python interface to the HDF5 binary data format, allowing storage of large amounts of numerical data.",
+    "tqdm": "[Python Package] A fast, extensible progress bar for loops and CLI applications.",
+    "joblib": "[Python Package] A set of tools to provide lightweight pipelining in Python, including transparent disk-caching and parallel computing.",
+    "opencv-python": "[Python Package] OpenCV library for computer vision tasks, useful for image analysis in biological contexts.",
+    "PyPDF2": "[Python Package] A library for working with PDF files, useful for extracting text from scientific papers.",
+    "googlesearch-python": "[Python Package] A library for performing Google searches programmatically.",
+    "scikit-image": "[Python Package] A collection of algorithms for image processing in Python.",
+    "pymed": "[Python Package] A Python library for accessing PubMed articles.",
+    "arxiv": "[Python Package] A Python wrapper for the arXiv API, allowing access to scientific papers.",
+    "scholarly": "[Python Package] A module to retrieve author and publication information from Google Scholar.",
+    "cryosparc-tools": "[Python Package] Tools for working with cryoSPARC, a platform for cryo-EM data processing.",
+    "mageck": "[Python Package] Analysis of CRISPR screen data.",
+    "igraph": "[Python Package] Network analysis and visualization.",
+    "pyscenic": "[Python Package] Analysis of single-cell RNA-seq data and gene regulatory networks.",
+    "cooler": "[Python Package] Storage and analysis of Hi-C data.",
+    "trackpy": "[Python Package] Particle tracking in images and video.",
+    # "flowcytometrytools": "[Python Package] Analysis and visualization of flow cytometry data.",
+    "cellpose": "[Python Package] Cell segmentation in microscopy images.",
+    "viennarna": "[Python Package] RNA secondary structure prediction.",
+    "PyMassSpec": "[Python Package] Mass spectrometry data analysis.",
+    "python-libsbml": "[Python Package] Working with SBML files for computational biology.",
+    "cobra": "[Python Package] Constraint-based modeling of metabolic networks.",
+    "reportlab": "[Python Package] Creation of PDF documents.",
+    "flowkit": "[Python Package] Toolkit for processing flow cytometry data.",
+    "hmmlearn": "[Python Package] Hidden Markov model analysis.",
+    "msprime": "[Python Package] Simulation of genetic variation.",
+    "tskit": "[Python Package] Handling tree sequences and population genetics data.",
+    "cyvcf2": "[Python Package] Fast parsing of VCF files.",
+    "pykalman": "[Python Package] Kalman filter and smoother implementation.",
+    "fanc": "[Python Package] Analysis of chromatin conformation data.",
+    "loompy": "A Python implementation of the Loom file format for efficiently storing and working with large omics datasets.",
+    "pyBigWig": "A Python library for accessing bigWig and bigBed files for genome browser track data.",
+    "pymzml": "A Python module for high-throughput bioinformatics analysis of mass spectrometry data.",
+    "optlang": "A Python package for modeling optimization problems symbolically.",
+    "FlowIO": "A Python package for reading and writing flow cytometry data files.",
+    "FlowUtils": "Utilities for processing and analyzing flow cytometry data.",
+    "arboreto": "A Python package for inferring gene regulatory networks from single-cell RNA-seq data.",
+    "pdbfixer": "A Python package for fixing problems in PDB files in preparation for molecular simulations.",
+    # === R PACKAGES ===
+    # Core R Packages for Data Analysis
+    "ggplot2": "[R Package] A system for declaratively creating graphics, based on The Grammar of Graphics. Use with subprocess.run(['Rscript', '-e', 'library(ggplot2); ...']).",
+    "dplyr": "[R Package] A grammar of data manipulation, providing a consistent set of verbs that help you solve the most common data manipulation challenges. Use with subprocess.",
+    "tidyr": "[R Package] A package that helps you create tidy data, where each column is a variable, each row is an observation, and each cell is a single value. Use with subprocess.",
+    "readr": "[R Package] A fast and friendly way to read rectangular data like CSV, TSV, and FWF. Use with subprocess.run(['Rscript', '-e', 'library(readr); ...']).",
+    "stringr": "[R Package] A cohesive set of functions designed to make working with strings as easy as possible. Use with subprocess calls.",
+    "Matrix": "[R Package] A package that provides classes and methods for dense and sparse matrices. Required for Seurat. Use with subprocess calls.",
+    # "Rcpp": "[R Package] Seamless R and C++ Integration, allowing R functions to call compiled C++ code. Use with subprocess calls.",
+    # "devtools": "[R Package] Tools to make developing R packages easier, including functions to install packages from GitHub. Use with subprocess calls.",
+    # "remotes": "[R Package] Install R packages from GitHub, GitLab, Bitbucket, or other remote repositories. Use with subprocess calls.",
+    # Bioinformatics R Packages
+    "DESeq2": "[R Package] Differential gene expression analysis based on the negative binomial distribution. Use with subprocess.run(['Rscript', '-e', 'library(DESeq2); ...']).",
+    "clusterProfiler": "[R Package] A package for statistical analysis and visualization of functional profiles for genes and gene clusters. Use with subprocess calls.",
+    # "DADA2": "[R Package] A package for modeling and correcting Illumina-sequenced amplicon errors. Use with subprocess calls.",
+    # "xcms": "[R Package] A package for processing and visualization of LC-MS and GC-MS data. Use with subprocess calls.",
+    # "FlowCore": "[R Package] Basic infrastructure for flow cytometry data. Use with subprocess calls.",
+    "edgeR": "[R Package] Empirical Analysis of Digital Gene Expression Data in R, for differential expression analysis. Use with subprocess calls.",
+    "limma": "[R Package] Linear Models for Microarray Data, for differential expression analysis. Use with subprocess calls.",
+    "harmony": "[R Package] A method for integrating and analyzing single-cell data across datasets. Use with subprocess calls.",
+    "WGCNA": "[R Package] Weighted Correlation Network Analysis for studying biological networks. Use with subprocess calls.",
+    # === CLI TOOLS ===
+    # Sequence Analysis Tools
+    "samtools": "[CLI Tool] A suite of programs for interacting with high-throughput sequencing data. Use with subprocess.run(['samtools', ...]).",
+    "bowtie2": "[CLI Tool] An ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences. Use with subprocess.run(['bowtie2', ...]).",
+    "bwa": "[CLI Tool] Burrows-Wheeler Aligner for mapping low-divergent sequences against a large reference genome. Use with subprocess.run(['bwa', ...]).",
+    "bedtools": "[CLI Tool] A powerful toolset for genome arithmetic, allowing operations like intersect, merge, count, and complement on genomic features. Use with subprocess.run(['bedtools', ...]).",
+    "macs2": "[CLI Tool] Model-based Analysis of ChIP-Seq data, a tool for identifying transcript factor binding sites.",
+    # Quality Control and Processing Tools
+    "fastqc": "[CLI Tool] A quality control tool for high throughput sequence data. Use with subprocess.run(['fastqc', ...]).",
+    "trimmomatic": "[CLI Tool] A flexible read trimming tool for Illumina NGS data. Use with subprocess.run(['trimmomatic', ...]).",
+    # Multiple Sequence Alignment and Phylogenetics
+    "mafft": "[CLI Tool] A multiple sequence alignment program for unix-like operating systems. Use with subprocess.run(['mafft', ...]).",
+    "Homer": "[CLI Tool] Motif discovery and next-gen sequencing analysis.",
+    "FastTree": "[CLI Tool] Phylogenetic trees from sequence alignments.",
+    "muscle": "[CLI Tool] Multiple sequence alignment tool.",
+    # Genetic Analysis Tools
+    "plink": "[CLI Tool] A comprehensive toolkit for genome association studies that can perform a range of large-scale analyses in a computationally efficient manner. Use with subprocess.run(['plink', ...]).",
+    "plink2": "[CLI Tool] A comprehensive toolkit for genome association studies that can perform a range of large-scale analyses in a computationally efficient manner. Use with subprocess.run(['plink2', ...]).",
+    "gcta64": "[CLI Tool] Genome-wide Complex Trait Analysis (GCTA) tool for estimating the proportion of phenotypic variance explained by genome-wide SNPs and analyzing genetic relationships. Use with subprocess.run(['gcta64', ...]).",
+    "iqtree2": "[CLI Tool] An efficient phylogenetic software for maximum likelihood analysis with built-in model selection and ultrafast bootstrap. Use with subprocess.run(['iqtree2', ...]).",
+    "ADFR": "AutoDock for Receptors suite for molecular docking and virtual screening. ",
+    "diamond": "A sequence aligner for protein and translated DNA searches, designed for high performance analysis of big sequence data. ",
+    "fcsparser": "A command-line tool for parsing and analyzing flow cytometry standard (FCS) files. ",
+    "plannotate": "[CLI Tool] A tool for annotating plasmid sequences with common features. ",
+    "vina": "[CLI Tool] An open-source program for molecular docking and virtual screening, known for its speed and accuracy improvements over AutoDock 4.",
+    "autosite": "[CLI Tool] A binding site detection tool used to identify potential ligand binding pockets on protein structures for molecular docking.",
+}

biomni/llm.py

@@ -0,0 +1,275 @@
+import os
+from typing import TYPE_CHECKING, Literal, Optional
+
+from langchain_core.language_models.chat_models import BaseChatModel
+
+if TYPE_CHECKING:
+    from biomni.config import BiomniConfig
+
+SourceType = Literal["OpenAI", "AzureOpenAI", "Anthropic", "Ollama", "Gemini", "Bedrock", "Groq", "Custom"]
+ALLOWED_SOURCES: set[str] = set(SourceType.__args__)
+
+
+def get_llm(
+    model: str | None = None,
+    temperature: float | None = None,
+    stop_sequences: list[str] | None = None,
+    source: SourceType | None = None,
+    base_url: str | None = None,
+    api_key: str | None = None,
+    config: Optional["BiomniConfig"] = None,
+) -> BaseChatModel:
+    """
+    Get a language model instance based on the specified model name and source.
+    This function supports models from OpenAI, Azure OpenAI, Anthropic, Ollama, Gemini, Bedrock, and custom model serving.
+    Args:
+        model (str): The model name to use
+        temperature (float): Temperature setting for generation
+        stop_sequences (list): Sequences that will stop generation
+        source (str): Source provider: "OpenAI", "AzureOpenAI", "Anthropic", "Ollama", "Gemini", "Bedrock", or "Custom"
+                      If None, will attempt to auto-detect from model name
+        base_url (str): The base URL for custom model serving (e.g., "http://localhost:8000/v1"), default is None
+        api_key (str): The API key for the custom llm
+        config (BiomniConfig): Optional configuration object. If provided, unspecified parameters will use config values
+    """
+    # Use config values for any unspecified parameters
+    if config is not None:
+        if model is None:
+            model = config.llm_model
+        if temperature is None:
+            temperature = config.temperature
+        if source is None:
+            source = config.source
+        if base_url is None:
+            base_url = config.base_url
+        if api_key is None:
+            api_key = config.api_key or "EMPTY"
+
+    # Use defaults if still not specified
+    if model is None:
+        model = "claude-3-5-sonnet-20241022"
+    if temperature is None:
+        temperature = 0.7
+    if api_key is None:
+        api_key = "EMPTY"
+    # Auto-detect source from model name if not specified
+    if source is None:
+        env_source = os.getenv("LLM_SOURCE")
+        if env_source in ALLOWED_SOURCES:
+            source = env_source
+        else:
+            if model[:7] == "claude-":
+                source = "Anthropic"
+            elif model[:7] == "gpt-oss":
+                source = "Ollama"
+            elif model[:4] == "gpt-":
+                source = "OpenAI"
+            elif model.startswith("azure-"):
+                source = "AzureOpenAI"
+            elif model[:7] == "gemini-":
+                source = "Gemini"
+            elif "groq" in model.lower():
+                source = "Groq"
+            elif base_url is not None:
+                source = "Custom"
+            elif "/" in model or any(
+                name in model.lower()
+                for name in [
+                    "llama",
+                    "mistral",
+                    "qwen",
+                    "gemma",
+                    "phi",
+                    "dolphin",
+                    "orca",
+                    "vicuna",
+                    "deepseek",
+                ]
+            ):
+                source = "Ollama"
+            elif model.startswith(
+                ("anthropic.claude-", "amazon.titan-", "meta.llama-", "mistral.", "cohere.", "ai21.", "us.")
+            ):
+                source = "Bedrock"
+            else:
+                raise ValueError("Unable to determine model source. Please specify 'source' parameter.")
+
+    # Create appropriate model based on source
+    if source == "OpenAI":
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-openai package is required for OpenAI models. Install with: pip install langchain-openai"
+            )
+        # Newer OpenAI models (e.g., gpt-5-*) require the Responses API and may reject
+        # legacy Chat Completions parameters like `stop`. Force Responses API when
+        # using gpt-5 models to avoid 400 errors such as: "Unsupported parameter: 'stop'".
+        use_responses = model.startswith("gpt-5")
+
+        if use_responses:
+            # Define a minimal subclass that drops the `stop` field when using the
+            # Responses API, since certain models (gpt-5-*) reject it entirely.
+            class _ChatOpenAIResponsesNoStop(ChatOpenAI):
+                def _get_request_payload(self, input_, *, stop=None, **kwargs):  # type: ignore[override]
+                    payload = super()._get_request_payload(input_, stop=stop, **kwargs)
+                    try:
+                        # If this call will use the Responses API, drop `stop` to avoid 400s.
+                        if hasattr(self, "_use_responses_api") and self._use_responses_api(payload):  # type: ignore[attr-defined]
+                            payload.pop("stop", None)
+                            # Also drop temperature for gpt-5 models as they only support default value
+                            payload.pop("temperature", None)
+                    except Exception:
+                        # Be conservative: if anything goes wrong, still remove `stop` and `temperature`.
+                        payload.pop("stop", None)
+                        payload.pop("temperature", None)
+                    return payload
+
+            return _ChatOpenAIResponsesNoStop(
+                model=model,
+                temperature=1,  # Set to default value for gpt-5, will be removed in payload
+                stop_sequences=stop_sequences,
+                use_responses_api=True,
+                output_version="v0",
+            )
+        else:
+            return ChatOpenAI(
+                model=model,
+                temperature=temperature,
+                stop_sequences=stop_sequences,
+            )
+
+    elif source == "AzureOpenAI":
+        try:
+            from langchain_openai import AzureChatOpenAI
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-openai package is required for Azure OpenAI models. Install with: pip install langchain-openai"
+            )
+        API_VERSION = "2024-12-01-preview"
+        model = model.replace("azure-", "")
+        return AzureChatOpenAI(
+            openai_api_key=os.getenv("OPENAI_API_KEY"),
+            azure_endpoint=os.getenv("OPENAI_ENDPOINT"),
+            azure_deployment=model,
+            openai_api_version=API_VERSION,
+            temperature=temperature,
+        )
+
+    elif source == "Anthropic":
+        try:
+            from langchain_anthropic import ChatAnthropic
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-anthropic package is required for Anthropic models. Install with: pip install langchain-anthropic"
+            )
+
+        # Ensure ANTHROPIC_API_KEY is loaded from bash_profile if not in environment
+        if not os.environ.get("ANTHROPIC_API_KEY"):
+            try:
+                import subprocess
+
+                result = subprocess.run(
+                    ["bash", "-c", "source ~/.bash_profile 2>/dev/null && echo $ANTHROPIC_API_KEY"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+                if result.stdout.strip():
+                    os.environ["ANTHROPIC_API_KEY"] = result.stdout.strip()
+                    print("✓ Loaded ANTHROPIC_API_KEY from ~/.bash_profile")
+            except Exception as e:
+                print(f"Note: Could not load ANTHROPIC_API_KEY from bash_profile: {e}")
+
+        return ChatAnthropic(
+            model=model,
+            temperature=temperature,
+            max_tokens=8192,
+            stop_sequences=stop_sequences,
+        )
+
+    elif source == "Gemini":
+        # If you want to use ChatGoogleGenerativeAI, you need to pass the stop sequences upon invoking the model.
+        # return ChatGoogleGenerativeAI(
+        #     model=model,
+        #     temperature=temperature,
+        #     google_api_key=api_key,
+        # )
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-openai package is required for Gemini models. Install with: pip install langchain-openai"
+            )
+        return ChatOpenAI(
+            model=model,
+            temperature=temperature,
+            api_key=os.getenv("GEMINI_API_KEY"),
+            base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+            stop_sequences=stop_sequences,
+        )
+
+    elif source == "Groq":
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-openai package is required for Groq models. Install with: pip install langchain-openai"
+            )
+        return ChatOpenAI(
+            model=model,
+            temperature=temperature,
+            api_key=os.getenv("GROQ_API_KEY"),
+            base_url="https://api.groq.com/openai/v1",
+            stop_sequences=stop_sequences,
+        )
+
+    elif source == "Ollama":
+        try:
+            from langchain_ollama import ChatOllama
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-ollama package is required for Ollama models. Install with: pip install langchain-ollama"
+            )
+        return ChatOllama(
+            model=model,
+            temperature=temperature,
+        )
+
+    elif source == "Bedrock":
+        try:
+            from langchain_aws import ChatBedrock
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-aws package is required for Bedrock models. Install with: pip install langchain-aws"
+            )
+        return ChatBedrock(
+            model=model,
+            temperature=temperature,
+            stop_sequences=stop_sequences,
+            region_name=os.getenv("AWS_REGION", "us-east-1"),
+        )
+
+    elif source == "Custom":
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-openai package is required for custom models. Install with: pip install langchain-openai"
+            )
+        # Custom LLM serving such as SGLang. Must expose an openai compatible API.
+        assert base_url is not None, "base_url must be provided for customly served LLMs"
+        llm = ChatOpenAI(
+            model=model,
+            temperature=temperature,
+            max_tokens=8192,
+            stop_sequences=stop_sequences,
+            base_url=base_url,
+            api_key=api_key,
+        )
+        return llm
+
+    else:
+        raise ValueError(
+            f"Invalid source: {source}. Valid options are 'OpenAI', 'AzureOpenAI', 'Anthropic', 'Gemini', 'Groq', 'Bedrock', or 'Ollama'"
+        )

biomni/utils.py

@@ -0,0 +1,2366 @@
+import ast
+import enum
+import importlib
+import json
+import os
+import pickle
+import subprocess
+import tempfile
+import traceback
+import zipfile
+from typing import Any, ClassVar
+from urllib.parse import urljoin
+
+import pandas as pd
+import requests
+import tqdm  # Add tqdm for progress bar
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages.base import get_msg_title_repr
+from langchain_core.tools import StructuredTool
+from langchain_core.utils.interactive_env import is_interactive_env
+from pydantic import BaseModel, Field, ValidationError
+
+
+# Add these new functions for running R code and CLI commands
+def run_r_code(code: str) -> str:
+    """Run R code using subprocess.
+
+    Args:
+        code: R code to run
+
+    Returns:
+        Output of the R code
+
+    """
+    try:
+        # Create a temporary file to store the R code
+        with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as f:
+            f.write(code)
+            temp_file = f.name
+
+        # Run the R code using Rscript
+        result = subprocess.run(["Rscript", temp_file], capture_output=True, text=True, check=False)
+
+        # Clean up the temporary file
+        os.unlink(temp_file)
+
+        # Return the output
+        if result.returncode != 0:
+            return f"Error running R code:\n{result.stderr}"
+        else:
+            return result.stdout
+    except Exception as e:
+        return f"Error running R code: {str(e)}"
+
+
+def run_bash_script(script: str) -> str:
+    """Run a Bash script using subprocess.
+
+    Args:
+        script: Bash script to run
+
+    Returns:
+        Output of the Bash script
+
+    Example:
+        This is how to use the function
+
+        .. code-block:: python
+
+            # Example of a complex Bash script
+            script = '''
+            #!/bin/bash
+
+            # Define variables
+            DATA_DIR="/path/to/data"
+            OUTPUT_FILE="results.txt"
+
+            # Create output directory if it doesn't exist
+            mkdir -p $(dirname $OUTPUT_FILE)
+
+            # Loop through files
+            for file in $DATA_DIR/*.txt; do
+                echo "Processing $file..."
+                # Count lines in each file
+                line_count=$(wc -l < $file)
+                echo "$file: $line_count lines" >> $OUTPUT_FILE
+            done
+
+            echo "Processing complete. Results saved to $OUTPUT_FILE"
+            '''
+            result = run_bash_script(script)
+            print(result)
+
+    """
+    try:
+        # Trim any leading/trailing whitespace
+        script = script.strip()
+
+        # If the script is empty, return an error
+        if not script:
+            return "Error: Empty script"
+
+        # Create a temporary file to store the Bash script
+        with tempfile.NamedTemporaryFile(suffix=".sh", mode="w", delete=False) as f:
+            # Add shebang if not present
+            if not script.startswith("#!/"):
+                f.write("#!/bin/bash\n")
+            # Add set -e to exit on error
+            if "set -e" not in script:
+                f.write("set -e\n")
+            f.write(script)
+            temp_file = f.name
+
+        # Make the script executable
+        os.chmod(temp_file, 0o755)
+
+        # Get current environment variables and working directory
+        env = os.environ.copy()
+        cwd = os.getcwd()
+
+        # Run the Bash script with the current environment and working directory
+        result = subprocess.run(
+            [temp_file],
+            shell=True,
+            capture_output=True,
+            text=True,
+            check=False,
+            env=env,
+            cwd=cwd,
+        )
+
+        # Clean up the temporary file
+        os.unlink(temp_file)
+
+        # Return the output
+        if result.returncode != 0:
+            traceback.print_stack()
+            print(result)
+            return f"Error running Bash script (exit code {result.returncode}):\n{result.stderr}"
+        else:
+            return result.stdout
+    except Exception as e:
+        traceback.print_exc()
+        return f"Error running Bash script: {str(e)}"
+
+
+# Keep the run_cli_command for backward compatibility
+def run_cli_command(command: str) -> str:
+    """Run a CLI command using subprocess.
+
+    Args:
+        command: CLI command to run
+
+    Returns:
+        Output of the CLI command
+
+    """
+    try:
+        # Trim any leading/trailing whitespace
+        command = command.strip()
+
+        # If the command is empty, return an error
+        if not command:
+            return "Error: Empty command"
+
+        # Split the command into a list of arguments, handling quoted arguments correctly
+        import shlex
+
+        args = shlex.split(command)
+
+        # Run the command
+        result = subprocess.run(args, capture_output=True, text=True, check=False)
+
+        # Return the output
+        if result.returncode != 0:
+            return f"Error running command '{command}':\n{result.stderr}"
+        else:
+            return result.stdout
+    except Exception as e:
+        return f"Error running command '{command}': {str(e)}"
+
+
+def run_with_timeout(func, args=None, kwargs=None, timeout=600):
+    """Run a function with a timeout using threading instead of multiprocessing.
+    This allows variables to persist in the global namespace between function calls.
+    Returns the function result or a timeout error message.
+    """
+    if args is None:
+        args = []
+    if kwargs is None:
+        kwargs = {}
+
+    import ctypes
+    import queue
+    import threading
+
+    result_queue = queue.Queue()
+
+    def thread_func(func, args, kwargs, result_queue):
+        """Function to run in a separate thread."""
+        try:
+            result = func(*args, **kwargs)
+            result_queue.put(("success", result))
+        except Exception as e:
+            result_queue.put(("error", str(e)))
+
+    # Start a separate thread
+    thread = threading.Thread(target=thread_func, args=(func, args, kwargs, result_queue))
+    thread.daemon = True  # Set as daemon so it will be killed when main thread exits
+    thread.start()
+
+    # Wait for the specified timeout
+    thread.join(timeout)
+
+    # Check if the thread is still running after timeout
+    if thread.is_alive():
+        print(f"TIMEOUT: Code execution timed out after {timeout} seconds")
+
+        # Unfortunately, there's no clean way to force terminate a thread in Python
+        # The recommended approach is to use daemon threads and let them be killed when main thread exits
+        # Here, we'll try to raise an exception in the thread to make it stop
+        try:
+            # Get thread ID and try to terminate it
+            thread_id = thread.ident
+            if thread_id:
+                # This is a bit dangerous and not 100% reliable
+                # It attempts to raise a SystemExit exception in the thread
+                res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(thread_id), ctypes.py_object(SystemExit))
+                if res > 1:
+                    # Oops, we raised too many exceptions
+                    ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(thread_id), None)
+        except Exception as e:
+            print(f"Error trying to terminate thread: {e}")
+
+        return f"ERROR: Code execution timed out after {timeout} seconds. Please try with simpler inputs or break your task into smaller steps."
+
+    # Get the result from the queue if available
+    try:
+        status, result = result_queue.get(block=False)
+        return result if status == "success" else f"Error in execution: {result}"
+    except queue.Empty:
+        return "Error: Execution completed but no result was returned"
+
+
+class api_schema(BaseModel):
+    """api schema specification."""
+
+    api_schema: str | None = Field(description="The api schema as a dictionary")
+
+
+def function_to_api_schema(function_string, llm):
+    prompt = """
+    Based on a code snippet and help me write an API docstring in the format like this:
+
+    {{'name': 'get_gene_set_enrichment',
+    'description': 'Given a list of genes, identify a pathway that is enriched for this gene set. Return a list of pathway name, p-value, z-scores.',
+    'required_parameters': [{{'name': 'genes',
+    'type': 'List[str]',
+    'description': 'List of g`ene symbols to analyze',
+    'default': None}}],
+    'optional_parameters': [{{'name': 'top_k',
+    'type': 'int',
+    'description': 'Top K pathways to return',
+    'default': 10}},  {{'name': 'database',
+    'type': 'str',
+    'description': 'Name of the database to use for enrichment analysis',
+    'default': "gene_ontology"}}]}}
+
+    Strictly follow the input from the function - don't create fake optional parameters.
+    For variable without default values, set them as None, not null.
+    For variable with boolean values, use capitalized True or False, not true or false.
+    Do not add any return type in the docstring.
+    Be as clear and succint as possible for the descriptions. Please do not make it overly verbose.
+    Here is the code snippet:
+    {code}
+    """
+    llm = llm.with_structured_output(api_schema)
+
+    for _ in range(7):
+        try:
+            api = llm.invoke(prompt.format(code=function_string)).dict()["api_schema"]
+            return ast.literal_eval(api)  # -> prefer "default": None
+            # return json.loads(api) # -> prefer "default": null
+        except Exception as e:
+            print("API string:", api)
+            print("Error parsing the API string:", e)
+            continue
+
+    return "Error: Could not parse the API schema"
+    # return
+
+
+def get_all_functions_from_file(file_path):
+    with open(file_path) as file:
+        file_content = file.read()
+
+    # Parse the file content into an AST (Abstract Syntax Tree)
+    tree = ast.parse(file_content)
+
+    # List to hold the top-level functions as strings
+    functions = []
+
+    # Walk through the AST nodes
+    for node in tree.body:  # Only consider top-level nodes in the body
+        if isinstance(node, ast.FunctionDef):  # Check if the node is a function definition
+            # Skip if function name starts with underscore
+            if node.name.startswith("_"):
+                continue
+
+            start_line = node.lineno - 1  # Get the starting line of the function
+            end_line = node.end_lineno  # Get the ending line of the function (only available in Python 3.8+)
+            func_code = file_content.splitlines()[start_line:end_line]
+            functions.append("\n".join(func_code))  # Join lines of the function and add to the list
+
+    return functions
+
+
+def write_python_code(request: str):
+    from langchain_anthropic import ChatAnthropic
+    from langchain_core.output_parsers import StrOutputParser
+    from langchain_core.prompts import ChatPromptTemplate
+
+    model = ChatAnthropic(model="claude-3-5-sonnet-20240620")
+    template = """Write some python code to solve the user's problem.
+
+    Return only python code in Markdown format, e.g.:
+
+    ```python
+    ....
+    ```"""
+    prompt = ChatPromptTemplate.from_messages([("system", template), ("human", "{input}")])
+
+    def _sanitize_output(text: str):
+        _, after = text.split("```python")
+        return after.split("```")[0]
+
+    chain = prompt | model | StrOutputParser() | _sanitize_output
+    return chain.invoke({"input": "write a code that " + request})
+
+
+def execute_graphql_query(
+    query: str,
+    variables: dict,
+    api_address: str = "https://api.genetics.opentargets.org/graphql",
+) -> dict:
+    """Executes a GraphQL query with variables and returns the data as a dictionary."""
+    headers = {"Content-Type": "application/json"}
+    response = requests.post(api_address, json={"query": query, "variables": variables}, headers=headers)
+    if response.status_code == 200:
+        return response.json()
+    else:
+        print(response.text)
+        response.raise_for_status()
+
+
+def get_tool_decorated_functions(relative_path):
+    import ast
+    import importlib.util
+    import os
+
+    # Get the directory of the current file (__init__.py)
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Construct the absolute path from the relative path
+    file_path = os.path.join(current_dir, relative_path)
+
+    with open(file_path) as file:
+        tree = ast.parse(file.read(), filename=file_path)
+
+    tool_function_names = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            for decorator in node.decorator_list:
+                if (
+                    isinstance(decorator, ast.Name)
+                    and decorator.id == "tool"
+                    or (
+                        isinstance(decorator, ast.Call)
+                        and isinstance(decorator.func, ast.Name)
+                        and decorator.func.id == "tool"
+                    )
+                ):
+                    tool_function_names.append(node.name)
+
+    # Calculate the module name from the relative path
+    package_path = os.path.relpath(file_path, start=current_dir)
+    module_name = package_path.replace(os.path.sep, ".").rsplit(".", 1)[0]
+
+    # Import the module and get the function objects
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    tool_functions = [getattr(module, name) for name in tool_function_names]
+
+    return tool_functions
+
+
+def process_bio_retrieval_ducoment(documents_df):
+    ir_corpus = {}
+    corpus2tool = {}
+    for row in documents_df.itertuples():
+        doc = row.document_content
+        ir_corpus[row.docid] = (
+            (doc.get("name", "") or "")
+            + ", "
+            + (doc.get("description", "") or "")
+            + ", "
+            + (doc.get("url", "") or "")
+            + ", "
+            + ", required_params: "
+            + json.dumps(doc.get("required_parameters", ""))
+            + ", optional_params: "
+            + json.dumps(doc.get("optional_parameters", ""))
+        )
+
+        corpus2tool[
+            (doc.get("name", "") or "")
+            + ", "
+            + (doc.get("description", "") or "")
+            + ", "
+            + (doc.get("url", "") or "")
+            + ", "
+            + ", required_params: "
+            + json.dumps(doc.get("required_parameters", ""))
+            + ", optional_params: "
+            + json.dumps(doc.get("optional_parameters", ""))
+        ] = doc["name"]
+    return ir_corpus, corpus2tool
+
+
+def load_pickle(file):
+    import pickle
+
+    with open(file, "rb") as f:
+        return pickle.load(f)
+
+
+def pretty_print(message, printout=True):
+    if isinstance(message, tuple):
+        title = message
+    elif isinstance(message.content, list):
+        title = get_msg_title_repr(message.type.title().upper() + " Message", bold=is_interactive_env())
+        if message.name is not None:
+            title += f"\nName: {message.name}"
+
+        for i in message.content:
+            if i["type"] == "text":
+                title += f"\n{i['text']}\n"
+            elif i["type"] == "tool_use":
+                title += f"\nTool: {i['name']}"
+                title += f"\nInput: {i['input']}"
+        if printout:
+            print(f"{title}")
+    else:
+        title = get_msg_title_repr(message.type.title() + " Message", bold=is_interactive_env())
+        if message.name is not None:
+            title += f"\nName: {message.name}"
+        title += f"\n\n{message.content}"
+        if printout:
+            print(f"{title}")
+    return title
+
+
+class CustomBaseModel(BaseModel):
+    api_schema: ClassVar[dict] = None  # Class variable to store api_schema
+
+    # Add model_config with arbitrary_types_allowed=True
+    model_config = {"arbitrary_types_allowed": True}
+
+    @classmethod
+    def set_api_schema(cls, schema: dict):
+        cls.api_schema = schema
+
+    @classmethod
+    def model_validate(cls, obj):
+        try:
+            return super().model_validate(obj)
+        except (ValidationError, AttributeError) as e:
+            if not cls.api_schema:
+                raise e  # If no api_schema is set, raise original error
+
+            error_msg = "Required Parameters:\n"
+            for param in cls.api_schema["required_parameters"]:
+                error_msg += f"- {param['name']} ({param['type']}): {param['description']}\n"
+
+            error_msg += "\nErrors:\n"
+            for err in e.errors():
+                field = err["loc"][0] if err["loc"] else "input"
+                error_msg += f"- {field}: {err['msg']}\n"
+
+            if not obj:
+                error_msg += "\nNo input provided"
+            else:
+                error_msg += "\nProvided Input:\n"
+                for key, value in obj.items():
+                    error_msg += f"- {key}: {value}\n"
+
+                missing_params = {param["name"] for param in cls.api_schema["required_parameters"]} - set(obj.keys())
+                if missing_params:
+                    error_msg += "\nMissing Parameters:\n"
+                    for param in missing_params:
+                        error_msg += f"- {param}\n"
+
+            # # Create proper validation error structure
+            raise ValidationError.from_exception_data(
+                title="Validation Error",
+                line_errors=[
+                    {
+                        "type": "value_error",
+                        "loc": ("input",),
+                        "input": obj,
+                        "ctx": {
+                            "error": error_msg,
+                        },
+                    }
+                ],
+            ) from None
+
+
+def safe_execute_decorator(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            return str(e)
+
+    return wrapper
+
+
+def api_schema_to_langchain_tool(api_schema, mode="generated_tool", module_name=None):
+    if mode == "generated_tool":
+        module = importlib.import_module("biomni.tool.generated_tool." + api_schema["tool_name"] + ".api")
+    elif mode == "custom_tool":
+        module = importlib.import_module(module_name)
+
+    api_function = getattr(module, api_schema["name"])
+    api_function = safe_execute_decorator(api_function)
+
+    # Define a mapping from string type names to actual Python type objects
+    type_mapping = {
+        "string": str,
+        "integer": int,
+        "boolean": bool,
+        "pandas": pd.DataFrame,  # Use the imported pandas.DataFrame directly
+        "str": str,
+        "int": int,
+        "bool": bool,
+        "List[str]": list[str],
+        "List[int]": list[int],
+        "Dict": dict,
+        "Any": Any,
+    }
+
+    # Create the fields and annotations
+    annotations = {}
+    for param in api_schema["required_parameters"]:
+        param_type = param["type"]
+        if param_type in type_mapping:
+            annotations[param["name"]] = type_mapping[param_type]
+        else:
+            # For types not in the mapping, try a safer approach than direct eval
+            try:
+                annotations[param["name"]] = eval(param_type)
+            except (NameError, SyntaxError):
+                # Default to Any for unknown types
+                annotations[param["name"]] = Any
+
+    fields = {param["name"]: Field(description=param["description"]) for param in api_schema["required_parameters"]}
+
+    # Create the ApiInput class dynamically
+    ApiInput = type("Input", (CustomBaseModel,), {"__annotations__": annotations, **fields})
+    # Set the api_schema
+    ApiInput.set_api_schema(api_schema)
+
+    # Create the StructuredTool
+    api_tool = StructuredTool.from_function(
+        func=api_function,
+        name=api_schema["name"],
+        description=api_schema["description"],
+        args_schema=ApiInput,
+        return_direct=True,
+    )
+
+    return api_tool
+
+
+class ID(enum.Enum):
+    ENTREZ = "Entrez"
+    ENSEMBL = "Ensembl without version"  # e.g. ENSG00000123374
+    ENSEMBL_W_VERSION = "Ensembl with version"  # e.g. ENSG00000123374.10 (needed for GTEx)
+
+
+def get_gene_id(gene_symbol: str, id_type: ID):
+    """Get the ID for a gene symbol. If no match found, returns None."""
+    if id_type == ID.ENTREZ:
+        return _get_gene_id_entrez(gene_symbol)
+    elif id_type == ID.ENSEMBL:
+        return _get_gene_id_ensembl(gene_symbol)
+    elif id_type == ID.ENSEMBL_W_VERSION:
+        return _get_gene_id_ensembl_with_version(gene_symbol)
+    else:
+        raise ValueError(f"ID type {id_type} not supported")
+
+
+def _get_gene_id_entrez(gene_symbol: str):
+    """Get the Entrez ID for a gene symbol. If no match found, returns None
+    e.g. 1017 (CDK2).
+    """
+    api_call = f"https://mygene.info/v3/query?species=human&q=symbol:{gene_symbol}"
+    response = requests.get(api_call)
+    response_json = response.json()
+
+    if len(response_json["hits"]) == 0:
+        return None
+    else:
+        return response_json["hits"][0]["entrezgene"]
+
+
+def _get_gene_id_ensembl(gene_symbol):
+    """Get the Ensembl ID for a gene symbol. If no match found, returns None
+    e.g. ENSG00000123374.
+    """
+    api_call = f"https://mygene.info/v3/query?species=human&fields=ensembl&q=symbol:{gene_symbol}"
+    response = requests.get(api_call)
+    response_json = response.json()
+
+    if len(response_json["hits"]) == 0:
+        return None
+    else:
+        ensembl = response_json["hits"][0]["ensembl"]
+        if isinstance(ensembl, list):
+            return ensembl[0][
+                "gene"
+            ]  # Sometimes returns a list, for example RNH1 (first elem is on chr11, second is on scaffold_hschr11)
+        else:
+            return ensembl["gene"]
+
+
+def _get_gene_id_ensembl_with_version(gene_symbol):
+    """Get the Ensembl ID for a gene symbol. If no match found, returns None
+    e.g. ENSG00000123374.10.
+    """
+    api_base = "https://gtexportal.org/api/v2/reference/gene"
+    params = {"geneId": gene_symbol}
+    response_json = requests.get(api_base, params=params).json()
+
+    if len(response_json["data"]) == 0:
+        return None
+    else:
+        return response_json["data"][0]["gencodeId"]
+
+
+def save_pkl(f, filename):
+    with open(filename, "wb") as file:
+        pickle.dump(f, file)
+
+
+def load_pkl(filename):
+    with open(filename, "rb") as file:
+        return pickle.load(file)
+
+
+_TEXT_COLOR_MAPPING = {
+    "blue": "36;1",
+    "yellow": "33;1",
+    "pink": "38;5;200",
+    "green": "32;1",
+    "red": "31;1",
+}
+
+
+def color_print(text, color="blue"):
+    color_str = _TEXT_COLOR_MAPPING[color]
+    print(f"\u001b[{color_str}m\033[1;3m{text}\u001b[0m")
+
+
+class PromptLogger(BaseCallbackHandler):
+    def on_chat_model_start(self, serialized, messages, **kwargs):
+        for message in messages[0]:
+            color_print(message.pretty_repr(), color="green")
+
+
+class NodeLogger(BaseCallbackHandler):
+    def on_llm_end(self, response, **kwargs):  # response of type LLMResult
+        for generations in response.generations:  # response.generations of type List[List[Generations]] becuase "each input could have multiple candidate generations"
+            for generation in generations:
+                generated_text = generation.message.content
+                # token_usage = generation.message.response_metadata["token_usage"]
+                color_print(generated_text, color="yellow")
+
+    def on_agent_action(self, action, **kwargs):
+        color_print(action.log, color="pink")
+
+    def on_agent_finish(self, finish, **kwargs):
+        color_print(finish, color="red")
+
+    def on_tool_start(self, serialized, input_str, **kwargs):
+        tool_name = serialized.get("name")
+        color_print(f"Calling {tool_name} with inputs: {input_str}", color="pink")
+
+    def on_tool_end(self, output, **kwargs):
+        output = str(output)
+        color_print(output, color="blue")
+
+
+def check_or_create_path(path=None):
+    # Set a default path if none is provided
+    if path is None:
+        path = os.path.join(os.getcwd(), "tmp_directory")
+
+    # Check if the path exists
+    if not os.path.exists(path):
+        # If it doesn't exist, create the directory
+        os.makedirs(path)
+        print(f"Directory created at: {path}")
+    else:
+        print(f"Directory already exists at: {path}")
+
+    return path
+
+
+def langchain_to_gradio_message(message):
+    # Build the title and content based on the message type
+    if isinstance(message.content, list):
+        # For a message with multiple content items (like text and tool use)
+        gradio_messages = []
+        for item in message.content:
+            gradio_message = {
+                "role": "user" if message.type == "human" else "assistant",
+                "content": "",
+                "metadata": {},
+            }
+
+            if item["type"] == "text":
+                item["text"] = item["text"].replace("<think>", "\n")
+                item["text"] = item["text"].replace("</think>", "\n")
+                gradio_message["content"] += f"{item['text']}\n"
+                gradio_messages.append(gradio_message)
+            elif item["type"] == "tool_use":
+                if item["name"] == "run_python_repl":
+                    gradio_message["metadata"]["title"] = "🛠️ Writing code..."
+                    # input = "```python {code_block}```\n".format(code_block=item['input']["command"])
+                    gradio_message["metadata"]["log"] = "Executing Code block..."
+                    gradio_message["content"] = f"##### Code: \n ```python \n {item['input']['command']} \n``` \n"
+                else:
+                    gradio_message["metadata"]["title"] = f"🛠️ Used tool ```{item['name']}```"
+                    to_print = ";".join([i + ": " + str(j) for i, j in item["input"].items()])
+                    gradio_message["metadata"]["log"] = f"🔍 Input -- {to_print}\n"
+                gradio_message["metadata"]["status"] = "pending"
+                gradio_messages.append(gradio_message)
+
+    else:
+        gradio_message = {
+            "role": "user" if message.type == "human" else "assistant",
+            "content": "",
+            "metadata": {},
+        }
+        print(message)
+        content = message.content
+        content = content.replace("<think>", "\n")
+        content = content.replace("</think>", "\n")
+        content = content.replace("<solution>", "\n")
+        content = content.replace("</solution>", "\n")
+
+        gradio_message["content"] = content
+        gradio_messages = [gradio_message]
+    return gradio_messages
+
+
+def parse_hpo_obo(file_path):
+    """Parse the HPO OBO file and create a dictionary mapping HP IDs to phenotype descriptions.
+
+    Args:
+        file_path (str): Path to the HPO OBO file.
+
+    Returns:
+        dict: A dictionary where keys are HP IDs and values are phenotype descriptions.
+
+    """
+    hp_dict = {}
+    current_id = None
+    current_name = None
+
+    with open(file_path) as file:
+        for line in file:
+            line = line.strip()
+            if line.startswith("[Term]"):
+                # If a new term block starts, save the previous term
+                if current_id and current_name:
+                    hp_dict[current_id] = current_name
+                current_id = None
+                current_name = None
+            elif line.startswith("id: HP:"):
+                current_id = line.split(": ")[1]
+            elif line.startswith("name:"):
+                current_name = line.split(": ", 1)[1]
+
+        # Add the last term to the dictionary
+        if current_id and current_name:
+            hp_dict[current_id] = current_name
+
+    return hp_dict
+
+
+def textify_api_dict(api_dict):
+    """Convert a nested API dictionary to a nicely formatted string."""
+    lines = []
+    for category, methods in api_dict.items():
+        lines.append(f"Import file: {category}")
+        lines.append("=" * (len("Import file: ") + len(category)))
+        for method in methods:
+            lines.append(f"Method: {method.get('name', 'N/A')}")
+            lines.append(f"  Description: {method.get('description', 'No description provided.')}")
+
+            # Process required parameters
+            req_params = method.get("required_parameters", [])
+            if req_params:
+                lines.append("  Required Parameters:")
+                for param in req_params:
+                    param_name = param.get("name", "N/A")
+                    param_type = param.get("type", "N/A")
+                    param_desc = param.get("description", "No description")
+                    param_default = param.get("default", "None")
+                    lines.append(f"    - {param_name} ({param_type}): {param_desc} [Default: {param_default}]")
+
+            # Process optional parameters
+            opt_params = method.get("optional_parameters", [])
+            if opt_params:
+                lines.append("  Optional Parameters:")
+                for param in opt_params:
+                    param_name = param.get("name", "N/A")
+                    param_type = param.get("type", "N/A")
+                    param_desc = param.get("description", "No description")
+                    param_default = param.get("default", "None")
+                    lines.append(f"    - {param_name} ({param_type}): {param_desc} [Default: {param_default}]")
+
+            lines.append("")  # Empty line between methods
+        lines.append("")  # Extra empty line after each category
+
+    return "\n".join(lines)
+
+
+def read_module2api():
+    fields = [
+        "literature",
+        "biochemistry",
+        "bioimaging",
+        "bioengineering",
+        "biophysics",
+        "glycoengineering",
+        "cancer_biology",
+        "cell_biology",
+        "molecular_biology",
+        "genetics",
+        "genomics",
+        "immunology",
+        "microbiology",
+        "pathology",
+        "pharmacology",
+        "physiology",
+        "synthetic_biology",
+        "systems_biology",
+        "support_tools",
+        "database",
+        "lab_automation",
+        "protocols",
+    ]
+
+    module2api = {}
+    for field in fields:
+        module_name = f"biomni.tool.tool_description.{field}"
+        module = importlib.import_module(module_name)
+        module2api[f"biomni.tool.{field}"] = module.description
+    return module2api
+
+
+def download_and_unzip(url: str, dest_dir: str) -> str:
+    """Download a zip file from a URL and extract it to the destination directory.
+
+    Args:
+        url: The URL to download the zip file from.
+        dest_dir: The directory to extract the contents to.
+
+    Returns:
+        The path to the extracted directory, or an error message.
+
+    """
+    try:
+        os.makedirs(dest_dir, exist_ok=True)
+        print(f"Downloading from {url} ...")
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            total_size = int(r.headers.get("content-length", 0))
+            chunk_size = 8192
+            with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_file:
+                with tqdm.tqdm(
+                    total=total_size / (1024**3),
+                    unit="GB",
+                    unit_scale=True,
+                    desc="Downloading",
+                    ncols=80,
+                ) as pbar:
+                    for chunk in r.iter_content(chunk_size=chunk_size):
+                        if chunk:
+                            tmp_file.write(chunk)
+                            pbar.update(len(chunk) / (1024**3))
+                tmp_zip_path = tmp_file.name
+        print(f"Downloaded to {tmp_zip_path}. Extracting...")
+        with zipfile.ZipFile(tmp_zip_path, "r") as zip_ref:
+            zip_ref.extractall(dest_dir)
+        os.unlink(tmp_zip_path)
+        print(f"Extraction complete to {dest_dir}")
+        return dest_dir
+    except Exception as e:
+        print(f"Error downloading or extracting zip: {e}")
+        return f"Error: {e}"
+
+
+def check_and_download_s3_files(
+    s3_bucket_url: str, local_data_lake_path: str, expected_files: list[str], folder: str = "data_lake"
+) -> dict[str, bool]:
+    """Check for missing files in the local data lake and download them from S3 bucket.
+
+    Args:
+        s3_bucket_url: Base URL of the S3 bucket (e.g., "https://biomni-release.s3.amazonaws.com")
+        local_data_lake_path: Local path to the data lake directory
+        expected_files: List of expected file names in the data lake
+        folder: S3 folder name ("data_lake" or "benchmark")
+
+    Returns:
+        Dictionary mapping file names to download success status
+    """
+
+    os.makedirs(local_data_lake_path, exist_ok=True)
+    download_results = {}
+
+    def download_with_progress(url: str, file_path: str, desc: str) -> bool:
+        """Download file with progress bar."""
+        try:
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+
+            total_size = int(response.headers.get("content-length", 0))
+
+            with open(file_path, "wb") as f:
+                if total_size > 0:
+                    with tqdm.tqdm(total=total_size, unit="B", unit_scale=True, desc=desc, ncols=80) as pbar:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            if chunk:
+                                f.write(chunk)
+                                pbar.update(len(chunk))
+                else:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)
+            return True
+        except Exception as e:
+            print(f"✗ Failed to download {desc}: {e}")
+            if os.path.exists(file_path):
+                try:
+                    os.remove(file_path)
+                except OSError:
+                    pass
+            return False
+
+    def cleanup_file(file_path: str):
+        """Clean up file if it exists."""
+        if os.path.exists(file_path):
+            try:
+                os.remove(file_path)
+            except OSError:
+                pass
+
+    # Handle benchmark folder (download as zip)
+    if folder == "benchmark":
+        print(f"Downloading entire {folder} folder structure...")
+        s3_zip_url = urljoin(s3_bucket_url + "/", folder + ".zip")
+
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
+            tmp_zip_path = tmp_zip.name
+
+            if download_with_progress(s3_zip_url, tmp_zip_path, f"{folder}.zip"):
+                print(f"Extracting {folder}.zip...")
+                try:
+                    with zipfile.ZipFile(tmp_zip_path, "r") as zip_ref:
+                        zip_ref.extractall(local_data_lake_path)
+                    print(f"✓ Successfully downloaded and extracted {folder} folder")
+                    download_results = dict.fromkeys(expected_files, True)
+                except Exception as e:
+                    print(f"✗ Error extracting {folder}.zip: {e}")
+                    download_results = dict.fromkeys(expected_files, False)
+                finally:
+                    cleanup_file(tmp_zip_path)
+            else:
+                download_results = dict.fromkeys(expected_files, False)
+
+        return download_results
+
+    # Handle data_lake folder (download individual files)
+    for filename in expected_files:
+        local_file_path = os.path.join(local_data_lake_path, filename)
+
+        if os.path.exists(local_file_path):
+            download_results[filename] = True
+            continue
+
+        s3_file_url = urljoin(s3_bucket_url + "/" + folder + "/", filename)
+        print(f"Downloading {filename} from {folder}...")
+
+        if download_with_progress(s3_file_url, local_file_path, filename):
+            print(f"✓ Successfully downloaded: {filename}")
+            download_results[filename] = True
+        else:
+            download_results[filename] = False
+
+    return download_results
+
+
+def clean_message_content(content: str) -> str:
+    """Clean message content by removing ANSI escape codes.
+
+    This function removes ANSI escape sequences (like color codes) from text content
+    that might be present in terminal output or console messages. This ensures clean
+    text for markdown generation and PDF conversion.
+
+    Args:
+        content: The raw message content that may contain ANSI escape codes
+
+    Returns:
+        Cleaned content with ANSI escape codes removed
+
+    Example:
+        >>> clean_message_content("Hello \x1b[31mworld\x1b[0m!")
+        "Hello world!"
+    """
+    import re
+
+    return re.sub(r"\x1b\[[0-9;]*m", "", content)
+
+
+def should_skip_message(clean_output: str) -> bool:
+    """Check if message should be skipped during markdown generation.
+
+    This function determines whether a message should be excluded from the final
+    markdown output. It skips empty or meaningless messages but preserves important
+    error messages that should be displayed to users.
+
+    Args:
+        clean_output: The cleaned message content to evaluate
+
+    Returns:
+        True if the message should be skipped, False otherwise
+
+    Note:
+        Parsing error messages are intentionally not skipped as they provide
+        important feedback to users about conversation flow issues.
+    """
+    return (
+        clean_output.strip() in ["", "None", "null", "undefined"]
+        # Don't skip parsing error messages - they should be displayed and increment step counter
+        # or "There are no tags" in clean_output
+        # or "Execution terminated due to repeated parsing errors" in clean_output
+    )
+
+
+def has_execution_results(clean_output: str, execution_results) -> bool:
+    """Check if message contains code execution and has associated results.
+
+    This function determines whether a message contains executable code and has
+    corresponding execution results available for display in the markdown output.
+
+    Args:
+        clean_output: The cleaned message content to check for execute tags
+        execution_results: List of execution results from the agent's execution history
+
+    Returns:
+        True if the message contains <execute> tags and has execution results available
+    """
+    return "<execute>" in clean_output and execution_results is not None and execution_results
+
+
+def find_matching_execution(clean_output: str, execution_results) -> dict | None:
+    """Find the execution result that matches the given message content.
+
+    This function searches through the execution results to find the one that
+    corresponds to the current message. It matches based on the triggering message
+    content to associate execution results with their originating AI messages.
+
+    Args:
+        clean_output: The cleaned message content to match against
+        execution_results: List of execution result dictionaries containing
+                         triggering messages and execution data
+
+    Returns:
+        The matching execution result dictionary if found, None otherwise
+
+    Note:
+        The matching is bidirectional - it checks if either the triggering message
+        is contained in the current output or vice versa to handle partial matches.
+    """
+    for exec_result in execution_results:
+        if exec_result["triggering_message"] in clean_output or clean_output in exec_result["triggering_message"]:
+            return exec_result
+    return None
+
+
+def create_parsing_error_html() -> str:
+    """Create HTML markup for displaying parsing errors in markdown output.
+
+    This function generates a styled HTML block that displays parsing errors
+    when the agent's response doesn't contain the required tags. The HTML
+    uses CSS classes for consistent styling in the final PDF output.
+
+    Returns:
+        HTML string containing a styled parsing error message box
+
+    Note:
+        The returned HTML uses CSS classes defined in get_pdf_css_content()
+        for consistent styling across the document.
+    """
+    return """
+<div class="parsing-error-box">
+    <div class="parsing-error-header">Parsing Error</div>
+    <div class="parsing-error-content">Each response must include thinking process followed by either execute or solution tag. But there are no tags in the current response.</div>
+</div>
+"""
+
+
+def parse_tool_calls_from_code(code: str, module2api: dict, custom_functions: dict = None) -> list[str]:
+    """Parse code to detect imported tools by analyzing import statements.
+
+    This function analyzes Python code to identify which tools/functions are being
+    imported and used. It extracts tool names from import statements and function
+    calls, then returns a deduplicated list of detected tool names.
+
+    Args:
+        code: The Python code string to analyze for tool imports
+        module2api: Dictionary mapping module names to their available API tools
+        custom_functions: Optional dictionary of custom functions that have been
+                         added to the agent
+
+    Returns:
+        Sorted list of unique tool names detected in the code
+
+    Example:
+        >>> code = "from biomni.tool import analyze_data\nimport pandas as pd"
+        >>> parse_tool_calls_from_code(code, module2api)
+        ['analyze_data', 'pandas']
+    """
+    tool_module_pairs = parse_tool_calls_with_modules(code, module2api, custom_functions)
+    return sorted({pair[0] for pair in tool_module_pairs})
+
+
+def parse_tool_calls_with_modules(code: str, module2api: dict, custom_functions: dict = None) -> list[tuple[str, str]]:
+    """Parse code to detect imported tools and their associated modules.
+
+    This function performs detailed analysis of Python code to identify which
+    tools/functions are being imported and which modules they belong to. It
+    handles various import patterns including direct imports, from-imports,
+    and module.function patterns.
+
+    Args:
+        code: The Python code string to analyze for tool imports
+        module2api: Dictionary mapping module names to their available API tools
+        custom_functions: Optional dictionary of custom functions that have been
+                         added to the agent
+
+    Returns:
+        List of tuples containing (tool_name, module_name) pairs for each
+        detected tool and its associated module
+
+    Note:
+        The function uses regex patterns to match various import statement
+        formats and also detects direct function calls without explicit imports.
+    """
+    import re
+
+    detected_tools = set()
+
+    # Get all available tools from module2api
+    all_tools = {}
+    for module_name, module_tools in module2api.items():
+        for tool in module_tools:
+            if isinstance(tool, dict) and "name" in tool:
+                tool_name = tool["name"]
+                if tool_name not in all_tools:
+                    all_tools[tool_name] = []
+                all_tools[tool_name].append(module_name)
+
+    # Add custom tools
+    if custom_functions:
+        for tool_name in custom_functions.keys():
+            if tool_name not in all_tools:
+                all_tools[tool_name] = []
+            all_tools[tool_name].append("custom_tools")
+
+    # Look for import statements in the code
+    import_patterns = [
+        r"from\s+([\w.]+)\s+import\s+([\w,\s]+)",  # from module import tool1, tool2
+        r"import\s+([\w.]+)",  # import module
+    ]
+
+    for pattern in import_patterns:
+        matches = re.findall(pattern, code)
+        for match in matches:
+            if len(match) == 2:  # from module import tools
+                module_name, tools_str = match
+                # Split tools by comma and clean up
+                tools = [tool.strip() for tool in tools_str.split(",")]
+
+                for tool in tools:
+                    # Check if this tool exists in any module
+                    if tool in all_tools:
+                        # Find the best matching module
+                        best_module = find_best_module_match(module_name, all_tools[tool])
+                        detected_tools.add((tool, best_module))
+                    # Also check if it's a module.function pattern
+                    elif "." in tool:
+                        parts = tool.split(".")
+                        if len(parts) == 2:
+                            module_part, func_part = parts
+                            if func_part in all_tools:
+                                best_module = find_best_module_match(module_part, all_tools[func_part])
+                                detected_tools.add((func_part, best_module))
+
+            elif len(match) == 1:  # import module
+                module_name = match[0]
+                # Check if any tools from this module are used
+                for tool_name, modules in all_tools.items():
+                    if any(module_name in mod for mod in modules):
+                        # Look for usage of this tool in the code
+                        if re.search(rf"\b{tool_name}\s*\(", code):
+                            best_module = find_best_module_match(module_name, modules)
+                            detected_tools.add((tool_name, best_module))
+
+    # Also look for direct function calls without imports
+    function_call_pattern = r"(\w+)\s*\("
+    function_calls = re.findall(function_call_pattern, code)
+
+    for func_call in function_calls:
+        if func_call in all_tools:
+            # For direct calls, use the first available module
+            best_module = all_tools[func_call][0]
+            detected_tools.add((func_call, best_module))
+
+    return sorted(detected_tools)
+
+
+def find_best_module_match(target_module: str, available_modules: list[str]) -> str:
+    """Find the best matching module from a list of available modules.
+
+    This function attempts to match a target module name against a list of
+    available modules using various matching strategies: exact match, partial
+    substring matches, and fallback to the first available module.
+
+    Args:
+        target_module: The module name we're trying to match
+        available_modules: List of available module names to search through
+
+    Returns:
+        The best matching module name from the available modules list.
+        Returns "unknown" if no modules are available.
+
+    Note:
+        The matching strategy prioritizes exact matches, then partial matches
+        (where either the target is contained in the module name or vice versa),
+        and finally falls back to the first available module.
+    """
+    # First try exact match
+    if target_module in available_modules:
+        return target_module
+
+    # Try partial matches
+    for module in available_modules:
+        if target_module in module or module in target_module:
+            return module
+
+    # Return the first available module as fallback
+    return available_modules[0] if available_modules else "unknown"
+
+
+def inject_custom_functions_to_repl(custom_functions: dict):
+    """Inject custom functions into the Python REPL execution environment.
+
+    This function makes custom tools available during code execution by injecting
+    them into both the persistent execution namespace and the builtins module.
+    This allows the agent to call custom functions that users have added via
+    agent.add_tool() when executing Python code in <execute> blocks.
+
+    Args:
+        custom_functions: Dictionary mapping function names to their callable objects
+
+    Note:
+        The function modifies both the persistent namespace used by run_python_repl
+        and the builtins module to ensure maximum compatibility and accessibility
+        of custom functions during code execution.
+    """
+    if custom_functions:
+        # Access the persistent namespace used by run_python_repl
+        from biomni.tool.support_tools import _persistent_namespace
+
+        # Inject all custom functions into the execution namespace
+        for name, func in custom_functions.items():
+            _persistent_namespace[name] = func
+
+        # Also make them available in builtins for broader access
+        import builtins
+
+        if not hasattr(builtins, "_biomni_custom_functions"):
+            builtins._biomni_custom_functions = {}
+        builtins._biomni_custom_functions.update(custom_functions)
+
+
+def format_execute_tags_in_content(content: str, parse_tool_calls_with_modules_func) -> str:
+    """Format execute tags in content by extracting code and creating highlighted tool call blocks.
+
+    This function processes content that contains <execute>...</execute> tags and
+    converts them into styled HTML blocks that display the code with syntax highlighting
+    and information about which tools are being used.
+
+    Args:
+        content: The content string that may contain <execute> tags
+        parse_tool_calls_with_modules_func: Function to parse tool calls with modules
+                                          (typically parse_tool_calls_with_modules)
+
+    Returns:
+        Formatted content with execute tags converted to highlighted tool call blocks.
+        Also processes <solution> tags in the same pass.
+
+    Note:
+        The function also calls format_solution_tags_in_content() to handle
+        solution tags in the same processing pass.
+    """
+    import re
+
+    # Pattern to match <execute>...</execute> blocks
+    execute_pattern = r"<execute>(.*?)</execute>"
+
+    def replace_execute_tag(match):
+        code_content = match.group(1).strip()
+        language, tool_name = detect_code_language_and_tool(code_content)
+        code_content = clean_code_content(code_content, language)
+
+        # Parse tools from the code content with module information
+        detected_tool_modules = parse_tool_calls_with_modules_func(code_content)
+
+        # Create the formatted block
+        formatted_block = create_tool_call_block(code_content, language, tool_name, detected_tool_modules)
+        return formatted_block
+
+    # Replace all execute tags with formatted tool call blocks
+    formatted_content = re.sub(execute_pattern, replace_execute_tag, content, flags=re.DOTALL)
+
+    # Also format solution tags
+    formatted_content = format_solution_tags_in_content(formatted_content)
+
+    return formatted_content
+
+
+def detect_code_language_and_tool(code_content: str) -> tuple[str, str]:
+    """Detect the programming language and tool name from code content.
+
+    This function analyzes code content to determine the programming language
+    and appropriate tool name based on language markers at the beginning of
+    the code block.
+
+    Args:
+        code_content: The code content to analyze for language markers
+
+    Returns:
+        Tuple containing (language, tool_name) where:
+        - language: The detected programming language ("python", "r", "bash")
+        - tool_name: The human-readable tool name for display
+
+    Example:
+        >>> detect_code_language_and_tool("#!R\nlibrary(ggplot2)")
+        ("r", "R REPL")
+        >>> detect_code_language_and_tool("#!BASH\necho 'hello'")
+        ("bash", "Bash Script")
+    """
+    if code_content.startswith("#!R") or code_content.startswith("# R code") or code_content.startswith("# R script"):
+        return "r", "R REPL"
+    elif code_content.startswith("#!BASH") or code_content.startswith("# Bash script"):
+        return "bash", "Bash Script"
+    elif code_content.startswith("#!CLI"):
+        return "bash", "CLI Command"
+    else:
+        return "python", "Python REPL"
+
+
+def clean_code_content(code_content: str, language: str) -> str:
+    """Clean code content by removing language markers.
+
+    This function removes language-specific markers from the beginning of code
+    content to prepare it for display in code blocks. The markers are used
+    internally for language detection but should not appear in the final output.
+
+    Args:
+        code_content: The raw code content that may contain language markers
+        language: The detected programming language ("python", "r", "bash")
+
+    Returns:
+        Cleaned code content with language markers removed
+
+    Example:
+        >>> clean_code_content("#!R\nlibrary(ggplot2)", "r")
+        "library(ggplot2)"
+        >>> clean_code_content("#!BASH\necho 'hello'", "bash")
+        "echo 'hello'"
+    """
+    import re
+
+    if language == "r":
+        return re.sub(r"^#!R|^# R code|^# R script", "", code_content, count=1).strip()
+    elif language == "bash":
+        if code_content.startswith("#!BASH") or code_content.startswith("# Bash script"):
+            return re.sub(r"^#!BASH|^# Bash script", "", code_content, count=1).strip()
+        elif code_content.startswith("#!CLI"):
+            return re.sub(r"^#!CLI", "", code_content, count=1).strip()
+    return code_content
+
+
+def create_tool_call_block(code_content: str, language: str, tool_name: str, detected_tool_modules: list) -> str:
+    """Create the HTML block for tool call highlighting.
+
+    This function generates a styled HTML block that displays code execution
+    information including the code itself, syntax highlighting, and a list of
+    tools that were used during execution.
+
+    Args:
+        code_content: The cleaned code content to display
+        language: The programming language for syntax highlighting
+        tool_name: The default tool name to display if no specific tools detected
+        detected_tool_modules: List of (tool_name, module_name) tuples for tools used
+
+    Returns:
+        HTML string containing a styled tool call block with code and tool information
+
+    Note:
+        The HTML uses CSS classes defined in get_pdf_css_content() for styling.
+        If no specific tools are detected, it falls back to a default tool name.
+    """
+    # Create the formatted block with code and tools used
+    formatted_block = f"""<div class="tool-call-highlight">
+<div class="tool-call-header">
+<strong>Code Execution</strong>
+</div>
+<div class="tool-call-input">
+```{language}
+{code_content}
+```
+</div>"""
+
+    # Add tools used section
+    if detected_tool_modules:
+        tools_list = format_detected_tools(detected_tool_modules)
+        formatted_block += f"""
+<div class="tools-used">
+<strong>Tools Used:</strong> {tools_list}
+</div>"""
+    else:
+        formatted_block += format_default_tool_name(language, tool_name)
+
+    formatted_block += "</div>"
+    return formatted_block
+
+
+def format_detected_tools(detected_tool_modules: list) -> str:
+    """Format detected tools with their modules for display.
+
+    This function takes a list of (tool_name, module_name) tuples and formats
+    them into a human-readable string for display in the tool call blocks.
+    It handles special cases for common tools and formats module names appropriately.
+
+    Args:
+        detected_tool_modules: List of (tool_name, module_name) tuples
+
+    Returns:
+        Comma-separated string of formatted tool descriptions
+
+    Example:
+        >>> format_detected_tools([("analyze_data", "biomni.tool"), ("pandas", "pandas")])
+        "biomni → analyze_data, pandas → pandas"
+    """
+    tool_descriptions = []
+    for tool_name, module_name in detected_tool_modules:
+        if tool_name == "python_repl":
+            tool_descriptions.append("Python REPL")
+        elif tool_name == "r_repl":
+            tool_descriptions.append("R REPL")
+        elif "bash" in tool_name.lower():
+            tool_descriptions.append("Bash Script")
+        else:
+            # Extract the last part of the module name for display
+            display_module = module_name.split(".")[-1] if "." in module_name else module_name
+            tool_descriptions.append(f"{display_module} → {tool_name}")
+
+    return ", ".join(sorted(tool_descriptions))
+
+
+def format_default_tool_name(language: str, tool_name: str) -> str:
+    """Format default tool name based on programming language.
+
+    This function generates HTML for displaying the default tool name when
+    no specific tools are detected in the code. It maps programming languages
+    to their appropriate default tool names.
+
+    Args:
+        language: The programming language ("python", "r", "bash")
+        tool_name: The detected tool name (used for bash CLI vs script distinction)
+
+    Returns:
+        HTML string containing a styled tools-used section
+
+    Note:
+        For bash, it distinguishes between CLI commands and bash scripts
+        based on the tool_name parameter.
+    """
+    if language == "r":
+        return """
+<div class="tools-used">
+<strong>Tools Used:</strong> R REPL
+</div>"""
+    elif language == "bash":
+        if tool_name == "CLI Command":
+            return """
+<div class="tools-used">
+<strong>Tools Used:</strong> CLI Command
+</div>"""
+        else:
+            return """
+<div class="tools-used">
+<strong>Tools Used:</strong> Bash Script
+</div>"""
+    else:
+        return """
+<div class="tools-used">
+<strong>Tools Used:</strong> Python REPL
+</div>"""
+
+
+def format_solution_tags_in_content(content: str) -> str:
+    """Format solution tags in content by extracting text and formatting as solution blocks.
+
+    This function processes content that contains <solution>...</solution> tags and
+    converts them into styled HTML blocks that display solution content with appropriate
+    formatting and CSS classes.
+
+    Args:
+        content: The content string that may contain <solution> tags
+
+    Returns:
+        Formatted content with solution tags converted to styled solution blocks
+
+    Note:
+        The solution blocks use the "title-text summary" CSS class for consistent
+        styling with other content blocks in the markdown output.
+    """
+    import re
+
+    # Pattern to match <solution>...</solution> blocks
+    solution_pattern = r"<solution>(.*?)</solution>"
+
+    def replace_solution_tag(match):
+        solution_content = match.group(1).strip()
+        # Format as regular text, not terminal
+        return f"""<div class="title-text summary">
+<div class="title-text-header">
+<strong>Summary and Solution</strong>
+</div>
+<div class="title-text-content">
+{solution_content}
+</div>
+</div>"""
+
+    # Replace all solution tags with formatted solution blocks
+    formatted_content = re.sub(solution_pattern, replace_solution_tag, content, flags=re.DOTALL)
+
+    return formatted_content
+
+
+def format_observation_as_terminal(content: str) -> str | None:
+    """Format observation content with terminal-like styling.
+
+    This function processes observation content from the agent's execution results
+    and formats it as a styled terminal block. It handles both text and image content,
+    with length limits to ensure the output fits within PDF page constraints.
+
+    Args:
+        content: The observation content string, potentially containing <observation> tags
+
+    Returns:
+        Formatted HTML content with terminal styling, or None if observation is
+        empty, invalid, or contains only meaningless content
+
+    Note:
+        - Content is limited to 10,000 characters to fit within 2 A4 pages
+        - Handles both text and base64-encoded images
+        - Uses CSS classes for consistent styling with other content blocks
+    """
+    import re
+
+    # Character limit for 2 A4 pages (approximately 10,000 characters)
+    MAX_OBSERVATION_LENGTH = 10000
+
+    # Remove the <observation> tags and extract the content
+    observation_pattern = r"<observation>(.*?)</observation>"
+    observation_match = re.search(observation_pattern, content, re.DOTALL)
+
+    if observation_match:
+        observation_content = observation_match.group(1).strip()
+    else:
+        # Fallback if no observation tags found - check if content is meaningful
+        if not (content.strip() and content.strip() not in ["", "None", "null", "undefined"]):
+            return None
+        observation_content = content.strip()
+
+    # Skip empty observations
+    if not observation_content or observation_content in ["", "None", "null", "undefined"]:
+        return None
+
+    # Check if observation is too long for 2 pages
+    if len(observation_content) > MAX_OBSERVATION_LENGTH:
+        cropped_content = observation_content[:MAX_OBSERVATION_LENGTH]
+        truncation_notice = f"\n\n[Output truncated - content was too long to display here ({len(observation_content)} characters total)]"
+        observation_content = cropped_content + truncation_notice
+
+    # Check if it contains plot data (base64 images)
+    if "data:image/" in observation_content:
+        content_html = process_observation_with_images(observation_content)
+    else:
+        # Regular text output - format as terminal output
+        content_html = f"```terminal\n{observation_content}\n```"
+
+    return f"""<div class="title-text observation">
+<div class="title-text-header">
+<strong>Observation</strong>
+</div>
+<div class="title-text-content">
+{content_html}
+</div>
+</div>"""
+
+
+def process_observation_with_images(observation_content: str) -> str:
+    """Process observation content that contains both text and base64-encoded images.
+
+    This function handles observation content that includes both text output and
+    base64-encoded images (typically plots from data analysis). It separates the
+    text and image content and formats them appropriately for markdown display.
+
+    Args:
+        observation_content: The observation content containing both text and images
+
+    Returns:
+        HTML string containing formatted text (as terminal blocks) and images
+        (as markdown image tags)
+
+    Note:
+        The function uses "data:image/" as a delimiter to split content into
+        text and image parts, then processes each part separately.
+    """
+    # Split content into text and image parts
+    parts = observation_content.split("data:image/")
+    text_parts = []
+    image_parts = []
+
+    for i, part in enumerate(parts):
+        if i == 0:
+            # First part is text only
+            if part.strip():
+                text_parts.append(part.strip())
+        else:
+            # Find the end of the base64 data
+            end_markers = ["\n", "\r", " ", "\t", ">", "<", "]", ")", "}"]
+            image_end = len(part)
+            for marker in end_markers:
+                marker_pos = part.find(marker)
+                if marker_pos != -1 and marker_pos < image_end:
+                    image_end = marker_pos
+
+            # Extract image data
+            image_data = "data:image/" + part[:image_end]
+            image_parts.append(image_data)
+
+            # Extract remaining text
+            remaining_text = part[image_end:].strip()
+            if remaining_text:
+                text_parts.append(remaining_text)
+
+    # Build the content
+    content_html = ""
+    if text_parts:
+        # Add text content as terminal output
+        text_content = "\n".join(text_parts)
+        content_html += f"```terminal\n{text_content}\n```\n\n"
+
+    if image_parts:
+        # Add image content
+        for image_data in image_parts:
+            content_html += f"![Plot]({image_data})\n\n"
+
+    return content_html
+
+
+def remove_emojis_from_text(text: str) -> str:
+    """Remove emojis from text for markdown/PDF output.
+
+    This function removes common emojis used in the system prompt and configuration
+    display from text content before it's converted to markdown or PDF. This ensures
+    clean, professional output while preserving emojis in the console display.
+
+    Args:
+        text: The text content that may contain emojis
+
+    Returns:
+        Text content with emojis removed
+
+    Note:
+        The function targets specific emojis used in the Biomni system:
+        - 🔧 for tools
+        - 📊 for data
+        - ⚙️ for software
+        - 📋 for configuration
+        - 🤖 for agent
+    """
+    import re
+
+    # Remove common emojis used in the system prompt, this makes conversion simpler
+    emoji_patterns = [
+        r"🔧\s*",  # Tool emoji
+        r"📊\s*",  # Data emoji
+        r"⚙️\s*",  # Software emoji
+        r"📋\s*",  # Config emoji
+        r"🤖\s*",  # Agent emoji
+    ]
+
+    for pattern in emoji_patterns:
+        text = re.sub(pattern, "", text)
+
+    return text
+
+
+def format_lists_in_text(text: str) -> str:
+    """Format numbered lists and bullet points in text to proper markdown format.
+
+    This function processes text content to identify and format various types of lists,
+    including numbered lists with checkboxes, regular lists, and plan structures.
+    It also handles preprocessing tasks like removing bold formatting from plan titles
+    and removing emojis for clean PDF output.
+
+    Args:
+        text: The text content to process for list formatting
+
+    Returns:
+        Formatted text with properly structured lists and cleaned formatting
+
+    Note:
+        The function performs several preprocessing steps:
+        - Removes bold formatting from plan titles
+        - Removes emojis for PDF output
+        - Identifies and formats checkbox lists
+        - Processes regular text blocks
+    """
+    import re
+
+    # Preprocess to remove bold formatting from plan titles
+    # Remove **Plan:**, **Updated Plan:**, **Completed Plan:**, etc.
+    text = re.sub(r"\*\*([Pp]lan|Updated [Pp]lan|Completed [Pp]lan|Final [Pp]lan):\*\*", r"\1:", text)
+    # Also handle cases without colons
+    text = re.sub(r"\*\*([Pp]lan|Updated [Pp]lan|Completed [Pp]lan|Final [Pp]lan)\*\*", r"\1", text)
+    # Handle any other bold formatting patterns for plan titles
+    text = re.sub(r"<strong>([Pp]lan|Updated [Pp]lan|Completed [Pp]lan|Final [Pp]lan):</strong>", r"\1:", text)
+    text = re.sub(r"<strong>([Pp]lan|Updated [Pp]lan|Completed [Pp]lan|Final [Pp]lan)</strong>", r"\1", text)
+
+    # Remove emojis from the text for markdown/PDF output
+    text = remove_emojis_from_text(text)
+
+    lines = text.split("\n")
+    list_blocks = identify_list_blocks(lines)
+
+    # Process each block
+    result_blocks = []
+    for block_text, is_checkbox_list in list_blocks:
+        if is_checkbox_list:
+            result_blocks.append(format_single_list(block_text))
+        else:
+            result_blocks.append(block_text)
+
+    return "\n".join(result_blocks)
+
+
+def identify_list_blocks(lines: list) -> list[tuple[str, bool]]:
+    """Identify blocks of text that contain lists.
+
+    This function analyzes a list of text lines to identify contiguous blocks
+    that contain numbered lists with checkboxes. It groups lines into blocks
+    and marks whether each block contains a checkbox list or regular text.
+
+    Args:
+        lines: List of text lines to analyze
+
+    Returns:
+        List of tuples containing (block_text, is_checkbox_list) where:
+        - block_text: The text content of the block
+        - is_checkbox_list: True if the block contains numbered items with checkboxes
+
+    Note:
+        The function looks for patterns like "1. [ ]", "2. [✓]", "3. [✗]" to
+        identify checkbox sequences and groups them into separate blocks.
+    """
+    import re
+
+    list_blocks = []
+    current_block = []
+    in_checkbox_sequence = False
+
+    for line in lines:
+        line_stripped = line.strip()
+
+        # Check if this line starts a numbered item with checkbox
+        if re.match(r"^\d+\.\s*\[[ ✓✗]\]", line_stripped):
+            if not in_checkbox_sequence:
+                # Start of a new checkbox sequence
+                if current_block:
+                    list_blocks.append(("\n".join(current_block), False))
+                current_block = [line]
+                in_checkbox_sequence = True
+            else:
+                # Continue the sequence
+                current_block.append(line)
+        else:
+            if in_checkbox_sequence:
+                # End of checkbox sequence
+                if current_block:
+                    list_blocks.append(("\n".join(current_block), True))
+                current_block = []
+                in_checkbox_sequence = False
+            current_block.append(line)
+
+    # Handle the last block
+    if current_block:
+        if in_checkbox_sequence:
+            list_blocks.append(("\n".join(current_block), True))
+        else:
+            list_blocks.append(("\n".join(current_block), False))
+
+    return list_blocks
+
+
+def format_single_list(text: str) -> str:
+    """Format a single list block with checkboxes and plan titles.
+
+    This function processes a text block that may contain numbered lists with
+    checkboxes and plan titles. It converts checkbox symbols to HTML list items
+    and wraps the content in a styled container with appropriate CSS classes.
+
+    Args:
+        text: The text block to format, potentially containing numbered lists
+
+    Returns:
+        HTML string containing either a formatted list with plan title or
+        regular text if no list items are found
+
+    Note:
+        The function recognizes plan titles like "Plan", "Updated Plan", "Completed Plan"
+        and converts checkbox symbols (✓, ✗) to HTML format ([x], [ ]).
+    """
+    import re
+
+    lines = text.split("\n")
+    list_items = []
+    has_list_items = False
+    plan_title = "Plan"  # Default title
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        # Check for plan title patterns
+        if re.match(r"^(Plan|Updated Plan|Completed Plan)$", line, re.IGNORECASE):
+            plan_title = line
+            continue
+
+        # Check for numbered lists with checkboxes (1. [ ] or 1. [✓] or 1. [✗])
+        if re.match(r"^\d+\.\s*\[[ ✓✗]\]", line):
+            has_list_items = True
+            # Extract the content after the checkbox
+            content = re.sub(r"^\d+\.\s*\[[ ✓✗]\]\s*", "", line)
+
+            # Replace checkbox symbols with text format
+            if "[✓]" in line:
+                list_items.append(f"<li><strong>[x]</strong> {content}</li>")
+            elif "[✗]" in line:
+                list_items.append(f"<li><strong>[ ]</strong> {content}</li>")
+            else:
+                list_items.append(f"<li><strong>[ ]</strong> {content}</li>")
+        else:
+            # Regular text - add as is (don't convert to list items)
+            list_items.append(line)
+
+    if has_list_items and list_items:
+        # This is a list - return with container div and styled title
+        return f"""<div class="title-text plan">
+<div class="title-text-header">
+<span class="plan-title">{plan_title}</span>
+</div>
+<div class="title-text-content">
+<ul>
+{chr(10).join(list_items)}
+</ul>
+</div>
+</div>"""
+    else:
+        # Regular text
+        return "\n".join(list_items)
+
+
+def convert_markdown_to_pdf(markdown_path: str, pdf_path: str) -> None:
+    """Convert markdown file to PDF using weasyprint or fallback libraries.
+
+    This function converts a markdown file to PDF format using multiple fallback
+    strategies. It prioritizes weasyprint for better layout control, then falls back
+    to markdown2pdf and finally pandoc if the preferred libraries are not available.
+
+    Args:
+        markdown_path: Path to the input markdown file
+        pdf_path: Path where the output PDF file should be saved
+
+    Raises:
+        ImportError: If no PDF conversion library is available
+        Exception: If PDF conversion fails for any other reason
+
+    Note:
+        The function uses minimal markdown extensions for better performance
+        and applies custom CSS styling for consistent formatting.
+    """
+    try:
+        # Try weasyprint first (better for complex layouts)
+        from weasyprint import HTML
+        from weasyprint.text.fonts import FontConfiguration
+
+        # Read markdown content
+        with open(markdown_path, encoding="utf-8") as f:
+            markdown_content = f.read()
+
+        # Convert markdown to HTML with minimal extensions for better performance
+        import markdown
+
+        # Use minimal extensions to improve performance
+        html_content = markdown.markdown(
+            markdown_content,
+            extensions=["fenced_code"],  # Removed codehilite for better performance
+        )
+
+        # Add CSS styling
+        css_content = get_pdf_css_content()
+
+        # Create HTML document
+        html_doc = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="utf-8">
+            <title>Biomni Conversation History</title>
+            <style>{css_content}</style>
+        </head>
+        <body>
+            {html_content}
+        </body>
+        </html>
+        """
+
+        # Convert to PDF with performance optimizations
+        font_config = FontConfiguration()
+        html_obj = HTML(string=html_doc)
+        html_obj.write_pdf(pdf_path, font_config=font_config, optimize_images=True)
+
+    except ImportError:
+        # Fallback to markdown2pdf if weasyprint is not available
+        try:
+            from markdown2pdf import markdown2pdf
+
+            markdown2pdf(markdown_path, pdf_path)
+        except ImportError:
+            # Final fallback - try using pandoc if available
+            import subprocess
+
+            try:
+                subprocess.run(["pandoc", markdown_path, "-o", pdf_path], check=True)
+            except (subprocess.CalledProcessError, FileNotFoundError) as e:
+                raise ImportError(
+                    "No PDF conversion library available. Please install weasyprint, markdown2pdf, or pandoc."
+                ) from e
+    except Exception as e:
+        raise Exception(f"PDF conversion failed: {e}") from e
+
+
+def get_pdf_css_content() -> str:
+    """Get the CSS content for PDF generation.
+
+    This function returns a comprehensive CSS stylesheet designed specifically
+    for PDF generation from markdown content. It includes styling for all
+    HTML elements that may appear in the converted markdown, with optimized
+    typography, spacing, and layout for print media.
+
+    Returns:
+        CSS string containing all styles needed for PDF generation
+
+    Note:
+        The CSS includes styles for:
+        - Typography and font families
+        - Headings and text formatting
+        - Code blocks and syntax highlighting
+        - Tables and lists
+        - Custom classes for tool calls, observations, and plans
+        - Print-optimized spacing and layout
+    """
+    return """
+    body {
+        /* Previously: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif, 'Noto Color Emoji', 'Apple Color Emoji', 'Segoe UI Emoji', 'Twemoji', 'EmojiOne Color' */
+        font-family: sans-serif;
+        font-size: 9pt;
+        line-height: 1.4;
+        max-width: 800px;
+        margin: 0 auto;
+        padding: 15px;
+        color: #333;
+    }
+    h1, h2, h3, h4, h5, h6 {
+        /* Previously: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif, 'Noto Color Emoji', 'Apple Color Emoji', 'Segoe UI Emoji', 'Twemoji', 'EmojiOne Color' */
+        font-family: sans-serif;
+        color: #2c3e50;
+        margin-top: 1em;
+        margin-bottom: 0.5em;
+    }
+    h1 {
+        border-bottom: 2px solid #3498db;
+        padding-bottom: 8px;
+        font-size: 16pt;
+    }
+    h2 {
+        border-bottom: 1px solid #bdc3c7;
+        padding-bottom: 3px;
+        font-size: 14pt;
+    }
+    h3 {
+        font-size: 12pt;
+    }
+    h4 {
+        font-size: 10pt;
+        margin-top: 0.8em;
+        margin-bottom: 0.3em;
+    }
+    h5, h6 {
+        font-size: 9pt;
+        margin-top: 0.6em;
+        margin-bottom: 0.2em;
+    }
+    code {
+        background-color: #f8f9fa;
+        padding: 1px 3px;
+        border-radius: 2px;
+        font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+        font-size: 8pt;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+    }
+    pre {
+        background-color: #f8f9fa;
+        padding: 10px;
+        border-radius: 3px;
+        overflow-x: auto;
+        border-left: 3px solid #3498db;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+        font-size: 8pt;
+        margin: 0.5em 0;
+    }
+    pre code {
+        background-color: transparent;
+        padding: 0;
+        border-radius: 0;
+        font-size: 8pt;
+    }
+    /* Code header styling */
+    strong {
+        font-size: 9pt;
+        font-weight: normal;
+        color: #6c757d;
+        font-style: italic;
+    }
+    blockquote {
+        border-left: 3px solid #bdc3c7;
+        margin: 0.5em 0;
+        padding-left: 15px;
+        color: #7f8c8d;
+        font-size: 8pt;
+    }
+    table {
+        border-collapse: collapse;
+        width: 100%;
+        margin: 0.5em 0;
+        font-size: 8pt;
+    }
+    th, td {
+        border: 1px solid #bdc3c7;
+        padding: 4px 8px;
+        text-align: left;
+    }
+    th {
+        background-color: #ecf0f1;
+        font-weight: bold;
+    }
+    img {
+        max-width: 100%;
+        height: auto;
+        display: block;
+        margin: 10px auto;
+        border: 1px solid #ddd;
+        border-radius: 3px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    p {
+        /* Previously: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif, 'Noto Color Emoji', 'Apple Color Emoji', 'Segoe UI Emoji', 'Twemoji', 'EmojiOne Color' */
+        font-family: sans-serif;
+        margin: 0.3em 0;
+    }
+    /* Tool call highlighting - matching observation and code formatting */
+    .tool-call-highlight {
+        background-color: #f8f9fa;
+        border: 1px solid #e9ecef;
+        border-radius: 3px;
+        padding: 0;
+        margin: 10px 0;
+        overflow: hidden;
+    }
+    .tool-call-header {
+        background-color: #e9ecef;
+        color: #495057;
+        padding: 8px 12px;
+        margin: 0;
+        font-weight: normal;
+        font-size: 9pt;
+        font-style: italic;
+        border-bottom: 1px solid #dee2e6;
+    }
+    .tool-call-input {
+        background-color: #f8f9fa;
+        border: none;
+        border-radius: 0;
+        padding: 10px 12px;
+        margin: 0;
+        color: #333;
+        font-size: 8pt;
+        line-height: 1.4;
+    }
+    .tool-call-input strong {
+        color: #495057;
+        font-weight: normal;
+        font-size: 8pt;
+        font-style: italic;
+    }
+    .tool-call-input pre {
+        background-color: #f8f9fa;
+        border: 1px solid #e9ecef;
+        border-radius: 3px;
+        padding: 10px;
+        margin: 0;
+        font-size: 8pt;
+        line-height: 1.4;
+        overflow-x: auto;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+    }
+    .tool-call-input code {
+        background-color: transparent;
+        padding: 0;
+        border-radius: 0;
+        font-size: 8pt;
+        color: #2c3e50;
+    }
+    .tools-used {
+        background-color: #f8f9fa;
+        border-top: 1px solid #dee2e6;
+        padding: 8px 12px;
+        margin: 0;
+        font-size: 8pt;
+        color: #6c757d;
+    }
+    .tools-used strong {
+        color: #6c757d;
+        font-weight: normal;
+        font-size: 8pt;
+        font-style: italic;
+    }
+    /* Title-text styling - unified for observations, plans, and solutions */
+    .title-text {
+        background-color: #f8f9fa;
+        border: 1px solid #e9ecef;
+        border-radius: 3px;
+        padding: 0;
+        margin: 10px 0;
+        overflow: hidden;
+    }
+    .title-text-header {
+        background-color: #e9ecef;
+        color: #495057;
+        padding: 8px 12px;
+        margin: 0;
+        font-weight: normal;
+        font-size: 9pt;
+        font-style: italic;
+        border-bottom: 1px solid #dee2e6;
+    }
+    .title-text-header strong {
+        color: #495057;
+        font-weight: normal;
+        font-size: 9pt;
+        font-style: italic;
+    }
+    .title-text-content {
+        background-color: #f8f9fa;
+        border: none;
+        border-radius: 0;
+        padding: 10px 12px;
+        margin: 0;
+        color: #333;
+        font-size: 8pt;
+        line-height: 1.4;
+    }
+    /* Plan-specific styling - soft blue pastel */
+    .title-text.plan {
+        background-color: #e3f2fd;
+        border-color: #bbdefb;
+    }
+    .title-text.plan .title-text-header {
+        background-color: #bbdefb;
+        color: #1976d2;
+    }
+    .title-text.plan .title-text-content {
+        background-color: #e3f2fd;
+    }
+    .plan-title {
+        font-style: italic;
+        font-weight: normal;
+        color: #1565c0;
+        text-shadow: 0 1px 2px rgba(0,0,0,0.1);
+    }
+    .plan-title strong {
+        font-weight: normal;
+    }
+    /* Code execution-specific styling - matching title-text styling */
+    .tool-call-highlight {
+        background-color: #f8f9fa;
+        border-color: #e9ecef;
+    }
+    .tool-call-header {
+        background-color: #e9ecef;
+        color: #495057;
+    }
+    .tool-call-input {
+        background-color: #f8f9fa;
+        color: #333;
+    }
+    /* Observation-specific styling - soft purple pastel */
+    .title-text.observation {
+        background-color: #f3e5f5;
+        border-color: #e1bee7;
+    }
+    .title-text.observation .title-text-header {
+        background-color: #e1bee7;
+        color: #7b1fa2;
+    }
+    .title-text.observation .title-text-content {
+        background-color: #f3e5f5;
+    }
+    /* Summary and solution-specific styling - soft orange pastel, no overlay */
+    .title-text.summary {
+        background-color: #fff3e0;
+        border-color: #ffcc02;
+    }
+    .title-text.summary .title-text-header {
+        background-color: #ffcc02;
+        color: #f57c00;
+    }
+    .title-text.summary .title-text-content {
+        background-color: #fff3e0;
+    }
+    .title-text-content ul {
+        background-color: transparent;
+        border: none;
+        border-radius: 0;
+        padding: 0;
+        margin: 0;
+        color: #333;
+        font-size: 8pt;
+        line-height: 1.4;
+    }
+    .title-text-content li {
+        margin: 3px 0;
+        color: #333;
+    }
+    .title-text-content li strong {
+        color: #495057;
+        font-weight: normal;
+        font-size: 8pt;
+        font-style: italic;
+    }
+    .title-text-content li code {
+        background-color: #e9ecef;
+        color: #333;
+        padding: 1px 3px;
+        border-radius: 2px;
+        font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+        font-size: 7pt;
+    }
+    .title-text-content pre {
+        background-color: #f8f9fa;
+        border: 1px solid #e9ecef;
+        border-radius: 3px;
+        padding: 10px;
+        margin: 0;
+        font-size: 8pt;
+        line-height: 1.4;
+        overflow-x: auto;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+    }
+    .title-text-content code {
+        background-color: transparent;
+        padding: 0;
+        border-radius: 0;
+        font-size: 8pt;
+        color: #2c3e50;
+    }
+    /* Parsing error display styling */
+    .parsing-error-box {
+        background-color: #ffebee;
+        border: 1px solid #f44336;
+        border-radius: 4px;
+        padding: 8px 12px;
+        margin: 8px 0;
+        font-size: 9pt;
+        color: #c62828;
+        box-shadow: 0 2px 4px rgba(244, 67, 54, 0.1);
+    }
+    .parsing-error-header {
+        font-weight: bold;
+        margin-bottom: 4px;
+        color: #d32f2f;
+    }
+    .parsing-error-content {
+        font-family: 'Courier New', monospace;
+        background-color: #ffcdd2;
+        padding: 4px 6px;
+        border-radius: 2px;
+        margin-top: 4px;
+        font-size: 8pt;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+    }
+    """

biomni/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.8"  # pragma: no cover

biomni_env/README.md

@@ -0,0 +1,74 @@
+# Biomni Environment Setup
+
+This directory contains scripts and configuration files to set up a comprehensive bioinformatics environment with various tools and packages.
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/snap-stanford/Biomni.git
+   cd Biomni/biomni_env
+   ```
+
+2. Setting up the environment:
+- (a) If you want to use or try out the basic agent without the full E1 or install your own softwares, run the following script:
+
+```bash
+conda env create -f environment.yml
+```
+
+- (b) If you want to use the full environment E1, run the setup script (this script takes > 10 hours to setup, and requires a disk of at least 30 GB quota). Follow the prompts to install the desired components.
+
+```bash
+bash setup.sh
+```
+
+If you already installed the base version, and just wants to add the additional packages in the new release, you can simply do:
+
+```bash
+bash new_software_v005.sh
+```
+
+Note: we have only tested this setup.sh script with Ubuntu 22.04, 64 bit.
+
+- (c) If you want to use a reduced conda environment without R or CLI tools, run the following script:
+
+```bash
+conda env create -f fixed_env.yml
+```
+
+This contains most of the packages from environment.yml and bio_env.yml, and requires a disk of at elast 13GB quota.
+
+- (d) **Python 3.10 Environment for Copy Number Analysis**: If you specifically need to use the `analyze_copy_number_purity_ploidy_and_focal_events` function, we provide a Python 3.10 environment option. This function has specific dependency requirements that are best met with Python 3.10. To set up this environment:
+
+```bash
+conda env create -f bio_env_py310.yml
+```
+
+This environment is optimized for copy number variation analysis and includes the necessary packages for purity, ploidy, and focal event detection.
+
+3. Lastly, to activate the biomni environment:
+```bash
+conda activate biomni_e1
+```
+
+For the Python 3.10 environment specifically:
+```bash
+conda activate biomni_py310
+```
+
+### 📦 Langchain Package Support
+
+The Biomni environment comes with a minimal set of langchain packages by default:
+- `langchain-openai` - for OpenAI model support
+- `langchain-anthropic` - for Anthropic model support
+- `langchain-ollama` - for Ollama model support
+
+If you need support for other external models or services, you'll need to install additional langchain packages manually. For example:
+
+```bash
+# For AWS Bedrock support
+pip install langchain-aws
+
+# For Google Gemini support
+pip install langchain-google-genai
+
+```

biomni_env/bio_env.yml

@@ -0,0 +1,70 @@
+name: biomni_e1
+channels:
+  - conda-forge
+  - bioconda
+  - defaults
+dependencies:
+  - blast
+  - samtools
+  - bowtie2
+  - bwa
+  - bedtools
+  - fastqc
+  - trimmomatic
+  - mafft
+  - gseapy
+  - mageck
+  - plannotate
+  - pip:
+    - scanpy
+    - biopython
+    - biopandas
+    - biotite
+    - opencv-python
+    - rdkit
+    - macs2
+    - pymc3
+    - cryosparc-tools
+    - lifelines
+    - scikit-image
+    - googlesearch-python
+    - PyPDF2
+    - gget
+    - faiss-cpu
+    - cellxgene-census
+    - scikit-bio
+    - pymed
+    - arxiv
+    - scholarly
+    - umap-learn
+    - scrublet
+    - scvelo
+    - scvi-tools
+    - harmony-pytorch
+    - pyliftover
+    - pytdc==0.4.0
+    - pysam
+    - pyfaidx
+    - pyranges
+    - pybedtools
+    - openmm
+    - pystan
+    - igraph
+    - pyscenic
+    - cooler
+    - trackpy
+    - flowcytometrytools
+    - cellpose
+    - viennarna
+    - PyMassSpec
+    - python-libsbml
+    - cobra
+    - reportlab
+    #- flowkit
+    - hmmlearn
+    - msprime
+    - tskit
+    - cyvcf2
+    - pykalman
+    - community
+    - fanc

biomni_env/bio_env_py310.yml

@@ -0,0 +1,19 @@
+name: bio_env_py310
+channels:
+  - conda-forge
+  - bioconda
+  - defaults
+dependencies:
+  - python=3.10
+  - cnvkit
+  - samtools
+  - bedtools
+  - pip
+
+# Purpose: Python 3.10 compatibility environment for tools not yet supporting newer Python versions.
+# Automaticlly setup on setup.sh execution.
+# Contains tools that require Python 3.10 or earlier versions.
+# Can be create with:
+#   micromamba create -f bio_env_py310.yml   OR   conda env create -f bio_env_py310.yml
+# Use tools via:
+#   conda run -n bio_env_py310 <command> ...

biomni_env/cli_tools_config.json

@@ -0,0 +1,94 @@
+{
+	"tools": [
+		{
+			"name": "PLINK 2.0",
+			"function_name": "install_plink2",
+			"description": "Whole genome association analysis toolset",
+			"website": "https://www.cog-genomics.org/plink/2.0/",
+			"downloads": {
+				"linux": "https://s3.amazonaws.com/plink2-assets/alpha6/plink2_linux_avx2_20250129.zip",
+				"macos_intel": "https://s3.amazonaws.com/plink2-assets/alpha6/plink2_mac_avx2_20250129.zip",
+				"macos_arm64": "https://s3.amazonaws.com/plink2-assets/alpha6/plink2_mac_arm64_20250129.zip"
+			},
+			"binary_path": "plink2",
+			"version_command": "--version"
+		},
+		{
+			"name": "IQ-TREE",
+			"function_name": "install_iqtree",
+			"description": "Efficient phylogenetic software by maximum likelihood",
+			"website": "http://www.iqtree.org/",
+			"downloads": {
+				"linux": "https://github.com/iqtree/iqtree2/releases/download/v2.2.2.7/iqtree-2.2.2.7-Linux.tar.gz",
+				"macos_intel": "https://github.com/iqtree/iqtree2/releases/download/v2.2.2.7/iqtree-2.2.2.7-MacOSX.zip",
+				"macos_arm64": "https://github.com/iqtree/iqtree2/releases/download/v2.2.2.7/iqtree-2.2.2.7-MacOSX.zip"
+			},
+			"binary_path": "bin/iqtree2",
+			"version_command": "--version"
+		},
+		{
+			"name": "GCTA",
+			"function_name": "install_gcta",
+			"description": "Genome-wide Complex Trait Analysis",
+			"website": "https://yanglab.westlake.edu.cn/software/gcta/",
+			"downloads": {
+				"linux": "https://yanglab.westlake.edu.cn/software/gcta/bin/gcta-1.94.4-linux-kernel-3-x86_64.zip",
+				"macos_intel": "https://yanglab.westlake.edu.cn/software/gcta/bin/gcta-1.94.1-macOS-x86_64.zip",
+				"macos_arm64": "https://yanglab.westlake.edu.cn/software/gcta/bin/gcta-1.94.3-macOS-arm64.zip"
+			},
+			"binary_path": "gcta64",
+			"version_command": ""
+		},
+		{
+			"name": "BWA",
+			"function_name": "install_bwa",
+			"description": "Burrow-Wheeler Aligner for short-read alignment",
+			"website": "https://github.com/lh3/bwa",
+			"downloads": {
+				"linux": "https://github.com/lh3/bwa.git",
+				"macos_intel": "https://github.com/lh3/bwa.git",
+				"macos_arm64": "https://github.com/lh3/bwa.git"
+			},
+			"binary_path": "bwa",
+			"version_command": ""
+		},
+		{
+			"name": "FastTree",
+			"function_name": "install_fasttree",
+			"description": "Approximately-Maximum-Likelihood phylogenetic trees from alignments",
+			"website": "https://morgannprice.github.io/fasttree/",
+			"downloads": {
+				"linux": "https://morgannprice.github.io/fasttree/FastTree.c",
+				"macos_intel": "https://morgannprice.github.io/fasttree/FastTree.c",
+				"macos_arm64": "https://morgannprice.github.io/fasttree/FastTree.c"
+			},
+			"binary_path": "FastTree",
+			"version_command": "-help | head -n 2"
+		},
+		{
+			"name": "MUSCLE",
+			"function_name": "install_muscle",
+			"description": "Multiple sequence alignment with high accuracy and performance",
+			"website": "https://github.com/rcedgar/muscle",
+			"downloads": {
+				"linux": "https://github.com/rcedgar/muscle/releases/download/v5.3/muscle-linux-x86.v5.3",
+				"macos_arm64": "https://github.com/rcedgar/muscle/releases/download/v5.3/muscle-osx-arm64.v5.3"
+			},
+			"binary_path": "muscle",
+			"version_command": "-version"
+		},
+		{
+			"name": "HOMER",
+			"function_name": "install_homer",
+			"description": "Software for motif discovery and next-gen sequencing analysis",
+			"website": "http://homer.ucsd.edu/homer/",
+			"downloads": {
+				"linux": "http://homer.ucsd.edu/homer/configureHomer.pl",
+				"macos_intel": "http://homer.ucsd.edu/homer/configureHomer.pl",
+				"macos_arm64": "http://homer.ucsd.edu/homer/configureHomer.pl"
+			},
+			"binary_path": "bin/findMotifs.pl",
+			"version_command": "-h"
+		}
+	]
+}

biomni_env/environment.yml

@@ -0,0 +1,39 @@
+name: biomni_e1
+channels:
+  - conda-forge
+  - defaults
+  - bioconda
+dependencies:
+  - python=3.11
+  - pip
+  - pip:
+      - numpy==2.1
+      - pandas
+      - matplotlib
+      - scipy
+      - statsmodels
+      - scikit-learn
+      - gradio
+      - langchain
+      - langgraph==0.3.18
+      - langchain-openai
+      - langchain-anthropic
+      - langchain-ollama
+      - langchain-community
+      - openai
+      - beautifulsoup4
+      - lxml
+      - tqdm
+      - seaborn
+      - networkx
+      - requests
+      - pyyaml
+      - jupyter
+      - notebook
+      - ipykernel
+      - pytest
+      - transformers
+      - sentencepiece
+      - mcp
+      - tooluniverse
+      - python-dotenv

biomni_env/fixed_env.yml

@@ -0,0 +1,742 @@
+name: biomni_e1
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - altair=5.5.0
+  - asttokens=3.0.0
+  - attrs=25.3.0
+  - aws-c-auth=0.9.0
+  - aws-c-cal=0.9.2
+  - aws-c-common=0.12.4
+  - aws-c-compression=0.3.1
+  - aws-c-event-stream=0.5.5
+  - aws-c-http=0.10.4
+  - aws-c-io=0.21.2
+  - aws-c-mqtt=0.13.3
+  - aws-c-s3=0.8.6
+  - aws-c-sdkutils=0.2.4
+  - aws-checksums=0.2.7
+  - aws-crt-cpp=0.33.1
+  - aws-sdk-cpp=1.11.606
+  - azure-core-cpp=1.16.0
+  - azure-identity-cpp=1.12.0
+  - azure-storage-blobs-cpp=12.14.0
+  - azure-storage-common-cpp=12.10.0
+  - azure-storage-files-datalake-cpp=12.12.0
+  - bedtools=2.31.1
+  - biopython=1.85
+  - blast=2.16.0
+  - blinker=1.9.0
+  - bokeh=3.7.3
+  - bowtie2=2.5.4
+  - brotli-bin=1.1.0
+  - brotli-python=1.1.0
+  - bwa=0.7.19
+  - bzip2=1.0.8
+  - c-ares=1.34.5
+  - ca-certificates=2025.8.3
+  - cairo=1.18.4
+  - certifi=2025.8.3
+  - cffi=1.17.1
+  - charset-normalizer=3.4.2
+  - contourpy=1.3.3
+  - curl=8.14.1
+  - cycler=0.12.1
+  - decorator=5.2.1
+  - diamond=2.1.13
+  - entrez-direct=22.4
+  - exceptiongroup=1.3.0
+  - executing=2.2.0
+  - fastqc=0.12.1
+  - font-ttf-dejavu-sans-mono=2.37
+  - font-ttf-inconsolata=3.000
+  - font-ttf-source-code-pro=2.038
+  - font-ttf-ubuntu=0.83
+  - fontconfig=2.15.0
+  - fonts-conda-ecosystem=1
+  - fonts-conda-forge=1
+  - fonttools=4.59.0
+  - freetype=2.13.3
+  - gflags=2.2.2
+  - giflib=5.2.2
+  - gitdb=4.0.12
+  - gitpython=3.1.45
+  - glog=0.7.1
+  - gmp=6.3.0
+  - graphite2=1.3.14
+  - gseapy=1.1.9
+  - h2=4.2.0
+  - harfbuzz=11.3.3
+  - hpack=4.1.0
+  - htslib=1.22.1
+  - hyperframe=6.1.0
+  - icu=75.1
+  - idna=3.10
+  - importlib-metadata=8.7.0
+  - infernal=1.1.5
+  - ipython=9.4.0
+  - ipython_pygments_lexers=1.1.1
+  - jedi=0.19.2
+  - jinja2=3.1.6
+  - jsonschema=4.25.0
+  - jsonschema-specifications=2025.4.1
+  - kiwisolver=1.4.8
+  - krb5=1.21.3
+  - lcms2=2.17
+  - lerc=4.0.0
+  - libabseil=20250512.1
+  - libarrow=21.0.0
+  - libarrow-acero=21.0.0
+  - libarrow-compute=21.0.0
+  - libarrow-dataset=21.0.0
+  - libarrow-substrait=21.0.0
+  - libasprintf=0.25.1
+  - libblas=3.9.0
+  - libbrotlicommon=1.1.0
+  - libbrotlidec=1.1.0
+  - libbrotlienc=1.1.0
+  - libcblas=3.9.0
+  - libcrc32c=1.1.2
+  - libcurl=8.14.1
+  - libdeflate=1.22
+  - libedit=3.1.20250104
+  - libev=4.33
+  - libevent=2.1.12
+  - libexpat=2.7.1
+  - libffi=3.4.6
+  - libfreetype=2.13.3
+  - libfreetype6=2.13.3
+  - libgettextpo=0.25.1
+  - libgfortran=15.1.0
+  - libgfortran5=15.1.0
+  - libglib=2.84.2
+  - libgoogle-cloud=2.39.0
+  - libgoogle-cloud-storage=2.39.0
+  - libgrpc=1.73.1
+  - libiconv=1.18
+  - libidn2=2.3.8
+  - libjpeg-turbo=3.1.0
+  - liblapack=3.9.0
+  - liblzma=5.8.1
+  - libnghttp2=1.64.0
+  - libopenblas=0.3.30
+  - libopentelemetry-cpp=1.21.0
+  - libopentelemetry-cpp-headers=1.21.0
+  - libparquet=21.0.0
+  - libpng=1.6.50
+  - libprotobuf=6.31.1
+  - libre2-11=2025.07.22
+  - libsqlite=3.50.4
+  - libssh2=1.11.1
+  - libthrift=0.22.0
+  - libtiff=4.7.0
+  - libunistring=0.9.10
+  - libutf8proc=2.10.0
+  - libwebp-base=1.6.0
+  - libxml2=2.13.8
+  - libzlib=1.3.1
+  - lz4-c=1.10.0
+  - mafft=7.526
+  # - mageck=0.5.9.5
+  - markupsafe=3.0.2
+  - matplotlib-base=3.10.5
+  - matplotlib-inline=0.1.7
+  - mpfr=4.2.1
+  - munkres=1.1.4
+  - narwhals=2.0.1
+  - ncbi-vdb=3.2.1
+  - ncurses=6.5
+  - nlohmann_json=3.12.0
+  - openjdk=23.0.2
+  - openjpeg=2.5.3
+  - openssl=3.5.1
+  - orc=2.1.3
+  - packaging=25.0
+  - pandas=2.3.1
+  - parso=0.8.4
+  - pcre2=10.45
+  - perl=5.32.1
+  - perl-archive-tar=3.04
+  - perl-carp=1.50
+  - perl-common-sense=3.75
+  - perl-compress-raw-bzip2=2.201
+  - perl-compress-raw-zlib=2.202
+  - perl-encode=3.21
+  - perl-exporter=5.74
+  - perl-exporter-tiny=1.002002
+  - perl-extutils-makemaker=7.70
+  - perl-io-compress=2.201
+  - perl-io-zlib=1.15
+  - perl-json=4.10
+  - perl-json-xs=4.03
+  - perl-list-moreutils=0.430
+  - perl-list-moreutils-xs=0.430
+  - perl-parent=0.243
+  - perl-pathtools=3.75
+  - perl-scalar-list-utils=1.70
+  - perl-storable=3.15
+  - perl-types-serialiser=1.01
+  - pexpect=4.9.0
+  - pickleshare=0.7.5
+  - pillow=11.3.0
+  - pip=25.2
+  - pixman=0.46.4
+  # - plannotate=1.2.0
+  - prometheus-cpp=1.3.0
+  - prompt-toolkit=3.0.51
+  - protobuf=6.31.1
+  - ptyprocess=0.7.0
+  - pure_eval=0.2.3
+  - pyarrow=21.0.0
+  - pyarrow-core=21.0.0
+  - pycparser=2.22
+  - pydeck=0.9.1
+  - pygments=2.19.2
+  - pyopengl=3.1.9
+  - pyparsing=3.2.3
+  - pysocks=1.7.1
+  - python=3.11.13
+  - python-dateutil=2.9.0.post0
+  - python-tzdata=2025.2
+  - python_abi=3.11
+  - pytz=2025.2
+  - pyyaml=6.0.2
+  - qhull=2020.2
+  - re2=2025.07.22
+  - readline=8.2
+  - referencing=0.36.2
+  - requests=2.32.4
+  - ripgrep=14.1.1
+  - rpds-py=0.26.0
+  - rpsbproc=0.5.0
+  - s2n=1.5.23
+  - samtools=1.22.1
+  - setuptools=80.9.0
+  - six=1.17.0
+  - smmap=5.0.2
+  - snappy=1.2.2
+  - stack_data=0.6.3
+  - streamlit=1.47.1
+  - tabulate=0.9.0
+  - tenacity=9.1.2
+  - tk=8.6.13
+  - toml=0.10.2
+  - tornado=6.5.1
+  - traitlets=5.14.3
+  - trimmomatic=0.39
+  - trnascan-se=2.0.12
+  - typing-extensions=4.14.1
+  - typing_extensions=4.14.1
+  - tzdata=2025b
+  - unicodedata2=16.0.0
+  - urllib3=2.5.0
+  - watchdog=6.0.0
+  - wcwidth=0.2.13
+  - wget=1.21.4
+  - wheel=0.45.1
+  - xyzservices=2025.4.0
+  - yaml=0.2.5
+  - zipp=3.23.0
+  - zlib=1.3.1
+  - zstd=1.5.7
+  - pip:
+      - absl-py==2.3.1
+      - adjusttext==1.3.0
+      - aiobotocore
+      - aiofiles==24.1.0
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.12.15
+      - aioitertools==0.12.0
+      - aiosignal==1.4.0
+      - airr==1.5.1
+      - alabaster==1.0.0
+      - anndata==0.12.1
+      - annotated-types==0.7.0
+      - annoy==1.17.3
+      - anthropic==0.60.0
+      - anyio==4.9.0
+      - appdirs==1.4.4
+      - arboreto==0.1.6
+      - argon2-cffi==25.1.0
+      - argon2-cffi-bindings==25.1.0
+      - array-api-compat==1.12.0
+      - arrow==1.3.0
+      - arviz==0.22.0
+      - arxiv==2.2.0
+      - asciitree==0.3.3
+      - async-lru==2.0.5
+      - authlib==1.6.1
+      - autograd==1.8.0
+      - autograd-gamma==0.5.0
+      - awkward==2.8.6
+      - awkward-cpp==48
+      - babel==2.17.0
+      - beautifulsoup4==4.13.4
+      - bibtexparser==1.4.3
+      - biom-format==2.1.16
+      # - biomni==0.0.8
+      - biopandas==0.5.1
+      - biotite==1.4.0
+      - biotraj==1.2.2
+      - bleach==6.2.0
+      - blitzgsea==1.3.54
+      - blosc2==3.6.1
+      - boltons==25.0.0
+      - boto3
+      - botocore
+      - brotli==1.1.0
+      - cachetools==5.5.2
+      - cellpose==4.0.6
+      - cellxgene-census==1.17.0
+      - cftime==1.6.4.post1
+      - chex==0.1.90
+      - click==8.2.1
+      - clikit==0.6.2
+      - cloudpickle==3.1.1
+      - cobra==0.29.1
+      - colorcet==3.1.0
+      - coloredlogs==15.0.1
+      - comm==0.2.3
+      - community==1.0.0b1
+      - cooler==0.10.4
+      - crashtest==0.3.1
+      - cryosparc-tools==4.7.1
+      - cryptography==45.0.5
+      - ctxcore==0.2.0
+      - cyclopts==3.22.5
+      - cython==0.29.37
+      - cytoolz==1.0.1
+      - cyvcf2==0.31.1
+      - dask==2024.11.2
+      - dask-expr==1.1.19
+      - dask-image==2024.5.3
+      - dataclasses==0.6
+      - dataclasses-json==0.6.7
+      - datashader==0.18.1
+      - debugpy==1.8.15
+      - decoupler==2.1.1
+      - defusedxml==0.7.1
+      - demes==0.2.3
+      - depinfo==2.2.0
+      - deprecated==1.2.18
+      - deprecation==2.1.0
+      - dill==0.4.0
+      - diskcache==5.6.3
+      - distributed==2024.11.2
+      - distro==1.9.0
+      - dnspython==2.7.0
+      - docrep==0.3.2
+      - docstring-parser==0.17.0
+      - docutils==0.21.2
+      - domdf-python-tools==3.10.0
+      - drmaa==0.7.9
+      - email-validator==2.2.0
+      - enum-tools==0.13.0
+      - equinox==0.13.0
+      - et-xmlfile==2.0.0
+      - etils==1.13.0
+      - faiss-cpu==1.11.0.post1
+      - fake-useragent==2.2.0
+      - fanc==0.9.28
+      - fast-array-utils==1.2.1
+      - fastapi==0.116.1
+      - fasteners==0.19
+      - fastjsonschema==2.21.1
+      - fastmcp==2.11.0
+      - fastprogress==1.0.3
+      - fastremap==1.17.2
+      - fcsparser==0.2.4
+      - feedparser==6.0.11
+      - ffmpy==0.6.1
+      - filelock==3.18.0
+      - filetype==1.2.0
+      - fill-voids==2.1.0
+      - flask==3.1.1
+      - flax==0.11.0
+      - flowcytometrytools==0.5.1
+      - formulaic==1.2.0
+      - formulaic-contrasts==1.0.0
+      - fqdn==1.5.1
+      - free-proxy==1.1.3
+      - frozendict==2.4.6
+      - frozenlist==1.7.0
+      - fsspec==2025.7.0
+      - future==1.0.0
+      - fuzzywuzzy==0.18.0
+      - genomic-regions==0.0.10
+      - geopandas==1.1.1
+      - gget==0.29.2
+      - google-ai-generativelanguage==0.6.18
+      - google-api-core==2.25.1
+      - google-auth==2.40.3
+      - googleapis-common-protos==1.70.0
+      - googlesearch-python==1.3.0
+      - gradio==5.39.0
+      - gradio-client==1.11.0
+      - graphql-core==3.2.6
+      - greenlet==3.2.3
+      - gridmap==0.15.0
+      - groovy==0.1.2
+      - grpcio==1.74.0
+      - grpcio-status==1.74.0
+      - h11==0.16.0
+      - h5netcdf==1.6.3
+      - h5py==3.14.0
+      - harmony-pytorch==0.1.8
+      - hf-xet==1.1.5
+      - hmmlearn==0.3.3
+      - httpcore==1.0.9
+      # - httpstan==4.13.0
+      - httpx==0.28.1
+      - httpx-sse==0.4.1
+      - huggingface-hub==0.34.3
+      - humanfriendly==10.0
+      - humanize==4.12.3
+      - igraph==0.11.9
+      - imagecodecs==2025.8.2
+      - imageio==2.37.0
+      - imagesize==1.4.1
+      - importlib-resources==6.5.2
+      - inflect==7.5.0
+      - iniconfig==2.1.0
+      - interface-meta==1.3.0
+      - interlap==0.2.7
+      - intervaltree==3.1.0
+      - ipykernel==6.30.0
+      - ipywidgets==8.1.7
+      - isodate==0.7.2
+      - isoduration==20.11.0
+      - itsdangerous==2.2.0
+      - jax==0.6.2
+      - jaxlib==0.6.2
+      - jaxopt==0.8.5
+      - jaxtyping==0.3.2
+      - jiter==0.10.0
+      - jmespath==1.0.1
+      - joblib==1.5.1
+      - json5==0.12.0
+      - jsonpatch==1.33
+      - jsonpointer==3.0.0
+      - jsonschema-path==0.3.4
+      - jupyter==1.1.1
+      - jupyter-client==8.6.3
+      - jupyter-console==6.6.3
+      - jupyter-core==5.8.1
+      - jupyter-events==0.12.0
+      - jupyter-lsp==2.2.6
+      - jupyter-server==2.16.0
+      - jupyter-server-terminals==0.5.3
+      - jupyterlab==4.4.5
+      - jupyterlab-pygments==0.3.0
+      - jupyterlab-server==2.27.3
+      - jupyterlab-widgets==3.0.15
+      - lamin-utils==0.15.0
+      - langchain==0.3.27
+      - langchain-anthropic==0.3.18
+      - langchain-community==0.3.27
+      - langchain-core==0.3.72
+      # - langchain-google-genai==2.1.8
+      - langchain-ollama==0.3.6
+      - langchain-openai==0.3.28
+      - langchain-text-splitters==0.3.9
+      - langgraph==0.3.18
+      - langgraph-checkpoint==2.1.1
+      - langgraph-prebuilt==0.1.8
+      - langgraph-sdk==0.1.74
+      - langsmith==0.4.10
+      - lark==1.2.2
+      - lazy-loader==0.4
+      - lazy-object-proxy==1.11.0
+      - legacy-api-wrap==1.4.1
+      - legendkit==0.3.6
+      - levenshtein==0.27.1
+      - lifelines==0.30.0
+      - lightning==2.5.2
+      - lightning-utilities==0.15.0
+      - lineax==0.0.8
+      - llvmlite==0.44.0
+      - locket==1.0.0
+      - logomaker==0.8.7
+      - loompy==3.0.8
+      - looseversion==1.1.2
+      - lxml==6.0.0
+      - lz4==4.4.4
+      - macs2==2.2.9.1
+      - markdown==3.8.2
+      - markdown-it-py==3.0.0
+      - marshmallow==3.26.1
+      - marsilea==0.5.4
+      - matplotlib-scalebar==0.9.0
+      - mcp==1.12.3
+      - mdurl==0.1.2
+      - mistune==3.1.3
+      - ml-collections==1.1.0
+      - ml-dtypes==0.5.3
+      - mmtf-python==1.1.3
+      - more-itertools==10.7.0
+      - mpmath==1.3.0
+      - msgpack==1.1.1
+      - msgpack-numpy==0.4.8
+      - msprime==1.3.4
+      - mudata==0.3.2
+      - multidict==6.6.3
+      - multipledispatch==1.0.0
+      - multiprocess==0.70.18
+      - multiprocessing-on-dill==3.5.0a4
+      - multiscale-spatial-image==2.0.2
+      - muon==0.1.7
+      - mypy-extensions==1.1.0
+      - mysql-connector-python==9.4.0
+      - natsort==8.4.0
+      - nbclient==0.10.2
+      - nbconvert==7.16.6
+      - nbformat==5.10.4
+      - ncls==0.0.70
+      - ndindex==1.10.0
+      - nest-asyncio==1.6.0
+      - netcdf4==1.7.2
+      - networkx==3.5
+      - newick==1.10.0
+      - notebook==7.4.4
+      - notebook-shim==0.2.4
+      - numba==0.61.2
+      - numcodecs==0.15.1
+      - numexpr==2.11.0
+      - numpy==2.1.0
+      - numpy-groupies==0.11.3
+      - numpyro==0.18.0
+      # - nvidia-cublas-cu12==12.6.4.1
+      # - nvidia-cuda-cupti-cu12==12.6.80
+      # - nvidia-cuda-nvrtc-cu12==12.6.77
+      # - nvidia-cuda-runtime-cu12==12.6.77
+      # - nvidia-cudnn-cu12==9.5.1.17
+      # - nvidia-cufft-cu12==11.3.0.4
+      # - nvidia-cufile-cu12==1.11.1.6
+      # - nvidia-curand-cu12==10.3.7.77
+      # - nvidia-cusolver-cu12==11.7.1.2
+      # - nvidia-cusparse-cu12==12.5.4.2
+      # - nvidia-cusparselt-cu12==0.6.3
+      # - nvidia-nccl-cu12==2.26.2
+      # - nvidia-nvjitlink-cu12==12.6.85
+      # - nvidia-nvtx-cu12==12.6.77
+      - ollama==0.5.1
+      - ome-zarr==0.11.1
+      - omnipath==1.0.12
+      - openai==1.98.0
+      - openapi-core==0.19.5
+      - openapi-pydantic==0.5.1
+      - openapi-schema-validator==0.6.3
+      - openapi-spec-validator==0.7.2
+      - opencv-python==4.12.0.88
+      - opencv-python-headless==4.12.0.88
+      - openmm==8.3.1
+      - openpyxl==3.1.5
+      - opt-einsum==3.4.0
+      - optax==0.2.5
+      - optlang==1.8.3
+      - orbax-checkpoint==0.11.20
+      - orjson==3.11.1
+      - ormsgpack==1.10.0
+      - ott-jax==0.5.1
+      - outcome==1.3.0.post0
+      - overrides==7.7.0
+      - pandocfilters==1.5.1
+      - param==2.2.1
+      - parse==1.20.2
+      - partd==1.4.2
+      - pastel==0.2.1
+      - pathable==0.4.4
+      - patsy==1.0.1
+      - pertpy==1.0.1
+      - pims==0.7
+      - platformdirs==4.3.8
+      - pluggy==1.6.0
+      - ply==3.11
+      - pooch==1.8.2
+      - progressbar2==4.5.0
+      - prometheus-client==0.22.1
+      - propcache==0.3.2
+      - proto-plus==1.26.1
+      - psutil==7.0.0
+      - pubchempy==1.0.4
+      - py-cpuinfo==9.0.0
+      - pyarrow-hotfix==0.7
+      - pyasn1==0.6.1
+      - pyasn1-modules==0.4.2
+      - pybedtools==0.12.0
+      - pybigwig==0.3.24
+      - pyct==0.5.0
+      - pydantic==2.11.7
+      - pydantic-core==2.33.2
+      - pydantic-settings==2.10.1
+      - pydeseq2==0.5.2
+      - pydub==0.25.1
+      - pyfaidx==0.8.1.4
+      - pykalman==0.10.1
+      - pylev==1.4.0
+      - pyliftover==0.4.1
+      - pymassspec==2.6.0.post1
+      - pymc3==3.11.4
+      - pymed==0.8.9
+      - pymzml==2.5.11
+      - pynndescent==0.5.13
+      - pyogrio==0.11.1
+      - pyomo==6.9.2
+      - pypdf2==3.0.1
+      - pyperclip==1.9.0
+      - pyproj==3.7.1
+      - pyranges==0.1.4
+      - pyro-api==0.1.2
+      - pyro-ppl==1.9.1
+      - pysam==0.23.3
+      - pyscenic==0.12.1
+      - pysimdjson==6.0.2
+      # - pystan==3.10.0
+      - pytdc==0.4.0
+      - pytest==8.4.1
+      - python-dotenv==1.1.1
+      - python-json-logger==3.3.0
+      - python-levenshtein==0.27.1
+      - python-libsbml==5.20.5
+      - python-multipart==0.0.20
+      - python-utils==3.9.1
+      - pytorch-lightning==2.5.2
+      - pyzmq==27.0.1
+      - rapidfuzz==3.13.0
+      - rdkit==2025.3.5
+      - rdkit-pypi==2022.9.5
+      - regex==2025.7.34
+      - reportlab==4.4.3
+      - requests-toolbelt==1.0.0
+      - rfc3339-validator==0.1.4
+      - rfc3986-validator==0.1.1
+      - rfc3987-syntax==1.1.0
+      - rich==14.1.0
+      - rich-rst==1.3.1
+      - roifile==2025.5.10
+      - roman-numerals-py==3.1.0
+      - rsa==4.9.1
+      - ruamel-yaml==0.18.14
+      - ruamel-yaml-clib==0.2.12
+      - ruff==0.12.7
+      - s3fs==2025.7.0
+      - s3transfer==0.13.1
+      - safehttpx==0.1.6
+      - safetensors==0.5.3
+      - scanpy==1.11.4
+      - scholarly==1.7.11
+      - scikit-base==0.12.4
+      - scikit-bio==0.7.0
+      - scikit-image==0.25.2
+      - scikit-learn==1.7.1
+      - scikit-misc==0.5.1
+      - scipy==1.15.0
+      - scirpy==0.22.1
+      - scrublet==0.2.3
+      - scvelo==0.3.3
+      - scvi-tools==1.3.3
+      - sdjson==0.5.0
+      - seaborn==0.13.2
+      - segment-anything==1.0
+      - selenium==4.34.2
+      - semantic-version==2.10.0
+      - semver==3.0.4
+      - send2trash==1.8.3
+      - sentencepiece==0.2.0
+      - session-info==1.0.1
+      - session-info2==0.2
+      - sgmllib3k==1.0.0
+      - shapely==2.1.1
+      - shellingham==1.5.4
+      - simplejson==3.20.1
+      - slicerator==1.1.0
+      - sniffio==1.3.1
+      - snowballstemmer==3.0.1
+      - somacore==1.0.28
+      - sorted-nearest==0.0.39
+      - sortedcontainers==2.4.0
+      - soupsieve==2.7
+      - sparse==0.17.0
+      - sparsecca==0.3.1
+      - spatial-image==1.2.2
+      - spatialdata==0.4.0
+      - sphinx==8.2.3
+      - sphinx-rtd-theme==3.0.2
+      - sphinxcontrib-applehelp==2.0.0
+      - sphinxcontrib-devhelp==2.0.0
+      - sphinxcontrib-htmlhelp==2.1.0
+      - sphinxcontrib-jquery==4.1
+      - sphinxcontrib-jsmath==1.0.1
+      - sphinxcontrib-qthelp==2.0.0
+      - sphinxcontrib-serializinghtml==2.0.0
+      - sqlalchemy==2.0.42
+      - squarify==0.4.4
+      - squidpy==1.6.5
+      - sse-starlette==3.0.2
+      - starlette==0.47.2
+      - statsmodels==0.14.5
+      - stdlib-list==0.11.1
+      - swiglpk==5.0.12
+      - sympy==1.14.0
+      - tables==3.10.2
+      - tblib==3.1.0
+      - tensorboard==2.20.0
+      - tensorboard-data-server==0.7.2
+      - tensorstore==0.1.76
+      - terminado==0.18.1
+      - texttable==1.7.0
+      - theano-pymc==1.1.2
+      - threadpoolctl==3.6.0
+      - tifffile==2025.6.11
+      - tiktoken==0.9.0
+      - tiledbsoma==1.17.1
+      - tinycss2==1.4.0
+      - tokenizers==0.21.4
+      - tomlkit==0.13.3
+      - tooluniverse==0.2.0
+      - toolz==1.0.0
+      - torch==2.7.1
+      - torchmetrics==1.8.0
+      - torchvision==0.22.1
+      - tqdm==4.67.1
+      - trackpy==0.7
+      - transformers==4.54.1
+      - treescope==0.1.9
+      - trio==0.30.0
+      - trio-websocket==0.12.2
+      # - triton==3.3.1
+      - tskit==0.6.4
+      - typeguard==4.4.4
+      - typer==0.16.0
+      - types-python-dateutil==2.9.0.20250708
+      - typing-inspect==0.9.0
+      - typing-inspection==0.4.1
+      - umap-learn==0.5.9.post2
+      - uri-template==1.3.0
+      - uvicorn==0.35.0
+      - validators==0.35.0
+      - viennarna==2.7.0
+      - wadler-lindig==0.1.7
+      - webargs==8.7.0
+      - webcolors==24.11.1
+      - webencodings==0.5.1
+      - websocket-client==1.8.0
+      - websockets==15.0.1
+      - werkzeug==3.1.1
+      - widgetsnbextension==4.0.14
+      - wrapt==1.17.2
+      - wsproto==1.2.0
+      - xarray==2024.11.0
+      - xarray-dataclass==3.0.0
+      - xarray-dataclasses==1.9.1
+      - xarray-einstats==0.9.1
+      - xarray-schema==0.0.3
+      - xarray-spatial==0.4.0
+      - yamlordereddictloader==0.4.2
+      - yarl==1.20.1
+      - zarr==2.18.7
+      - zict==3.0.0
+      - zstandard==0.23.0
+      - mi-googlesearch-python==1.3.0.post1

biomni_env/install_cli_tools.sh

@@ -0,0 +1,912 @@
+#!/bin/bash
+
+# Script to install command-line bioinformatics tools
+
+# Set up colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Check for wget or fallback to curl
+if command -v wget &> /dev/null; then
+  DOWNLOADER="wget -v -O"
+elif command -v curl &> /dev/null; then
+  DOWNLOADER="curl -L -o"
+  echo -e "${YELLOW}Warning: wget not found, using curl instead.${NC}"
+else
+  echo -e "${RED}Error: Neither wget nor curl is installed.${NC}"
+  echo -e "${YELLOW}Please install one of them (e.g., brew install wget on macOS).${NC}"
+  exit 1
+fi
+
+# Check if jq is installed
+if ! command -v jq &> /dev/null; then
+    echo -e "${YELLOW}jq is not installed. Installing jq for JSON parsing...${NC}"
+    # Use conda to install jq (no sudo required)
+    conda install -y -c conda-forge jq
+
+    if [ $? -ne 0 ]; then
+        echo -e "${RED}Failed to install jq with conda. Please install it manually.${NC}"
+        echo "Visit: https://stedolan.github.io/jq/download/"
+        exit 1
+    fi
+fi
+
+# Function to clean up old installations
+cleanup_old_installations() {
+    echo -e "${YELLOW}Checking for old installations...${NC}"
+
+    # Check for old installation in AFS
+    local old_afs_dir="/afs/cs.stanford.edu/u/$(whoami)/biomni_tools"
+    if [ -d "$old_afs_dir" ]; then
+        echo -e "${YELLOW}Found old installation in $old_afs_dir${NC}"
+        echo -e "${YELLOW}Removing old bin directory...${NC}"
+        rm -rf "$old_afs_dir/bin"
+        echo -e "${GREEN}Old bin directory removed.${NC}"
+    fi
+
+    # Check for old installation in HOME
+    local old_home_dir="$HOME/biomni_tools"
+    if [ -d "$old_home_dir" ] && [ "$old_home_dir" != "$TOOLS_DIR" ]; then
+        echo -e "${YELLOW}Found old installation in $old_home_dir${NC}"
+        echo -e "${YELLOW}Removing old bin directory...${NC}"
+        rm -rf "$old_home_dir/bin"
+        echo -e "${GREEN}Old bin directory removed.${NC}"
+    fi
+
+    # Clean up PATH
+    echo -e "${YELLOW}Cleaning up PATH...${NC}"
+    PATH=$(echo $PATH | tr ':' '\n' | grep -v "biomni_tools/bin" | tr '\n' ':' | sed 's/:$//')
+    export PATH="$TOOLS_DIR/bin:$PATH"
+    echo -e "${GREEN}PATH cleaned up.${NC}"
+}
+
+# Create a directory for CLI tools if it doesn't exist
+if [ -n "$BIOMNI_TOOLS_DIR" ]; then
+    TOOLS_DIR="$BIOMNI_TOOLS_DIR"
+else
+    TOOLS_DIR="$(pwd)/biomni_tools"
+fi
+
+# Clean up any existing installation if it exists
+if [ -d "$TOOLS_DIR" ]; then
+    echo -e "${YELLOW}Cleaning up existing installation in $TOOLS_DIR...${NC}"
+    # Remove bin directory to clean up symlinks
+    rm -rf "$TOOLS_DIR/bin"
+fi
+
+# Clean up old installations
+cleanup_old_installations
+
+# Create fresh directories
+mkdir -p "$TOOLS_DIR"
+mkdir -p "$TOOLS_DIR/bin"
+
+# Add the tools bin directory to PATH in the current session
+# Remove any old paths first to avoid duplicates
+PATH=$(echo $PATH | tr ':' '\n' | grep -v "biomni_tools/bin" | tr '\n' ':' | sed 's/:$//')
+export PATH="$TOOLS_DIR/bin:$PATH"
+
+# Clear the shell's command hash table to force it to re-search the PATH
+hash -r 2>/dev/null || rehash 2>/dev/null || true
+
+# Create a setup_path.sh file in the tools directory
+echo "#!/bin/bash" > "$TOOLS_DIR/setup_path.sh"
+echo "# Added by biomni setup" >> "$TOOLS_DIR/setup_path.sh"
+echo "# Remove any old paths first to avoid duplicates" >> "$TOOLS_DIR/setup_path.sh"
+echo "PATH=\$(echo \$PATH | tr ':' '\n' | grep -v \"biomni_tools/bin\" | tr '\n' ':' | sed 's/:$//')" >> "$TOOLS_DIR/setup_path.sh"
+echo "export PATH=\"$TOOLS_DIR/bin:\$PATH\"" >> "$TOOLS_DIR/setup_path.sh"
+echo "# Clear the shell's command hash table to force it to re-search the PATH" >> "$TOOLS_DIR/setup_path.sh"
+echo "hash -r 2>/dev/null || rehash 2>/dev/null || true" >> "$TOOLS_DIR/setup_path.sh"
+chmod +x "$TOOLS_DIR/setup_path.sh"
+
+# Config file path
+CONFIG_FILE="cli_tools_config.json"
+
+# Check if config file exists
+if [ ! -f "$CONFIG_FILE" ]; then
+    echo -e "${RED}Configuration file $CONFIG_FILE not found.${NC}"
+    exit 1
+fi
+
+# Function to download and install a tool
+install_tool() {
+    local tool_name=$1
+    local download_url=$2
+    local binary_path=$3
+    local version_cmd=$4
+    local tool_dir_name=$(echo "$tool_name" | tr '[:upper:]' '[:lower:]' | tr ' .' '_')
+    local binary_name=$(basename "$binary_path")
+
+    echo -e "\n${BLUE}=== Installing $tool_name ===${NC}"
+
+    # Check if the tool is already installed
+    if [ -f "$TOOLS_DIR/bin/$binary_name" ]; then
+        echo -e "${GREEN}$tool_name is already installed at $TOOLS_DIR/bin/$binary_name${NC}"
+        echo -e "${YELLOW}Testing installation...${NC}"
+
+        if [ -n "$version_cmd" ]; then
+            echo -e "${YELLOW}Running version command: $TOOLS_DIR/bin/$binary_name $version_cmd${NC}"
+            $TOOLS_DIR/bin/$binary_name $version_cmd
+        fi
+
+        echo -e "${GREEN}Skipping download and installation.${NC}"
+        return 0
+    fi
+
+    # Create directory for the tool
+    mkdir -p "$TOOLS_DIR/$tool_dir_name"
+
+    # Special handling for HOMER
+    if [ "$tool_name" = "HOMER" ]; then
+        echo -e "${YELLOW}Installing HOMER via Perl script...${NC}"
+
+        # Download the configuration script directly to the bin directory
+        $DOWNLOADER "$TOOLS_DIR/bin/configureHomer.pl" "$download_url"
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to download HOMER configuration script from $download_url${NC}"
+            return 1
+        fi
+
+        # Make the script executable
+        chmod +x "$TOOLS_DIR/bin/configureHomer.pl"
+
+        # Create a HOMER installation directory
+        mkdir -p "$TOOLS_DIR/$tool_dir_name/homer"
+
+        # Run the configuration script
+        echo -e "${YELLOW}Running HOMER configuration script...${NC}"
+        echo -e "${YELLOW}This will install HOMER to $TOOLS_DIR/$tool_dir_name/homer${NC}"
+
+        # Install HOMER with batch mode ("-b" flag for basic installation)
+        # Use -local to specify the absolute installation directory
+        "$TOOLS_DIR/bin/configureHomer.pl" -install -local "$TOOLS_DIR/$tool_dir_name/homer" -b
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to install HOMER.${NC}"
+            return 1
+        fi
+
+        # Create symlinks to HOMER binaries
+        echo -e "${YELLOW}Creating symlinks to HOMER binaries...${NC}"
+        for homer_bin in "$TOOLS_DIR/$tool_dir_name/homer/bin/"*; do
+            if [ -f "$homer_bin" ] && [ -x "$homer_bin" ]; then
+                ln -sf "$homer_bin" "$TOOLS_DIR/bin/$(basename "$homer_bin")"
+            fi
+        done
+
+        # Create a sourceable environment setup file
+        echo "#!/bin/bash" > "$TOOLS_DIR/$tool_dir_name/homer_env.sh"
+        echo "export PATH=\"$TOOLS_DIR/$tool_dir_name/homer/bin:\$PATH\"" >> "$TOOLS_DIR/$tool_dir_name/homer_env.sh"
+        echo "export HOMER=\"$TOOLS_DIR/$tool_dir_name/homer\"" >> "$TOOLS_DIR/$tool_dir_name/homer_env.sh"
+        chmod +x "$TOOLS_DIR/$tool_dir_name/homer_env.sh"
+
+        # Add the HOMER environment to the global setup_path.sh
+        echo "# HOMER environment" >> "$TOOLS_DIR/setup_path.sh"
+        echo "export PATH=\"$TOOLS_DIR/$tool_dir_name/homer/bin:\$PATH\"" >> "$TOOLS_DIR/setup_path.sh"
+        echo "export HOMER=\"$TOOLS_DIR/$tool_dir_name/homer\"" >> "$TOOLS_DIR/setup_path.sh"
+
+        echo -e "${GREEN}HOMER installed successfully!${NC}"
+        echo -e "${YELLOW}To use HOMER, you may need to source the environment file:${NC}"
+        echo -e "${GREEN}source $TOOLS_DIR/$tool_dir_name/homer_env.sh${NC}"
+        echo -e "${YELLOW}Or you can run configureHomer.pl directly from:${NC}"
+        echo -e "${GREEN}$TOOLS_DIR/bin/configureHomer.pl${NC}"
+        return 0
+
+    # Special handling for FastTree (requires compilation)
+    elif [ "$tool_name" = "FastTree" ]; then
+        echo -e "${YELLOW}Installing FastTree from source...${NC}"
+
+        # Download the source
+        $DOWNLOADER "$TOOLS_DIR/$tool_dir_name/FastTree.c" "$download_url"
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to download FastTree source from $download_url${NC}"
+            return 1
+        fi
+
+        # Compile FastTree
+        echo -e "${YELLOW}Compiling FastTree...${NC}"
+        echo -e "${YELLOW}This may take a few minutes.${NC}"
+
+        # Try to compile with SSE support first
+        (cd "$TOOLS_DIR/$tool_dir_name" && gcc -O3 -finline-functions -funroll-loops -Wall -o FastTree FastTree.c -lm)
+
+        # If compilation fails, try without SSE support
+        if [ $? -ne 0 ]; then
+            echo -e "${YELLOW}Compilation with SSE failed, trying without SSE...${NC}"
+            (cd "$TOOLS_DIR/$tool_dir_name" && gcc -DNO_SSE -O3 -finline-functions -funroll-loops -Wall -o FastTree FastTree.c -lm)
+
+            if [ $? -ne 0 ]; then
+                echo -e "${RED}Failed to compile FastTree.${NC}"
+                return 1
+            fi
+        fi
+
+        # Create symlink
+        ln -sf "$TOOLS_DIR/$tool_dir_name/FastTree" "$TOOLS_DIR/bin/FastTree"
+
+        echo -e "${GREEN}FastTree installed successfully!${NC}"
+
+        # Test installation
+        if [ -f "$TOOLS_DIR/bin/FastTree" ]; then
+            echo -e "${GREEN}FastTree installed successfully!${NC}"
+            if [ -n "$version_cmd" ]; then
+                echo -e "${YELLOW}Running version command: $TOOLS_DIR/bin/FastTree $version_cmd | head -n 5${NC}"
+                "$TOOLS_DIR/bin/FastTree" $version_cmd | head -n 5
+            fi
+        else
+            echo -e "${RED}FastTree installation failed.${NC}"
+            echo -e "${YELLOW}Binary not found at: $TOOLS_DIR/bin/FastTree${NC}"
+            return 1
+        fi
+
+        return 0
+
+    # Special handling for BWA (requires compilation)
+    elif [ "$tool_name" = "BWA" ]; then
+        echo -e "${YELLOW}Installing BWA...${NC}"
+
+        # Check if git is installed
+        if ! command -v git &> /dev/null; then
+            echo -e "${RED}Git is not installed. Please install git to continue.${NC}"
+            return 1
+        fi
+
+        # Clone the repository
+        echo -e "${YELLOW}Cloning BWA repository from $download_url...${NC}"
+        mkdir -p "$TOOLS_DIR/$tool_dir_name"
+        git clone "$download_url" "$TOOLS_DIR/$tool_dir_name"
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to clone BWA repository from $download_url${NC}"
+            return 1
+        fi
+
+        # Compile BWA
+        echo -e "${YELLOW}Compiling BWA...${NC}"
+        (cd "$TOOLS_DIR/$tool_dir_name" && make)
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to compile BWA.${NC}"
+            return 1
+        fi
+
+        # Create symlink
+        ln -sf "$TOOLS_DIR/$tool_dir_name/bwa" "$TOOLS_DIR/bin/bwa"
+
+        # Test installation
+        if [ -f "$TOOLS_DIR/bin/bwa" ]; then
+            echo -e "${GREEN}BWA installed successfully!${NC}"
+            echo -e "${YELLOW}Running version check:${NC}"
+            "$TOOLS_DIR/bin/bwa" 2>&1 | head -n 3
+        else
+            echo -e "${RED}BWA installation failed.${NC}"
+            echo -e "${YELLOW}Binary not found at: $TOOLS_DIR/bin/bwa${NC}"
+            return 1
+        fi
+
+        return 0
+    fi
+
+    # Download the tool
+    echo -e "${YELLOW}Downloading $tool_name from: $download_url${NC}"
+
+    # Determine file extension
+    if [[ "$download_url" == *".zip" ]]; then
+        # Use verbose output to help diagnose issues
+        $DOWNLOADER "$TOOLS_DIR/$tool_dir_name.zip" "$download_url"
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to download $tool_name from $download_url${NC}"
+            echo -e "${YELLOW}Please check your internet connection and try again.${NC}"
+            echo -e "${YELLOW}If the problem persists, the download URL may be incorrect or the server may be down.${NC}"
+            return 1
+        fi
+
+        echo -e "${YELLOW}Extracting $tool_name...${NC}"
+        unzip -q -o "$TOOLS_DIR/$tool_dir_name.zip" -d "$TOOLS_DIR/$tool_dir_name"
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to extract $tool_name.${NC}"
+            return 1
+        fi
+
+        # Clean up
+        rm "$TOOLS_DIR/$tool_dir_name.zip"
+    elif [[ "$download_url" == *".tar.gz" ]]; then
+        # Use verbose output to help diagnose issues
+        $DOWNLOADER "$TOOLS_DIR/$tool_dir_name.tar.gz" "$download_url"
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to download $tool_name from $download_url${NC}"
+            echo -e "${YELLOW}Please check your internet connection and try again.${NC}"
+            echo -e "${YELLOW}If the problem persists, the download URL may be incorrect or the server may be down.${NC}"
+            return 1
+        fi
+
+        echo -e "${YELLOW}Extracting $tool_name...${NC}"
+        mkdir -p "$TOOLS_DIR/$tool_dir_name"
+        tar -xzf "$TOOLS_DIR/$tool_dir_name.tar.gz" -C "$TOOLS_DIR/$tool_dir_name" --strip-components=1
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to extract $tool_name.${NC}"
+            return 1
+        fi
+
+        # Clean up
+        rm "$TOOLS_DIR/$tool_dir_name.tar.gz"
+    # Handle executable files directly (for MUSCLE)
+    elif [[ "$tool_name" = "MUSCLE" ]]; then
+        echo -e "${YELLOW}Downloading $tool_name binary...${NC}"
+        $DOWNLOADER "$TOOLS_DIR/$tool_dir_name/$binary_name" "$download_url"
+
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to download $tool_name from $download_url${NC}"
+            return 1
+        fi
+
+        # Make executable
+        chmod +x "$TOOLS_DIR/$tool_dir_name/$binary_name"
+
+        # Create symlink
+        ln -sf "$TOOLS_DIR/$tool_dir_name/$binary_name" "$TOOLS_DIR/bin/$binary_name"
+
+        # Test installation
+        if [ -f "$TOOLS_DIR/bin/$binary_name" ]; then
+            echo -e "${GREEN}$tool_name installed successfully!${NC}"
+            if [ -n "$version_cmd" ]; then
+                echo -e "${YELLOW}Running version command: $TOOLS_DIR/bin/$binary_name $version_cmd${NC}"
+                "$TOOLS_DIR/bin/$binary_name" $version_cmd
+            fi
+        else
+            echo -e "${RED}$tool_name installation failed.${NC}"
+            echo -e "${YELLOW}Binary not found at: $TOOLS_DIR/bin/$binary_name${NC}"
+            return 1
+        fi
+
+        return 0
+    else
+        echo -e "${RED}Unsupported file format for $tool_name.${NC}"
+        return 1
+    fi
+
+    # Find the binary path
+    local full_binary_path=$(find "$TOOLS_DIR/$tool_dir_name" -name "$(basename "$binary_path")" | head -n 1)
+
+    if [ -z "$full_binary_path" ]; then
+        echo -e "${RED}Could not find binary for $tool_name.${NC}"
+        echo -e "${YELLOW}Looking for binary at expected path: $TOOLS_DIR/$tool_dir_name/$binary_path${NC}"
+        full_binary_path="$TOOLS_DIR/$tool_dir_name/$binary_path"
+    fi
+
+    # Make the binary executable
+    chmod +x "$full_binary_path"
+
+    # Create symlink in bin directory
+    ln -sf "$full_binary_path" "$TOOLS_DIR/bin/$binary_name"
+
+    # Test installation
+    if [ -f "$TOOLS_DIR/bin/$binary_name" ]; then
+        echo -e "${GREEN}$tool_name installed successfully!${NC}"
+        if [ -n "$version_cmd" ]; then
+            echo -e "${YELLOW}Running version command: $TOOLS_DIR/bin/$binary_name $version_cmd${NC}"
+            "$TOOLS_DIR/bin/$binary_name" $version_cmd
+        fi
+    else
+        echo -e "${RED}$tool_name installation failed.${NC}"
+        echo -e "${YELLOW}Binary not found at: $TOOLS_DIR/bin/$binary_name${NC}"
+        return 1
+    fi
+
+    return 0
+}
+
+# Function to install a tool from the config
+install_tool_from_config() {
+    local tool_index=$1
+    local auto_install=${2:-0}
+
+    # Get tool information from config
+    local tool_name=$(jq -r ".tools[$tool_index].name" "$CONFIG_FILE")
+    local tool_desc=$(jq -r ".tools[$tool_index].description" "$CONFIG_FILE")
+
+    # Determine the appropriate download URL based on the system
+    local download_url=""
+    if [[ "$(uname)" == "Darwin" ]]; then
+        if [[ "$(uname -m)" == "arm64" ]]; then
+            # macOS M1
+            download_url=$(jq -r ".tools[$tool_index].downloads.macos_arm64" "$CONFIG_FILE")
+        else
+            # macOS Intel
+            download_url=$(jq -r ".tools[$tool_index].downloads.macos_intel" "$CONFIG_FILE")
+        fi
+    else
+        # Linux
+        download_url=$(jq -r ".tools[$tool_index].downloads.linux" "$CONFIG_FILE")
+    fi
+
+    local binary_path=$(jq -r ".tools[$tool_index].binary_path" "$CONFIG_FILE")
+    local version_cmd=$(jq -r ".tools[$tool_index].version_command" "$CONFIG_FILE")
+
+    # Install the tool
+    echo -e "\n${YELLOW}$tool_name: $tool_desc${NC}"
+
+    # If auto_install is enabled, install without asking
+    if [ "$auto_install" -eq 1 ]; then
+        install_tool "$tool_name" "$download_url" "$binary_path" "$version_cmd"
+        return $?
+    fi
+
+    # Otherwise, ask for confirmation
+    read -p "Install $tool_name? (y/n) " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        install_tool "$tool_name" "$download_url" "$binary_path" "$version_cmd"
+        return $?
+    fi
+
+    return 0
+}
+
+# Function to add a new tool to the config
+add_new_tool() {
+    echo -e "\n${BLUE}=== Add a New Tool ===${NC}"
+
+    read -p "Tool name: " tool_name
+    read -p "Tool description: " tool_desc
+    read -p "Tool website: " tool_website
+    read -p "Linux download URL: " linux_url
+    read -p "macOS Intel download URL: " macos_intel_url
+    read -p "macOS ARM64 download URL: " macos_arm64_url
+    read -p "Binary path (relative to extraction): " binary_path
+    read -p "Version command (e.g., --version): " version_cmd
+
+    # Generate function name
+    function_name="install_$(echo "$tool_name" | tr '[:upper:]' '[:lower:]' | tr ' .' '_')"
+
+    # Create new tool JSON
+    new_tool=$(cat <<EOF
+{
+  "name": "$tool_name",
+  "function_name": "$function_name",
+  "description": "$tool_desc",
+  "website": "$tool_website",
+  "downloads": {
+    "linux": "$linux_url",
+    "macos_intel": "$macos_intel_url",
+    "macos_arm64": "$macos_arm64_url"
+  },
+  "binary_path": "$binary_path",
+  "version_command": "$version_cmd"
+}
+EOF
+)
+
+    # Add to config file
+    jq ".tools += [$new_tool]" "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
+
+    echo -e "${GREEN}Tool added to configuration!${NC}"
+
+    # Ask if user wants to install the tool now
+    read -p "Install $tool_name now? (y/n) " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        local tool_index=$(jq '.tools | length - 1' "$CONFIG_FILE")
+        install_tool_from_config "$tool_index"
+    fi
+}
+
+# Function to install all tools
+install_all_tools() {
+    local auto_install=${1:-0}
+    local num_tools=$(jq '.tools | length' "$CONFIG_FILE")
+
+    echo -e "\n${BLUE}Installing all command-line tools...${NC}"
+
+    for (( i=0; i<$num_tools; i++ )); do
+        install_tool_from_config "$i" "$auto_install"
+    done
+
+    return 0
+}
+
+# Function to add PATH to shell profile
+add_path_to_profile() {
+    local force_profile=${1:-""}
+
+    # Try to detect the shell profile file
+    local profile_file=""
+    local shell_name=$(basename "$SHELL")
+
+    # Create a sourceable file in the tools directory with PATH cleanup
+    echo "#!/bin/bash" > "$TOOLS_DIR/setup_path.sh"
+    echo "# Added by biomni setup" >> "$TOOLS_DIR/setup_path.sh"
+    echo "# Remove any old paths first to avoid duplicates" >> "$TOOLS_DIR/setup_path.sh"
+    echo "PATH=\$(echo \$PATH | tr ':' '\n' | grep -v \"biomni_tools/bin\" | tr '\n' ':' | sed 's/:$//')" >> "$TOOLS_DIR/setup_path.sh"
+    echo "export PATH=\"$TOOLS_DIR/bin:\$PATH\"" >> "$TOOLS_DIR/setup_path.sh"
+    echo "# Clear the shell's command hash table to force it to re-search the PATH" >> "$TOOLS_DIR/setup_path.sh"
+    echo "hash -r 2>/dev/null || rehash 2>/dev/null || true" >> "$TOOLS_DIR/setup_path.sh"
+    chmod +x "$TOOLS_DIR/setup_path.sh"
+    echo -e "${GREEN}Created sourceable file at $TOOLS_DIR/setup_path.sh${NC}"
+    echo -e "${YELLOW}You can add this to your PATH by running:${NC}"
+    echo -e "${GREEN}source $TOOLS_DIR/setup_path.sh${NC}"
+
+    # If a specific profile is forced, use that
+    if [ -n "$force_profile" ]; then
+        profile_file="$HOME/$force_profile"
+        echo -e "${YELLOW}Using specified profile file: $profile_file${NC}"
+    else
+        # Auto-detect based on current shell
+        case "$shell_name" in
+            bash)
+                if [ -f "$HOME/.bash_profile" ]; then
+                    profile_file="$HOME/.bash_profile"
+                elif [ -f "$HOME/.profile" ]; then
+                    profile_file="$HOME/.profile"
+                elif [ -f "$HOME/.bashrc" ]; then
+                    profile_file="$HOME/.bashrc"
+                fi
+                ;;
+            zsh)
+                profile_file="$HOME/.zshrc"
+                ;;
+            fish)
+                # Fish has a different configuration structure
+                mkdir -p "$HOME/.config/fish"
+                profile_file="$HOME/.config/fish/config.fish"
+                ;;
+            *)
+                # For other shells, try common profile files
+                if [ -f "$HOME/.profile" ]; then
+                    profile_file="$HOME/.profile"
+                elif [ -f "$HOME/.bashrc" ]; then
+                    profile_file="$HOME/.bashrc"
+                elif [ -f "$HOME/.zshrc" ]; then
+                    profile_file="$HOME/.zshrc"
+                fi
+                ;;
+        esac
+    fi
+
+    # If we found a profile file and it's writable, add the PATH
+    if [ -n "$profile_file" ]; then
+        # Create the file if it doesn't exist
+        if [ ! -f "$profile_file" ]; then
+            echo -e "${YELLOW}Creating new profile file: $profile_file${NC}"
+            touch "$profile_file"
+        fi
+
+        if [ -w "$profile_file" ]; then
+            # Check if the PATH is already in the profile
+            if ! grep -q "export PATH=\"$TOOLS_DIR/bin:\$PATH\"" "$profile_file"; then
+                # Remove any old biomni_tools paths first
+                if grep -q "biomni_tools/bin" "$profile_file"; then
+                    echo -e "${YELLOW}Removing old biomni_tools paths from $profile_file...${NC}"
+                    sed -i '/biomni_tools\/bin/d' "$profile_file"
+                fi
+
+                echo "" >> "$profile_file"
+                echo "# Added by biomni setup" >> "$profile_file"
+                echo "# Remove any old paths first to avoid duplicates" >> "$profile_file"
+                echo "PATH=\$(echo \$PATH | tr ':' '\n' | grep -v \"biomni_tools/bin\" | tr '\n' ':' | sed 's/:$//')" >> "$profile_file"
+
+                # Use the appropriate syntax for the shell
+                if [ "$shell_name" = "fish" ]; then
+                    echo "set -gx PATH $TOOLS_DIR/bin \$PATH" >> "$profile_file"
+                else
+                    echo "export PATH=\"$TOOLS_DIR/bin:\$PATH\"" >> "$profile_file"
+                fi
+
+                echo -e "${GREEN}Added tools directory to PATH in $profile_file${NC}"
+                echo -e "${YELLOW}Note: You may need to restart your shell or run 'source $profile_file' for changes to take effect.${NC}"
+            else
+                echo -e "${GREEN}PATH already configured in $profile_file${NC}"
+            fi
+        else
+            echo -e "${RED}Profile file $profile_file is not writable.${NC}"
+            echo -e "${YELLOW}Please add the following line to your shell profile manually:${NC}"
+
+            if [ "$shell_name" = "fish" ]; then
+                echo -e "${GREEN}set -gx PATH $TOOLS_DIR/bin \$PATH${NC}"
+            else
+                echo -e "${GREEN}export PATH=\"$TOOLS_DIR/bin:\$PATH\"${NC}"
+            fi
+
+            echo -e "${YELLOW}Or source the setup file we created:${NC}"
+            echo -e "${GREEN}source $TOOLS_DIR/setup_path.sh${NC}"
+        fi
+    else
+        # If we couldn't find a profile file, just print instructions
+        echo -e "${YELLOW}Could not determine appropriate shell profile file.${NC}"
+        echo -e "${YELLOW}Please add the following line to your shell profile manually:${NC}"
+
+        if [ "$shell_name" = "fish" ]; then
+            echo -e "${GREEN}set -gx PATH $TOOLS_DIR/bin \$PATH${NC}"
+        else
+            echo -e "${GREEN}export PATH=\"$TOOLS_DIR/bin:\$PATH\"${NC}"
+        fi
+
+        echo -e "${YELLOW}Or source the setup file we created:${NC}"
+        echo -e "${GREEN}source $TOOLS_DIR/setup_path.sh${NC}"
+    fi
+
+    # Always export PATH for the current session
+    # Remove any old paths first to avoid duplicates
+    PATH=$(echo $PATH | tr ':' '\n' | grep -v "biomni_tools/bin" | tr '\n' ':' | sed 's/:$//')
+    export PATH="$TOOLS_DIR/bin:$PATH"
+
+    # Clear the shell's command hash table to force it to re-search the PATH
+    hash -r 2>/dev/null || rehash 2>/dev/null || true
+
+    # Create a test script to verify the tools are in the PATH
+    echo "#!/bin/bash" > "$TOOLS_DIR/test_tools.sh"
+    echo "echo \"Testing if tools are in the PATH...\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "echo \"Current PATH: \$PATH\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "echo \"\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "echo \"Looking for tools in: $TOOLS_DIR/bin\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "ls -la \"$TOOLS_DIR/bin\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "echo \"\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "echo \"Checking for path caching issues...\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "for tool in \$(ls \"$TOOLS_DIR/bin\"); do" >> "$TOOLS_DIR/test_tools.sh"
+    echo "  which \$tool 2>/dev/null | grep -q \"/afs/cs.stanford.edu\" && {" >> "$TOOLS_DIR/test_tools.sh"
+    echo "    echo \"WARNING: \$tool is still pointing to the old AFS location!\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "    echo \"Run 'hash -r' (bash) or 'rehash' (zsh) to clear the command cache.\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "    break" >> "$TOOLS_DIR/test_tools.sh"
+    echo "  }" >> "$TOOLS_DIR/test_tools.sh"
+    echo "done" >> "$TOOLS_DIR/test_tools.sh"
+    echo "echo \"\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "for tool in \$(ls \"$TOOLS_DIR/bin\"); do" >> "$TOOLS_DIR/test_tools.sh"
+    echo "  if command -v \$tool &> /dev/null; then" >> "$TOOLS_DIR/test_tools.sh"
+    echo "    echo \"\$tool: \$(which \$tool)\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "  else" >> "$TOOLS_DIR/test_tools.sh"
+    echo "    echo \"\$tool: NOT FOUND IN PATH\"" >> "$TOOLS_DIR/test_tools.sh"
+    echo "  fi" >> "$TOOLS_DIR/test_tools.sh"
+    echo "done" >> "$TOOLS_DIR/test_tools.sh"
+    chmod +x "$TOOLS_DIR/test_tools.sh"
+
+    echo -e "${YELLOW}Created test script at $TOOLS_DIR/test_tools.sh${NC}"
+    echo -e "${YELLOW}You can run it to verify the tools are in your PATH:${NC}"
+    echo -e "${GREEN}$TOOLS_DIR/test_tools.sh${NC}"
+
+    # Create a quick fix script for path caching issues
+    echo "#!/bin/bash" > "$TOOLS_DIR/fix_path.sh"
+    echo "# Script to fix path caching issues" >> "$TOOLS_DIR/fix_path.sh"
+    echo "echo \"Fixing path caching issues...\"" >> "$TOOLS_DIR/fix_path.sh"
+    echo "# Remove any old paths first to avoid duplicates" >> "$TOOLS_DIR/fix_path.sh"
+    echo "PATH=\$(echo \$PATH | tr ':' '\n' | grep -v \"biomni_tools/bin\" | tr '\n' ':' | sed 's/:$//')" >> "$TOOLS_DIR/fix_path.sh"
+    echo "export PATH=\"$TOOLS_DIR/bin:\$PATH\"" >> "$TOOLS_DIR/fix_path.sh"
+    echo "# Clear the shell's command hash table to force it to re-search the PATH" >> "$TOOLS_DIR/fix_path.sh"
+    echo "hash -r 2>/dev/null || rehash 2>/dev/null || true" >> "$TOOLS_DIR/fix_path.sh"
+    echo "echo \"Path fixed. Try running your command again.\"" >> "$TOOLS_DIR/fix_path.sh"
+    chmod +x "$TOOLS_DIR/fix_path.sh"
+
+    echo -e "${YELLOW}Created fix script at $TOOLS_DIR/fix_path.sh${NC}"
+    echo -e "${YELLOW}If you encounter 'No such file or directory' errors, run:${NC}"
+    echo -e "${GREEN}source $TOOLS_DIR/fix_path.sh${NC}"
+}
+
+# Function to verify installation
+verify_installation() {
+    echo -e "\n${BLUE}=== Verifying Installation ===${NC}"
+    echo -e "${YELLOW}Tools directory: $TOOLS_DIR${NC}"
+    echo -e "${YELLOW}Bin directory: $TOOLS_DIR/bin${NC}"
+
+    # Check if bin directory exists
+    if [ ! -d "$TOOLS_DIR/bin" ]; then
+        echo -e "${RED}Bin directory does not exist!${NC}"
+        return 1
+    fi
+
+    # Check if there are any tools in the bin directory
+    local tool_count=$(ls -1 "$TOOLS_DIR/bin" 2>/dev/null | wc -l)
+    if [ "$tool_count" -eq 0 ]; then
+        echo -e "${RED}No tools found in bin directory!${NC}"
+        return 1
+    fi
+
+    echo -e "${GREEN}Found $tool_count tools in bin directory.${NC}"
+
+    # List all tools
+    echo -e "${YELLOW}Installed tools:${NC}"
+    ls -la "$TOOLS_DIR/bin"
+
+    # Check if tools are in PATH
+    echo -e "\n${YELLOW}Checking if tools are in PATH...${NC}"
+    echo -e "${YELLOW}Current PATH: $PATH${NC}"
+
+    # Check if TOOLS_DIR/bin is in PATH
+    if [[ "$PATH" == *"$TOOLS_DIR/bin"* ]]; then
+        echo -e "${GREEN}Tools directory is in PATH.${NC}"
+    else
+        echo -e "${RED}Tools directory is NOT in PATH!${NC}"
+        echo -e "${YELLOW}Please run: source $TOOLS_DIR/setup_path.sh${NC}"
+        return 1
+    fi
+
+    # Check if each tool is accessible
+    echo -e "\n${YELLOW}Testing tool accessibility:${NC}"
+    for tool in $(ls "$TOOLS_DIR/bin"); do
+        if command -v "$tool" &> /dev/null; then
+            echo -e "${GREEN}$tool: $(which $tool)${NC}"
+        else
+            echo -e "${RED}$tool: NOT FOUND IN PATH${NC}"
+        fi
+    done
+
+    echo -e "\n${GREEN}Installation verification completed.${NC}"
+    echo -e "${YELLOW}If you encounter any issues, please run:${NC}"
+    echo -e "${GREEN}source $TOOLS_DIR/setup_path.sh${NC}"
+    echo -e "${YELLOW}And then run the test script:${NC}"
+    echo -e "${GREEN}$TOOLS_DIR/test_tools.sh${NC}"
+
+    echo -e "\n${YELLOW}IMPORTANT: If you see 'No such file or directory' errors when running tools,${NC}"
+    echo -e "${YELLOW}your shell may be using cached paths to old tool locations.${NC}"
+    echo -e "${YELLOW}To fix this, run:${NC}"
+    echo -e "${GREEN}source $TOOLS_DIR/fix_path.sh${NC}"
+    echo -e "${YELLOW}Or run one of these commands:${NC}"
+    echo -e "${GREEN}hash -r${NC} (for bash/sh)"
+    echo -e "${GREEN}rehash${NC} (for zsh/csh)"
+    echo -e "${YELLOW}Or simply start a new terminal session.${NC}"
+
+    return 0
+}
+
+# Main installation function
+install_cli_tools() {
+    echo -e "${YELLOW}=== Installing Command-Line Bioinformatics Tools ===${NC}"
+
+    # Try to add the tools bin directory to PATH
+    add_path_to_profile
+
+    # Check if auto-install mode is enabled
+    if [ -n "$BIOMNI_AUTO_INSTALL" ]; then
+        install_all_tools 1
+
+        echo -e "\n${GREEN}CLI tools installation completed!${NC}"
+        echo -e "The tools are installed in: ${YELLOW}$TOOLS_DIR${NC}"
+        echo -e "Binaries are symlinked in: ${YELLOW}$TOOLS_DIR/bin${NC}"
+        echo -e "Tools have been added to your PATH for the current session."
+
+        # Verify installation
+        verify_installation
+
+        return 0
+    fi
+
+    # Get the number of tools in the config
+    local num_tools=$(jq '.tools | length' "$CONFIG_FILE")
+
+    # Display menu
+    echo -e "\n${BLUE}Available tools:${NC}"
+    for (( i=0; i<$num_tools; i++ )); do
+        local tool_name=$(jq -r ".tools[$i].name" "$CONFIG_FILE")
+        local tool_desc=$(jq -r ".tools[$i].description" "$CONFIG_FILE")
+        echo -e "${YELLOW}$((i+1)). $tool_name${NC} - $tool_desc"
+    done
+    echo -e "${YELLOW}$((num_tools+1)). Add a new tool${NC}"
+    echo -e "${YELLOW}$((num_tools+2)). Install all tools${NC}"
+    echo -e "${YELLOW}$((num_tools+3)). Add tools directory to shell profile${NC}"
+    echo -e "${YELLOW}0. Exit${NC}"
+
+    # Get user choice
+    read -p "Enter your choice (0-$((num_tools+3))): " choice
+
+    if [[ "$choice" -eq 0 ]]; then
+        echo -e "${YELLOW}Exiting...${NC}"
+        return 0
+    elif [[ "$choice" -eq $((num_tools+1)) ]]; then
+        add_new_tool
+    elif [[ "$choice" -eq $((num_tools+2)) ]]; then
+        # Install all tools
+        install_all_tools
+    elif [[ "$choice" -eq $((num_tools+3)) ]]; then
+        # Add to shell profile
+        echo -e "\n${BLUE}=== Adding to Shell Profile ===${NC}"
+        echo -e "1. Auto-detect profile (recommended)"
+        echo -e "2. Specify profile file"
+        read -p "Enter your choice (1-2): " profile_choice
+
+        if [[ "$profile_choice" -eq 1 ]]; then
+            add_path_to_profile
+        elif [[ "$profile_choice" -eq 2 ]]; then
+            echo -e "\nCommon profile files:"
+            echo -e "- .bash_profile (for Bash on macOS/login shells)"
+            echo -e "- .bashrc (for Bash on Linux/non-login shells)"
+            echo -e "- .zshrc (for Zsh)"
+            echo -e "- .config/fish/config.fish (for Fish)"
+            echo -e "- .profile (generic)"
+            read -p "Enter profile filename (without $HOME/ prefix): " profile_file
+            add_path_to_profile "$profile_file"
+        else
+            echo -e "${RED}Invalid choice.${NC}"
+        fi
+    elif [[ "$choice" -ge 1 ]] && [[ "$choice" -le "$num_tools" ]]; then
+        # Install selected tool
+        install_tool_from_config "$((choice-1))"
+    else
+        echo -e "${RED}Invalid choice.${NC}"
+        return 1
+    fi
+
+    echo -e "\n${GREEN}CLI tools installation completed!${NC}"
+    echo -e "The tools are installed in: ${YELLOW}$TOOLS_DIR${NC}"
+    echo -e "Binaries are symlinked in: ${YELLOW}$TOOLS_DIR/bin${NC}"
+    echo -e "Tools have been added to your PATH for the current session."
+
+    # Ask if user wants to install more tools or configure PATH
+    read -p "Install more tools or configure PATH? (y/n) " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        install_cli_tools
+    fi
+}
+
+# Function to display help message
+show_help() {
+    echo "Usage: $0 [OPTION]"
+    echo "Install command-line bioinformatics tools for BioAgentOS."
+    echo
+    echo "Options:"
+    echo "  --auto                 Automatically install all tools without prompting"
+    echo "  --profile PROFILE      Add tools directory to the specified shell profile file"
+    echo "                         Example: $0 --profile .zshrc"
+    echo "  --help                 Display this help message and exit"
+    echo
+    echo "Without options, the script runs in interactive mode."
+}
+
+# Check command-line arguments
+if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+    show_help
+    exit 0
+elif [ "$1" = "--auto" ]; then
+    # Set BIOMNI_AUTO_INSTALL if it's not already set
+    export BIOMNI_AUTO_INSTALL=1
+
+    # Run in auto-install mode without showing the menu
+    install_all_tools 1
+
+    # Add to profile automatically
+    add_path_to_profile
+
+    # Verify installation
+    verify_installation
+
+    echo -e "\n${GREEN}CLI tools installation completed!${NC}"
+    echo -e "The tools are installed in: ${YELLOW}$TOOLS_DIR${NC}"
+    echo -e "Binaries are symlinked in: ${YELLOW}$TOOLS_DIR/bin${NC}"
+    echo -e "Tools have been added to your PATH for the current session."
+
+    exit 0
+elif [ "$1" = "--profile" ] && [ -n "$2" ]; then
+    # Add to a specific profile file
+    add_path_to_profile "$2"
+    exit 0
+elif [ -n "$BIOMNI_AUTO_INSTALL" ]; then
+    # Run in auto-install mode without showing the menu
+    install_all_tools 1
+
+    # Add to profile automatically
+    add_path_to_profile
+
+    # Verify installation
+    verify_installation
+
+    echo -e "\n${GREEN}CLI tools installation completed!${NC}"
+    echo -e "The tools are installed in: ${YELLOW}$TOOLS_DIR${NC}"
+    echo -e "Binaries are symlinked in: ${YELLOW}$TOOLS_DIR/bin${NC}"
+    echo -e "Tools have been added to your PATH for the current session."
+
+    exit 0
+elif [ -n "$1" ]; then
+    echo -e "${RED}Unknown option: $1${NC}"
+    show_help
+    exit 1
+else
+    # Run the interactive installation
+    install_cli_tools
+fi

biomni_env/install_r_packages.R

@@ -0,0 +1,132 @@
+#!/usr/bin/env Rscript
+
+# Script to install R packages that might be missing from the conda environment
+# Run this script after creating the conda environment if you encounter issues with R packages
+
+# Set repository
+options(repos = c(CRAN = "https://cran.rstudio.com/"))
+
+# Function to install a package if it's not already installed
+install_if_missing <- function(package_name, bioconductor = FALSE) {
+  if (!require(package_name, character.only = TRUE, quietly = TRUE)) {
+    cat(sprintf("Installing package: %s\n", package_name))
+
+    if (bioconductor) {
+      if (!require("BiocManager", quietly = TRUE)) {
+        install.packages("BiocManager", dependencies = TRUE)
+      }
+      BiocManager::install(package_name, update = FALSE, ask = FALSE, dependencies = TRUE)
+    } else {
+      install.packages(package_name, dependencies = TRUE)
+    }
+
+    # Check if installation was successful
+    if (require(package_name, character.only = TRUE, quietly = TRUE)) {
+      cat(sprintf("✓ Successfully installed %s\n", package_name))
+    } else {
+      cat(sprintf("✗ Failed to install %s\n", package_name))
+    }
+  } else {
+    cat(sprintf("✓ Package %s is already installed\n", package_name))
+  }
+}
+
+# Install BiocManager first with dependencies
+cat("Installing BiocManager...\n")
+if (!require("BiocManager", quietly = TRUE)) {
+  install.packages("BiocManager", dependencies = TRUE)
+}
+
+# Make sure BiocManager is up to date
+BiocManager::install(version = BiocManager::version(), update = TRUE, ask = FALSE)
+
+# Install system dependencies for Bioconductor packages
+cat("\nInstalling system dependencies for Bioconductor packages...\n")
+
+# Install CRAN packages
+cran_packages <- c(
+  "ggplot2",
+  "lme4",
+  "dplyr",
+  "tidyr",
+  "readr",
+  "stringr",
+  "Matrix",  # Required for Seurat
+  "Rcpp",    # Required for many packages
+  "devtools", # Useful for package installation
+  "remotes",  # Required for GitHub installations
+  "harmony"
+)
+
+# Install Bioconductor packages
+bioc_packages <- c(
+  "DESeq2",
+  "dada2",
+  "xcms",
+  "flowCore",
+  "edgeR",
+  "limma"
+)
+
+# Install CRAN packages
+cat("\nInstalling CRAN packages...\n")
+for (pkg in cran_packages) {
+  install_if_missing(pkg)
+}
+
+# Install Bioconductor packages one by one with specific handling
+cat("\nInstalling Bioconductor packages...\n")
+
+# Install DESeq2 with dependencies
+cat("\nInstalling DESeq2 and dependencies...\n")
+if (!require("DESeq2", quietly = TRUE)) {
+  BiocManager::install("DESeq2", dependencies = TRUE, update = FALSE, ask = FALSE)
+}
+
+# Install WGCNA (from CRAN, not Bioconductor)
+# Following official instructions from https://cran.r-project.org/web/packages/WGCNA/index.html
+cat("\nInstalling WGCNA and dependencies...\n")
+if (!require("WGCNA", quietly = TRUE)) {
+  # Install WGCNA dependencies first
+  wgcna_deps <- c("dynamicTreeCut", "fastcluster", "matrixStats", "Hmisc", "foreach", "doParallel")
+  for (dep in wgcna_deps) {
+    install_if_missing(dep)
+  }
+
+  # Install Bioconductor dependencies for WGCNA
+  bioc_deps <- c("impute", "preprocessCore", "GO.db", "AnnotationDbi")
+  for (dep in bioc_deps) {
+    if (!require(dep, character.only = TRUE, quietly = TRUE)) {
+      BiocManager::install(dep, update = FALSE, ask = FALSE)
+    }
+  }
+
+  # Install WGCNA from CRAN
+  install.packages("WGCNA", dependencies = TRUE)
+}
+
+# Install clusterProfiler
+cat("\nInstalling clusterProfiler and dependencies...\n")
+if (!require("clusterProfiler", quietly = TRUE)) {
+  BiocManager::install("clusterProfiler", dependencies = TRUE, update = FALSE, ask = FALSE)
+}
+
+# Install remaining Bioconductor packages
+remaining_bioc <- setdiff(bioc_packages, c("DESeq2", "clusterProfiler"))
+for (pkg in remaining_bioc) {
+  install_if_missing(pkg, bioconductor = TRUE)
+}
+
+# Verify installations
+cat("\nVerifying installations...\n")
+all_packages <- c(cran_packages, bioc_packages, "WGCNA")
+for (pkg in unique(all_packages)) {
+  if (require(pkg, character.only = TRUE, quietly = TRUE)) {
+    cat(sprintf("✓ Package %s is successfully installed\n", pkg))
+  } else {
+    cat(sprintf("✗ Package %s is NOT installed\n", pkg))
+  }
+}
+
+cat("\nPackage installation completed!\n")
+cat("If you still encounter issues with specific packages, please install them manually.\n")

biomni_env/new_software_v008.sh

@@ -0,0 +1,18 @@
+# Biomni v0.0.8 - Incremental Software Installation
+# Add any new packages/software introduced in version 0.0.8 below
+pip install transformers sentencepiece langchain-google-genai langchain_ollama mcp
+pip install lazyslide
+pip install "git+https://github.com/YosefLab/popV.git@refs/pull/100/head"
+pip install uv
+sudo apt-get install git-lfs # or brew install git-lfs if you are on macOS
+git lfs install
+pip install pybiomart
+pip install fair-esm
+pip install uv
+uv pip install transcriptformer
+pip install "zarr>=2.0,<3.0" #this resolved transcripformer download isses
+uv tool install arc-state
+pip install nnunet nibabel nilearn
+pip install mi-googlesearch-python
+pip install git+https://github.com/pylabrobot/pylabrobot.git
+conda install weasyprint

biomni_env/r_packages.yml

@@ -0,0 +1,7 @@
+name: biomni_e1
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - r-essentials
+  - r-base>=4.4

biomni_env/setup.sh

@@ -0,0 +1,232 @@
+#!/bin/bash
+
+# BioAgentOS - Biomni Environment Setup Script
+# This script sets up a comprehensive bioinformatics environment with various tools and packages
+
+# Set up colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Default tools directory is the current directory
+DEFAULT_TOOLS_DIR="$(pwd)/biomni_tools"
+TOOLS_DIR=""
+
+echo -e "${YELLOW}=== Biomni Environment Setup ===${NC}"
+echo -e "${BLUE}This script will set up a comprehensive bioinformatics environment with various tools and packages.${NC}"
+
+# Check if conda is installed
+if ! command -v conda &> /dev/null && ! command -v micromamba &> /dev/null; then
+    echo -e "${RED}Error: Conda is not installed or not in PATH.${NC}"
+    echo "Please install Miniconda or Anaconda first."
+    echo "Visit: https://docs.conda.io/en/latest/miniconda.html"
+    exit 1
+fi
+
+# redirect to micromamba if needed
+if ! command -v conda &> /dev/null && command -v micromamba &> /dev/null; then
+    conda() {
+        micromamba "$@"
+    }
+    export -f conda
+fi
+
+# Function to handle errors
+handle_error() {
+    local exit_code=$1
+    local error_message=$2
+    local optional=${3:-false}
+
+    if [ $exit_code -ne 0 ]; then
+        echo -e "${RED}Error: $error_message${NC}"
+        if [ "$optional" = true ]; then
+            echo -e "${YELLOW}Continuing with setup as this component is optional.${NC}"
+            return 0
+        else
+            if [ -z "$NON_INTERACTIVE" ]; then
+                read -p "Continue with setup? (y/n) " -n 1 -r
+                echo
+                if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+                    echo -e "${RED}Setup aborted.${NC}"
+                    exit 1
+                fi
+            else
+                echo -e "${YELLOW}Non-interactive mode: continuing despite error.${NC}"
+            fi
+        fi
+    fi
+    return $exit_code
+}
+
+# Function to install a specific environment file
+install_env_file() {
+    local env_file=$1
+    local description=$2
+    local optional=${3:-false}
+
+    echo -e "\n${BLUE}=== Installing $description ===${NC}"
+
+    if [ "$optional" = true ]; then
+        if [ -z "$NON_INTERACTIVE" ]; then
+            read -p "Do you want to install $description? (y/n) " -n 1 -r
+            echo
+            if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+                echo -e "${YELLOW}Skipping $description installation.${NC}"
+                return 0
+            fi
+        else
+            echo -e "${YELLOW}Non-interactive mode: automatically installing $description.${NC}"
+        fi
+    fi
+
+    echo -e "${YELLOW}Installing $description from $env_file...${NC}"
+    conda env update -f $env_file
+    handle_error $? "Failed to install $description." $optional
+
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}Successfully installed $description!${NC}"
+    fi
+}
+
+# Function to install CLI tools
+install_cli_tools() {
+    echo -e "\n${BLUE}=== Installing Command-Line Bioinformatics Tools ===${NC}"
+
+    # Ask user for the directory to install CLI tools
+    if [ -z "$NON_INTERACTIVE" ]; then
+        echo -e "${YELLOW}Where would you like to install the command-line tools?${NC}"
+        echo -e "${BLUE}Default: $DEFAULT_TOOLS_DIR${NC}"
+        read -p "Enter directory path (or press Enter for default): " user_tools_dir
+    else
+        user_tools_dir=""
+        echo -e "${YELLOW}Non-interactive mode: using default directory $DEFAULT_TOOLS_DIR for CLI tools.${NC}"
+    fi
+
+    if [ -z "$user_tools_dir" ]; then
+        TOOLS_DIR="$DEFAULT_TOOLS_DIR"
+    else
+        TOOLS_DIR="$user_tools_dir"
+    fi
+
+    # Export the tools directory for the CLI tools installer
+    export BIOMNI_TOOLS_DIR="$TOOLS_DIR"
+
+    echo -e "${YELLOW}Installing command-line tools (PLINK, IQ-TREE, GCTA, etc.) to $TOOLS_DIR...${NC}"
+
+    # Set environment variable to skip prompts in the CLI tools installer
+    export BIOMNI_AUTO_INSTALL=1
+
+    # Run the CLI tools installer
+    bash install_cli_tools.sh
+    handle_error $? "Failed to install CLI tools." true
+
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}Successfully installed command-line tools!${NC}"
+
+        # Create a setup_path.sh file in the current directory
+        echo "#!/bin/bash" > setup_path.sh
+        echo "# Added by biomni setup" >> setup_path.sh
+        echo "# Remove any old paths first to avoid duplicates" >> setup_path.sh
+        echo "PATH=\$(echo \$PATH | tr ':' '\n' | grep -v \"biomni_tools/bin\" | tr '\n' ':' | sed 's/:$//')" >> setup_path.sh
+        echo "export PATH=\"$TOOLS_DIR/bin:\$PATH\"" >> setup_path.sh
+        chmod +x setup_path.sh
+
+        echo -e "${GREEN}Created setup_path.sh in the current directory.${NC}"
+        echo -e "${YELLOW}You can add the tools to your PATH by running:${NC}"
+        echo -e "${GREEN}source $(pwd)/setup_path.sh${NC}"
+
+        # Also add to the current session
+        # Remove any old paths first to avoid duplicates
+        PATH=$(echo $PATH | tr ':' '\n' | grep -v "biomni_tools/bin" | tr '\n' ':' | sed 's/:$//')
+        export PATH="$TOOLS_DIR/bin:$PATH"
+    fi
+
+    # Unset the environment variables
+    unset BIOMNI_AUTO_INSTALL
+    unset BIOMNI_TOOLS_DIR
+}
+
+# Main installation process
+main() {
+    # Step 1: Create base conda environment
+    echo -e "\n${YELLOW}Step 1: Creating base environment from environment.yml...${NC}"
+    conda env create -n biomni_e1 -f environment.yml
+    handle_error $? "Failed to create base conda environment."
+
+    # Step 2: Activate the environment
+    echo -e "\n${YELLOW}Step 2: Activating conda environment...${NC}"
+    if command -v micromamba &> /dev/null; then
+        eval "$("$MAMBA_EXE" shell hook --shell bash)"
+        micromamba activate biomni_e1
+    else
+        eval "$(conda shell.bash hook)"
+        conda activate biomni_e1
+    fi
+    handle_error $? "Failed to activate biomni_e1 environment."
+
+    # Step 3: Install core bioinformatics tools (including QIIME2)
+    echo -e "\n${YELLOW}Step 3: Installing core bioinformatics tools (including QIIME2)...${NC}"
+    install_env_file "bio_env.yml" "core bioinformatics tools"
+
+    # Step 4: Install R packages
+    echo -e "\n${YELLOW}Step 4: Installing R packages...${NC}"
+    install_env_file "r_packages.yml" "core R packages"
+
+    # Step 5: Install additional R packages through R's package manager
+    echo -e "\n${YELLOW}Step 5: Installing additional R packages through R's package manager...${NC}"
+    Rscript install_r_packages.R
+    handle_error $? "Failed to install additional R packages." true
+
+    # Step 6: Install CLI tools
+    echo -e "\n${YELLOW}Step 6: Installing command-line bioinformatics tools...${NC}"
+    install_cli_tools
+
+    # Setup completed
+    echo -e "\n${GREEN}=== Biomni Environment Setup Completed! ===${NC}"
+    echo -e "You can now run the example analysis with: ${YELLOW}python bio_analysis_example.py${NC}"
+    echo -e "To activate this environment in the future, run: ${YELLOW}conda activate biomni_e1${NC}"
+    echo -e "To use BioAgentOS, navigate to the BioAgentOS directory and follow the instructions in the README."
+
+    # Display CLI tools setup instructions
+    if [ -n "$TOOLS_DIR" ]; then
+        echo -e "\n${BLUE}=== Command-Line Tools Setup ===${NC}"
+        echo -e "The command-line tools are installed in: ${YELLOW}$TOOLS_DIR${NC}"
+        echo -e "To add these tools to your PATH, run: ${YELLOW}source $(pwd)/setup_path.sh${NC}"
+        echo -e "You can also add this line to your shell profile for permanent access:"
+        echo -e "${GREEN}export PATH=\"$TOOLS_DIR/bin:\$PATH\"${NC}"
+
+        # Test if tools are accessible
+        echo -e "\n${BLUE}=== Testing CLI Tools ===${NC}"
+        if command -v plink2 &> /dev/null; then
+            echo -e "${GREEN}PLINK2 is accessible in the current PATH${NC}"
+            echo -e "PLINK2 location: $(which plink2)"
+        else
+            echo -e "${RED}PLINK2 is not accessible in the current PATH${NC}"
+            echo -e "Please run: ${YELLOW}source $(pwd)/setup_path.sh${NC} to update your PATH"
+        fi
+
+        if command -v gcta64 &> /dev/null; then
+            echo -e "${GREEN}GCTA is accessible in the current PATH${NC}"
+            echo -e "GCTA location: $(which gcta64)"
+        else
+            echo -e "${RED}GCTA is not accessible in the current PATH${NC}"
+            echo -e "Please run: ${YELLOW}source $(pwd)/setup_path.sh${NC} to update your PATH"
+        fi
+
+        if command -v iqtree2 &> /dev/null; then
+            echo -e "${GREEN}IQ-TREE is accessible in the current PATH${NC}"
+            echo -e "IQ-TREE location: $(which iqtree2)"
+        else
+            echo -e "${RED}IQ-TREE is not accessible in the current PATH${NC}"
+            echo -e "Please run: ${YELLOW}source $(pwd)/setup_path.sh${NC} to update your PATH"
+        fi
+    fi
+
+    PATH=$(echo $PATH | tr ':' '\n' | grep -v "biomni_tools/bin" | tr '\n' ':' | sed 's/:$//')
+    export PATH="$(pwd)/biomni_tools/bin:$PATH"
+}
+
+# Run the main installation process
+main

docs/Makefile

@@ -0,0 +1,28 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+
+html:
+	@echo "Step 1: Generating API documentation..."
+	@python generate_api_docs.py
+
+	@echo "Step 2: Building HTML documentation with Sphinx..."
+	@$(SPHINXBUILD) -M html "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/building_documentation.md

@@ -0,0 +1,36 @@
+
+# Building Project Documentation
+
+To build the project's documentation locally, use the `Makefile` located in the `docs` directory.
+
+## Prerequisites
+
+First, ensure you have activated the `biomni_e1` conda environment. Then, install the required dependencies:
+
+```bash
+pip install sphinx sphinx-rtd-theme
+```
+
+
+## Build the Documentation
+
+1.  Navigate to the `docs` directory:
+
+    ```bash
+    cd docs
+    ```
+
+2.  Run the `make html` command:
+
+    ```bash
+    make html
+    ```
+
+    This command will automatically generate the API documentation and build all HTML files.
+
+
+## View the Documentation
+
+Once the build is complete, you can find the generated documentation in the `docs/build/html` directory.
+
+Open the `index.html` file in your browser to view it.

docs/configuration.md

@@ -0,0 +1,147 @@
+# Biomni Configuration Guide
+
+## Quick Start
+
+**Recommended approach**: Use environment variables or modify `default_config` for consistent behavior across your entire application.
+
+```python
+from biomni.config import default_config
+from biomni.agent import A1
+
+# Option 1: Modify global defaults (affects everything)
+default_config.llm = "gpt-4"
+default_config.timeout_seconds = 1200
+
+# Option 2: Use environment variables (set in .env file)
+# BIOMNI_LLM=gpt-4
+# BIOMNI_TIMEOUT_SECONDS=1200
+
+agent = A1()  # Uses your configuration
+```
+
+## Configuration Methods
+
+### 1. Environment Variables (Recommended for Production)
+
+Create a `.env` file in your project:
+
+```bash
+# Required API Keys (at least one)
+ANTHROPIC_API_KEY=your_key
+OPENAI_API_KEY=your_key
+
+# Optional Settings
+BIOMNI_LLM=claude-3-5-sonnet-20241022
+BIOMNI_TIMEOUT_SECONDS=1200
+BIOMNI_PATH=/path/to/data
+```
+
+### 2. Runtime Configuration (Recommended for Scripts)
+
+```python
+from biomni.config import default_config
+
+# Changes apply to all agents and database queries
+default_config.llm = "gpt-4"
+default_config.timeout_seconds = 1200
+```
+
+### 3. Direct Parameters (Use with Caution)
+
+```python
+# ⚠️ Only affects this agent's reasoning, NOT database queries
+agent = A1(llm="claude-3-5-sonnet-20241022")
+```
+
+## Common Examples
+
+### Using Different Models
+
+```python
+# Use GPT-4 everywhere
+default_config.llm = "gpt-4"
+agent = A1()
+```
+
+### Cost Optimization (Different Models for Agent vs Database)
+
+```python
+# Cheaper model for database queries
+default_config.llm = "claude-3-5-haiku-20241022"
+
+# More powerful model for agent reasoning
+agent = A1(llm="claude-3-5-sonnet-20241022")
+```
+
+### Custom/Local Models
+
+```python
+default_config.source = "Custom"
+default_config.base_url = "http://localhost:8000/v1"
+default_config.api_key = "local_key"
+default_config.llm = "local-llama-70b"
+```
+
+## All Available Settings
+
+### Environment Variables
+
+```bash
+# API Keys
+ANTHROPIC_API_KEY=your_key
+OPENAI_API_KEY=your_key
+GEMINI_API_KEY=your_key
+GROQ_API_KEY=your_key
+AWS_BEARER_TOKEN_BEDROCK=your_key
+AWS_REGION=us-east-1
+
+# Azure OpenAI
+OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
+
+# Biomni Settings
+BIOMNI_PATH=/path/to/data                   # Default: ./data
+BIOMNI_TIMEOUT_SECONDS=1200                 # Default: 600
+BIOMNI_LLM=model_name                        # Default: claude-sonnet-4-20250514
+BIOMNI_TEMPERATURE=0.7                      # Default: 0.7
+BIOMNI_USE_TOOL_RETRIEVER=true             # Default: true
+BIOMNI_SOURCE=Anthropic                     # Auto-detected if not set
+BIOMNI_CUSTOM_BASE_URL=http://localhost:8000/v1
+BIOMNI_CUSTOM_API_KEY=custom_key
+```
+
+### Python Configuration
+
+```python
+from biomni.config import default_config
+
+# All available settings
+default_config.path = "./data"
+default_config.timeout_seconds = 600
+default_config.llm = "claude-sonnet-4-20250514"
+default_config.temperature = 0.7
+default_config.use_tool_retriever = True
+default_config.source = None  # Auto-detected
+default_config.base_url = None  # For custom models
+default_config.api_key = None  # For custom models
+```
+
+## Important Notes
+
+- **For pip-installed packages**: You can't edit the package files, but you can still use environment variables or modify `default_config` at runtime
+- **Configuration consistency**: Database queries always use `default_config`, regardless of agent parameters
+- **Priority order**: Direct params > Runtime config > Env vars > Defaults
+
+## Troubleshooting
+
+**API Key Not Found**:
+- Check `.env` file exists in your working directory
+- Verify with: `echo $ANTHROPIC_API_KEY`
+
+**Configuration Not Applied**:
+- Changes to `default_config` only affect agents created after the change
+- Direct parameters only affect that specific agent, not database queries
+
+**Model Not Found**:
+- Check spelling of model name
+- For Azure, prefix with "azure-" (e.g., "azure-gpt-4o")
+- Ensure you have the right API key for that provider

docs/generate_api_docs.py

@@ -0,0 +1,124 @@
+# generate_api_docs.py
+
+import os
+
+
+def generate_api_docs(base_path, output_dir, package_name, exclude_list=None):
+    """
+    Automatically generates .rst files for Sphinx API documentation.
+
+    Args:
+        base_path (str): The root directory of the Python package (e.g., 'biomni').
+        output_dir (str): The directory where the .rst files will be generated (e.g., 'source/api').
+        package_name (str): The name of the Python package.
+        exclude_list (list): A list of paths (directories or files) to exclude from documentation.
+                             Paths should be relative to the base_path.
+    """
+    if exclude_list is None:
+        exclude_list = []
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Walk through the package directory
+    for root, dirs, files in os.walk(base_path):
+        # Exclude directories if they are in the exclude list
+        dirs[:] = [d for d in dirs if os.path.join(os.path.relpath(root, base_path), d) not in exclude_list]
+
+        for file in files:
+            file_path_relative = os.path.relpath(os.path.join(root, file), base_path)
+
+            # Check if the file should be excluded
+            if file_path_relative in exclude_list:
+                print(f"Skipping excluded file: {file_path_relative}")
+                continue
+
+            if file.endswith(".py") and file != "__init__.py":
+                # Construct the full module name (e.g., biomni.agent.a1)
+                rel_path = os.path.relpath(root, base_path)
+                module_name = f"{package_name}.{rel_path.replace(os.path.sep, '.')}.{os.path.splitext(file)[0]}"
+
+                # Clean up the module name if it starts with the package name
+                if module_name.startswith(f"{package_name}.{package_name}."):
+                    module_name = f"{package_name}.{module_name[len(f'{package_name}.{package_name}.') :]}"
+
+                # Create the directory structure in the output folder
+                output_path_dir = os.path.join(output_dir, rel_path)
+                if not os.path.exists(output_path_dir):
+                    os.makedirs(output_path_dir)
+
+                # Define the output .rst file path
+                output_file = os.path.join(output_path_dir, f"{os.path.splitext(file)[0]}.rst")
+
+                # Generate the RST content
+                rst_content = f"""{module_name}
+{"=" * len(module_name)}
+
+.. automodule:: {module_name}
+   :members:
+   :undoc-members:
+   :show-inheritance:
+"""
+                # Write the content to the .rst file
+                with open(output_file, "w", encoding="utf-8") as f:
+                    f.write(rst_content)
+                print(f"Generated {output_file}")
+
+
+def create_index_rst(output_dir, package_name):
+    """
+    Creates or updates the main index file that lists all generated .rst files.
+    """
+    output_dir = os.path.join(output_dir, "../")
+    index_path = os.path.join(output_dir, "index.rst")
+    rst_files = []
+
+    # Find all generated rst files
+    for root, _dirs, files in os.walk(output_dir):
+        for file in files:
+            if file.endswith(".rst") and file != "index.rst":
+                rel_path = os.path.relpath(os.path.join(root, file), output_dir)
+                rst_files.append(os.path.splitext(rel_path)[0])
+
+    rst_files.sort()
+
+    index_content = f"""{package_name} API Reference
+{"=" * (len(package_name) + len(" API Reference"))}
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API Contents:
+
+"""
+    for file in rst_files:
+        index_content += f"   {file}\n"
+
+    with open(index_path, "w", encoding="utf-8") as f:
+        f.write(index_content)
+    print(f"Updated {index_path} with module links.")
+
+    # update ../index.rst to include api/index
+    # index_path = os.path.join(output_dir, '../index.rst')
+    # with open(index_path, 'w', encoding='utf-8') as f:
+
+
+if __name__ == "__main__":
+    package_to_document = "../biomni"
+    api_docs_path = "./source/api"
+    package_name = "biomni"
+
+    os.makedirs(api_docs_path, exist_ok=True)
+
+    exclude_list = [
+        "llm.py",
+        "env_desc.py",
+        "version.py",
+        "tool/tool_description",
+        "tool/example_mcp_tools",
+    ]
+
+    generate_api_docs(package_to_document, api_docs_path, package_name, exclude_list)
+    create_index_rst(api_docs_path, package_name)
+
+    print("\nAPI documentation source files have been generated.")
+    print("Now run 'make html' from your project's root directory to build the documentation.")

docs/known_conflicts.md

@@ -0,0 +1,34 @@
+# Known Package Conflicts in Biomni
+
+This file lists Python packages that are known to have dependency conflicts with the default Biomni environment. These packages are not installed by default. If you require their functionality, you must install them manually and may need to uncomment relevant code in the codebase.
+
+## Packages
+
+### 1. hyperimpute
+- Not installed by default due to dependency conflicts with the main environment.
+- If you need imputation tools that require this package, install it manually in a separate environment or with caution.
+
+### 2. langchain_aws
+- Needed for Amazon Bedrock support.
+- Amazon Bedrock support is present in the codebase, but due to package dependency conflicts, you should install `langchain_aws` only when you need Bedrock support.
+- You must also uncomment the relevant Bedrock support code sections in the codebase to enable this feature.
+
+### 3. cnvkit
+- **Environment Requirement**: Requires Python 3.10 environment (`bio_env_py310.yml`)
+- **Function**: Supports the `analyze_copy_number_purity_ploidy_and_focal_events` function
+- **Why Separate Environment**: cnvkit has strict dependency requirements that conflict with newer Python versions and other packages in the main Biomni environment. Python 3.10 provides the optimal compatibility for cnvkit and its dependencies, ensuring reliable copy number variation analysis, purity estimation, ploidy detection, and focal event identification.
+- **Installation**: Use `conda env create -f bio_env_py310.yml` to create the dedicated environment
+
+### 4. panhumanpy
+- **Environment Requirement**: Requires its own dedicated environment due to specific dependency constraints
+- **Function**: Supports the `annotate_celltype_with_panhumanpy` function for automated cell type annotation in scRNA-seq data
+- **Why Separate Environment**: panhumanpy has strict version requirements including:
+  - TensorFlow 2.17 (specific version)
+  - scikit-learn 1.6.0 (specific version)
+  - Python >=3.9 but optimized for Python 3.12
+  - These version constraints conflict with the main Biomni environment and other packages
+- **Installation**: Install in a separate conda environment with the exact versions specified in the package requirements
+
+---
+
+If you encounter other package conflicts, please add them to this file or open an issue.

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/mcp_integration.md

@@ -0,0 +1,347 @@
+# MCP (Model Context Protocol) Integration in Biomni
+
+Biomni provides comprehensive support for the Model Context Protocol (MCP), allowing you to both integrate external MCP servers and expose Biomni tools as MCP servers. This enables seamless interoperability with a wide ecosystem of AI tools and services.
+
+## Overview
+
+MCP (Model Context Protocol) is a standard protocol for AI applications to communicate with external tools and services. Biomni supports two main MCP integration patterns:
+
+1. **Adding External MCP Servers**: Import tools from external MCP servers into Biomni
+2. **Exposing Biomni as MCP Server**: Make Biomni tools available to other MCP clients
+
+## Adding External MCP Servers to Biomni
+
+### Configuration File Format
+
+MCP servers are configured using a YAML file that defines server connections and their tools. The `command` field specifies how to start the MCP server, which varies depending on how the server is packaged and distributed.
+
+```yaml
+mcp_servers:
+  server_name:
+    enabled: true  # Optional, defaults to true
+    command: ["docker", "run", "-i", "--rm", "-e", "ENV_VAR", "image:tag"]  # Docker-based server
+    # OR
+    command: ["npx", "-y", "@modelcontextprotocol/server-name"]  # NPM-based server
+    # OR
+    command: ["python", "-m", "my_mcp_server"]  # Python-based server
+    # OR
+    command: ["./my-mcp-server", "--config", "config.json"]  # Binary server
+    env:
+      API_KEY: "${OPENAI_API_KEY}"  # Environment variable substitution
+      CUSTOM_VAR: "static_value"
+```
+
+**Note**: The exact command format depends on the MCP server. Check the server's documentation for the correct command to use.
+
+### Example Configuration
+
+```yaml
+mcp_servers:
+  # GitHub MCP Server (Docker approach - recommended)
+  github:
+    command: ["docker", "run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"]
+    enabled: true
+    description: "Official GitHub MCP server for repository and issue management"
+    env:
+      GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_TOKEN}"
+
+  # Custom Local MCP Server - Only add tools necessary
+  pubmed:
+    command: ["python", "-m", "biomni.tool.mcp_tools.pubmed_mcp"]
+    enabled: true
+    tools:
+      - biomni_name: search_pubmed
+        description: "Search PubMed"
+        parameters:
+          query: {type: str, required: true,  description: "PubMed search term"}
+          max_results:  {type: int, required: false, default: 10, description: "Maximum number of hits"}
+      - biomni_name: get_article_abstract
+        description: "Fetch PubMed abstract"
+        parameters:
+          pmid: {type: str, required: true, description: "PubMed ID"}
+
+```
+
+You can also create custom MCP servers and define your own tools by implementing the MCP protocol and adding them to your configuration file.
+
+### Using the `add_mcp` Method
+
+```python
+from biomni.agent import A1
+
+# Initialize Biomni agent
+agent = A1()
+
+# Optional: Set email for PubMed
+# import os
+# os.environ.setdefault("NCBI_EMAIL", "Your email address")
+
+# Add MCP servers from configuration file
+agent.add_mcp(config_path="./mcp_config.yaml")
+
+# Now you can use the MCP tools in your queries
+result = agent.go("Please list all repositories in the github account of the user.")
+```
+
+### How It Works
+
+1. **Tool Discovery**: Biomni automatically discovers available tools from each MCP server
+2. **Async-to-Sync Wrapping**: MCP tools are wrapped to work with Biomni's synchronous execution model
+3. **Integration**: Tools are registered in Biomni's tool registry and made available for retrieval
+4. **Module Organization**: Each MCP server gets its own module namespace (e.g., `mcp_servers.github`)
+
+### Tool Registration Process
+
+When you call `add_mcp()`, Biomni:
+
+1. Loads the configuration file
+2. For each enabled server:
+   - Establishes a connection to the MCP server
+   - Discovers available tools
+   - Creates synchronous wrapper functions
+   - Registers tools in the tool registry
+   - Adds tools to the module2api mapping
+   - Stores tools in custom functions registry
+
+### Environment Variable Substitution
+
+The configuration supports environment variable substitution using `${VARIABLE_NAME}` syntax:
+
+```yaml
+mcp_servers:
+  my_server:
+    command: ["my-server"]
+    env:
+      API_KEY: "${MY_API_KEY}"  # Will be replaced with os.getenv("MY_API_KEY")
+      DEBUG: "true"              # Static value
+```
+
+You will need to properly set your environment variables (e.g., `GITHUB_TOKEN`) using a `.env` file or shell exports before running the agent.
+
+## Exposing Biomni Tools as MCP Server
+
+### Using the `create_mcp_server` Method
+
+Biomni can expose its internal tools as an MCP server, making them available to other MCP clients:
+
+```python
+from biomni.agent.a1 import A1
+
+# Create the agent
+agent = A1()
+
+# Create the MCP server with specific modules
+mcp = agent.create_mcp_server(tool_modules=["biomni.tool.database"])
+
+if __name__ == "__main__":
+    # Run the server using stdio transport
+    print("Starting Biomni MCP server...")
+    mcp.run(transport="stdio")
+```
+
+### Server Configuration
+
+The MCP server can be configured with various options:
+
+```python
+# Create server with specific modules
+mcp = agent.create_mcp_server(tool_modules=[
+    "biomni.tool.genetics",
+    "biomni.tool.database",
+    "biomni.tool.cell_biology"
+])
+
+# The server will expose all tools from these modules
+# Tools are automatically wrapped with proper parameter validation
+```
+
+## Best Practices
+
+### Configuration Management
+
+1. **Environment Variables**: Use environment variables for sensitive data like API keys
+2. **Docker Images**: Use official Docker images for MCP servers when available
+3. **Server Validation**: Test server connections before adding them to production
+4. **Tool Naming**: Ensure unique tool names across different servers to avoid conflicts
+
+### Performance Considerations
+
+1. **Connection Management**: MCP servers are created on-demand for each tool call
+2. **Tool Discovery**: Tool discovery happens once during `add_mcp()` call
+3. **Error Handling**: Failed tool calls are properly handled and reported
+4. **Docker Overhead**: Containerized servers may have additional startup time
+
+### Security
+
+1. **Environment Variables**: Never hardcode sensitive information in configuration files
+2. **Docker Security**: Use trusted Docker images and consider security implications
+3. **Server Permissions**: Ensure MCP servers have appropriate permissions for their operations
+4. **Network Access**: Be aware of network access requirements for external MCP servers
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Docker Not Running**: Ensure Docker is running for containerized MCP servers
+2. **Environment Variables**: Verify that required environment variables are set (e.g., `GITHUB_TOKEN`, `NCBI_EMAIL`)
+3. **Tool Discovery Failures**: Check server logs for connection or authentication issues
+4. **Naming Conflicts**: Tools with duplicate names will be skipped with a warning
+
+### Debugging
+
+```python
+# Test MCP connections without adding tools
+test_results = agent.test_mcp_connection("./mcp_config.yaml")
+print(test_results)
+
+# List all MCP servers and their tools
+servers = agent.list_mcp_servers()
+print(servers)
+
+# Remove specific MCP tools
+agent.remove_mcp_tools("server_name")
+```
+
+### Testing MCP Server
+
+Use the provided test script to verify your MCP server is working:
+
+```bash
+cd tutorials/examples/expose_biomni_server
+python test_mcp_server.py
+```
+
+The test script allows you to:
+- Test individual tools with custom parameters
+- View available tools and their schemas
+- Debug connection issues
+- Validate tool responses
+
+## Example Use Cases
+
+### Adding External MCP Servers
+
+```python
+from biomni.agent import A1
+
+# Initialize agent and add MCP servers
+agent = A1()
+agent.add_mcp(config_path="./mcp_config.yaml")
+
+# Use GitHub tools alongside Biomni tools
+result = agent.go("""
+Please list all repositories in the github account of the user.
+Then use Biomni's genetics tools to analyze any bioinformatics repositories found.
+""")
+```
+
+### Exposing Biomni as MCP Server
+
+```python
+from biomni.agent.a1 import A1
+
+# Create agent and MCP server
+agent = A1()
+mcp = agent.create_mcp_server(tool_modules=["biomni.tool.database"])
+
+# Run the server
+if __name__ == "__main__":
+    print("Starting Biomni MCP server...")
+    mcp.run(transport="stdio")
+```
+
+## Integration with Other Systems
+
+### Available Examples
+
+The Biomni repository includes complete examples in the `tutorials/examples/` directory:
+
+#### Adding MCP Servers
+- **Location**: `tutorials/examples/add_mcp_server/`
+- **Files**:
+  - `mcp_config.yaml` - Example configuration file
+  - `mcp_example.ipynb` - Jupyter notebook demonstrating usage
+
+#### Exposing Biomni as MCP Server
+- **Location**: `tutorials/examples/expose_biomni_server/`
+- **Files**:
+  - `run_mcp_server.py` - Script to run Biomni MCP server
+  - `test_mcp_server.py` - Comprehensive test script for MCP tools
+
+To run the examples:
+
+```bash
+# Add MCP servers
+cd tutorials/examples/add_mcp_server
+jupyter notebook mcp_example.ipynb
+
+# Expose Biomni as MCP server
+cd tutorials/examples/expose_biomni_server
+python run_mcp_server.py
+
+# Test the server
+python test_mcp_server.py
+```
+
+### Testing MCP Server
+
+You can test the Biomni MCP server using the provided test script:
+
+```python
+#!/usr/bin/env python3
+"""
+Simple test script for testing a single Biomni MCP tool.
+"""
+
+import asyncio
+import json
+import sys
+
+from mcp import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+# Configuration - Change these to test different tools
+TOOL_TO_TEST = "query_uniprot"  # Change this to the tool you want to test
+TEST_ARGS = {"prompt": "Find information about human insulin protein"}
+
+async def test_single_tool():
+    """Test a single tool in the Biomni MCP server."""
+
+    # Set up the server parameters
+    import os
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    server_script = os.path.join(current_dir, "run_mcp_server.py")
+    server_params = StdioServerParameters(command="python", args=[server_script])
+
+    try:
+        print("🔌 Connecting to MCP server...")
+
+        # Connect to the server
+        async with stdio_client(server_params) as (reader, writer):
+            async with ClientSession(reader, writer) as session:
+                # Initialize the session
+                await session.initialize()
+                print("✅ Connected to MCP server")
+
+                # List available tools
+                response = await session.list_tools()
+                tools = response.tools
+                print(f"✅ Found {len(tools)} tools")
+
+                # Test the tool
+                result = await session.call_tool(TOOL_TO_TEST, TEST_ARGS)
+                print("✅ Tool call successful!")
+                print(f"📄 Result: {result.content[0].text}")
+
+    except Exception as e:
+        print(f"❌ Failed to connect to MCP server: {e}")
+        return False
+
+if __name__ == "__main__":
+    success = asyncio.run(test_single_tool())
+    sys.exit(0 if success else 1)
+```
+
+## Conclusion
+
+Biomni's MCP integration provides a powerful way to extend its capabilities with external tools and services, while also making Biomni tools available to the broader MCP ecosystem. This enables seamless interoperability and allows you to build sophisticated AI workflows that combine the best of multiple tool ecosystems.

experiments/bioagent_bench/README.md

@@ -0,0 +1,102 @@
+# Biomni MCP Tool Scaling Experiment
+
+This experiment studies how Biomni behaves when the MCP tool background grows from
+about 100 tools to about 500, 1000, 1500, and 2000 tools on bioagent-bench.
+
+## Generated Configs
+
+The configs are generated from `/225040511/project/Biomni/mcp_generated` and can be
+registered directly with Biomni:
+
+```python
+from biomni.agent import A1
+
+agent = A1(use_tool_retriever=True)
+agent.add_mcp(
+    "/225040511/project/Biomni/experiments/bioagent_bench/configs/mcp_scale_100.yaml"
+)
+```
+
+Generated files:
+
+- `configs/mcp_scale_100.yaml`: 10 MCP servers, 107 tools
+- `configs/mcp_scale_500.yaml`: 96 MCP servers, 504 tools
+- `configs/mcp_scale_1000.yaml`: 276 MCP servers, 1003 tools
+- `configs/mcp_scale_1500.yaml`: 378 MCP servers, 1527 tools
+- `configs/mcp_scale_2000.yaml`: 526 MCP servers, 2000 tools
+- `configs/mcp_scale_manifest.json`: exact server/tool counts and selected server order
+- `configs/mcp_server_inventory.json`: parseable MCP inventory
+
+The generator writes explicit `tools` metadata into YAML, so `A1.add_mcp()` does
+not have to start every server just to discover schemas. The runtime command for
+each tool still points to the corresponding generated MCP server file.
+
+## Regenerate
+
+```bash
+cd /225040511/project/Biomni
+python experiments/bioagent_bench/scripts/generate_mcp_scale_configs.py
+```
+
+The generator prioritizes benchmark-relevant tools first, then fills each tier by
+whole MCP server units until the target tool count is reached.
+
+## Benchmark Design
+
+Use the tasks in `/225040511/project/bioagent-bench/src/task_metadata.json`.
+For each task, run Biomni once per tool tier:
+
+1. Create a fresh run directory named like:
+   `runs/<tier>/<task_id>_<timestamp>/`
+2. Initialize Biomni with `use_tool_retriever=True`.
+3. Register exactly one tier config with `agent.add_mcp(config_path=...)`.
+4. Run the bioagent-bench task prompt with the same data policy used in your
+   existing runs.
+5. Save `retrieval_plan.json`, `execution_log.json`, `execution_log.txt`,
+   `run_metadata.json`, `run_summary.json`, `output_validation.json`, and final
+   deliverables in the run directory.
+
+Use identical model, decoding settings, timeout, conda environment, and benchmark
+data policy across tiers. Repeat each task at least 3 times if you want confidence
+intervals, because LLM tool retrieval and planning can vary.
+
+## Metrics
+
+Metric definitions used here:
+
+- `Retrieval Recall@k`: fraction of task gold tools/servers present in the first
+  `k` retrieved candidates from `retrieval_plan.json`. The table export uses a
+  primary `k` value, defaulting to `10`.
+- `Workflow Validity`: whether observed tool/log evidence covers the task's gold
+  workflow stages in order.
+- `Execution Success Rate`: whether benchmark output validation or required
+  output paths indicate the pipeline completed.
+- `Context Tokens`: rough planning-context token count from
+  `retrieval_plan.json/planning_context_text`.
+- `Planning Latency`: retrieval/planning latency recorded by the agent during
+  tool selection.
+- `Hallucinated Tool Rate`: fraction of executed MCP tools mentioned in the
+  execution trace that were not present in the retrieved candidate tool set
+  persisted in `retrieval_plan.json`.
+- `Data-Type Mismatch Rate`: heuristic rate of execution attempts that emitted
+  argument/schema/type mismatch errors, estimated from execution-log patterns.
+- `Biological Constraint Error Rate`: heuristic rate of execution attempts that
+  violated benchmark biological/data constraints, such as sibling-task data
+  access, truth/results access, or external installs/downloads.
+
+Gold tool and workflow definitions are in `gold_tools.json`. They are deliberately
+pattern based, because MCP wrapper names differ across generated servers.
+
+## Aggregate Existing Runs
+
+```bash
+python experiments/bioagent_bench/scripts/evaluate_mcp_scaling_runs.py \
+  --runs-root /path/to/runs/scale_100 \
+  --out experiments/bioagent_bench/results/scale_100_metrics.json
+```
+
+Run this once per tier, then compare the aggregate blocks or the exported table:
+
+- `results/scale_<N>_mcp_metrics.json`
+- `results/experiment1_scaling_table.json`
+- `results/experiment1_scaling_table.csv`

experiments/bioagent_bench/README_RUN.md

@@ -0,0 +1,208 @@
+# BioAgent Bench MCP Scaling 新手运行指南
+
+这份说明用于继续运行 Biomni 在 BioAgent Bench 上的 MCP tool scale 实验。当前实验目录是：
+
+```bash
+/225040511/project/Biomni/experiments/bioagent_bench
+```
+
+## 1. 进入项目目录
+
+```bash
+cd /225040511/project/Biomni
+```
+
+## 2. 准备 LLM API Key
+
+实验需要至少设置下面任意一种 key：
+
+```bash
+export ANTHROPIC_API_KEY="你的 Anthropic key"
+```
+
+或者：
+
+```bash
+export OPENAI_API_KEY="你的 OpenAI key"
+```
+
+或者使用 DeepSeek：
+
+```bash
+export DEEPSEEK_API_KEY="你的 DeepSeek key"
+export DEEPSEEK_MODEL_NAME="deepseek-chat"
+export DEEPSEEK_BASE_URL="https://api.deepseek.com/v1"
+```
+
+脚本会自动把 `DEEPSEEK_API_KEY` 转成 Biomni 使用的 `BIOMNI_CUSTOM_API_KEY`。
+
+可以用下面命令确认 key 是否已经设置，不会打印 key 内容：
+
+```bash
+for k in ANTHROPIC_API_KEY OPENAI_API_KEY BIOMNI_CUSTOM_API_KEY DEEPSEEK_API_KEY; do
+  if [ -n "${!k:-}" ]; then echo "$k=set"; else echo "$k=unset"; fi
+done
+```
+
+## 3. 检查 MCP 配置
+
+新增 scale 的配置已经生成在：
+
+```bash
+ls -lh experiments/bioagent_bench/configs/mcp_scale_1500.yaml
+ls -lh experiments/bioagent_bench/configs/mcp_scale_2000.yaml
+```
+
+当前 manifest 在：
+
+```bash
+experiments/bioagent_bench/configs/mcp_scale_manifest.json
+```
+
+其中：
+
+- `scale_1500`: 378 个 MCP servers，1527 个 tools
+- `scale_2000`: 526 个 MCP servers，2000 个 tools
+
+如果以后需要重新生成配置：
+
+```bash
+/225040511/miniconda3/envs/biomni_e1/bin/python \
+  experiments/bioagent_bench/scripts/generate_mcp_scale_configs.py
+```
+
+## 4. 后台运行 1500 和 2000 scale
+
+推荐后台跑，因为完整实验可能需要很久：
+
+```bash
+experiments/bioagent_bench/scripts/run_biomni_scaling_experiment.sh \
+  --background \
+  --scale 1500 \
+  --scale 2000
+```
+
+脚本启动后会打印：
+
+- `PID`: 后台进程号
+- `Log`: 日志文件路径
+- `Monitor with`: 查看日志的命令
+
+## 5. 查看运行日志
+
+把下面的路径替换成脚本启动时打印的 log 路径：
+
+```bash
+tail -f experiments/bioagent_bench/results/logs/run_biomni_scaling_experiment_YYYYMMDD_HHMMSS.log
+```
+
+如果日志里出现：
+
+```text
+No LLM API key found.
+```
+
+说明第 2 步的 API key 没有在当前 shell 里生效，需要重新 `export` 后再启动。
+
+## 6. 结果输出位置
+
+每个 scale 的原始运行结果会写到：
+
+```bash
+experiments/bioagent_bench/runs/scale_1500
+experiments/bioagent_bench/runs/scale_2000
+```
+
+每个 task 会生成自己的子目录，例如：
+
+```bash
+experiments/bioagent_bench/runs/scale_1500/alzheimer-mouse_YYYYMMDD_HHMMSS
+```
+
+常见文件包括：
+
+- `run_metadata.json`
+- `retrieval_plan.json`
+- `execution_log.json`
+- `execution_log.txt`
+- `output_validation.json`
+- `final_answer.txt`
+- task 对应的最终输出文件
+
+汇总指标会写到：
+
+```bash
+experiments/bioagent_bench/results/scale_1500_mcp_metrics.json
+experiments/bioagent_bench/results/scale_1500_task_metrics.json
+experiments/bioagent_bench/results/scale_1500_task_metrics.csv
+experiments/bioagent_bench/results/scale_1500_bioagent_bench_rule_eval.json
+
+experiments/bioagent_bench/results/scale_2000_mcp_metrics.json
+experiments/bioagent_bench/results/scale_2000_task_metrics.json
+experiments/bioagent_bench/results/scale_2000_task_metrics.csv
+experiments/bioagent_bench/results/scale_2000_bioagent_bench_rule_eval.json
+```
+
+总表会更新到：
+
+```bash
+experiments/bioagent_bench/results/experiment1_scaling_table.json
+experiments/bioagent_bench/results/experiment1_scaling_table.csv
+```
+
+## 7. 断点续跑
+
+runner 默认带 `--skip-completed`，所以中途失败后可以直接重新运行同一条命令。已经完成的 task 会被跳过，未完成的 task 会继续跑。
+
+```bash
+experiments/bioagent_bench/scripts/run_biomni_scaling_experiment.sh \
+  --background \
+  --scale 1500 \
+  --scale 2000
+```
+
+## 8. 只跑单个 scale
+
+例如只跑 1500：
+
+```bash
+experiments/bioagent_bench/scripts/run_biomni_scaling_experiment.sh \
+  --background \
+  --scale 1500
+```
+
+只跑 2000：
+
+```bash
+experiments/bioagent_bench/scripts/run_biomni_scaling_experiment.sh \
+  --background \
+  --scale 2000
+```
+
+## 9. 前台调试
+
+如果想直接在终端里看报错，可以用前台模式：
+
+```bash
+experiments/bioagent_bench/scripts/run_biomni_scaling_experiment.sh \
+  --foreground \
+  --scale 1500
+```
+
+前台模式会占住当前终端，适合调试，不适合长时间完整实验。
+
+## 10. 快速检查是否完成
+
+查看每个 scale 是否有 batch summary：
+
+```bash
+ls -lh experiments/bioagent_bench/runs/scale_1500/latest_batch_summary.json
+ls -lh experiments/bioagent_bench/runs/scale_2000/latest_batch_summary.json
+```
+
+查看汇总表是否更新：
+
+```bash
+ls -lh experiments/bioagent_bench/results/experiment1_scaling_table.csv
+```
+

experiments/bioagent_bench/configs/mcp_scale_manifest.json

@@ -0,0 +1,1329 @@
+{
+  "mcp_root": "/225040511/project/Biomni/mcp_generated",
+  "execution_python": "/225040511/miniconda3/envs/biomni_e1/bin/python",
+  "available_server_count": 793,
+  "available_tool_count": 3189,
+  "targets": {
+    "100": {
+      "config": "/225040511/project/Biomni/experiments/bioagent_bench/configs/mcp_scale_100.yaml",
+      "server_count": 10,
+      "tool_count": 107,
+      "servers": [
+        "mcp_kallisto",
+        "mcp_kraken2",
+        "mcp_csvtk",
+        "mcp_megahit",
+        "mcp_kaiju",
+        "mcp_fastp",
+        "mcp_spades",
+        "mcp_scanpy",
+        "mcp_scanpy-cli",
+        "mcp_scanpy-scripts"
+      ]
+    },
+    "500": {
+      "config": "/225040511/project/Biomni/experiments/bioagent_bench/configs/mcp_scale_500.yaml",
+      "server_count": 96,
+      "tool_count": 504,
+      "servers": [
+        "mcp_kallisto",
+        "mcp_kraken2",
+        "mcp_csvtk",
+        "mcp_megahit",
+        "mcp_kaiju",
+        "mcp_fastp",
+        "mcp_spades",
+        "mcp_scanpy",
+        "mcp_scanpy-cli",
+        "mcp_scanpy-scripts",
+        "mcp_seurat-scripts",
+        "mcp_bioconductor-deseq2",
+        "mcp_bioconductor-edger",
+        "mcp_bioconductor-limma",
+        "mcp_bioconductor-clusterprofiler",
+        "mcp_star",
+        "mcp_hisat2",
+        "mcp_subread",
+        "mcp_bcftools",
+        "mcp_bwa",
+        "mcp_gatk4",
+        "mcp_gatk",
+        "mcp_snpeff",
+        "mcp_freebayes",
+        "mcp_orthofinder",
+        "mcp_blast",
+        "mcp_blast-legacy",
+        "mcp_diamond",
+        "mcp_gffread",
+        "mcp_seqkit",
+        "mcp_multiqc",
+        "mcp_fastqc",
+        "mcp_trimmomatic",
+        "mcp_bioconductor-keggrest",
+        "mcp_snpsift",
+        "mcp_bioconductor-rsubread",
+        "mcp_bioconductor-tximport",
+        "mcp_bioconductor-variantannotation",
+        "mcp_celltypist",
+        "mcp_abnumber",
+        "mcp_abricate",
+        "mcp_abundancebin",
+        "mcp_abyss",
+        "mcp_adapterremoval",
+        "mcp_alfred",
+        "mcp_anansescanpy",
+        "mcp_anarci",
+        "mcp_aragorn",
+        "mcp_aria2",
+        "mcp_ariba",
+        "mcp_arriba",
+        "mcp_art",
+        "mcp_arvados-cwl-runner",
+        "mcp_arvados-python-client",
+        "mcp_atropos",
+        "mcp_augustus",
+        "mcp_auspice",
+        "mcp_bactopia",
+        "mcp_bamtools",
+        "mcp_barrnap",
+        "mcp_bbmap",
+        "mcp_bcbio-gff",
+        "mcp_bcbio-nextgen",
+        "mcp_bedops",
+        "mcp_bedtools",
+        "mcp_bin2cell",
+        "mcp_bioawk",
+        "mcp_biobambam",
+        "mcp_bioconductor-affy",
+        "mcp_bioconductor-affyio",
+        "mcp_bioconductor-alabaster",
+        "mcp_bioconductor-alabaster.sfe",
+        "mcp_bioconductor-alabaster.spatial",
+        "mcp_bioconductor-annotate",
+        "mcp_bioconductor-annotationdbi",
+        "mcp_bioconductor-annotationfilter",
+        "mcp_bioconductor-apeglm",
+        "mcp_bioconductor-apl",
+        "mcp_bioconductor-awaggregator",
+        "mcp_bioconductor-banksy",
+        "mcp_bioconductor-beachmat",
+        "mcp_bioconductor-benchdamic",
+        "mcp_bioconductor-biobase",
+        "mcp_bioconductor-biocbaseutils",
+        "mcp_bioconductor-biocfilecache",
+        "mcp_bioconductor-biocgenerics",
+        "mcp_bioconductor-biocio",
+        "mcp_bioconductor-biocneighbors",
+        "mcp_bioconductor-biocparallel",
+        "mcp_bioconductor-biocsingular",
+        "mcp_bioconductor-biomart",
+        "mcp_bioconductor-biomformat",
+        "mcp_bioconductor-biostrings",
+        "mcp_bioconductor-biovizbase",
+        "mcp_bioconductor-blase",
+        "mcp_bioconductor-bluster"
+      ]
+    },
+    "1000": {
+      "config": "/225040511/project/Biomni/experiments/bioagent_bench/configs/mcp_scale_1000.yaml",
+      "server_count": 276,
+      "tool_count": 1003,
+      "servers": [
+        "mcp_kallisto",
+        "mcp_kraken2",
+        "mcp_csvtk",
+        "mcp_megahit",
+        "mcp_kaiju",
+        "mcp_fastp",
+        "mcp_spades",
+        "mcp_scanpy",
+        "mcp_scanpy-cli",
+        "mcp_scanpy-scripts",
+        "mcp_seurat-scripts",
+        "mcp_bioconductor-deseq2",
+        "mcp_bioconductor-edger",
+        "mcp_bioconductor-limma",
+        "mcp_bioconductor-clusterprofiler",
+        "mcp_star",
+        "mcp_hisat2",
+        "mcp_subread",
+        "mcp_bcftools",
+        "mcp_bwa",
+        "mcp_gatk4",
+        "mcp_gatk",
+        "mcp_snpeff",
+        "mcp_freebayes",
+        "mcp_orthofinder",
+        "mcp_blast",
+        "mcp_blast-legacy",
+        "mcp_diamond",
+        "mcp_gffread",
+        "mcp_seqkit",
+        "mcp_multiqc",
+        "mcp_fastqc",
+        "mcp_trimmomatic",
+        "mcp_bioconductor-keggrest",
+        "mcp_snpsift",
+        "mcp_bioconductor-rsubread",
+        "mcp_bioconductor-tximport",
+        "mcp_bioconductor-variantannotation",
+        "mcp_celltypist",
+        "mcp_abnumber",
+        "mcp_abricate",
+        "mcp_abundancebin",
+        "mcp_abyss",
+        "mcp_adapterremoval",
+        "mcp_alfred",
+        "mcp_anansescanpy",
+        "mcp_anarci",
+        "mcp_aragorn",
+        "mcp_aria2",
+        "mcp_ariba",
+        "mcp_arriba",
+        "mcp_art",
+        "mcp_arvados-cwl-runner",
+        "mcp_arvados-python-client",
+        "mcp_atropos",
+        "mcp_augustus",
+        "mcp_auspice",
+        "mcp_bactopia",
+        "mcp_bamtools",
+        "mcp_barrnap",
+        "mcp_bbmap",
+        "mcp_bcbio-gff",
+        "mcp_bcbio-nextgen",
+        "mcp_bedops",
+        "mcp_bedtools",
+        "mcp_bin2cell",
+        "mcp_bioawk",
+        "mcp_biobambam",
+        "mcp_bioconductor-affy",
+        "mcp_bioconductor-affyio",
+        "mcp_bioconductor-alabaster",
+        "mcp_bioconductor-alabaster.sfe",
+        "mcp_bioconductor-alabaster.spatial",
+        "mcp_bioconductor-annotate",
+        "mcp_bioconductor-annotationdbi",
+        "mcp_bioconductor-annotationfilter",
+        "mcp_bioconductor-apeglm",
+        "mcp_bioconductor-apl",
+        "mcp_bioconductor-awaggregator",
+        "mcp_bioconductor-banksy",
+        "mcp_bioconductor-beachmat",
+        "mcp_bioconductor-benchdamic",
+        "mcp_bioconductor-biobase",
+        "mcp_bioconductor-biocbaseutils",
+        "mcp_bioconductor-biocfilecache",
+        "mcp_bioconductor-biocgenerics",
+        "mcp_bioconductor-biocio",
+        "mcp_bioconductor-biocneighbors",
+        "mcp_bioconductor-biocparallel",
+        "mcp_bioconductor-biocsingular",
+        "mcp_bioconductor-biomart",
+        "mcp_bioconductor-biomformat",
+        "mcp_bioconductor-biostrings",
+        "mcp_bioconductor-biovizbase",
+        "mcp_bioconductor-blase",
+        "mcp_bioconductor-bluster",
+        "mcp_bioconductor-bulksignalr",
+        "mcp_bioconductor-cardspa",
+        "mcp_bioconductor-catscradle",
+        "mcp_bioconductor-cdi",
+        "mcp_bioconductor-cellhashr",
+        "mcp_bioconductor-cellid",
+        "mcp_bioconductor-cellmigration",
+        "mcp_bioconductor-clusterfoldsimilarity",
+        "mcp_bioconductor-clustifyr",
+        "mcp_bioconductor-clustsignal",
+        "mcp_bioconductor-complexheatmap",
+        "mcp_bioconductor-concordexr",
+        "mcp_bioconductor-cotan",
+        "mcp_bioconductor-csoa",
+        "mcp_bioconductor-ctsv",
+        "mcp_bioconductor-curatedatlasqueryr",
+        "mcp_bioconductor-cytomapper",
+        "mcp_bioconductor-dada2",
+        "mcp_bioconductor-data-packages",
+        "mcp_bioconductor-decipher",
+        "mcp_bioconductor-decontam",
+        "mcp_bioconductor-decontx",
+        "mcp_bioconductor-deconvobuddies",
+        "mcp_bioconductor-delayedmatrixstats",
+        "mcp_bioconductor-despace",
+        "mcp_bioconductor-diffbind",
+        "mcp_bioconductor-dino",
+        "mcp_bioconductor-dirichletmultinomial",
+        "mcp_bioconductor-dnacopy",
+        "mcp_bioconductor-dose",
+        "mcp_bioconductor-ensembldb",
+        "mcp_bioconductor-erma",
+        "mcp_bioconductor-escher",
+        "mcp_bioconductor-experimentsubset",
+        "mcp_bioconductor-fgsea",
+        "mcp_bioconductor-genefilter",
+        "mcp_bioconductor-geneplotter",
+        "mcp_bioconductor-genomeinfodb",
+        "mcp_bioconductor-genomeinfodbdata",
+        "mcp_bioconductor-genomicalignments",
+        "mcp_bioconductor-genomicfeatures",
+        "mcp_bioconductor-genomicranges",
+        "mcp_bioconductor-geomxtools",
+        "mcp_bioconductor-ggsc",
+        "mcp_bioconductor-ggspavis",
+        "mcp_bioconductor-ggtree",
+        "mcp_bioconductor-glmgampoi",
+        "mcp_bioconductor-go.db",
+        "mcp_bioconductor-gosemsim",
+        "mcp_bioconductor-graph",
+        "mcp_bioconductor-gsva",
+        "mcp_bioconductor-hcatonsildata",
+        "mcp_bioconductor-hdf5array",
+        "mcp_bioconductor-hoodscanr",
+        "mcp_bioconductor-humanhippocampus2024",
+        "mcp_bioconductor-imcdatasets",
+        "mcp_bioconductor-imcrtools",
+        "mcp_bioconductor-impute",
+        "mcp_bioconductor-infercnv",
+        "mcp_bioconductor-interactivedisplaybase",
+        "mcp_bioconductor-iranges",
+        "mcp_bioconductor-irisfgm",
+        "mcp_bioconductor-jazzpanda",
+        "mcp_bioconductor-lisaclust",
+        "mcp_bioconductor-mastr",
+        "mcp_bioconductor-matrixgenerics",
+        "mcp_bioconductor-merfishdata",
+        "mcp_bioconductor-metabolomicsworkbenchr",
+        "mcp_bioconductor-metapod",
+        "mcp_bioconductor-mia",
+        "mcp_bioconductor-moleculeexperiment",
+        "mcp_bioconductor-mosim",
+        "mcp_bioconductor-mousegastrulationdata",
+        "mcp_bioconductor-mspurity",
+        "mcp_bioconductor-multiassayexperiment",
+        "mcp_bioconductor-multtest",
+        "mcp_bioconductor-nebulosa",
+        "mcp_bioconductor-nnsvg",
+        "mcp_bioconductor-noiseq",
+        "mcp_bioconductor-orfhunter",
+        "mcp_bioconductor-org.ce.eg.db",
+        "mcp_bioconductor-org.hs.eg.db",
+        "mcp_bioconductor-org.mm.eg.db",
+        "mcp_bioconductor-partcnv",
+        "mcp_bioconductor-phemd",
+        "mcp_bioconductor-phyloseq",
+        "mcp_bioconductor-pipecomp",
+        "mcp_bioconductor-poem",
+        "mcp_bioconductor-preprocesscore",
+        "mcp_bioconductor-proteomicsannotationhubdata",
+        "mcp_bioconductor-protgenerics",
+        "mcp_bioconductor-qvalue",
+        "mcp_bioconductor-rbgl",
+        "mcp_bioconductor-reactomegsa.data",
+        "mcp_bioconductor-regionalst",
+        "mcp_bioconductor-rforproteomics",
+        "mcp_bioconductor-rgraphviz",
+        "mcp_bioconductor-rhdf5",
+        "mcp_bioconductor-rhdf5filters",
+        "mcp_bioconductor-rhdf5lib",
+        "mcp_bioconductor-rhtslib",
+        "mcp_bioconductor-rsamtools",
+        "mcp_bioconductor-scaledmatrix",
+        "mcp_bioconductor-scalign",
+        "mcp_bioconductor-scarray.sat",
+        "mcp_bioconductor-scbfa",
+        "mcp_bioconductor-scbubbletree",
+        "mcp_bioconductor-sccb2",
+        "mcp_bioconductor-scclassifr",
+        "mcp_bioconductor-scdataviz",
+        "mcp_bioconductor-scdotplot",
+        "mcp_bioconductor-scfeatures",
+        "mcp_bioconductor-scider",
+        "mcp_bioconductor-scmageck",
+        "mcp_bioconductor-scqtltools",
+        "mcp_bioconductor-scran",
+        "mcp_bioconductor-screpertoire",
+        "mcp_bioconductor-scrnaseq",
+        "mcp_bioconductor-sctreeviz",
+        "mcp_bioconductor-scuttle",
+        "mcp_bioconductor-scvir",
+        "mcp_bioconductor-seraster",
+        "mcp_bioconductor-shortread",
+        "mcp_bioconductor-signifinder",
+        "mcp_bioconductor-singlecellmultimodal",
+        "mcp_bioconductor-smoothclust",
+        "mcp_bioconductor-smoppix",
+        "mcp_bioconductor-sosta",
+        "mcp_bioconductor-spacetrooper",
+        "mcp_bioconductor-spaniel",
+        "mcp_bioconductor-spari",
+        "mcp_bioconductor-sparsematrixstats",
+        "mcp_bioconductor-spatialcpie",
+        "mcp_bioconductor-spatialdatasets",
+        "mcp_bioconductor-spatialdecon",
+        "mcp_bioconductor-spatialdmelxsim",
+        "mcp_bioconductor-spatialexperiment",
+        "mcp_bioconductor-spatialexperimentio",
+        "mcp_bioconductor-spatialfda",
+        "mcp_bioconductor-spatialfeatureexperiment",
+        "mcp_bioconductor-spatialheatmap",
+        "mcp_bioconductor-speckle",
+        "mcp_bioconductor-spoon",
+        "mcp_bioconductor-spotclean",
+        "mcp_bioconductor-spotsweeper",
+        "mcp_bioconductor-standr",
+        "mcp_bioconductor-statial",
+        "mcp_bioconductor-stjoincount",
+        "mcp_bioconductor-summarizedexperiment",
+        "mcp_bioconductor-svp",
+        "mcp_bioconductor-tenxxeniumdata",
+        "mcp_bioconductor-tidyomics",
+        "mcp_bioconductor-tidyspatialexperiment",
+        "mcp_bioconductor-treesummarizedexperiment",
+        "mcp_bioconductor-vectrapolarisdata",
+        "mcp_bioconductor-visiumio",
+        "mcp_bioconductor-weberdivechalcdata",
+        "mcp_bioconductor-xcms",
+        "mcp_bioconductor-xenlite",
+        "mcp_bioconductor-xvector",
+        "mcp_bioconductor-zlibbioc",
+        "mcp_biopython",
+        "mcp_bowtie",
+        "mcp_bowtie2",
+        "mcp_bpipe",
+        "mcp_brooklyn_plot",
+        "mcp_busco",
+        "mcp_bx-python",
+        "mcp_c-ares",
+        "mcp_cascade-reg",
+        "mcp_cd-hit",
+        "mcp_cdbtools",
+        "mcp_cell2cell",
+        "mcp_cellitac",
+        "mcp_cellqc",
+        "mcp_cellrank",
+        "mcp_cellsnake",
+        "mcp_celltypist-so",
+        "mcp_checkatlas",
+        "mcp_checkm-genome"
+      ]
+    },
+    "1500": {
+      "config": "/225040511/project/Biomni/experiments/bioagent_bench/configs/mcp_scale_1500.yaml",
+      "server_count": 378,
+      "tool_count": 1527,
+      "servers": [
+        "mcp_kallisto",
+        "mcp_kraken2",
+        "mcp_csvtk",
+        "mcp_megahit",
+        "mcp_kaiju",
+        "mcp_fastp",
+        "mcp_spades",
+        "mcp_scanpy",
+        "mcp_scanpy-cli",
+        "mcp_scanpy-scripts",
+        "mcp_seurat-scripts",
+        "mcp_bioconductor-deseq2",
+        "mcp_bioconductor-edger",
+        "mcp_bioconductor-limma",
+        "mcp_bioconductor-clusterprofiler",
+        "mcp_star",
+        "mcp_hisat2",
+        "mcp_subread",
+        "mcp_bcftools",
+        "mcp_bwa",
+        "mcp_gatk4",
+        "mcp_gatk",
+        "mcp_snpeff",
+        "mcp_freebayes",
+        "mcp_orthofinder",
+        "mcp_blast",
+        "mcp_blast-legacy",
+        "mcp_diamond",
+        "mcp_gffread",
+        "mcp_seqkit",
+        "mcp_multiqc",
+        "mcp_fastqc",
+        "mcp_trimmomatic",
+        "mcp_bioconductor-keggrest",
+        "mcp_snpsift",
+        "mcp_bioconductor-rsubread",
+        "mcp_bioconductor-tximport",
+        "mcp_bioconductor-variantannotation",
+        "mcp_celltypist",
+        "mcp_abnumber",
+        "mcp_abricate",
+        "mcp_abundancebin",
+        "mcp_abyss",
+        "mcp_adapterremoval",
+        "mcp_alfred",
+        "mcp_anansescanpy",
+        "mcp_anarci",
+        "mcp_aragorn",
+        "mcp_aria2",
+        "mcp_ariba",
+        "mcp_arriba",
+        "mcp_art",
+        "mcp_arvados-cwl-runner",
+        "mcp_arvados-python-client",
+        "mcp_atropos",
+        "mcp_augustus",
+        "mcp_auspice",
+        "mcp_bactopia",
+        "mcp_bamtools",
+        "mcp_barrnap",
+        "mcp_bbmap",
+        "mcp_bcbio-gff",
+        "mcp_bcbio-nextgen",
+        "mcp_bedops",
+        "mcp_bedtools",
+        "mcp_bin2cell",
+        "mcp_bioawk",
+        "mcp_biobambam",
+        "mcp_bioconductor-affy",
+        "mcp_bioconductor-affyio",
+        "mcp_bioconductor-alabaster",
+        "mcp_bioconductor-alabaster.sfe",
+        "mcp_bioconductor-alabaster.spatial",
+        "mcp_bioconductor-annotate",
+        "mcp_bioconductor-annotationdbi",
+        "mcp_bioconductor-annotationfilter",
+        "mcp_bioconductor-apeglm",
+        "mcp_bioconductor-apl",
+        "mcp_bioconductor-awaggregator",
+        "mcp_bioconductor-banksy",
+        "mcp_bioconductor-beachmat",
+        "mcp_bioconductor-benchdamic",
+        "mcp_bioconductor-biobase",
+        "mcp_bioconductor-biocbaseutils",
+        "mcp_bioconductor-biocfilecache",
+        "mcp_bioconductor-biocgenerics",
+        "mcp_bioconductor-biocio",
+        "mcp_bioconductor-biocneighbors",
+        "mcp_bioconductor-biocparallel",
+        "mcp_bioconductor-biocsingular",
+        "mcp_bioconductor-biomart",
+        "mcp_bioconductor-biomformat",
+        "mcp_bioconductor-biostrings",
+        "mcp_bioconductor-biovizbase",
+        "mcp_bioconductor-blase",
+        "mcp_bioconductor-bluster",
+        "mcp_bioconductor-bulksignalr",
+        "mcp_bioconductor-cardspa",
+        "mcp_bioconductor-catscradle",
+        "mcp_bioconductor-cdi",
+        "mcp_bioconductor-cellhashr",
+        "mcp_bioconductor-cellid",
+        "mcp_bioconductor-cellmigration",
+        "mcp_bioconductor-clusterfoldsimilarity",
+        "mcp_bioconductor-clustifyr",
+        "mcp_bioconductor-clustsignal",
+        "mcp_bioconductor-complexheatmap",
+        "mcp_bioconductor-concordexr",
+        "mcp_bioconductor-cotan",
+        "mcp_bioconductor-csoa",
+        "mcp_bioconductor-ctsv",
+        "mcp_bioconductor-curatedatlasqueryr",
+        "mcp_bioconductor-cytomapper",
+        "mcp_bioconductor-dada2",
+        "mcp_bioconductor-data-packages",
+        "mcp_bioconductor-decipher",
+        "mcp_bioconductor-decontam",
+        "mcp_bioconductor-decontx",
+        "mcp_bioconductor-deconvobuddies",
+        "mcp_bioconductor-delayedmatrixstats",
+        "mcp_bioconductor-despace",
+        "mcp_bioconductor-diffbind",
+        "mcp_bioconductor-dino",
+        "mcp_bioconductor-dirichletmultinomial",
+        "mcp_bioconductor-dnacopy",
+        "mcp_bioconductor-dose",
+        "mcp_bioconductor-ensembldb",
+        "mcp_bioconductor-erma",
+        "mcp_bioconductor-escher",
+        "mcp_bioconductor-experimentsubset",
+        "mcp_bioconductor-fgsea",
+        "mcp_bioconductor-genefilter",
+        "mcp_bioconductor-geneplotter",
+        "mcp_bioconductor-genomeinfodb",
+        "mcp_bioconductor-genomeinfodbdata",
+        "mcp_bioconductor-genomicalignments",
+        "mcp_bioconductor-genomicfeatures",
+        "mcp_bioconductor-genomicranges",
+        "mcp_bioconductor-geomxtools",
+        "mcp_bioconductor-ggsc",
+        "mcp_bioconductor-ggspavis",
+        "mcp_bioconductor-ggtree",
+        "mcp_bioconductor-glmgampoi",
+        "mcp_bioconductor-go.db",
+        "mcp_bioconductor-gosemsim",
+        "mcp_bioconductor-graph",
+        "mcp_bioconductor-gsva",
+        "mcp_bioconductor-hcatonsildata",
+        "mcp_bioconductor-hdf5array",
+        "mcp_bioconductor-hoodscanr",
+        "mcp_bioconductor-humanhippocampus2024",
+        "mcp_bioconductor-imcdatasets",
+        "mcp_bioconductor-imcrtools",
+        "mcp_bioconductor-impute",
+        "mcp_bioconductor-infercnv",
+        "mcp_bioconductor-interactivedisplaybase",
+        "mcp_bioconductor-iranges",
+        "mcp_bioconductor-irisfgm",
+        "mcp_bioconductor-jazzpanda",
+        "mcp_bioconductor-lisaclust",
+        "mcp_bioconductor-mastr",
+        "mcp_bioconductor-matrixgenerics",
+        "mcp_bioconductor-merfishdata",
+        "mcp_bioconductor-metabolomicsworkbenchr",
+        "mcp_bioconductor-metapod",
+        "mcp_bioconductor-mia",
+        "mcp_bioconductor-moleculeexperiment",
+        "mcp_bioconductor-mosim",
+        "mcp_bioconductor-mousegastrulationdata",
+        "mcp_bioconductor-mspurity",
+        "mcp_bioconductor-multiassayexperiment",
+        "mcp_bioconductor-multtest",
+        "mcp_bioconductor-nebulosa",
+        "mcp_bioconductor-nnsvg",
+        "mcp_bioconductor-noiseq",
+        "mcp_bioconductor-orfhunter",
+        "mcp_bioconductor-org.ce.eg.db",
+        "mcp_bioconductor-org.hs.eg.db",
+        "mcp_bioconductor-org.mm.eg.db",
+        "mcp_bioconductor-partcnv",
+        "mcp_bioconductor-phemd",
+        "mcp_bioconductor-phyloseq",
+        "mcp_bioconductor-pipecomp",
+        "mcp_bioconductor-poem",
+        "mcp_bioconductor-preprocesscore",
+        "mcp_bioconductor-proteomicsannotationhubdata",
+        "mcp_bioconductor-protgenerics",
+        "mcp_bioconductor-qvalue",
+        "mcp_bioconductor-rbgl",
+        "mcp_bioconductor-reactomegsa.data",
+        "mcp_bioconductor-regionalst",
+        "mcp_bioconductor-rforproteomics",
+        "mcp_bioconductor-rgraphviz",
+        "mcp_bioconductor-rhdf5",
+        "mcp_bioconductor-rhdf5filters",
+        "mcp_bioconductor-rhdf5lib",
+        "mcp_bioconductor-rhtslib",
+        "mcp_bioconductor-rsamtools",
+        "mcp_bioconductor-scaledmatrix",
+        "mcp_bioconductor-scalign",
+        "mcp_bioconductor-scarray.sat",
+        "mcp_bioconductor-scbfa",
+        "mcp_bioconductor-scbubbletree",
+        "mcp_bioconductor-sccb2",
+        "mcp_bioconductor-scclassifr",
+        "mcp_bioconductor-scdataviz",
+        "mcp_bioconductor-scdotplot",
+        "mcp_bioconductor-scfeatures",
+        "mcp_bioconductor-scider",
+        "mcp_bioconductor-scmageck",
+        "mcp_bioconductor-scqtltools",
+        "mcp_bioconductor-scran",
+        "mcp_bioconductor-screpertoire",
+        "mcp_bioconductor-scrnaseq",
+        "mcp_bioconductor-sctreeviz",
+        "mcp_bioconductor-scuttle",
+        "mcp_bioconductor-scvir",
+        "mcp_bioconductor-seraster",
+        "mcp_bioconductor-shortread",
+        "mcp_bioconductor-signifinder",
+        "mcp_bioconductor-singlecellmultimodal",
+        "mcp_bioconductor-smoothclust",
+        "mcp_bioconductor-smoppix",
+        "mcp_bioconductor-sosta",
+        "mcp_bioconductor-spacetrooper",
+        "mcp_bioconductor-spaniel",
+        "mcp_bioconductor-spari",
+        "mcp_bioconductor-sparsematrixstats",
+        "mcp_bioconductor-spatialcpie",
+        "mcp_bioconductor-spatialdatasets",
+        "mcp_bioconductor-spatialdecon",
+        "mcp_bioconductor-spatialdmelxsim",
+        "mcp_bioconductor-spatialexperiment",
+        "mcp_bioconductor-spatialexperimentio",
+        "mcp_bioconductor-spatialfda",
+        "mcp_bioconductor-spatialfeatureexperiment",
+        "mcp_bioconductor-spatialheatmap",
+        "mcp_bioconductor-speckle",
+        "mcp_bioconductor-spoon",
+        "mcp_bioconductor-spotclean",
+        "mcp_bioconductor-spotsweeper",
+        "mcp_bioconductor-standr",
+        "mcp_bioconductor-statial",
+        "mcp_bioconductor-stjoincount",
+        "mcp_bioconductor-summarizedexperiment",
+        "mcp_bioconductor-svp",
+        "mcp_bioconductor-tenxxeniumdata",
+        "mcp_bioconductor-tidyomics",
+        "mcp_bioconductor-tidyspatialexperiment",
+        "mcp_bioconductor-treesummarizedexperiment",
+        "mcp_bioconductor-vectrapolarisdata",
+        "mcp_bioconductor-visiumio",
+        "mcp_bioconductor-weberdivechalcdata",
+        "mcp_bioconductor-xcms",
+        "mcp_bioconductor-xenlite",
+        "mcp_bioconductor-xvector",
+        "mcp_bioconductor-zlibbioc",
+        "mcp_biopython",
+        "mcp_bowtie",
+        "mcp_bowtie2",
+        "mcp_bpipe",
+        "mcp_brooklyn_plot",
+        "mcp_busco",
+        "mcp_bx-python",
+        "mcp_c-ares",
+        "mcp_cascade-reg",
+        "mcp_cd-hit",
+        "mcp_cdbtools",
+        "mcp_cell2cell",
+        "mcp_cellitac",
+        "mcp_cellqc",
+        "mcp_cellrank",
+        "mcp_cellsnake",
+        "mcp_celltypist-so",
+        "mcp_checkatlas",
+        "mcp_checkm-genome",
+        "mcp_circexplorer2",
+        "mcp_circos",
+        "mcp_clustalw",
+        "mcp_cmappy",
+        "mcp_cnmf",
+        "mcp_cnvkit",
+        "mcp_comebin",
+        "mcp_comet-ms",
+        "mcp_constellations",
+        "mcp_cooler",
+        "mcp_cooltools",
+        "mcp_coreutils",
+        "mcp_cosg",
+        "mcp_cospar",
+        "mcp_crispresso2",
+        "mcp_crispritz",
+        "mcp_crisprme",
+        "mcp_cromwell",
+        "mcp_cutadapt",
+        "mcp_cwltool",
+        "mcp_cytoscape",
+        "mcp_cytotrace2-python",
+        "mcp_cyvcf2",
+        "mcp_ddocent",
+        "mcp_deblur",
+        "mcp_decoupler",
+        "mcp_deeptools",
+        "mcp_deeptoolsintervals",
+        "mcp_delly",
+        "mcp_dendropy",
+        "mcp_dnaio",
+        "mcp_doubletdetection",
+        "mcp_dropkick",
+        "mcp_dsh-bio",
+        "mcp_dxpy",
+        "mcp_easy_vitessce",
+        "mcp_echidna",
+        "mcp_emboss",
+        "mcp_ena-webin-cli",
+        "mcp_ensembl-vep",
+        "mcp_entrez-direct",
+        "mcp_epic",
+        "mcp_episcanpy",
+        "mcp_eva-sub-cli",
+        "mcp_f5c",
+        "mcp_famsa",
+        "mcp_fast5",
+        "mcp_fastani",
+        "mcp_fastdtw",
+        "mcp_fasttree",
+        "mcp_fermi2",
+        "mcp_fgbio",
+        "mcp_filechunkio",
+        "mcp_flagx",
+        "mcp_flye",
+        "mcp_ftputil",
+        "mcp_fwdpy11",
+        "mcp_galaxy-lib",
+        "mcp_gatk4-spark",
+        "mcp_gdk-pixbuf",
+        "mcp_gecode",
+        "mcp_gene-trajectory-python",
+        "mcp_genecircuitry",
+        "mcp_geneimpacts",
+        "mcp_genoboo",
+        "mcp_genomepy",
+        "mcp_genometools-genometools",
+        "mcp_gffutils",
+        "mcp_ghostscript",
+        "mcp_gimmemotifs",
+        "mcp_glimmerhmm",
+        "mcp_gmap",
+        "mcp_gneiss",
+        "mcp_gnuplot",
+        "mcp_gofasta",
+        "mcp_goleft",
+        "mcp_gromacs",
+        "mcp_gseapy",
+        "mcp_gsmap",
+        "mcp_gtdbtk",
+        "mcp_harpy",
+        "mcp_hicexplorer",
+        "mcp_hifiasm",
+        "mcp_hmmer",
+        "mcp_htseq",
+        "mcp_humann2",
+        "mcp_igv",
+        "mcp_igv-reports",
+        "mcp_illumina-interop",
+        "mcp_infernal",
+        "mcp_intarna",
+        "mcp_involucro",
+        "mcp_iow",
+        "mcp_ipyrad",
+        "mcp_ipython-cluster-helper",
+        "mcp_iqtree",
+        "mcp_itsxpress",
+        "mcp_ivar",
+        "mcp_jalview",
+        "mcp_java-jdk",
+        "mcp_jbrowse2",
+        "mcp_jcvi"
+      ]
+    },
+    "2000": {
+      "config": "/225040511/project/Biomni/experiments/bioagent_bench/configs/mcp_scale_2000.yaml",
+      "server_count": 526,
+      "tool_count": 2000,
+      "servers": [
+        "mcp_kallisto",
+        "mcp_kraken2",
+        "mcp_csvtk",
+        "mcp_megahit",
+        "mcp_kaiju",
+        "mcp_fastp",
+        "mcp_spades",
+        "mcp_scanpy",
+        "mcp_scanpy-cli",
+        "mcp_scanpy-scripts",
+        "mcp_seurat-scripts",
+        "mcp_bioconductor-deseq2",
+        "mcp_bioconductor-edger",
+        "mcp_bioconductor-limma",
+        "mcp_bioconductor-clusterprofiler",
+        "mcp_star",
+        "mcp_hisat2",
+        "mcp_subread",
+        "mcp_bcftools",
+        "mcp_bwa",
+        "mcp_gatk4",
+        "mcp_gatk",
+        "mcp_snpeff",
+        "mcp_freebayes",
+        "mcp_orthofinder",
+        "mcp_blast",
+        "mcp_blast-legacy",
+        "mcp_diamond",
+        "mcp_gffread",
+        "mcp_seqkit",
+        "mcp_multiqc",
+        "mcp_fastqc",
+        "mcp_trimmomatic",
+        "mcp_bioconductor-keggrest",
+        "mcp_snpsift",
+        "mcp_bioconductor-rsubread",
+        "mcp_bioconductor-tximport",
+        "mcp_bioconductor-variantannotation",
+        "mcp_celltypist",
+        "mcp_abnumber",
+        "mcp_abricate",
+        "mcp_abundancebin",
+        "mcp_abyss",
+        "mcp_adapterremoval",
+        "mcp_alfred",
+        "mcp_anansescanpy",
+        "mcp_anarci",
+        "mcp_aragorn",
+        "mcp_aria2",
+        "mcp_ariba",
+        "mcp_arriba",
+        "mcp_art",
+        "mcp_arvados-cwl-runner",
+        "mcp_arvados-python-client",
+        "mcp_atropos",
+        "mcp_augustus",
+        "mcp_auspice",
+        "mcp_bactopia",
+        "mcp_bamtools",
+        "mcp_barrnap",
+        "mcp_bbmap",
+        "mcp_bcbio-gff",
+        "mcp_bcbio-nextgen",
+        "mcp_bedops",
+        "mcp_bedtools",
+        "mcp_bin2cell",
+        "mcp_bioawk",
+        "mcp_biobambam",
+        "mcp_bioconductor-affy",
+        "mcp_bioconductor-affyio",
+        "mcp_bioconductor-alabaster",
+        "mcp_bioconductor-alabaster.sfe",
+        "mcp_bioconductor-alabaster.spatial",
+        "mcp_bioconductor-annotate",
+        "mcp_bioconductor-annotationdbi",
+        "mcp_bioconductor-annotationfilter",
+        "mcp_bioconductor-apeglm",
+        "mcp_bioconductor-apl",
+        "mcp_bioconductor-awaggregator",
+        "mcp_bioconductor-banksy",
+        "mcp_bioconductor-beachmat",
+        "mcp_bioconductor-benchdamic",
+        "mcp_bioconductor-biobase",
+        "mcp_bioconductor-biocbaseutils",
+        "mcp_bioconductor-biocfilecache",
+        "mcp_bioconductor-biocgenerics",
+        "mcp_bioconductor-biocio",
+        "mcp_bioconductor-biocneighbors",
+        "mcp_bioconductor-biocparallel",
+        "mcp_bioconductor-biocsingular",
+        "mcp_bioconductor-biomart",
+        "mcp_bioconductor-biomformat",
+        "mcp_bioconductor-biostrings",
+        "mcp_bioconductor-biovizbase",
+        "mcp_bioconductor-blase",
+        "mcp_bioconductor-bluster",
+        "mcp_bioconductor-bulksignalr",
+        "mcp_bioconductor-cardspa",
+        "mcp_bioconductor-catscradle",
+        "mcp_bioconductor-cdi",
+        "mcp_bioconductor-cellhashr",
+        "mcp_bioconductor-cellid",
+        "mcp_bioconductor-cellmigration",
+        "mcp_bioconductor-clusterfoldsimilarity",
+        "mcp_bioconductor-clustifyr",
+        "mcp_bioconductor-clustsignal",
+        "mcp_bioconductor-complexheatmap",
+        "mcp_bioconductor-concordexr",
+        "mcp_bioconductor-cotan",
+        "mcp_bioconductor-csoa",
+        "mcp_bioconductor-ctsv",
+        "mcp_bioconductor-curatedatlasqueryr",
+        "mcp_bioconductor-cytomapper",
+        "mcp_bioconductor-dada2",
+        "mcp_bioconductor-data-packages",
+        "mcp_bioconductor-decipher",
+        "mcp_bioconductor-decontam",
+        "mcp_bioconductor-decontx",
+        "mcp_bioconductor-deconvobuddies",
+        "mcp_bioconductor-delayedmatrixstats",
+        "mcp_bioconductor-despace",
+        "mcp_bioconductor-diffbind",
+        "mcp_bioconductor-dino",
+        "mcp_bioconductor-dirichletmultinomial",
+        "mcp_bioconductor-dnacopy",
+        "mcp_bioconductor-dose",
+        "mcp_bioconductor-ensembldb",
+        "mcp_bioconductor-erma",
+        "mcp_bioconductor-escher",
+        "mcp_bioconductor-experimentsubset",
+        "mcp_bioconductor-fgsea",
+        "mcp_bioconductor-genefilter",
+        "mcp_bioconductor-geneplotter",
+        "mcp_bioconductor-genomeinfodb",
+        "mcp_bioconductor-genomeinfodbdata",
+        "mcp_bioconductor-genomicalignments",
+        "mcp_bioconductor-genomicfeatures",
+        "mcp_bioconductor-genomicranges",
+        "mcp_bioconductor-geomxtools",
+        "mcp_bioconductor-ggsc",
+        "mcp_bioconductor-ggspavis",
+        "mcp_bioconductor-ggtree",
+        "mcp_bioconductor-glmgampoi",
+        "mcp_bioconductor-go.db",
+        "mcp_bioconductor-gosemsim",
+        "mcp_bioconductor-graph",
+        "mcp_bioconductor-gsva",
+        "mcp_bioconductor-hcatonsildata",
+        "mcp_bioconductor-hdf5array",
+        "mcp_bioconductor-hoodscanr",
+        "mcp_bioconductor-humanhippocampus2024",
+        "mcp_bioconductor-imcdatasets",
+        "mcp_bioconductor-imcrtools",
+        "mcp_bioconductor-impute",
+        "mcp_bioconductor-infercnv",
+        "mcp_bioconductor-interactivedisplaybase",
+        "mcp_bioconductor-iranges",
+        "mcp_bioconductor-irisfgm",
+        "mcp_bioconductor-jazzpanda",
+        "mcp_bioconductor-lisaclust",
+        "mcp_bioconductor-mastr",
+        "mcp_bioconductor-matrixgenerics",
+        "mcp_bioconductor-merfishdata",
+        "mcp_bioconductor-metabolomicsworkbenchr",
+        "mcp_bioconductor-metapod",
+        "mcp_bioconductor-mia",
+        "mcp_bioconductor-moleculeexperiment",
+        "mcp_bioconductor-mosim",
+        "mcp_bioconductor-mousegastrulationdata",
+        "mcp_bioconductor-mspurity",
+        "mcp_bioconductor-multiassayexperiment",
+        "mcp_bioconductor-multtest",
+        "mcp_bioconductor-nebulosa",
+        "mcp_bioconductor-nnsvg",
+        "mcp_bioconductor-noiseq",
+        "mcp_bioconductor-orfhunter",
+        "mcp_bioconductor-org.ce.eg.db",
+        "mcp_bioconductor-org.hs.eg.db",
+        "mcp_bioconductor-org.mm.eg.db",
+        "mcp_bioconductor-partcnv",
+        "mcp_bioconductor-phemd",
+        "mcp_bioconductor-phyloseq",
+        "mcp_bioconductor-pipecomp",
+        "mcp_bioconductor-poem",
+        "mcp_bioconductor-preprocesscore",
+        "mcp_bioconductor-proteomicsannotationhubdata",
+        "mcp_bioconductor-protgenerics",
+        "mcp_bioconductor-qvalue",
+        "mcp_bioconductor-rbgl",
+        "mcp_bioconductor-reactomegsa.data",
+        "mcp_bioconductor-regionalst",
+        "mcp_bioconductor-rforproteomics",
+        "mcp_bioconductor-rgraphviz",
+        "mcp_bioconductor-rhdf5",
+        "mcp_bioconductor-rhdf5filters",
+        "mcp_bioconductor-rhdf5lib",
+        "mcp_bioconductor-rhtslib",
+        "mcp_bioconductor-rsamtools",
+        "mcp_bioconductor-scaledmatrix",
+        "mcp_bioconductor-scalign",
+        "mcp_bioconductor-scarray.sat",
+        "mcp_bioconductor-scbfa",
+        "mcp_bioconductor-scbubbletree",
+        "mcp_bioconductor-sccb2",
+        "mcp_bioconductor-scclassifr",
+        "mcp_bioconductor-scdataviz",
+        "mcp_bioconductor-scdotplot",
+        "mcp_bioconductor-scfeatures",
+        "mcp_bioconductor-scider",
+        "mcp_bioconductor-scmageck",
+        "mcp_bioconductor-scqtltools",
+        "mcp_bioconductor-scran",
+        "mcp_bioconductor-screpertoire",
+        "mcp_bioconductor-scrnaseq",
+        "mcp_bioconductor-sctreeviz",
+        "mcp_bioconductor-scuttle",
+        "mcp_bioconductor-scvir",
+        "mcp_bioconductor-seraster",
+        "mcp_bioconductor-shortread",
+        "mcp_bioconductor-signifinder",
+        "mcp_bioconductor-singlecellmultimodal",
+        "mcp_bioconductor-smoothclust",
+        "mcp_bioconductor-smoppix",
+        "mcp_bioconductor-sosta",
+        "mcp_bioconductor-spacetrooper",
+        "mcp_bioconductor-spaniel",
+        "mcp_bioconductor-spari",
+        "mcp_bioconductor-sparsematrixstats",
+        "mcp_bioconductor-spatialcpie",
+        "mcp_bioconductor-spatialdatasets",
+        "mcp_bioconductor-spatialdecon",
+        "mcp_bioconductor-spatialdmelxsim",
+        "mcp_bioconductor-spatialexperiment",
+        "mcp_bioconductor-spatialexperimentio",
+        "mcp_bioconductor-spatialfda",
+        "mcp_bioconductor-spatialfeatureexperiment",
+        "mcp_bioconductor-spatialheatmap",
+        "mcp_bioconductor-speckle",
+        "mcp_bioconductor-spoon",
+        "mcp_bioconductor-spotclean",
+        "mcp_bioconductor-spotsweeper",
+        "mcp_bioconductor-standr",
+        "mcp_bioconductor-statial",
+        "mcp_bioconductor-stjoincount",
+        "mcp_bioconductor-summarizedexperiment",
+        "mcp_bioconductor-svp",
+        "mcp_bioconductor-tenxxeniumdata",
+        "mcp_bioconductor-tidyomics",
+        "mcp_bioconductor-tidyspatialexperiment",
+        "mcp_bioconductor-treesummarizedexperiment",
+        "mcp_bioconductor-vectrapolarisdata",
+        "mcp_bioconductor-visiumio",
+        "mcp_bioconductor-weberdivechalcdata",
+        "mcp_bioconductor-xcms",
+        "mcp_bioconductor-xenlite",
+        "mcp_bioconductor-xvector",
+        "mcp_bioconductor-zlibbioc",
+        "mcp_biopython",
+        "mcp_bowtie",
+        "mcp_bowtie2",
+        "mcp_bpipe",
+        "mcp_brooklyn_plot",
+        "mcp_busco",
+        "mcp_bx-python",
+        "mcp_c-ares",
+        "mcp_cascade-reg",
+        "mcp_cd-hit",
+        "mcp_cdbtools",
+        "mcp_cell2cell",
+        "mcp_cellitac",
+        "mcp_cellqc",
+        "mcp_cellrank",
+        "mcp_cellsnake",
+        "mcp_celltypist-so",
+        "mcp_checkatlas",
+        "mcp_checkm-genome",
+        "mcp_circexplorer2",
+        "mcp_circos",
+        "mcp_clustalw",
+        "mcp_cmappy",
+        "mcp_cnmf",
+        "mcp_cnvkit",
+        "mcp_comebin",
+        "mcp_comet-ms",
+        "mcp_constellations",
+        "mcp_cooler",
+        "mcp_cooltools",
+        "mcp_coreutils",
+        "mcp_cosg",
+        "mcp_cospar",
+        "mcp_crispresso2",
+        "mcp_crispritz",
+        "mcp_crisprme",
+        "mcp_cromwell",
+        "mcp_cutadapt",
+        "mcp_cwltool",
+        "mcp_cytoscape",
+        "mcp_cytotrace2-python",
+        "mcp_cyvcf2",
+        "mcp_ddocent",
+        "mcp_deblur",
+        "mcp_decoupler",
+        "mcp_deeptools",
+        "mcp_deeptoolsintervals",
+        "mcp_delly",
+        "mcp_dendropy",
+        "mcp_dnaio",
+        "mcp_doubletdetection",
+        "mcp_dropkick",
+        "mcp_dsh-bio",
+        "mcp_dxpy",
+        "mcp_easy_vitessce",
+        "mcp_echidna",
+        "mcp_emboss",
+        "mcp_ena-webin-cli",
+        "mcp_ensembl-vep",
+        "mcp_entrez-direct",
+        "mcp_epic",
+        "mcp_episcanpy",
+        "mcp_eva-sub-cli",
+        "mcp_f5c",
+        "mcp_famsa",
+        "mcp_fast5",
+        "mcp_fastani",
+        "mcp_fastdtw",
+        "mcp_fasttree",
+        "mcp_fermi2",
+        "mcp_fgbio",
+        "mcp_filechunkio",
+        "mcp_flagx",
+        "mcp_flye",
+        "mcp_ftputil",
+        "mcp_fwdpy11",
+        "mcp_galaxy-lib",
+        "mcp_gatk4-spark",
+        "mcp_gdk-pixbuf",
+        "mcp_gecode",
+        "mcp_gene-trajectory-python",
+        "mcp_genecircuitry",
+        "mcp_geneimpacts",
+        "mcp_genoboo",
+        "mcp_genomepy",
+        "mcp_genometools-genometools",
+        "mcp_gffutils",
+        "mcp_ghostscript",
+        "mcp_gimmemotifs",
+        "mcp_glimmerhmm",
+        "mcp_gmap",
+        "mcp_gneiss",
+        "mcp_gnuplot",
+        "mcp_gofasta",
+        "mcp_goleft",
+        "mcp_gromacs",
+        "mcp_gseapy",
+        "mcp_gsmap",
+        "mcp_gtdbtk",
+        "mcp_harpy",
+        "mcp_hicexplorer",
+        "mcp_hifiasm",
+        "mcp_hmmer",
+        "mcp_htseq",
+        "mcp_humann2",
+        "mcp_igv",
+        "mcp_igv-reports",
+        "mcp_illumina-interop",
+        "mcp_infernal",
+        "mcp_intarna",
+        "mcp_involucro",
+        "mcp_iow",
+        "mcp_ipyrad",
+        "mcp_ipython-cluster-helper",
+        "mcp_iqtree",
+        "mcp_itsxpress",
+        "mcp_ivar",
+        "mcp_jalview",
+        "mcp_java-jdk",
+        "mcp_jbrowse2",
+        "mcp_jcvi",
+        "mcp_jellyfish",
+        "mcp_jq",
+        "mcp_k8",
+        "mcp_kalign2",
+        "mcp_kb-python",
+        "mcp_khipu-metabolomics",
+        "mcp_kmer-jellyfish",
+        "mcp_krona",
+        "mcp_last",
+        "mcp_lastz",
+        "mcp_libcifpp",
+        "mcp_libdeflate",
+        "mcp_libsequence",
+        "mcp_locarna",
+        "mcp_macs2",
+        "mcp_mafft",
+        "mcp_mageck",
+        "mcp_mameshiba",
+        "mcp_mappy",
+        "mcp_markerrepo",
+        "mcp_mash",
+        "mcp_maxquant",
+        "mcp_medaka",
+        "mcp_meme",
+        "mcp_mentalist",
+        "mcp_metagenome-atlas",
+        "mcp_metaphlan",
+        "mcp_metaphlan2",
+        "mcp_mikado",
+        "mcp_minced",
+        "mcp_miniasm",
+        "mcp_minimap2",
+        "mcp_minvar",
+        "mcp_mitos",
+        "mcp_mmtf-python",
+        "mcp_mobivision-m",
+        "mcp_moments",
+        "mcp_mosdepth",
+        "mcp_mothur",
+        "mcp_msisensor-pro",
+        "mcp_msproteomicstools",
+        "mcp_msstitch",
+        "mcp_multiqc-bcbio",
+        "mcp_multiqc-xenium-extra",
+        "mcp_multivelo",
+        "mcp_mummer",
+        "mcp_munkres",
+        "mcp_muscle",
+        "mcp_mysql-connector-c",
+        "mcp_mztosqlite",
+        "mcp_nanocomp",
+        "mcp_nanoget",
+        "mcp_nanomath",
+        "mcp_nanopolish",
+        "mcp_ncbi-datasets-pylib",
+        "mcp_ncbi-genome-download",
+        "mcp_ncbi-ngs-sdk",
+        "mcp_ncbi-vdb",
+        "mcp_ncls",
+        "mcp_nextalign",
+        "mcp_nextclade",
+        "mcp_nextflow",
+        "mcp_nf-core",
+        "mcp_nglview",
+        "mcp_ngmlr",
+        "mcp_ngs-smap",
+        "mcp_ngs-tools",
+        "mcp_novae",
+        "mcp_novoalign",
+        "mcp_ont-fast5-api",
+        "mcp_openms-thirdparty",
+        "mcp_pairix",
+        "mcp_palantir",
+        "mcp_paml",
+        "mcp_pango-designation",
+        "mcp_pangolearn",
+        "mcp_parasail-python",
+        "mcp_pasta",
+        "mcp_paste-bio",
+        "mcp_pcdl",
+        "mcp_peakqc",
+        "mcp_peptide-shaker",
+        "mcp_perl-aceperl",
+        "mcp_perl-algorithm-diff",
+        "mcp_perl-alien-libxml2",
+        "mcp_perl-app-cpanminus",
+        "mcp_perl-appconfig",
+        "mcp_perl-archive-tar",
+        "mcp_perl-autoloader",
+        "mcp_perl-base",
+        "mcp_perl-bio-asn1-entrezgene",
+        "mcp_perl-bio-coordinate",
+        "mcp_perl-bio-featureio",
+        "mcp_perl-bio-samtools",
+        "mcp_perl-bio-searchio-hmmer",
+        "mcp_perl-bio-tools-phylo-paml",
+        "mcp_perl-bio-tools-run-alignment-clustalw",
+        "mcp_perl-bioperl-core",
+        "mcp_perl-business-isbn",
+        "mcp_perl-business-isbn-data",
+        "mcp_perl-capture-tiny",
+        "mcp_perl-cgi",
+        "mcp_perl-class-inspector",
+        "mcp_perl-common-sense",
+        "mcp_perl-compress-raw-zlib",
+        "mcp_perl-config-general",
+        "mcp_perl-constant",
+        "mcp_perl-convert-binary-c",
+        "mcp_perl-convert-binhex",
+        "mcp_perl-cpan-meta-requirements",
+        "mcp_perl-crypt-rc4",
+        "mcp_perl-data-dumper",
+        "mcp_perl-data-optlist",
+        "mcp_perl-date-format",
+        "mcp_perl-dbi",
+        "mcp_perl-devel-overloadinfo",
+        "mcp_perl-devel-stacktrace",
+        "mcp_perl-digest-md5",
+        "mcp_perl-digest-perl-md5",
+        "mcp_perl-digest-sha1",
+        "mcp_perl-encode-locale",
+        "mcp_perl-exception-class",
+        "mcp_perl-exporter",
+        "mcp_perl-extutils-cbuilder",
+        "mcp_perl-extutils-makemaker",
+        "mcp_perl-ffi-checklib",
+        "mcp_perl-file-sort",
+        "mcp_perl-file-spec",
+        "mcp_perl-file-which",
+        "mcp_perl-font-afm",
+        "mcp_perl-getopt-long",
+        "mcp_perl-graph",
+        "mcp_perl-graphviz",
+        "mcp_perl-html-element-extended",
+        "mcp_perl-html-formatter",
+        "mcp_perl-html-parser",
+        "mcp_perl-html-tableextract",
+        "mcp_perl-html-tagset",
+        "mcp_perl-html-tree",
+        "mcp_perl-html-treebuilder-xpath",
+        "mcp_perl-http-cookies",
+        "mcp_perl-http-daemon",
+        "mcp_perl-http-date",
+        "mcp_perl-http-negotiate",
+        "mcp_perl-image-info",
+        "mcp_perl-image-size",
+        "mcp_perl-importer",
+        "mcp_perl-io-compress"
+      ]
+    }
+  }
+}

experiments/bioagent_bench/evaluate_bioagent_bench.py

@@ -0,0 +1,1198 @@
+#!/usr/bin/env python3
+"""Evaluate Hypo_Bio_OS BioAgent Bench runs.
+
+This evaluator follows the BioAgent Bench paper's grader design:
+evaluate each trial as a pipeline execution, prioritize demonstrable
+pipeline completion over exact numeric agreement, and return an
+EvaluationResults-style JSON object.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import json
+import os
+import re
+from bisect import bisect_right
+from datetime import timezone, datetime
+from difflib import SequenceMatcher
+from pathlib import Path
+from statistics import mean
+from typing import Any
+
+
+DATASET_ROOT = Path("/225040511/project/bioagent-bench/dataset")
+METADATA_PATH = Path("/225040511/project/bioagent-bench/src/task_metadata.json")
+DEFAULT_RUNS_ROOT = Path("/225040511/project/Hypo_Bio_OS/bioagent-bench-runs")
+
+
+FLEXIBLE_TABLE_MATCH_CONFIGS: dict[tuple[str, str], dict[str, Any]] = {
+    (
+        "alzheimer-mouse",
+        "pathway_comparison.csv",
+    ): {
+        "soft_key_columns": ["Pathway"],
+        "threshold": 0.62,
+        "text_weight": 0.9,
+        "numeric_weight": 0.1,
+    },
+    (
+        "comparative-genomics",
+        "cluster_annotation_mapping.csv",
+    ): {
+        "soft_key_columns": ["consensus_annotation"],
+        "threshold": 0.68,
+    },
+    (
+        "metagenomics",
+        "phylum_relative_abundances.csv",
+    ): {
+        "soft_key_columns": ["Phylum"],
+        "threshold": 0.9,
+        "text_weight": 1.0,
+        "numeric_weight": 0.0,
+    },
+    (
+        "single-cell",
+        "all_clusters_de_genes.csv",
+    ): {
+        "soft_key_columns": ["gene_name", "cluster_id"],
+        "threshold": 0.78,
+        "text_weight": 0.85,
+        "numeric_weight": 0.15,
+    },
+    (
+        "viral-metagenomics",
+        "taxonomy.csv",
+    ): {
+        "soft_key_columns": ["domain", "species"],
+        "threshold": 0.72,
+        "text_weight": 0.85,
+        "numeric_weight": 0.15,
+    },
+}
+
+
+TASK_CONFIGS: dict[str, dict[str, Any]] = {
+    "alzheimer-mouse": {
+        "truth_files": ["pathway_comparison.csv"],
+        "result_files": ["pathway_comparison.csv"],
+        "key_columns": ["Pathway"],
+        "numeric_columns": ["5xFAD_pvalue", "3xTG_AD_pvalue", "PS3O1S_pvalue"],
+        "pipeline_steps": [
+            "inspect mouse count/DEA inputs",
+            "prepare metadata and count matrices for 5xFAD and 3xTG-AD",
+            "perform differential expression for 5xFAD",
+            "perform differential expression for 3xTG-AD",
+            "use provided PS3O1S differential expression results",
+            "run pathway enrichment per model",
+            "merge shared/comparative pathway p-values into final CSV",
+        ],
+        "results_match_guidance": (
+            "Treat mouse mmu/Mus musculus pathway labels as semantically compatible with hsa/Homo sapiens labels "
+            "when the pathway identity is the same. Do not require exact p-value equality if the pipeline is plausible."
+        ),
+    },
+    "comparative-genomics": {
+        "truth_files": ["cluster_annotation_mapping.csv"],
+        "result_files": ["cluster_annotation_mapping.csv"],
+        "key_columns": ["cluster_number", "consensus_annotation"],
+        "numeric_columns": [],
+        "pipeline_steps": [
+            "inspect Micrococcus FASTA/GFF/reference inputs",
+            "predict or extract protein-coding genes",
+            "identify orthologous/co-evolving clusters across genomes",
+            "filter clusters present across intended genomes and coding-only",
+            "assign high-confidence consensus annotations",
+            "write cluster_number,consensus_annotation CSV",
+        ],
+        "results_match_guidance": (
+            "Prioritize whether the output represents conserved annotated coding clusters. Exact cluster numbering "
+            "can vary by method, but placeholder annotations or unrelated organisms should not match."
+        ),
+    },
+    "cystic-fibrosis": {
+        "truth_files": ["cf_variants.csv"],
+        "result_files": ["cf_variants.csv"],
+        "key_columns": ["chromosome", "position", "reference", "alternate"],
+        "numeric_columns": [],
+        "verifiable": True,
+        "pipeline_steps": [
+            "inspect family description and variant VCF",
+            "filter variants by recessive inheritance in affected siblings",
+            "exclude variants inconsistent with unaffected relatives/parents",
+            "annotate candidate variant with ClinVar/reference metadata",
+            "write the requested causal-variant CSV schema",
+        ],
+        "results_match_guidance": (
+            "The result should identify the CFTR pathogenic recessive variant. Exact textual disease lists may differ, "
+            "but chromosome, position, ref/alt, gene, and clinical interpretation must be consistent."
+        ),
+    },
+    "deseq": {
+        "truth_files": ["up_regulated_genes.csv"],
+        "result_files": ["up_regulated_genes.csv"],
+        "key_columns": ["gene_id"],
+        "numeric_columns": ["log2FoldChange", "pvalue", "padj"],
+        "pipeline_steps": [
+            "inspect RNA-seq reads and Candida reference files",
+            "prepare genome annotation/index",
+            "align reads or otherwise quantify genes",
+            "count reads per gene",
+            "construct biofilm/planktonic sample metadata",
+            "run differential expression",
+            "filter up-regulated significant genes and write final CSV",
+        ],
+        "results_match_guidance": (
+            "Prioritize evidence of a complete RNA-seq DE pipeline and a plausible up-regulated gene table. "
+            "Do not require exact equality for all p-values/log fold changes."
+        ),
+    },
+    "evolution": {
+        "truth_files": ["variants_shared.csv", "gene_annotations.csv"],
+        "result_files": ["variants_shared.csv", "gene_annotations.csv"],
+        "key_columns": {
+            "variants_shared.csv": ["CHROM", "POS", "REF", "ALT"],
+            "gene_annotations.csv": ["Gene_Name"],
+        },
+        "numeric_columns": {"variants_shared.csv": [], "gene_annotations.csv": []},
+        "pipeline_steps": [
+            "inspect ancestor/evolved-line reads",
+            "prepare or identify valid E. coli reference/assembly",
+            "align ancestor and evolved reads",
+            "call variants for all samples",
+            "identify variants shared by evolved lines and absent from ancestor",
+            "annotate variant/gene effects",
+            "write variants_shared.csv and gene_annotations.csv",
+        ],
+        "results_match_guidance": (
+            "Reward a biologically coherent shared-variant workflow. Penalize using forbidden external/sibling references "
+            "or hallucinated annotations even if the final schema exists."
+        ),
+    },
+    "giab": {
+        "truth_files": ["HG001_GRCh38_1_22_v4.2.1_benchmark.vcf.gz"],
+        "result_files": ["predicted.vcf.gz"],
+        "vcf": True,
+        "verifiable": True,
+        "pipeline_steps": [
+            "inspect paired reads, BED targets, and GRCh38 reference",
+            "align reads to reference",
+            "sort/index BAM",
+            "mark duplicates or prepare analysis-ready BAM",
+            "call variants",
+            "compress/index final VCF if needed",
+            "write predicted.vcf.gz",
+        ],
+        "results_match_guidance": (
+            "Use GIAB variant concordance as the correctness signal. The f1_score field should reflect variant-level "
+            "overlap where available."
+        ),
+    },
+    "metagenomics": {
+        "truth_files": ["phylum_relative_abundances.csv"],
+        "result_files": ["phylum_relative_abundances.csv"],
+        "key_columns": ["OTU"],
+        "numeric_columns": ["JP4D", "JC1A"],
+        "pipeline_steps": [
+            "inspect paired metagenomic reads and reference database",
+            "classify reads taxonomically",
+            "aggregate classifications at bacterial phylum level",
+            "normalize relative abundances for JP4D and JC1A",
+            "write OTU,Kingdom,Phylum,JP4D,JC1A CSV",
+        ],
+        "results_match_guidance": (
+            "Prioritize correct use of the bacterial/metagenomic reference and plausible phylum-level abundance table. "
+            "Small abundance differences are acceptable."
+        ),
+    },
+    "single-cell": {
+        "truth_files": ["all_clusters_de_genes.csv"],
+        "result_files": ["all_clusters_de_genes.csv"],
+        "key_columns": ["cluster_id", "gene_name"],
+        "numeric_columns": ["logfoldchanges", "pvals", "pvals_adj", "abs_logfc"],
+        "pipeline_steps": [
+            "load 10X matrices and metadata",
+            "perform QC/normalization",
+            "cluster cells and preserve cluster IDs",
+            "annotate cell types using marker evidence",
+            "compare pre/post exercise within cell types or clusters",
+            "write all significant DE genes in requested schema",
+        ],
+        "results_match_guidance": (
+            "Cell-type labels and cluster identities may vary, so prioritize marker-supported annotation, DE evidence, "
+            "and schema correctness over exact row equality."
+        ),
+    },
+    "transcript-quant": {
+        "truth_files": ["truth.tsv"],
+        "result_files": ["truth.tsv"],
+        "tsv_no_header": True,
+        "key_columns": ["transcript_id"],
+        "numeric_columns": ["count"],
+        "verifiable": True,
+        "pipeline_steps": [
+            "inspect paired RNA-seq reads and transcriptome reference",
+            "build transcriptome index",
+            "quantify transcript abundance/counts",
+            "extract transcript_id and count columns",
+            "write no-header two-column TSV",
+        ],
+        "results_match_guidance": (
+            "Because the data is simulated, counts should closely reproduce the truth. Headerless two-column TSV format "
+            "is required."
+        ),
+    },
+    "viral-metagenomics": {
+        "truth_files": ["taxonomy.csv"],
+        "result_files": ["taxonomy.csv"],
+        "key_columns": ["domain", "species"],
+        "numeric_columns": ["contig_count"],
+        "verifiable": True,
+        "pipeline_steps": [
+            "inspect dolphin metagenomic reads and viral reference resources",
+            "assemble reads into contigs",
+            "classify contigs against compatible viral reference resources",
+            "aggregate contig counts by domain/species",
+            "write contig_count,domain,species CSV",
+        ],
+        "results_match_guidance": (
+            "Prioritize using this task's viral reference resources and correctly identifying viral species. "
+            "Unclassified contigs are allowed when supported by classification output."
+        ),
+    },
+}
+
+
+def utc_timestamp() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+
+
+def normalize_text(value: Any) -> str:
+    return " ".join(str(value).strip().split()).lower()
+
+
+def normalize_for_soft_match(value: Any) -> str:
+    text = normalize_text(value)
+    text = re.sub(r"\b(homo sapiens|mus musculus|human|mouse)\b", " ", text)
+    text = re.sub(r"\b(hsa|mmu)(?=\d)", " ", text)
+    text = re.sub(r"[^a-z0-9]+", " ", text)
+    return " ".join(text.split())
+
+
+def normalize_chrom(value: Any) -> str:
+    chrom = normalize_text(value)
+    if chrom.startswith("chr"):
+        chrom = chrom[3:]
+    return {"m": "mt", "mitochondria": "mt"}.get(chrom, chrom)
+
+
+def maybe_float(value: Any) -> float | None:
+    try:
+        return float(str(value).strip())
+    except Exception:
+        return None
+
+
+def get_row_value(row: dict, column: str, default: str = ""):
+    if column in row:
+        return row.get(column, default)
+    target = normalize_text(column)
+    for key, value in row.items():
+        if normalize_text(key) == target:
+            return value
+    return default
+
+
+def token_similarity(left: str, right: str) -> float:
+    left_tokens = set(left.split())
+    right_tokens = set(right.split())
+    if not left_tokens and not right_tokens:
+        return 1.0
+    if not left_tokens or not right_tokens:
+        return 0.0
+    return len(left_tokens & right_tokens) / len(left_tokens | right_tokens)
+
+
+def text_similarity(left: Any, right: Any) -> float:
+    left_norm = normalize_for_soft_match(left)
+    right_norm = normalize_for_soft_match(right)
+    if left_norm == right_norm:
+        return 1.0
+    if not left_norm or not right_norm:
+        return 0.0
+    sequence_score = SequenceMatcher(None, left_norm, right_norm).ratio()
+    token_score = token_similarity(left_norm, right_norm)
+    return max(sequence_score, token_score)
+
+
+def numeric_similarity(left: Any, right: Any, rel_scale: float = 0.1) -> float | None:
+    left_value = maybe_float(left)
+    right_value = maybe_float(right)
+    if left_value is None or right_value is None:
+        return None
+    if left_value == right_value:
+        return 1.0
+    scale = max(abs(left_value), abs(right_value), 1e-12)
+    relative_error = abs(left_value - right_value) / scale
+    return max(0.0, 1.0 - (relative_error / rel_scale))
+
+
+def load_task_metadata(metadata_path: Path) -> dict[str, dict]:
+    if not metadata_path.exists():
+        return {}
+    payload = json.loads(metadata_path.read_text(encoding="utf-8"))
+    return {item["task_id"]: item for item in payload}
+
+
+def load_run_metadata(run_dir: Path) -> dict:
+    path = run_dir / "run_metadata.json"
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def load_csv_rows(path: Path) -> list[dict]:
+    with path.open("r", encoding="utf-8", errors="ignore", newline="") as handle:
+        return list(csv.DictReader(handle))
+
+
+def load_tsv_no_header(path: Path) -> list[dict]:
+    rows = []
+    with path.open("r", encoding="utf-8", errors="ignore") as handle:
+        for line in handle:
+            line = line.rstrip("\n")
+            if not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) >= 2:
+                rows.append({"transcript_id": parts[0], "count": parts[1]})
+    return rows
+
+
+def read_text_preview(path: Path, max_lines: int = 80, max_chars: int = 24000) -> str:
+    opener = gzip.open if path.suffix == ".gz" else open
+    preview_lines = []
+    total_chars = 0
+    with opener(path, "rt", encoding="utf-8", errors="ignore") as handle:
+        for i, line in enumerate(handle):
+            if i >= max_lines:
+                preview_lines.append("... [truncated]")
+                break
+            preview_lines.append(line.rstrip("\n"))
+            total_chars += len(line)
+            if total_chars >= max_chars:
+                preview_lines.append("... [truncated]")
+                break
+    return "\n".join(preview_lines)
+
+
+def load_prediction_rows(task_id: str, file_name: str, prediction_path: Path) -> list[dict]:
+    if TASK_CONFIGS[task_id].get("tsv_no_header"):
+        return load_tsv_no_header(prediction_path)
+    return load_csv_rows(prediction_path)
+
+
+def open_text_auto(path: Path):
+    return gzip.open(path, "rt", encoding="utf-8", errors="ignore") if path.suffix == ".gz" else path.open(
+        "r", encoding="utf-8", errors="ignore"
+    )
+
+
+def parse_bed_intervals(path: Path) -> dict[str, list[tuple[int, int]]]:
+    intervals: dict[str, list[tuple[int, int]]] = {}
+    if not path.exists():
+        return intervals
+    with open_text_auto(path) as handle:
+        for line in handle:
+            if not line.strip() or line.startswith(("#", "track", "browser")):
+                continue
+            fields = line.rstrip("\n").split("\t")
+            if len(fields) < 3:
+                continue
+            try:
+                start = int(fields[1])
+                end = int(fields[2])
+            except ValueError:
+                continue
+            chrom = normalize_chrom(fields[0])
+            intervals.setdefault(chrom, []).append((start, end))
+    for chrom in intervals:
+        intervals[chrom].sort()
+    return intervals
+
+
+def position_in_intervals(chrom: str, pos: str, intervals: dict[str, list[tuple[int, int]]] | None) -> bool:
+    if not intervals:
+        return True
+    try:
+        pos_1_based = int(pos)
+    except ValueError:
+        return False
+    pos_0_based = pos_1_based - 1
+    chrom_intervals = intervals.get(normalize_chrom(chrom), [])
+    interval_index = bisect_right(chrom_intervals, (pos_0_based, 10**18)) - 1
+    if interval_index < 0:
+        return False
+    start, end = chrom_intervals[interval_index]
+    return start <= pos_0_based < end
+
+
+def load_vcf_keys(path: Path, intervals: dict[str, list[tuple[int, int]]] | None = None) -> set[tuple[str, str, str, str]]:
+    keys = set()
+    with open_text_auto(path) as handle:
+        for line in handle:
+            if not line or line.startswith("#"):
+                continue
+            fields = line.rstrip("\n").split("\t")
+            if len(fields) < 5:
+                continue
+            chrom, pos, _vid, ref, alt = fields[:5]
+            if not position_in_intervals(chrom, pos, intervals):
+                continue
+            for alt_item in alt.split(","):
+                keys.add((normalize_chrom(chrom), normalize_text(pos), normalize_text(ref), normalize_text(alt_item)))
+    return keys
+
+
+def f1_from_counts(tp: int, pred_count: int, truth_count: int) -> dict[str, float]:
+    precision = tp / pred_count if pred_count else 0.0
+    recall = tp / truth_count if truth_count else 0.0
+    f1 = 0.0 if precision + recall == 0 else (2 * precision * recall) / (precision + recall)
+    return {"precision": precision, "recall": recall, "f1": f1}
+
+
+def compare_variant_sets(pred_keys: set[tuple[str, str, str, str]], truth_keys: set[tuple[str, str, str, str]]) -> dict:
+    tp = len(pred_keys & truth_keys)
+    metrics = f1_from_counts(tp, len(pred_keys), len(truth_keys))
+    return {
+        "pred_variant_count": len(pred_keys),
+        "truth_variant_count": len(truth_keys),
+        "shared_variant_count": tp,
+        "precision": metrics["precision"],
+        "recall": metrics["recall"],
+        "f1": metrics["f1"],
+    }
+
+
+def compare_vcf(prediction_path: Path, truth_path: Path, task_id: str, dataset_root: Path) -> dict:
+    bed_candidates = [
+        dataset_root / task_id / "data" / "Agilent_v7.chr.bed",
+        dataset_root / task_id / "results" / "HG001_GRCh38_1_22_v4.2.1_benchmark.bed",
+    ]
+    bed_path = next((path for path in bed_candidates if path.exists()), None)
+    if not bed_path:
+        unfiltered_pred_keys = load_vcf_keys(prediction_path)
+        unfiltered_truth_keys = load_vcf_keys(truth_path)
+        unfiltered = compare_variant_sets(unfiltered_pred_keys, unfiltered_truth_keys)
+        return {
+            **unfiltered,
+            "truth_scope": "all_truth_variants",
+            "unfiltered_f1": unfiltered["f1"],
+            "note": "Approximate VCF comparison by normalized CHROM,POS,REF,ALT; no BED scope was available.",
+        }
+
+    intervals = parse_bed_intervals(bed_path)
+    scoped_pred_keys = load_vcf_keys(prediction_path, intervals=intervals)
+    scoped_truth_keys = load_vcf_keys(truth_path, intervals=intervals)
+    scoped = compare_variant_sets(scoped_pred_keys, scoped_truth_keys)
+    return {
+        **scoped,
+        "truth_scope": "target_bed",
+        "target_bed": str(bed_path),
+        "unfiltered_f1": None,
+        "note": "Primary F1 is restricted to the task target BED and uses normalized CHROM,POS,REF,ALT.",
+    }
+
+
+def row_similarity(
+    pred: dict,
+    truth: dict,
+    soft_key_columns: list[str],
+    numeric_columns: list[str],
+    text_weight: float,
+    numeric_weight: float,
+) -> float:
+    text_scores = [
+        text_similarity(get_row_value(pred, column, ""), get_row_value(truth, column, ""))
+        for column in soft_key_columns
+    ]
+    text_score = sum(text_scores) / len(text_scores) if text_scores else 0.0
+
+    numeric_scores = [
+        score
+        for column in numeric_columns
+        if (score := numeric_similarity(get_row_value(pred, column, ""), get_row_value(truth, column, ""))) is not None
+    ]
+    if not numeric_scores or numeric_weight <= 0:
+        return text_score
+    numeric_score = sum(numeric_scores) / len(numeric_scores)
+    total_weight = text_weight + numeric_weight
+    return ((text_score * text_weight) + (numeric_score * numeric_weight)) / total_weight
+
+
+def greedy_soft_row_match(
+    pred_rows: list[dict],
+    truth_rows: list[dict],
+    soft_key_columns: list[str],
+    numeric_columns: list[str],
+    threshold: float,
+    text_weight: float,
+    numeric_weight: float,
+) -> tuple[list[tuple[int, int, float]], list[int], list[int]]:
+    candidates = []
+    first_soft_column = soft_key_columns[0] if soft_key_columns else None
+    truth_buckets: dict[str, list[tuple[int, dict]]] = {}
+    use_bucketed_candidates = first_soft_column is not None and len(pred_rows) * len(truth_rows) > 200_000
+    if use_bucketed_candidates:
+        for truth_index, truth in enumerate(truth_rows):
+            bucket_key = normalize_for_soft_match(get_row_value(truth, first_soft_column, ""))
+            truth_buckets.setdefault(bucket_key, []).append((truth_index, truth))
+
+    for pred_index, pred in enumerate(pred_rows):
+        if use_bucketed_candidates:
+            bucket_key = normalize_for_soft_match(get_row_value(pred, first_soft_column, ""))
+            candidate_truth_rows = truth_buckets.get(bucket_key, [])
+        else:
+            candidate_truth_rows = list(enumerate(truth_rows))
+        for truth_index, truth in candidate_truth_rows:
+            score = row_similarity(pred, truth, soft_key_columns, numeric_columns, text_weight, numeric_weight)
+            if score >= threshold:
+                candidates.append((score, pred_index, truth_index))
+
+    candidates.sort(reverse=True)
+    used_pred = set()
+    used_truth = set()
+    matches = []
+    for score, pred_index, truth_index in candidates:
+        if pred_index in used_pred or truth_index in used_truth:
+            continue
+        used_pred.add(pred_index)
+        used_truth.add(truth_index)
+        matches.append((pred_index, truth_index, score))
+    unmatched_pred = [index for index in range(len(pred_rows)) if index not in used_pred]
+    unmatched_truth = [index for index in range(len(truth_rows)) if index not in used_truth]
+    return matches, unmatched_pred, unmatched_truth
+
+
+def compare_table_rows(task_id: str, file_name: str, pred_rows: list[dict], truth_rows: list[dict]) -> dict:
+    config = TASK_CONFIGS[task_id]
+    key_columns = config["key_columns"][file_name] if isinstance(config["key_columns"], dict) else config["key_columns"]
+    numeric_columns = (
+        config["numeric_columns"][file_name] if isinstance(config["numeric_columns"], dict) else config["numeric_columns"]
+    )
+
+    pred_map = {
+        tuple(normalize_text(get_row_value(row, col, "")) for col in key_columns): row
+        for row in pred_rows
+    }
+    truth_map = {
+        tuple(normalize_text(get_row_value(row, col, "")) for col in key_columns): row
+        for row in truth_rows
+    }
+
+    pred_keys = set(pred_map)
+    truth_keys = set(truth_map)
+    shared_keys = pred_keys & truth_keys
+    metrics = f1_from_counts(len(shared_keys), len(pred_keys), len(truth_keys))
+
+    numeric_diffs = {col: [] for col in numeric_columns}
+    for key in shared_keys:
+        pred = pred_map[key]
+        truth = truth_map[key]
+        for col in numeric_columns:
+            pred_value = maybe_float(get_row_value(pred, col, ""))
+            truth_value = maybe_float(get_row_value(truth, col, ""))
+            if pred_value is not None and truth_value is not None:
+                numeric_diffs[col].append(abs(pred_value - truth_value))
+
+    summary = {
+        "pred_row_count": len(pred_rows),
+        "truth_row_count": len(truth_rows),
+        "shared_key_count": len(shared_keys),
+        "exact_key_precision": metrics["precision"],
+        "exact_key_recall": metrics["recall"],
+        "exact_key_f1": metrics["f1"],
+        "key_precision": metrics["precision"],
+        "key_recall": metrics["recall"],
+        "key_f1": metrics["f1"],
+        "match_strategy": "exact_key",
+        "match_precision": metrics["precision"],
+        "match_recall": metrics["recall"],
+        "match_f1": metrics["f1"],
+    }
+
+    flexible_config = FLEXIBLE_TABLE_MATCH_CONFIGS.get((task_id, file_name))
+    if flexible_config:
+        soft_key_columns = flexible_config.get("soft_key_columns", key_columns)
+        threshold = flexible_config.get("threshold", 0.75)
+        text_weight = flexible_config.get("text_weight", 1.0)
+        numeric_weight = flexible_config.get("numeric_weight", 0.0)
+        matches, unmatched_pred, unmatched_truth = greedy_soft_row_match(
+            pred_rows,
+            truth_rows,
+            soft_key_columns,
+            numeric_columns,
+            threshold,
+            text_weight,
+            numeric_weight,
+        )
+        soft_metrics = f1_from_counts(len(matches), len(pred_rows), len(truth_rows))
+        summary.update(
+            {
+                "match_strategy": "soft_row_similarity",
+                "soft_key_columns": soft_key_columns,
+                "match_threshold": threshold,
+                "soft_match_count": len(matches),
+                "match_precision": soft_metrics["precision"],
+                "match_recall": soft_metrics["recall"],
+                "match_f1": soft_metrics["f1"],
+                "mean_match_score": mean([score for *_unused, score in matches]) if matches else 0.0,
+                "unmatched_prediction_examples": [
+                    {column: get_row_value(pred_rows[index], column, "") for column in soft_key_columns}
+                    for index in unmatched_pred[:5]
+                ],
+                "unmatched_truth_examples": [
+                    {column: get_row_value(truth_rows[index], column, "") for column in soft_key_columns}
+                    for index in unmatched_truth[:5]
+                ],
+            }
+        )
+    if numeric_columns:
+        summary["numeric_mae"] = {
+            col: (sum(values) / len(values) if values else None) for col, values in numeric_diffs.items()
+        }
+    return summary
+
+
+def summarize_file_for_judge(task_id: str, path: Path) -> dict:
+    config = TASK_CONFIGS[task_id]
+    if not path.exists():
+        return {"path": str(path), "exists": False}
+    if config.get("vcf"):
+        return {
+            "path": str(path),
+            "exists": True,
+            "type": "vcf.gz",
+            "size_bytes": path.stat().st_size,
+            "preview": read_text_preview(path, max_lines=60, max_chars=20000),
+        }
+    if path.suffix.lower() == ".tsv" and config.get("tsv_no_header"):
+        rows = load_tsv_no_header(path)
+        return {
+            "path": str(path),
+            "exists": True,
+            "type": "tsv",
+            "row_count": len(rows),
+            "columns": ["transcript_id", "count"],
+            "preview": read_text_preview(path, max_lines=80, max_chars=22000),
+        }
+    rows = load_csv_rows(path)
+    return {
+        "path": str(path),
+        "exists": True,
+        "type": path.suffix.lower().lstrip(".") or "text",
+        "row_count": len(rows),
+        "columns": list(rows[0].keys()) if rows else [],
+        "preview": read_text_preview(path, max_lines=80, max_chars=22000),
+    }
+
+
+def locate_prediction_file(task_id: str, run_dir: Path, file_name: str) -> Path | None:
+    candidate = run_dir / file_name
+    if candidate.exists():
+        return candidate
+    matches = sorted(run_dir.rglob(file_name))
+    return matches[0] if matches else None
+
+
+def infer_latest_run_dir(task_id: str, runs_root: Path) -> Path | None:
+    candidates = sorted(path for path in runs_root.glob(f"{task_id}_*") if path.is_dir())
+    return candidates[-1] if candidates else None
+
+
+def build_processing_tree(run_dir: Path, max_entries: int = 600) -> list[str]:
+    entries = []
+    for path in sorted(run_dir.rglob("*")):
+        rel = path.relative_to(run_dir)
+        if len(entries) >= max_entries:
+            entries.append("... [truncated]")
+            break
+        if path.is_dir():
+            entries.append(f"{rel}/")
+        else:
+            entries.append(f"{rel}\t{path.stat().st_size} bytes")
+    return entries
+
+
+def collect_trace_path_evidence(run_dir: Path) -> dict:
+    """Collect only folders/file paths from the run, matching the paper's trace input."""
+    execution_log = run_dir / "execution_log.txt"
+    path_mentions = []
+    if execution_log.exists():
+        text = execution_log.read_text(encoding="utf-8", errors="ignore")
+        for token in text.replace('"', " ").replace("'", " ").split():
+            if token.startswith("/") and ("/bioagent-bench/" in token or "/bioagent-bench-runs/" in token):
+                cleaned = token.rstrip("),.;:<>")
+                if cleaned not in path_mentions:
+                    path_mentions.append(cleaned)
+            if len(path_mentions) >= 250:
+                break
+    return {
+        "processing_tree": build_processing_tree(run_dir),
+        "path_mentions_from_trace": path_mentions,
+    }
+
+
+def build_artifact_metrics(task_id: str, run_dir: Path, dataset_root: Path) -> list[dict]:
+    config = TASK_CONFIGS[task_id]
+    truth_dir = dataset_root / task_id / "results"
+    artifacts = []
+    for truth_name, result_name in zip(config["truth_files"], config["result_files"], strict=False):
+        truth_path = truth_dir / truth_name
+        prediction_path = locate_prediction_file(task_id, run_dir, result_name)
+        entry = {
+            "truth_file": str(truth_path),
+            "prediction_file": str(prediction_path) if prediction_path else None,
+            "prediction_exists": bool(prediction_path and prediction_path.exists()),
+        }
+        if not prediction_path or not prediction_path.exists() or not truth_path.exists():
+            entry["metrics"] = {"error": "missing prediction or truth file"}
+            artifacts.append(entry)
+            continue
+        if config.get("vcf"):
+            entry["metrics"] = compare_vcf(prediction_path, truth_path, task_id, dataset_root)
+        else:
+            pred_rows = load_prediction_rows(task_id, truth_name, prediction_path)
+            truth_rows = load_prediction_rows(task_id, truth_name, truth_path)
+            entry["metrics"] = compare_table_rows(task_id, truth_name, pred_rows, truth_rows)
+        artifacts.append(entry)
+    return artifacts
+
+
+def result_artifact_summaries(task_id: str, run_dir: Path, dataset_root: Path) -> tuple[list[dict], list[dict]]:
+    config = TASK_CONFIGS[task_id]
+    truth_dir = dataset_root / task_id / "results"
+    result_summaries = []
+    truth_summaries = []
+    for truth_name, result_name in zip(config["truth_files"], config["result_files"], strict=False):
+        prediction_path = locate_prediction_file(task_id, run_dir, result_name)
+        truth_path = truth_dir / truth_name
+        result_summaries.append(
+            summarize_file_for_judge(task_id, prediction_path) if prediction_path else {"path": result_name, "exists": False}
+        )
+        truth_summaries.append(summarize_file_for_judge(task_id, truth_path))
+    return result_summaries, truth_summaries
+
+
+def infer_rule_steps(task_id: str, artifacts: list[dict], trace_evidence: dict) -> tuple[int, int, list[str]]:
+    config = TASK_CONFIGS[task_id]
+    expected_steps = config["pipeline_steps"]
+    total = len(expected_steps)
+    haystack = "\n".join(trace_evidence["processing_tree"] + trace_evidence["path_mentions_from_trace"]).lower()
+    completed = 0
+    evidence = []
+    keyword_sets = {
+        "inspect": ["task_query", "run_metadata", "data"],
+        "metadata": ["metadata", "counts"],
+        "differential": ["deseq", "de_results", "differential", "log2fold"],
+        "enrichment": ["kegg", "enrichment", "pathway"],
+        "protein": ["prodigal", ".faa", "protein"],
+        "ortholog": ["orthofinder", "mmseqs", "diamond", "cluster"],
+        "variant": [".vcf", "bcftools", "variant"],
+        "align": [".bam", ".sam", "bwa", "star", "aligned"],
+        "count": ["feature_counts", "counts", "abundance"],
+        "classify": ["kraken", "kaiju", "classification", "report"],
+        "assemble": ["spades", "megahit", "contigs", "assembly"],
+        "single-cell": ["matrix", "scanpy", "cluster", "umap", "markers"],
+        "index": ["index", ".idx", "star_index"],
+        "final": [artifact["prediction_file"] or "" for artifact in artifacts],
+    }
+    for step in expected_steps:
+        step_l = step.lower()
+        if (
+            ("write" in step_l or "final" in step_l)
+            and any(name in step_l for name in ["csv", "tsv", "vcf", "predicted"])
+            and not any(artifact.get("prediction_exists") for artifact in artifacts)
+        ):
+            continue
+        if (
+            ("write" in step_l or "final" in step_l)
+            and any(name in step_l for name in ["csv", "tsv", "vcf", "predicted"])
+            and all(artifact.get("prediction_exists") for artifact in artifacts)
+        ):
+            completed += 1
+            evidence.append(step)
+            continue
+        keys = []
+        for concept, words in keyword_sets.items():
+            if concept in step_l or any(word in step_l for word in words[:2]):
+                keys.extend(words)
+        if not keys:
+            generic = {"and", "or", "the", "to", "a", "an", "write", "final", "requested"}
+            keys = [token for token in step_l.replace(",", " ").split() if len(token) > 3 and token not in generic][:4]
+        if any(key and key.lower() in haystack for key in keys):
+            completed += 1
+            evidence.append(step)
+
+    # Final artifacts are the strongest evidence for final-result step.
+    final_files = [artifact for artifact in artifacts if artifact.get("prediction_exists")]
+    if final_files and completed < total:
+        completed = max(completed, total - 1)
+        evidence.append("final artifact(s) exist; inferred most upstream steps completed")
+    return min(completed, total), total, evidence
+
+
+def rule_trial_judge(task_id: str, artifacts: list[dict], trace_evidence: dict) -> dict:
+    steps_completed, steps_to_completion, evidence = infer_rule_steps(task_id, artifacts, trace_evidence)
+    final_result_reached = all(artifact.get("prediction_exists") for artifact in artifacts)
+    metric_scores = []
+    giab_f1 = None
+    for artifact in artifacts:
+        metrics = artifact.get("metrics", {})
+        if "match_f1" in metrics:
+            metric_scores.append(metrics["match_f1"])
+        elif "f1" in metrics:
+            metric_scores.append(metrics["f1"])
+            if task_id == "giab":
+                giab_f1 = metrics["f1"]
+        elif "key_f1" in metrics:
+            metric_scores.append(metrics["key_f1"])
+    mean_metric_score = mean(metric_scores) if metric_scores else 0.0
+
+    # Paper-style correctness flag is task/rubric specific. In rule mode, use a conservative helper.
+    if TASK_CONFIGS[task_id].get("verifiable"):
+        threshold = 0.5 if task_id == "giab" else 0.8
+        results_match = final_result_reached and mean_metric_score >= threshold
+    else:
+        results_match = final_result_reached and steps_completed == steps_to_completion
+
+    notes = (
+        "Rule-mode approximation of the paper's LLM grader. "
+        f"Evidence-backed steps: {', '.join(evidence[:8]) if evidence else 'none detected'}."
+    )
+    return {
+        "steps_completed": steps_completed,
+        "steps_to_completion": steps_to_completion,
+        "final_result_reached": final_result_reached,
+        "notes": notes,
+        "results_match": results_match,
+        "f1_score": giab_f1,
+    }
+
+
+def resolve_judge_client(provider: str, model: str | None, base_url: str | None, api_key: str | None):
+    try:
+        from openai import OpenAI
+    except ImportError as exc:
+        raise ImportError("openai package is required for LLM judging.") from exc
+
+    provider = provider.lower().strip()
+    if provider == "deepseek":
+        resolved_model = model or os.getenv("DEEPSEEK_MODEL_NAME", "deepseek-chat")
+        resolved_base_url = base_url or os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1")
+        resolved_api_key = api_key or os.getenv("DEEPSEEK_API_KEY")
+        if not resolved_api_key:
+            raise RuntimeError("Missing DEEPSEEK_API_KEY for DeepSeek LLM judge.")
+        return OpenAI(api_key=resolved_api_key, base_url=resolved_base_url), resolved_model, provider
+    if provider == "openai":
+        resolved_model = model or os.getenv("OPENAI_MODEL_NAME", "gpt-5.1")
+        resolved_api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not resolved_api_key:
+            raise RuntimeError("Missing OPENAI_API_KEY for OpenAI LLM judge.")
+        return OpenAI(api_key=resolved_api_key), resolved_model, provider
+    raise ValueError(f"Unsupported LLM judge provider: {provider}")
+
+
+def extract_json_object(text: str) -> dict:
+    text = text.strip()
+    if not text:
+        raise ValueError("Empty LLM judge response.")
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        start = text.find("{")
+        end = text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            return json.loads(text[start : end + 1])
+        raise
+
+
+def llm_trial_judge(
+    task_id: str,
+    task_prompt: str,
+    input_data_path: Path,
+    reference_data_path: Path,
+    result_summaries: list[dict],
+    truth_summaries: list[dict],
+    trace_evidence: dict,
+    artifacts: list[dict],
+    provider: str,
+    model: str | None,
+    base_url: str | None,
+    api_key: str | None,
+) -> dict:
+    client, resolved_model, resolved_provider = resolve_judge_client(provider, model, base_url, api_key)
+    config = TASK_CONFIGS[task_id]
+    compact_tree = "\n".join(trace_evidence["processing_tree"][:450])
+    path_mentions = "\n".join(trace_evidence["path_mentions_from_trace"][:180])
+
+    user_prompt = f"""
+You are a strict, impartial Bioinformatics Pipeline Judge. Evaluate an LLM agent's work for executing a bioinformatics pipeline instructed by the prompt.
+
+Inputs:
+1. Input data: {input_data_path}
+2. Reference data: {reference_data_path if reference_data_path.exists() else "<none>"}
+3. Processing tree:
+{compact_tree}
+
+Trace path mentions:
+{path_mentions or "<none>"}
+
+4. Results:
+{json.dumps(result_summaries, ensure_ascii=False, indent=2)}
+
+5. Truth:
+{json.dumps(truth_summaries, ensure_ascii=False, indent=2)}
+
+6. Prompt:
+{task_prompt}
+
+Task expected pipeline steps:
+{json.dumps(config["pipeline_steps"], ensure_ascii=False, indent=2)}
+
+Auxiliary rule-based artifact metrics:
+{json.dumps(artifacts, ensure_ascii=False, indent=2)}
+
+Evaluation rules:
+- Prioritize evaluation of pipeline completion over exact numerical correctness.
+- If gene names are of different naming conventions, the result can still be valid.
+- Estimate steps_to_completion from bioinformatics-relevant steps required for this task.
+- Count upstream steps only if their expected artifacts are present.
+- Do not count placeholders or mock completion as completed steps.
+- For p-values, log-fold values, abundances, or other statistics, check that plausible prior steps generated them.
+- Task-specific results-match guidance: {config.get("results_match_guidance", "")}
+
+Return JSON only with exactly these fields:
+- steps_completed: integer
+- steps_to_completion: integer
+- final_result_reached: boolean
+- notes: string
+- results_match: boolean
+- f1_score: number or null; only use a real F1 for GIAB/variant concordance, otherwise null
+""".strip()
+
+    response = client.chat.completions.create(
+        model=resolved_model,
+        temperature=0,
+        response_format={"type": "json_object"},
+        messages=[
+            {"role": "system", "content": "Return strict JSON only. Follow the BioAgent Bench EvaluationResults schema."},
+            {"role": "user", "content": user_prompt},
+        ],
+    )
+    parsed = extract_json_object(response.choices[0].message.content or "{}")
+    parsed["provider"] = resolved_provider
+    parsed["model"] = resolved_model
+    return parsed
+
+
+def normalize_evaluation_results(raw: dict) -> dict:
+    steps_completed = int(raw.get("steps_completed", 0) or 0)
+    steps_to_completion = int(raw.get("steps_to_completion", 0) or 0)
+    final_result_reached = bool(raw.get("final_result_reached", False))
+    results_match = bool(raw.get("results_match", False))
+    f1_score = raw.get("f1_score")
+    if f1_score is not None:
+        try:
+            f1_score = float(f1_score)
+        except Exception:
+            f1_score = None
+    completion_rate = steps_completed / steps_to_completion if steps_to_completion else 0.0
+    return {
+        "steps_completed": steps_completed,
+        "steps_to_completion": steps_to_completion,
+        "completion_rate": completion_rate,
+        "final_result_reached": final_result_reached,
+        "results_match": results_match,
+        "f1_score": f1_score,
+        "notes": str(raw.get("notes", "")),
+    }
+
+
+def evaluate_task(
+    task_id: str,
+    run_dir: Path,
+    dataset_root: Path,
+    task_metadata: dict[str, dict],
+    judge_mode: str = "rule",
+    llm_provider: str = "deepseek",
+    llm_model: str | None = None,
+    llm_base_url: str | None = None,
+    llm_api_key: str | None = None,
+) -> dict:
+    task_dir = dataset_root / task_id
+    run_metadata = load_run_metadata(run_dir)
+    task_prompt = (
+        run_metadata.get("benchmark_task_context", {}).get("task_prompt")
+        or task_metadata.get(task_id, {}).get("task_prompt")
+        or run_metadata.get("query")
+        or ""
+    )
+    trace_evidence = collect_trace_path_evidence(run_dir)
+    artifacts = build_artifact_metrics(task_id, run_dir, dataset_root)
+    result_summaries, truth_summaries = result_artifact_summaries(task_id, run_dir, dataset_root)
+
+    rule_raw = rule_trial_judge(task_id, artifacts, trace_evidence)
+    rule_result = normalize_evaluation_results(rule_raw)
+
+    selected_raw = rule_raw
+    llm_result = None
+    if judge_mode in {"llm", "both"}:
+        selected_raw = llm_trial_judge(
+            task_id=task_id,
+            task_prompt=task_prompt,
+            input_data_path=task_dir / "data",
+            reference_data_path=task_dir / "reference",
+            result_summaries=result_summaries,
+            truth_summaries=truth_summaries,
+            trace_evidence=trace_evidence,
+            artifacts=artifacts,
+            provider=llm_provider,
+            model=llm_model,
+            base_url=llm_base_url,
+            api_key=llm_api_key,
+        )
+        llm_result = normalize_evaluation_results(selected_raw)
+
+    selected = rule_result if judge_mode == "rule" else llm_result
+    assert selected is not None
+    return {
+        "task_id": task_id,
+        "run_dir": str(run_dir),
+        "evaluated_at_utc": utc_timestamp(),
+        "judge_mode": judge_mode,
+        "evaluation_results": selected,
+        "overall_score": selected["completion_rate"],
+        "score_definition": (
+            "BioAgent Bench-style completion rate: steps_completed / steps_to_completion. "
+            "results_match and f1_score are reported separately."
+        ),
+        "rule_evaluation_results": rule_result,
+        "llm_evaluation_results": llm_result,
+        "artifacts": artifacts,
+        "result_summaries": result_summaries,
+        "truth_summaries": truth_summaries,
+        "trace_evidence": trace_evidence,
+        "paper_alignment": {
+            "grader_inputs": [
+                "input data path",
+                "reference data path",
+                "expected outcome/truth as text summary",
+                "agent outcome as text summary",
+                "agent trace represented as folders/file paths",
+                "task prompt and grading logic",
+            ],
+            "grader_outputs": [
+                "steps_completed",
+                "steps_to_completion",
+                "final_result_reached",
+                "notes",
+                "results_match",
+                "f1_score",
+            ],
+        },
+    }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Evaluate Hypo_Bio_OS outputs on bioagent-bench.")
+    parser.add_argument("--task", action="append", help="Task ID to evaluate. Can be provided multiple times.")
+    parser.add_argument("--all", action="store_true", help="Evaluate all tasks that have run directories.")
+    parser.add_argument("--run-dir", help="Specific run directory for single-task evaluation.")
+    parser.add_argument("--runs-root", default=str(DEFAULT_RUNS_ROOT))
+    parser.add_argument("--dataset-root", default=str(DATASET_ROOT))
+    parser.add_argument("--metadata", default=str(METADATA_PATH))
+    parser.add_argument("--output", default=None, help="Where to save the evaluation JSON.")
+    parser.add_argument(
+        "--judge-mode",
+        choices=["rule", "llm", "both"],
+        default="rule",
+        help="Use local paper-shaped heuristic grading, LLM grading, or both.",
+    )
+    parser.add_argument(
+        "--llm-provider",
+        choices=["openai", "deepseek"],
+        default=os.getenv("BIOAGENT_BENCH_JUDGE_PROVIDER", "deepseek"),
+        help="OpenAI-compatible backend provider for the LLM judge.",
+    )
+    parser.add_argument("--llm-model", default=None, help="Override model name for the LLM judge.")
+    parser.add_argument("--llm-base-url", default=None, help="Override base URL for the LLM judge.")
+    parser.add_argument("--llm-api-key", default=None, help="Override API key for the LLM judge.")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    dataset_root = Path(args.dataset_root)
+    runs_root = Path(args.runs_root)
+    task_metadata = load_task_metadata(Path(args.metadata))
+
+    if args.all:
+        task_ids = list(TASK_CONFIGS)
+    else:
+        task_ids = args.task or []
+    if not task_ids:
+        raise SystemExit("Provide --task <task_id> or use --all.")
+
+    results = []
+    for task_id in task_ids:
+        if task_id not in TASK_CONFIGS:
+            raise SystemExit(f"Unsupported task ID: {task_id}")
+        if args.run_dir and len(task_ids) == 1:
+            run_dir = Path(args.run_dir)
+        else:
+            run_dir = infer_latest_run_dir(task_id, runs_root)
+            if run_dir is None:
+                print(f"Skipping {task_id}: no run directory found under {runs_root}")
+                continue
+        result = evaluate_task(
+            task_id=task_id,
+            run_dir=run_dir,
+            dataset_root=dataset_root,
+            task_metadata=task_metadata,
+            judge_mode=args.judge_mode,
+            llm_provider=args.llm_provider,
+            llm_model=args.llm_model,
+            llm_base_url=args.llm_base_url,
+            llm_api_key=args.llm_api_key,
+        )
+        results.append(result)
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+
+    completion_rates = [item["evaluation_results"]["completion_rate"] for item in results]
+    payload = {
+        "evaluated_at_utc": utc_timestamp(),
+        "judge_mode": args.judge_mode,
+        "primary_metric": "completion_rate",
+        "mean_completion_rate": mean(completion_rates) if completion_rates else 0.0,
+        "results": results,
+    }
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        task_eval_dir = runs_root  / "evaluation_results"
+        task_eval_dir.mkdir(parents=True, exist_ok=True)
+        output_path = task_eval_dir / f"evaluation_{task_id}.json"
+    output_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"Saved evaluation summary to: {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

experiments/bioagent_bench/gold_tools.json

@@ -0,0 +1,553 @@
+{
+  "alzheimer-mouse": {
+    "task_name": "Alzheimer Mouse Models: Comparative Pathway Analysis",
+    "gold_tools": [
+      "DESeq2",
+      "edgeR",
+      "limma",
+      "clusterProfiler",
+      "KEGGREST"
+    ],
+    "gold_servers": [
+      "mcp_bioconductor-deseq2",
+      "mcp_bioconductor-edger",
+      "mcp_bioconductor-limma",
+      "mcp_bioconductor-clusterprofiler",
+      "mcp_bioconductor-keggrest"
+    ],
+    "workflow": [
+      {
+        "name": "load_mouse_count_tables",
+        "tool_patterns": [
+          "read",
+          "csv",
+          "count",
+          "pandas",
+          "data.table"
+        ]
+      },
+      {
+        "name": "normalize_and_model_expression",
+        "tool_patterns": [
+          "deseq",
+          "edger",
+          "limma",
+          "normalize"
+        ]
+      },
+      {
+        "name": "run_kegg_pathway_enrichment",
+        "tool_patterns": [
+          "clusterprofiler",
+          "kegg",
+          "enrich",
+          "pathway"
+        ]
+      },
+      {
+        "name": "compare_shared_pathways",
+        "tool_patterns": [
+          "merge",
+          "join",
+          "shared",
+          "csv",
+          "pandas"
+        ]
+      }
+    ]
+  },
+  "comparative-genomics": {
+    "task_name": "Comparative Genomics: Co-evolving Gene Clusters",
+    "gold_tools": [
+      "OrthoFinder",
+      "BLAST",
+      "DIAMOND",
+      "gffread",
+      "seqkit"
+    ],
+    "gold_servers": [
+      "mcp_orthofinder",
+      "mcp_blast",
+      "mcp_diamond",
+      "mcp_gffread",
+      "mcp_seqkit"
+    ],
+    "workflow": [
+      {
+        "name": "extract_or_prepare_proteomes",
+        "tool_patterns": [
+          "gffread",
+          "seqkit",
+          "fasta",
+          "faa"
+        ]
+      },
+      {
+        "name": "infer_orthogroups",
+        "tool_patterns": [
+          "orthofinder",
+          "orthogroup",
+          "blast",
+          "diamond"
+        ]
+      },
+      {
+        "name": "filter_core_coding_clusters",
+        "tool_patterns": [
+          "core",
+          "present",
+          "coding",
+          "orthogroup",
+          "pandas"
+        ]
+      },
+      {
+        "name": "assign_consensus_annotations",
+        "tool_patterns": [
+          "blast",
+          "diamond",
+          "kegg",
+          "annotation",
+          "consensus"
+        ]
+      }
+    ]
+  },
+  "cystic-fibrosis": {
+    "task_name": "Cystic Fibrosis Mendelian Variant Identification",
+    "gold_tools": [
+      "BWA",
+      "samtools",
+      "bcftools",
+      "GATK",
+      "SnpEff",
+      "SnpSift"
+    ],
+    "gold_servers": [
+      "mcp_bwa",
+      "mcp_samtools",
+      "mcp_bcftools",
+      "mcp_gatk4",
+      "mcp_snpeff",
+      "mcp_snpsift"
+    ],
+    "workflow": [
+      {
+        "name": "prepare_family_variant_data",
+        "tool_patterns": [
+          "bwa",
+          "samtools",
+          "bam",
+          "vcf"
+        ]
+      },
+      {
+        "name": "call_or_filter_variants",
+        "tool_patterns": [
+          "bcftools",
+          "gatk",
+          "variant",
+          "filter"
+        ]
+      },
+      {
+        "name": "annotate_with_effect_and_clinvar",
+        "tool_patterns": [
+          "snpeff",
+          "snpsift",
+          "clinvar",
+          "annotation"
+        ]
+      },
+      {
+        "name": "apply_recessive_family_filter",
+        "tool_patterns": [
+          "recessive",
+          "affected",
+          "family",
+          "genotype",
+          "pandas"
+        ]
+      }
+    ]
+  },
+  "deseq": {
+    "task_name": "RNA-Seq Differential Expression (DESeq2)",
+    "gold_tools": [
+      "STAR",
+      "HISAT2",
+      "featureCounts",
+      "Subread",
+      "DESeq2",
+      "tximport"
+    ],
+    "gold_servers": [
+      "mcp_star",
+      "mcp_hisat2",
+      "mcp_subread",
+      "mcp_bioconductor-rsubread",
+      "mcp_bioconductor-deseq2",
+      "mcp_bioconductor-tximport"
+    ],
+    "workflow": [
+      {
+        "name": "align_rnaseq_reads",
+        "tool_patterns": [
+          "star",
+          "hisat2",
+          "align",
+          "bam"
+        ]
+      },
+      {
+        "name": "count_gene_features",
+        "tool_patterns": [
+          "featurecounts",
+          "subread",
+          "count"
+        ]
+      },
+      {
+        "name": "differential_expression",
+        "tool_patterns": [
+          "deseq",
+          "edger",
+          "limma",
+          "log2foldchange"
+        ]
+      },
+      {
+        "name": "write_de_results_csv",
+        "tool_patterns": [
+          "csv",
+          "gene_id",
+          "padj",
+          "pvalue"
+        ]
+      }
+    ]
+  },
+  "evolution": {
+    "task_name": "Experimental Evolution Variant Calling (E. coli)",
+    "gold_tools": [
+      "BWA",
+      "samtools",
+      "bcftools",
+      "FreeBayes",
+      "SnpEff",
+      "SnpSift"
+    ],
+    "gold_servers": [
+      "mcp_bwa",
+      "mcp_samtools",
+      "mcp_bcftools",
+      "mcp_freebayes",
+      "mcp_snpeff",
+      "mcp_snpsift"
+    ],
+    "workflow": [
+      {
+        "name": "align_evolved_and_ancestor_reads",
+        "tool_patterns": [
+          "bwa",
+          "samtools",
+          "align",
+          "bam"
+        ]
+      },
+      {
+        "name": "call_variants_per_line",
+        "tool_patterns": [
+          "bcftools",
+          "freebayes",
+          "variant",
+          "vcf"
+        ]
+      },
+      {
+        "name": "annotate_variant_effects",
+        "tool_patterns": [
+          "snpeff",
+          "effect",
+          "impact",
+          "moderate"
+        ]
+      },
+      {
+        "name": "intersect_shared_variants",
+        "tool_patterns": [
+          "shared",
+          "intersect",
+          "evolved",
+          "pandas"
+        ]
+      }
+    ]
+  },
+  "giab": {
+    "task_name": "GIAB Variant Calling",
+    "gold_tools": [
+      "BWA",
+      "samtools",
+      "bcftools",
+      "GATK",
+      "FreeBayes",
+      "VariantAnnotation"
+    ],
+    "gold_servers": [
+      "mcp_bwa",
+      "mcp_samtools",
+      "mcp_bcftools",
+      "mcp_gatk4",
+      "mcp_freebayes",
+      "mcp_bioconductor-variantannotation"
+    ],
+    "workflow": [
+      {
+        "name": "align_exome_reads",
+        "tool_patterns": [
+          "bwa",
+          "samtools",
+          "align",
+          "bam"
+        ]
+      },
+      {
+        "name": "sort_index_and_qc_bam",
+        "tool_patterns": [
+          "samtools",
+          "sort",
+          "index",
+          "flagstat"
+        ]
+      },
+      {
+        "name": "call_germline_variants",
+        "tool_patterns": [
+          "gatk",
+          "bcftools",
+          "freebayes",
+          "haplotypecaller"
+        ]
+      },
+      {
+        "name": "compress_and_index_vcf",
+        "tool_patterns": [
+          "vcf",
+          "bgzip",
+          "tabix",
+          "index"
+        ]
+      }
+    ]
+  },
+  "metagenomics": {
+    "task_name": "Metagenomics: Community Comparison (Cuatro Cienegas)",
+    "gold_tools": [
+      "Kraken2",
+      "csvtk",
+      "pandas"
+    ],
+    "gold_servers": [
+      "mcp_kraken2",
+      "mcp_csvtk"
+    ],
+    "workflow": [
+      {
+        "name": "classify_paired_reads",
+        "tool_patterns": [
+          "kraken2",
+          "classify",
+          "paired",
+          "fastq"
+        ]
+      },
+      {
+        "name": "parse_kraken_reports",
+        "tool_patterns": [
+          "report",
+          "taxonomy",
+          "taxid",
+          "phylum"
+        ]
+      },
+      {
+        "name": "compute_bacterial_phylum_relative_abundance",
+        "tool_patterns": [
+          "bacteria",
+          "phylum",
+          "relative",
+          "abundance"
+        ]
+      },
+      {
+        "name": "write_phylum_abundance_csv",
+        "tool_patterns": [
+          "csv",
+          "OTU",
+          "Kingdom",
+          "Phylum",
+          "JP4D",
+          "JC1A"
+        ]
+      }
+    ]
+  },
+  "single-cell": {
+    "task_name": "Single-cell RNA-seq: Skeletal Muscle Exercise Response",
+    "gold_tools": [
+      "Scanpy",
+      "Seurat",
+      "CellTypist"
+    ],
+    "gold_servers": [
+      "mcp_scanpy",
+      "mcp_scanpy-cli",
+      "mcp_scanpy-scripts",
+      "mcp_seurat-scripts",
+      "mcp_celltypist"
+    ],
+    "workflow": [
+      {
+        "name": "load_single_cell_matrix",
+        "tool_patterns": [
+          "scanpy",
+          "read_h5ad",
+          "h5ad",
+          "matrix"
+        ]
+      },
+      {
+        "name": "normalize_cluster_and_embed",
+        "tool_patterns": [
+          "normalize",
+          "neighbors",
+          "leiden",
+          "umap",
+          "scanpy"
+        ]
+      },
+      {
+        "name": "annotate_cell_types",
+        "tool_patterns": [
+          "celltypist",
+          "marker",
+          "annotation",
+          "cell_type"
+        ]
+      },
+      {
+        "name": "differential_expression_by_condition",
+        "tool_patterns": [
+          "rank_genes",
+          "differential",
+          "exercise",
+          "wilcoxon"
+        ]
+      }
+    ]
+  },
+  "transcript-quant": {
+    "task_name": "Transcript Quantification (Simulated RNA-Seq)",
+    "gold_tools": [
+      "Kallisto",
+      "Salmon"
+    ],
+    "gold_servers": [
+      "mcp_kallisto",
+      "mcp_salmon"
+    ],
+    "workflow": [
+      {
+        "name": "build_transcriptome_index",
+        "tool_patterns": [
+          "kallisto_index",
+          "salmon",
+          "index",
+          "transcriptome"
+        ]
+      },
+      {
+        "name": "quantify_paired_end_reads",
+        "tool_patterns": [
+          "kallisto_quant",
+          "salmon",
+          "quant",
+          "paired"
+        ]
+      },
+      {
+        "name": "extract_transcript_counts",
+        "tool_patterns": [
+          "abundance",
+          "est_counts",
+          "count",
+          "transcript_id"
+        ]
+      },
+      {
+        "name": "write_no_header_tsv",
+        "tool_patterns": [
+          "tsv",
+          "transcript_id",
+          "count"
+        ]
+      }
+    ]
+  },
+  "viral-metagenomics": {
+    "task_name": "Viral Metagenomics: Species Identification (Dolphin)",
+    "gold_tools": [
+      "MEGAHIT",
+      "SPAdes",
+      "Kaiju",
+      "fastp",
+      "BLAST"
+    ],
+    "gold_servers": [
+      "mcp_megahit",
+      "mcp_spades",
+      "mcp_kaiju",
+      "mcp_fastp",
+      "mcp_blast"
+    ],
+    "workflow": [
+      {
+        "name": "assemble_viral_metagenomic_contigs",
+        "tool_patterns": [
+          "megahit",
+          "spades",
+          "assembly",
+          "contig"
+        ]
+      },
+      {
+        "name": "classify_contigs_taxonomically",
+        "tool_patterns": [
+          "kaiju",
+          "blast",
+          "taxonomy",
+          "virus"
+        ]
+      },
+      {
+        "name": "resolve_taxon_names",
+        "tool_patterns": [
+          "names",
+          "nodes",
+          "taxon",
+          "species"
+        ]
+      },
+      {
+        "name": "summarize_contig_counts_by_species",
+        "tool_patterns": [
+          "species",
+          "contig_count",
+          "domain",
+          "csv"
+        ]
+      }
+    ]
+  }
+}

experiments/lab_bench/README_RUN.md

@@ -0,0 +1,289 @@
+# LAB-Bench Biomni 实验新手运行指南
+
+这份说明用于运行 Biomni 在 LAB-Bench 上的实验，并且数据集设置要和
+`/225040511/project/Hypo_Bio_OS/experiments/lab_bench/scripts` 里的 HypoBioOS
+实验保持一致。
+
+```bash
+/225040511/project/Biomni/experiments/lab_bench
+```
+
+LAB-Bench 数据和代码默认位于：
+
+```bash
+/225040511/project/LAB-Bench
+```
+
+## 1. 进入 Biomni 项目
+
+```bash
+cd /225040511/project/Biomni
+```
+
+## 2. 本实验跑什么数据
+
+不要跑 LAB-Bench 全量。为了和 HypoBioOS 对照实验一致，本实验只跑：
+
+- `DbQA`
+- `SeqQA`
+
+默认数据设置：
+
+- split: `test`
+- dev offset: `45`
+- test size: `315`
+- seed: `20260514`
+- shard count: `10`
+- runner threads: `1`
+
+对应 HypoBioOS 脚本里的默认环境变量：
+
+```bash
+LAB_BENCH_SPLITS=test
+LAB_BENCH_DEV_SIZE=45
+LAB_BENCH_TEST_SIZE=315
+LAB_BENCH_SUBSET_SEED=20260514
+LAB_BENCH_TEST_SHARD_COUNT=10
+LAB_BENCH_N_THREADS=1
+```
+
+Biomni 这边的 `run_all_labbench_with_biomni.sh` 已经改成只代理 DbQA + SeqQA 子集，不会启动 LAB-Bench 全量 eval。
+
+## 3. 挂 DeepSeek 后端
+
+推荐把 DeepSeek key 写到 Biomni 项目根目录的 `.env`：
+
+```bash
+cat > /225040511/project/Biomni/.env <<'EOF'
+DEEPSEEK_API_KEY=你的 DeepSeek API Key
+DEEPSEEK_MODEL_NAME=deepseek-chat
+DEEPSEEK_BASE_URL=https://api.deepseek.com/v1
+EOF
+```
+
+也可以只在当前 shell 里临时设置：
+
+```bash
+export DEEPSEEK_API_KEY="你的 DeepSeek API Key"
+export DEEPSEEK_MODEL_NAME="deepseek-chat"
+export DEEPSEEK_BASE_URL="https://api.deepseek.com/v1"
+```
+
+实验脚本会自动把 DeepSeek 变量转换成 Biomni 需要的 Custom provider 配置：
+
+```bash
+BIOMNI_SOURCE=Custom
+BIOMNI_LLM=$DEEPSEEK_MODEL_NAME
+BIOMNI_CUSTOM_BASE_URL=$DEEPSEEK_BASE_URL
+BIOMNI_CUSTOM_API_KEY=$DEEPSEEK_API_KEY
+```
+
+可以用下面命令确认 key 是否已设置，不会打印 key 内容：
+
+```bash
+for k in DEEPSEEK_API_KEY BIOMNI_CUSTOM_API_KEY BIOMNI_SOURCE BIOMNI_LLM BIOMNI_CUSTOM_BASE_URL; do
+  if [ -n "${!k:-}" ]; then echo "$k=set"; else echo "$k=unset"; fi
+done
+```
+
+如果你把 key 写进 `.env`，上面的检查命令在手动 `source .env` 之前可能显示 unset，这是正常的；运行脚本时会自动读取 `/225040511/project/Biomni/.env` 和 `/225040511/project/LAB-Bench/.env`。
+
+## 4. Python 环境
+
+默认使用：
+
+```bash
+/225040511/miniconda3/envs/biomni_e1/bin/python
+```
+
+如果要换 Python，可以设置：
+
+```bash
+export LAB_BENCH_RUNNER_PYTHON=/path/to/python
+```
+
+## 5. 快速跑一个小样本
+
+先用 debug 模式验证 DeepSeek、Biomni 和 LAB-Bench 都能跑通：
+
+```bash
+/225040511/miniconda3/envs/biomni_e1/bin/python \
+  experiments/lab_bench/run_labbench_with_biomni.py \
+  --eval DbQA \
+  --split test \
+  --debug \
+  --output experiments/lab_bench/results/debug_dbqa.json
+```
+
+成功后会生成：
+
+```bash
+experiments/lab_bench/results/debug_dbqa.json
+```
+
+## 6. 正式运行 DbQA 和 SeqQA
+
+推荐使用分片脚本。它们默认后台运行、默认断点续跑，并把结果追加到 JSONL。
+
+同时跑 DbQA + SeqQA：
+
+```bash
+export LAB_BENCH_SPLITS=test
+export LAB_BENCH_DEV_SIZE=45
+export LAB_BENCH_TEST_SIZE=315
+export LAB_BENCH_SUBSET_SEED=20260514
+export LAB_BENCH_TEST_SHARD_COUNT=10
+experiments/lab_bench/run_dbqa_seqqa_biomni_experiment.sh --background --resume
+```
+
+只跑 DbQA：
+
+```bash
+experiments/lab_bench/run_dbqa_biomni_experiment.sh --background --resume
+```
+
+只跑 SeqQA：
+
+```bash
+experiments/lab_bench/run_seqqa_biomni_experiment.sh --background --resume
+```
+
+默认每个 eval 分成 10 个 shard 并行跑。可以调整 shard 数：
+
+```bash
+export LAB_BENCH_TEST_SHARD_COUNT=5
+experiments/lab_bench/run_dbqa_seqqa_biomni_experiment.sh --background --resume
+```
+
+## 7. 前台调试
+
+如果想直接在终端看到错误，使用前台模式：
+
+```bash
+experiments/lab_bench/run_dbqa_biomni_experiment.sh --foreground --resume
+```
+
+或者：
+
+```bash
+experiments/lab_bench/run_seqqa_biomni_experiment.sh --foreground --resume
+```
+
+前台模式会占住当前终端，适合调试；长时间正式实验建议用后台模式。
+
+## 8. 结果位置
+
+DbQA 分片结果：
+
+```bash
+experiments/lab_bench/results/dbqa_batch/dbqa_results.jsonl
+experiments/lab_bench/results/dbqa_batch/dbqa_reasoning.log
+```
+
+SeqQA 分片结果：
+
+```bash
+experiments/lab_bench/results/seqqa_batch/seqqa_results.jsonl
+experiments/lab_bench/results/seqqa_batch/seqqa_reasoning.log
+```
+
+`*_results.jsonl` 每行是一道题的紧凑结果，包含：
+
+- `question`
+- `answer`
+- `agent_answer`
+
+`*_reasoning.log` 保存每题的 prompt、raw output 和 Biomni reasoning log，方便排查错误。
+
+## 9. 断点续跑和重新开始
+
+默认推荐断点续跑：
+
+```bash
+experiments/lab_bench/run_dbqa_seqqa_biomni_experiment.sh --background --resume
+```
+
+脚本会跳过已经存在于 `*_results.jsonl` 里的问题。
+
+如果���清空旧结果重新跑：
+
+```bash
+experiments/lab_bench/run_dbqa_seqqa_biomni_experiment.sh --background --fresh
+```
+
+## 10. 常用参数
+
+切换 split。为了和 HypoBioOS 正式实验一致，默认用 `test`：
+
+```bash
+export LAB_BENCH_SPLITS=test
+```
+
+Biomni 分片脚本一次只支持一个 split。如果设置成 `dev test`，脚本会退出，避免和 HypoBioOS 默认测试集设置混淆。
+
+调整 dev/test 数量：
+
+```bash
+export LAB_BENCH_DEV_SIZE=45
+export LAB_BENCH_TEST_SIZE=315
+```
+
+固定抽样种子：
+
+```bash
+export LAB_BENCH_SUBSET_SEED=20260514
+```
+
+Biomni A1 runner 是有状态的，脚本默认：
+
+```bash
+LAB_BENCH_N_THREADS=1
+```
+
+不建议改成更大的值。
+
+## 11. 检查是否在跑
+
+查看后台进程：
+
+```bash
+ps -ef | grep lab_bench | grep -v grep
+```
+
+查看结果是否持续增长：
+
+```bash
+wc -l experiments/lab_bench/results/dbqa_batch/dbqa_results.jsonl
+wc -l experiments/lab_bench/results/seqqa_batch/seqqa_results.jsonl
+```
+
+查看最近 reasoning log：
+
+```bash
+tail -80 experiments/lab_bench/results/dbqa_batch/dbqa_reasoning.log
+tail -80 experiments/lab_bench/results/seqqa_batch/seqqa_reasoning.log
+```
+
+## 12. 常见报错
+
+如果看到：
+
+```text
+No LLM API key found.
+```
+
+说明脚本没有读到 DeepSeek key。检查：
+
+```bash
+ls -lh /225040511/project/Biomni/.env
+```
+
+并确认 `.env` 里至少有：
+
+```bash
+DEEPSEEK_API_KEY=你的 DeepSeek API Key
+DEEPSEEK_MODEL_NAME=deepseek-chat
+DEEPSEEK_BASE_URL=https://api.deepseek.com/v1
+```
+
+如果使用临时环境变量，确认你是在同一个 shell 里先 `export`，再启动脚本。

experiments/lab_bench/run_all_labbench_with_biomni.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+echo "This experiment is aligned with Hypo_Bio_OS: DbQA + SeqQA only, default split=test."
+echo "Delegating to run_dbqa_seqqa_biomni_experiment.sh; no full LAB-Bench run will be launched."
+
+"${SCRIPT_DIR}/run_dbqa_seqqa_biomni_experiment.sh" "$@"

experiments/lab_bench/run_dbqa_biomni_experiment.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BIOMNI_ROOT="/225040511/project/Biomni"
+LAB_BENCH_ROOT="/225040511/project/LAB-Bench"
+RUNNER="${BIOMNI_ROOT}/experiments/lab_bench/run_labbench_with_biomni.py"
+RUNNER_PYTHON="${LAB_BENCH_RUNNER_PYTHON:-${BIOMNI_EXECUTION_PYTHON:-/225040511/miniconda3/envs/biomni_e1/bin/python}}"
+
+OUTPUT_ROOT="${BIOMNI_ROOT}/experiments/lab_bench/results/dbqa_batch"
+RESULT_FILE="${OUTPUT_ROOT}/dbqa_results.jsonl"
+REASONING_LOG="${OUTPUT_ROOT}/dbqa_reasoning.log"
+EVAL_NAME="DbQA"
+
+DEV_SIZE="${LAB_BENCH_DEV_SIZE:-45}"
+TEST_SIZE="${LAB_BENCH_TEST_SIZE:-315}"
+SEED="${LAB_BENCH_SUBSET_SEED:-20260514}"
+N_THREADS="${LAB_BENCH_N_THREADS:-1}"
+TEST_SHARD_COUNT="${LAB_BENCH_TEST_SHARD_COUNT:-10}"
+SPLITS_TEXT="${LAB_BENCH_SPLITS:-${LAB_BENCH_SPLIT:-test}}"
+
+BACKGROUND=1
+RESUME=1
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --foreground)
+            BACKGROUND=0
+            shift
+            ;;
+        --background)
+            BACKGROUND=1
+            shift
+            ;;
+        --fresh)
+            RESUME=0
+            shift
+            ;;
+        --resume)
+            RESUME=1
+            shift
+            ;;
+        *)
+            exit 2
+            ;;
+    esac
+done
+
+if [[ "${BACKGROUND}" -eq 1 ]]; then
+    SCRIPT_ABS_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/$(basename "${BASH_SOURCE[0]}")"
+    FORWARD_ARGS=(--foreground)
+    if [[ "${RESUME}" -eq 0 ]]; then
+        FORWARD_ARGS+=(--fresh)
+    else
+        FORWARD_ARGS+=(--resume)
+    fi
+    nohup "${SCRIPT_ABS_PATH}" "${FORWARD_ARGS[@]}" > /dev/null 2>&1 < /dev/null &
+    exit 0
+fi
+
+mkdir -p "${OUTPUT_ROOT}"
+if [[ "${RESUME}" -eq 0 ]]; then
+    : > "${RESULT_FILE}"
+    : > "${REASONING_LOG}"
+else
+    touch "${RESULT_FILE}" "${REASONING_LOG}"
+fi
+
+for ENV_FILE in "${BIOMNI_ROOT}/.env" "${LAB_BENCH_ROOT}/.env"; do
+    if [[ -f "${ENV_FILE}" ]]; then
+        set -a
+        # shellcheck disable=SC1090
+        source "${ENV_FILE}"
+        set +a
+    fi
+done
+
+if [[ -n "${DEEPSEEK_API_KEY:-}" && -z "${BIOMNI_CUSTOM_API_KEY:-}" ]]; then
+    export BIOMNI_SOURCE="${BIOMNI_SOURCE:-Custom}"
+    export BIOMNI_LLM="${BIOMNI_LLM:-${DEEPSEEK_MODEL_NAME:-deepseek-chat}}"
+    export BIOMNI_CUSTOM_BASE_URL="${BIOMNI_CUSTOM_BASE_URL:-${DEEPSEEK_BASE_URL:-https://api.deepseek.com/v1}}"
+    export BIOMNI_CUSTOM_API_KEY="${DEEPSEEK_API_KEY}"
+fi
+
+if [[ -z "${ANTHROPIC_API_KEY:-}" && -z "${OPENAI_API_KEY:-}" && -z "${BIOMNI_CUSTOM_API_KEY:-}" ]]; then
+    printf "[launcher] missing LLM API key environment variables; batch did not start\n" >> "${REASONING_LOG}"
+    exit 2
+fi
+
+read -r -a SPLIT_ARRAY <<< "${SPLITS_TEXT}"
+if [[ "${#SPLIT_ARRAY[@]}" -ne 1 ]]; then
+    printf "[launcher] Biomni LAB-Bench runner supports one split per batch; got LAB_BENCH_SPLITS='%s'\n" "${SPLITS_TEXT}" >> "${REASONING_LOG}"
+    exit 2
+fi
+SPLIT="${SPLIT_ARRAY[0]}"
+
+declare -a CHILD_PIDS=()
+
+launch_shard() {
+    local shard_index="$1"
+    local run_label="dbqa_shard$(printf '%02d' "$((shard_index + 1))")of$(printf '%02d' "${TEST_SHARD_COUNT}")"
+    local -a cmd=(
+        "${RUNNER_PYTHON}" "${RUNNER}"
+        "--eval" "${EVAL_NAME}"
+        "--split" "${SPLIT}"
+        "--dev-size" "${DEV_SIZE}"
+        "--test-size" "${TEST_SIZE}"
+        "--seed" "${SEED}"
+        "--repeat" "1"
+        "--n_threads" "${N_THREADS}"
+        "--output-root" "${OUTPUT_ROOT}"
+        "--agent-root" "${BIOMNI_ROOT}/experiments/lab_bench/agent_runtime"
+        "--run-label" "${run_label}"
+        "--shard-index" "${shard_index}"
+        "--shard-count" "${TEST_SHARD_COUNT}"
+        "--reasoning-log-path" "${REASONING_LOG}"
+        "--compact-results-path" "${RESULT_FILE}"
+        "--compact-output-only"
+        "--skip-existing-results"
+    )
+    "${cmd[@]}" > /dev/null 2>&1 &
+    CHILD_PIDS+=("$!")
+}
+
+for (( shard_index=0; shard_index<TEST_SHARD_COUNT; shard_index++ )); do
+    launch_shard "${shard_index}"
+done
+
+for pid in "${CHILD_PIDS[@]}"; do
+    wait "${pid}"
+done

experiments/lab_bench/run_dbqa_seqqa_biomni_experiment.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BIOMNI_ROOT="/225040511/project/Biomni"
+DBQA_SCRIPT="${BIOMNI_ROOT}/experiments/lab_bench/run_dbqa_biomni_experiment.sh"
+SEQQA_SCRIPT="${BIOMNI_ROOT}/experiments/lab_bench/run_seqqa_biomni_experiment.sh"
+
+BACKGROUND=1
+EXTRA_ARGS=()
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --foreground)
+            BACKGROUND=0
+            EXTRA_ARGS+=("$1")
+            shift
+            ;;
+        --background)
+            shift
+            ;;
+        --fresh|--resume)
+            EXTRA_ARGS+=("$1")
+            shift
+            ;;
+        *)
+            exit 2
+            ;;
+    esac
+done
+
+if [[ "${BACKGROUND}" -eq 1 ]]; then
+    SCRIPT_ABS_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/$(basename "${BASH_SOURCE[0]}")"
+    nohup "${SCRIPT_ABS_PATH}" --foreground "${EXTRA_ARGS[@]}" > /dev/null 2>&1 < /dev/null &
+    exit 0
+fi
+
+"${DBQA_SCRIPT}" "${EXTRA_ARGS[@]}"
+"${SEQQA_SCRIPT}" "${EXTRA_ARGS[@]}"

experiments/lab_bench/run_seqqa_biomni_experiment.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BIOMNI_ROOT="/225040511/project/Biomni"
+LAB_BENCH_ROOT="/225040511/project/LAB-Bench"
+RUNNER="${BIOMNI_ROOT}/experiments/lab_bench/run_labbench_with_biomni.py"
+RUNNER_PYTHON="${LAB_BENCH_RUNNER_PYTHON:-${BIOMNI_EXECUTION_PYTHON:-/225040511/miniconda3/envs/biomni_e1/bin/python}}"
+
+OUTPUT_ROOT="${BIOMNI_ROOT}/experiments/lab_bench/results/seqqa_batch"
+RESULT_FILE="${OUTPUT_ROOT}/seqqa_results.jsonl"
+REASONING_LOG="${OUTPUT_ROOT}/seqqa_reasoning.log"
+EVAL_NAME="SeqQA"
+
+DEV_SIZE="${LAB_BENCH_DEV_SIZE:-45}"
+TEST_SIZE="${LAB_BENCH_TEST_SIZE:-315}"
+SEED="${LAB_BENCH_SUBSET_SEED:-20260514}"
+N_THREADS="${LAB_BENCH_N_THREADS:-1}"
+TEST_SHARD_COUNT="${LAB_BENCH_TEST_SHARD_COUNT:-10}"
+SPLITS_TEXT="${LAB_BENCH_SPLITS:-${LAB_BENCH_SPLIT:-test}}"
+
+BACKGROUND=1
+RESUME=1
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --foreground)
+            BACKGROUND=0
+            shift
+            ;;
+        --background)
+            BACKGROUND=1
+            shift
+            ;;
+        --fresh)
+            RESUME=0
+            shift
+            ;;
+        --resume)
+            RESUME=1
+            shift
+            ;;
+        *)
+            exit 2
+            ;;
+    esac
+done
+
+if [[ "${BACKGROUND}" -eq 1 ]]; then
+    SCRIPT_ABS_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/$(basename "${BASH_SOURCE[0]}")"
+    FORWARD_ARGS=(--foreground)
+    if [[ "${RESUME}" -eq 0 ]]; then
+        FORWARD_ARGS+=(--fresh)
+    else
+        FORWARD_ARGS+=(--resume)
+    fi
+    nohup "${SCRIPT_ABS_PATH}" "${FORWARD_ARGS[@]}" > /dev/null 2>&1 < /dev/null &
+    exit 0
+fi
+
+mkdir -p "${OUTPUT_ROOT}"
+if [[ "${RESUME}" -eq 0 ]]; then
+    : > "${RESULT_FILE}"
+    : > "${REASONING_LOG}"
+else
+    touch "${RESULT_FILE}" "${REASONING_LOG}"
+fi
+
+for ENV_FILE in "${BIOMNI_ROOT}/.env" "${LAB_BENCH_ROOT}/.env"; do
+    if [[ -f "${ENV_FILE}" ]]; then
+        set -a
+        # shellcheck disable=SC1090
+        source "${ENV_FILE}"
+        set +a
+    fi
+done
+
+if [[ -n "${DEEPSEEK_API_KEY:-}" && -z "${BIOMNI_CUSTOM_API_KEY:-}" ]]; then
+    export BIOMNI_SOURCE="${BIOMNI_SOURCE:-Custom}"
+    export BIOMNI_LLM="${BIOMNI_LLM:-${DEEPSEEK_MODEL_NAME:-deepseek-chat}}"
+    export BIOMNI_CUSTOM_BASE_URL="${BIOMNI_CUSTOM_BASE_URL:-${DEEPSEEK_BASE_URL:-https://api.deepseek.com/v1}}"
+    export BIOMNI_CUSTOM_API_KEY="${DEEPSEEK_API_KEY}"
+fi
+
+if [[ -z "${ANTHROPIC_API_KEY:-}" && -z "${OPENAI_API_KEY:-}" && -z "${BIOMNI_CUSTOM_API_KEY:-}" ]]; then
+    printf "[launcher] missing LLM API key environment variables; batch did not start\n" >> "${REASONING_LOG}"
+    exit 2
+fi
+
+read -r -a SPLIT_ARRAY <<< "${SPLITS_TEXT}"
+if [[ "${#SPLIT_ARRAY[@]}" -ne 1 ]]; then
+    printf "[launcher] Biomni LAB-Bench runner supports one split per batch; got LAB_BENCH_SPLITS='%s'\n" "${SPLITS_TEXT}" >> "${REASONING_LOG}"
+    exit 2
+fi
+SPLIT="${SPLIT_ARRAY[0]}"
+
+declare -a CHILD_PIDS=()
+
+launch_shard() {
+    local shard_index="$1"
+    local run_label="seqqa_shard$(printf '%02d' "$((shard_index + 1))")of$(printf '%02d' "${TEST_SHARD_COUNT}")"
+    local -a cmd=(
+        "${RUNNER_PYTHON}" "${RUNNER}"
+        "--eval" "${EVAL_NAME}"
+        "--split" "${SPLIT}"
+        "--dev-size" "${DEV_SIZE}"
+        "--test-size" "${TEST_SIZE}"
+        "--seed" "${SEED}"
+        "--repeat" "1"
+        "--n_threads" "${N_THREADS}"
+        "--output-root" "${OUTPUT_ROOT}"
+        "--agent-root" "${BIOMNI_ROOT}/experiments/lab_bench/agent_runtime"
+        "--run-label" "${run_label}"
+        "--shard-index" "${shard_index}"
+        "--shard-count" "${TEST_SHARD_COUNT}"
+        "--reasoning-log-path" "${REASONING_LOG}"
+        "--compact-results-path" "${RESULT_FILE}"
+        "--compact-output-only"
+        "--skip-existing-results"
+    )
+    "${cmd[@]}" > /dev/null 2>&1 &
+    CHILD_PIDS+=("$!")
+}
+
+for (( shard_index=0; shard_index<TEST_SHARD_COUNT; shard_index++ )); do
+    launch_shard "${shard_index}"
+done
+
+for pid in "${CHILD_PIDS[@]}"; do
+    wait "${pid}"
+done

license_info.md

@@ -0,0 +1,52 @@
+# Biomni Data Source License Information
+
+This document provides an overview of the data sources used by Biomni, their licenses, and suitability for internal hosting and commercial use.
+
+A significant portion of the data used in Biomni requires a commercial license for any commercial application. Several datasets are explicitly licensed for non-commercial use only, which would prohibit their use in a commercial product without a separate agreement. Before proceeding with any commercial use, a thorough legal review of the licenses for each dataset you intend to use is strongly recommended.
+
+## Data License and Internal Hosting Analysis
+
+| Data Source Category | Example Files | License | Internal Hosting | Source |
+| :--- | :--- | :--- | :--- | :--- |
+| **COSMIC** | `Cosmic_*.csv`, `Cosmic_*.parquet` | Requires commercial license for commercial use. | Yes, with a valid commercial license. | [Sanger Institute](https://cancer.sanger.ac.uk/cosmic) |
+| **BindingDB** | `BindingDB_All_202409.tsv` | Custom, non-commercial use granted. Commercial use requires a license. | Yes, with a commercial license. | [BindingDB](https://www.bindingdb.org) |
+| **Broad Repurposing Hub** | `broad_repurposing_hub_*.parquet` | CC BY 4.0 | Yes | [Broad Institute](https://www.broadinstitute.org/drug-repurposing-hub) |
+| **DDInter** | `ddinter_*.csv` | CC BY-NC-SA 4.0 | No, non-commercial use only. | [DDInter](http://ddinter.scbdd.com/) |
+| **DisGeNET** | `DisGeNET.parquet` | CC BY-NC-SA 4.0 | No, non-commercial use only. | [DisGeNET](https://www.disgenet.org/) |
+| **Enamine** | `enamine_cloud_library_smiles.pkl` | Proprietary. Requires license for screening. | Yes, with a valid license. | [Enamine](https://enamine.net/) |
+| **EveBio** | `evebio_*.csv` | Appears to be proprietary data from EveBio. | Requires permission from EveBio. | EveBio |
+| **Gene Ontology (GO)** | `go-plus.json` | CC BY 4.0 | Yes | [Gene Ontology Consortium](http://geneontology.org/) |
+| **GTEx** | `gtex_tissue_gene_tpm.parquet` | dbGaP controlled access. | Yes, with authorization. | [GTEx Portal](https://gtexportal.org/) |
+| **Human Protein Atlas** | `proteinatlas.tsv` | CC BY-SA 3.0 | Yes | [Human Protein Atlas](https://www.proteinatlas.org/) |
+| **MSigDB** | `msigdb_human_*.parquet` | Custom, requires license for commercial use. | Yes, with a license. | [Broad Institute](https://www.gsea-msigdb.org/gsea/msigdb) |
+| **OMIM** | `omim.parquet` | Custom, requires license for commercial use. | Yes, with a license. | [OMIM](https://omim.org/) |
+| **BioGRID** | `affinity_capture-ms.parquet`, etc. | OSL 3.0 | Yes | [BioGRID](https://thebiogrid.org/) |
+| **CZI Cell Census** | `czi_census_datasets_v4.parquet` | CC BY 4.0 | Yes | [Chan Zuckerberg Initiative](https://cellxgene.cziscience.com/census) |
+| **DepMap** | `DepMap_*.csv` | CC BY 4.0 | Yes | [Broad Institute DepMap](https://depmap.org/) |
+| **Genebass** | `genebass_*.pkl` | ODC-By v1.0 | Yes | [Genebass](https://genebass.org/) |
+| **GWAS Catalog** | `gwas_catalog.pkl` | Apache 2.0 | Yes | [EBI GWAS Catalog](https://www.ebi.ac.uk/gwas/) |
+| **HPO** | `hp.obo` | Custom, free for all uses. | Yes | [Human Phenotype Ontology](https://hpo.jax.org/) |
+| **McPAS-TCR** | `McPAS-TCR.parquet` | CC BY-NC-SA 4.0 | No, non-commercial use only. | [McPAS-TCR](http://friedmanlab.weizmann.ac.il/McPAS-TCR/) |
+| **miRDB** | `miRDB_v6.0_results.parquet` | Custom, free for non-commercial use. | No, non-commercial use only. | [miRDB](http://mirdb.org/) |
+| **miRTarBase** | `miRTarBase_*.parquet` | CC BY-NC 4.0 | No, non-commercial use only. | [miRTarBase](https://mirtarbase.cuhk.edu.cn/) |
+| **MouseMine** | `mousemine_*.parquet` | CC BY 4.0 | Yes | [MouseMine](http://www.mousemine.org/) |
+| **P-HIPSTER** | `Virus-Host_PPI_P-HIPSTER_2020.parquet` | CC BY 4.0 | Yes | [P-HIPSTER](http://phipster.org) |
+| **TXGNN** | `txgnn_*.pkl` | MIT License | Yes | - |
+
+## Configuration for Commercial Use
+
+To manage which datasets are used based on licensing, Biomni provides a configuration option. You can set the `commercial_mode` flag to `True` in your configuration to automatically exclude datasets that are not licensed for commercial use.
+
+### Usage
+
+```python
+from biomni.agent import A1
+
+# For commercial use (excludes non-commercial datasets)
+agent = A1(commercial_mode=True)
+
+# For academic/research use (includes all datasets)
+agent = A1(commercial_mode=False)  # default
+```
+
+This configuration automatically selects the appropriate data environment description file and ensures compliance with licensing requirements.

pyproject.toml

@@ -0,0 +1,105 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "biomni"
+dynamic = ["version"]
+description = "Biomni"
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [
+    {name = "Biomni Team", email = "kexinh@cs.stanford.edu"}
+]
+requires-python = ">=3.11"
+dependencies = ["pydantic", "langchain", "python-dotenv"]
+
+[project.urls]
+Homepage = "https://github.com/snap-stanford/biomni"
+Repository = "https://github.com/snap-stanford/biomni"
+
+[project.optional-dependencies]
+gradio = ["gradio>=5.0,<6.0"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.dynamic]
+version = {attr = "biomni.version.__version__"}
+
+[tool.setuptools.packages.find]
+exclude = ["test*", "tutorials*"]
+
+[tool.ruff]
+src = ["src"]
+line-length = 120
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = [
+    "F",      # Errors detected by Pyflakes
+    "E",      # Error detected by Pycodestyle
+    "W",      # Warning detected by Pycodestyle
+    "I",      # isort
+    #"D",      # pydocstyle
+    "B",      # flake8-bugbear
+    "TID",    # flake8-tidy-imports
+    "C4",     # flake8-comprehensions
+    "BLE",    # flake8-blind-except
+    "UP",     # pyupgrade
+    "RUF100", # Report unused noqa directives
+    "TCH",    # Typing imports
+    #"NPY",    # Numpy specific rules
+    #"PTH",    # Use pathlib
+    #"PL"      # pylint
+]
+ignore = [
+    # line too long -> we accept long comment lines; black gets rid of long code lines
+    "E501",
+    # Do not assign a lambda expression, use a def -> lambda expression assignments are convenient
+    "E731",
+    # allow I, O, l as variable names -> I is the identity matrix
+    "E741",
+    # Missing docstring in public package
+    "D104",
+    # Missing docstring in public module
+    "D100",
+    # Missing docstring in __init__
+    "D107",
+    # Errors from function calls in argument defaults. These are fine when the result is immutable.
+    "B008",
+    # __magic__ methods are are often self-explanatory, allow missing docstrings
+    "D105",
+    # first line should end with a period [Bug: doesn't work with single-line docstrings]
+    "D400",
+    # First line should be in imperative mood; try rephrasing
+    "D401",
+    ## Disable one in each pair of mutually incompatible rules
+    # We don’t want a blank line before a class docstring
+    "D203",
+    # We want docstrings to start immediately after the opening triple quote
+    "D213",
+    # camcelcase imported as lowercase
+    "N813",
+    # module import not at top level of file
+    "E402",
+    # Too many arguments in function definition
+    "PLR0913",
+    # Too many branches
+    "PLR0912",
+    # magic value used in comparison
+    "PLR2004",
+    # Too many statements
+    "PLR0915",
+    # Extracting value from dictionary without calling `.items()` - clashes with sim
+    "PLC0206",
+    # import should be at top of file
+    "PLC0415",
+    # do not catch blind exception
+    "BLE001",
+    # strip with multi characters
+    "B005"
+]

tutorials/biomni_101.ipynb

@@ -0,0 +1,1070 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Biomni 101"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Welcome to Biomni! Here is a simple tutorial on the basics of Biomni package. After you installed the environment, you can then simply try this to initialize the agent, which will automatically download the raw data lake files:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🎓 Academic mode: Using all datasets (including non-commercial)\n",
+      "\n",
+      "==================================================\n",
+      "🔧 BIOMNI CONFIGURATION\n",
+      "==================================================\n",
+      "📋 DEFAULT CONFIG (Including Database LLM):\n",
+      "  Path: ./data\n",
+      "  Timeout Seconds: 600\n",
+      "  Llm: claude-sonnet-4-5\n",
+      "  Temperature: 0.7\n",
+      "  Use Tool Retriever: True\n",
+      "  Commercial Mode: Academic (all datasets)\n",
+      "\n",
+      "🤖 AGENT LLM (Constructor Override):\n",
+      "  LLM Model: claude-sonnet-4-5-20250929\n",
+      "==================================================\n",
+      "\n",
+      "Created directory: ./biomni_data\n",
+      "Checking and downloading missing data lake files...\n",
+      "Downloading affinity_capture-ms.parquet from data_lake...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "affinity_capture-ms.parquet: 100%|█████████| 5.59M/5.59M [00:00<00:00, 11.8MB/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Successfully downloaded: affinity_capture-ms.parquet\n",
+      "Downloading affinity_capture-rna.parquet from data_lake...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "affinity_capture-rna.parquet: 100%|████████| 43.0k/43.0k [00:00<00:00, 1.21MB/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Successfully downloaded: affinity_capture-rna.parquet\n",
+      "Downloading BindingDB_All_202409.tsv from data_lake...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "BindingDB_All_202409.tsv:   2%|▎            | 154M/6.25G [00:43<28:35, 3.55MB/s]\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m      3\u001b[39m sys.path.append(\u001b[33m\"\u001b[39m\u001b[33m../\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m      5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mbiomni\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01magent\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m A1\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m agent = \u001b[43mA1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m./biomni_data\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mllm\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mclaude-sonnet-4-5-20250929\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Desktop/Biomni/tutorials/../biomni/agent/a1.py:167\u001b[39m, in \u001b[36mA1.__init__\u001b[39m\u001b[34m(self, path, llm, source, use_tool_retriever, timeout_seconds, base_url, api_key, commercial_mode, expected_data_lake_files)\u001b[39m\n\u001b[32m    165\u001b[39m \u001b[38;5;66;03m# Check and download missing data lake files\u001b[39;00m\n\u001b[32m    166\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mChecking and downloading missing data lake files...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m--> \u001b[39m\u001b[32m167\u001b[39m \u001b[43mcheck_and_download_s3_files\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    168\u001b[39m \u001b[43m    \u001b[49m\u001b[43ms3_bucket_url\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mhttps://biomni-release.s3.amazonaws.com\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m    169\u001b[39m \u001b[43m    \u001b[49m\u001b[43mlocal_data_lake_path\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdata_lake_dir\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    170\u001b[39m \u001b[43m    \u001b[49m\u001b[43mexpected_files\u001b[49m\u001b[43m=\u001b[49m\u001b[43mexpected_data_lake_files\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    171\u001b[39m \u001b[43m    \u001b[49m\u001b[43mfolder\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mdata_lake\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m    172\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    174\u001b[39m \u001b[38;5;66;03m# Check if benchmark directory structure is complete\u001b[39;00m\n\u001b[32m    175\u001b[39m benchmark_ok = \u001b[38;5;28;01mFalse\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Desktop/Biomni/tutorials/../biomni/utils.py:1011\u001b[39m, in \u001b[36mcheck_and_download_s3_files\u001b[39m\u001b[34m(s3_bucket_url, local_data_lake_path, expected_files, folder)\u001b[39m\n\u001b[32m   1008\u001b[39m s3_file_url = urljoin(s3_bucket_url + \u001b[33m\"\u001b[39m\u001b[33m/\u001b[39m\u001b[33m\"\u001b[39m + folder + \u001b[33m\"\u001b[39m\u001b[33m/\u001b[39m\u001b[33m\"\u001b[39m, filename)\n\u001b[32m   1009\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mDownloading \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfilename\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfolder\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m-> \u001b[39m\u001b[32m1011\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[43mdownload_with_progress\u001b[49m\u001b[43m(\u001b[49m\u001b[43ms3_file_url\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlocal_file_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[32m   1012\u001b[39m     \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33m✓ Successfully downloaded: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfilename\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m   1013\u001b[39m     download_results[filename] = \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Desktop/Biomni/tutorials/../biomni/utils.py:949\u001b[39m, in \u001b[36mcheck_and_download_s3_files.<locals>.download_with_progress\u001b[39m\u001b[34m(url, file_path, desc)\u001b[39m\n\u001b[32m    947\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m total_size > \u001b[32m0\u001b[39m:\n\u001b[32m    948\u001b[39m     \u001b[38;5;28;01mwith\u001b[39;00m tqdm.tqdm(total=total_size, unit=\u001b[33m\"\u001b[39m\u001b[33mB\u001b[39m\u001b[33m\"\u001b[39m, unit_scale=\u001b[38;5;28;01mTrue\u001b[39;00m, desc=desc, ncols=\u001b[32m80\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m pbar:\n\u001b[32m--> \u001b[39m\u001b[32m949\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mchunk\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mresponse\u001b[49m\u001b[43m.\u001b[49m\u001b[43miter_content\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchunk_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m8192\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m    950\u001b[39m \u001b[43m            \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mchunk\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m    951\u001b[39m \u001b[43m                \u001b[49m\u001b[43mf\u001b[49m\u001b[43m.\u001b[49m\u001b[43mwrite\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchunk\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/site-packages/requests/models.py:820\u001b[39m, in \u001b[36mResponse.iter_content.<locals>.generate\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m    818\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m.raw, \u001b[33m\"\u001b[39m\u001b[33mstream\u001b[39m\u001b[33m\"\u001b[39m):\n\u001b[32m    819\u001b[39m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m820\u001b[39m         \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m.raw.stream(chunk_size, decode_content=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m    821\u001b[39m     \u001b[38;5;28;01mexcept\u001b[39;00m ProtocolError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m    822\u001b[39m         \u001b[38;5;28;01mraise\u001b[39;00m ChunkedEncodingError(e)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/site-packages/urllib3/response.py:1091\u001b[39m, in \u001b[36mHTTPResponse.stream\u001b[39m\u001b[34m(self, amt, decode_content)\u001b[39m\n\u001b[32m   1089\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m   1090\u001b[39m     \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_fp_closed(\u001b[38;5;28mself\u001b[39m._fp) \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m._decoded_buffer) > \u001b[32m0\u001b[39m:\n\u001b[32m-> \u001b[39m\u001b[32m1091\u001b[39m         data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mamt\u001b[49m\u001b[43m=\u001b[49m\u001b[43mamt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1093\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m data:\n\u001b[32m   1094\u001b[39m             \u001b[38;5;28;01myield\u001b[39;00m data\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/site-packages/urllib3/response.py:980\u001b[39m, in \u001b[36mHTTPResponse.read\u001b[39m\u001b[34m(self, amt, decode_content, cache_content)\u001b[39m\n\u001b[32m    977\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m._decoded_buffer) >= amt:\n\u001b[32m    978\u001b[39m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._decoded_buffer.get(amt)\n\u001b[32m--> \u001b[39m\u001b[32m980\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_raw_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mamt\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    982\u001b[39m flush_decoder = amt \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m (amt != \u001b[32m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m data)\n\u001b[32m    984\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m data \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m._decoded_buffer) == \u001b[32m0\u001b[39m:\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/site-packages/urllib3/response.py:904\u001b[39m, in \u001b[36mHTTPResponse._raw_read\u001b[39m\u001b[34m(self, amt, read1)\u001b[39m\n\u001b[32m    901\u001b[39m fp_closed = \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m._fp, \u001b[33m\"\u001b[39m\u001b[33mclosed\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m    903\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m._error_catcher():\n\u001b[32m--> \u001b[39m\u001b[32m904\u001b[39m     data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_fp_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mamt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mread1\u001b[49m\u001b[43m=\u001b[49m\u001b[43mread1\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m fp_closed \u001b[38;5;28;01melse\u001b[39;00m \u001b[33mb\u001b[39m\u001b[33m\"\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    905\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m amt \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m amt != \u001b[32m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m data:\n\u001b[32m    906\u001b[39m         \u001b[38;5;66;03m# Platform-specific: Buggy versions of Python.\u001b[39;00m\n\u001b[32m    907\u001b[39m         \u001b[38;5;66;03m# Close the connection when no data is returned\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    912\u001b[39m         \u001b[38;5;66;03m# not properly close the connection in all cases. There is\u001b[39;00m\n\u001b[32m    913\u001b[39m         \u001b[38;5;66;03m# no harm in redundantly calling close.\u001b[39;00m\n\u001b[32m    914\u001b[39m         \u001b[38;5;28mself\u001b[39m._fp.close()\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/site-packages/urllib3/response.py:887\u001b[39m, in \u001b[36mHTTPResponse._fp_read\u001b[39m\u001b[34m(self, amt, read1)\u001b[39m\n\u001b[32m    884\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._fp.read1(amt) \u001b[38;5;28;01mif\u001b[39;00m amt \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m._fp.read1()\n\u001b[32m    885\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    886\u001b[39m     \u001b[38;5;66;03m# StringIO doesn't like amt=None\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m887\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_fp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mamt\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mif\u001b[39;00m amt \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m._fp.read()\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/http/client.py:473\u001b[39m, in \u001b[36mHTTPResponse.read\u001b[39m\u001b[34m(self, amt)\u001b[39m\n\u001b[32m    470\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.length \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m amt > \u001b[38;5;28mself\u001b[39m.length:\n\u001b[32m    471\u001b[39m     \u001b[38;5;66;03m# clip the read to the \"end of response\"\u001b[39;00m\n\u001b[32m    472\u001b[39m     amt = \u001b[38;5;28mself\u001b[39m.length\n\u001b[32m--> \u001b[39m\u001b[32m473\u001b[39m s = \u001b[38;5;28mself\u001b[39m.fp.read(amt)\n\u001b[32m    474\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m s \u001b[38;5;129;01mand\u001b[39;00m amt:\n\u001b[32m    475\u001b[39m     \u001b[38;5;66;03m# Ideally, we would raise IncompleteRead if the content-length\u001b[39;00m\n\u001b[32m    476\u001b[39m     \u001b[38;5;66;03m# wasn't satisfied, but it might break compatibility.\u001b[39;00m\n\u001b[32m    477\u001b[39m     \u001b[38;5;28mself\u001b[39m._close_conn()\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/socket.py:718\u001b[39m, in \u001b[36mSocketIO.readinto\u001b[39m\u001b[34m(self, b)\u001b[39m\n\u001b[32m    716\u001b[39m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[32m    717\u001b[39m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m718\u001b[39m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_sock\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrecv_into\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    719\u001b[39m     \u001b[38;5;28;01mexcept\u001b[39;00m timeout:\n\u001b[32m    720\u001b[39m         \u001b[38;5;28mself\u001b[39m._timeout_occurred = \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/ssl.py:1314\u001b[39m, in \u001b[36mSSLSocket.recv_into\u001b[39m\u001b[34m(self, buffer, nbytes, flags)\u001b[39m\n\u001b[32m   1310\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m flags != \u001b[32m0\u001b[39m:\n\u001b[32m   1311\u001b[39m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m   1312\u001b[39m           \u001b[33m\"\u001b[39m\u001b[33mnon-zero flags not allowed in calls to recv_into() on \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\u001b[39m %\n\u001b[32m   1313\u001b[39m           \u001b[38;5;28mself\u001b[39m.\u001b[34m__class__\u001b[39m)\n\u001b[32m-> \u001b[39m\u001b[32m1314\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnbytes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1315\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m   1316\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m().recv_into(buffer, nbytes, flags)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/biomni_fixed/lib/python3.11/ssl.py:1166\u001b[39m, in \u001b[36mSSLSocket.read\u001b[39m\u001b[34m(self, len, buffer)\u001b[39m\n\u001b[32m   1164\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m   1165\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m buffer \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1166\u001b[39m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_sslobj\u001b[49m\u001b[43m.\u001b[49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1167\u001b[39m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m   1168\u001b[39m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._sslobj.read(\u001b[38;5;28mlen\u001b[39m)\n",
+      "\u001b[31mKeyboardInterrupt\u001b[39m: "
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "\n",
+    "sys.path.append(\"../\")\n",
+    "\n",
+    "from biomni.agent import A1\n",
+    "\n",
+    "agent = A1(path=\"./biomni_data\", llm=\"claude-sonnet-4-5-20250929\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then, you can simply start prompting the agent with the desired biomedical research task!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using prompt-based retrieval with the agent's LLM\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "Plan a CRISPR screen to identify genes that regulate T cell exhaustion, \n",
+      "        measured by the change in T cell receptor (TCR) signaling between acute \n",
+      "        (interleukin-2 [IL-2] only) and chronic (anti-CD3 and IL-2) stimulation conditions. \n",
+      "        Generate 32 genes that maximize the perturbation effect.\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "I'll help you plan a CRISPR screen to identify genes that regulate T cell exhaustion. Let me break this down into a systematic approach.\n",
+      "\n",
+      "## Plan:\n",
+      "\n",
+      "1. [ ] Research T cell exhaustion biology and identify key pathways\n",
+      "2. [ ] Query databases for genes involved in T cell exhaustion, TCR signaling, and chronic stimulation\n",
+      "3. [ ] Identify genes from exhaustion-related pathways (checkpoint inhibitors, metabolic regulators, transcription factors)\n",
+      "4. [ ] Select genes that are likely to show differential effects between acute vs chronic stimulation\n",
+      "5. [ ] Design sgRNAs for the selected 32 genes\n",
+      "6. [ ] Validate the gene list and provide experimental design recommendations\n",
+      "\n",
+      "Let me start by researching the biological basis of T cell exhaustion and identifying relevant genes.\n",
+      "\n",
+      "<execute>\n",
+      "# First, let's import necessary libraries and query databases for T cell exhaustion-related genes\n",
+      "from biomni.tool.database import query_uniprot, query_kegg, query_reactome, query_ensembl\n",
+      "from biomni.tool.genomics import gene_set_enrichment_analysis, get_gene_set_enrichment_analysis_supported_database_list\n",
+      "from biomni.tool.molecular_biology import design_knockout_sgrna\n",
+      "import pandas as pd\n",
+      "import numpy as np\n",
+      "\n",
+      "print(\"=== Step 1: Researching T cell exhaustion biology ===\")\n",
+      "\n",
+      "# Query for T cell exhaustion pathways\n",
+      "exhaustion_pathways = query_reactome(\n",
+      "    prompt=\"Find pathways related to T cell exhaustion, TCR signaling, and chronic T cell stimulation\"\n",
+      ")\n",
+      "print(\"Reactome pathways for T cell exhaustion:\")\n",
+      "print(exhaustion_pathways)\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>The output is too long to be added to context. Here are the first 10K characters...\n",
+      "=== Step 1: Researching T cell exhaustion biology ===\n",
+      "Reactome pathways for T cell exhaustion:\n",
+      "{'success': True, 'query_info': {'endpoint': 'https://reactome.org/ContentService/search/query', 'method': 'GET', 'description': 'Search Reactome for pathways related to T cell exhaustion, T cell receptor signaling, and chronic T cell stimulation'}, 'result': {'results': [{'entries': [{'dbId': '202403', 'stId': 'R-HSA-202403', 'id': 'R-HSA-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Homo sapiens'], 'summation': 'The <span class=\"highlighting\" >TCR</span> is a multisubunit complex that consists of clonotypic alpha/beta chains noncovalently associated with the invariant CD3 delta/epsilon/gamma and <span class=\"highlighting\" >TCR</span> zeta chains. T <span class=\"highlighting\" >cell</span> activation by antigen presenting cells (APCs) results in the activation of protein tyrosine kinases (PTKs) that associate with CD3 and <span class=\"highlighting\" >TCR</span> zeta subunits and the co-receptor CD4. Members of the Src kinases (Lck), Syk kinases (ZAP-70), Tec (Itk) and Csk families of nonreceptor PTKs play a crucial role in T <span class=\"highlighting\" >cell</span> activation. Activation of PTKs following <span class=\"highlighting\" >TCR</span> engagement results in the recruitment and tyrosine phosphorylation of enzymes such as phospholipase C gamma1 and Vav as well as critical adaptor proteins such as LAT, SLP-76 and Gads. These proximal activation leads to reorganization of the cytoskeleton as well as transcription activation of multiple genes leading to T lymphocyte proliferation, differentiation and/or effector function. ', 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10069478', 'stId': 'R-MMU-202403', 'id': 'R-MMU-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Mus musculus'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10185057', 'stId': 'R-RNO-202403', 'id': 'R-RNO-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Rattus norvegicus'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10293315', 'stId': 'R-CFA-202403', 'id': 'R-CFA-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Canis familiaris'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10407569', 'stId': 'R-BTA-202403', 'id': 'R-BTA-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Bos taurus'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10523735', 'stId': 'R-SSC-202403', 'id': 'R-SSC-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Sus scrofa'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10585787', 'stId': 'R-DRE-202403', 'id': 'R-DRE-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Danio rerio'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10661801', 'stId': 'R-XTR-202403', 'id': 'R-XTR-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Xenopus tropicalis'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10759741', 'stId': 'R-GGA-202403', 'id': 'R-GGA-202403', 'name': '<span class=\"highlighting\" >TCR</span> <span class=\"highlighting\" >signaling</span>', 'exactType': 'Pathway', 'species': ['Gallus gallus'], 'summation': \"This event has been computationally inferred from an event that has been demonstrated in another species.<p>The inference is based on the homology mapping from PANTHER. Briefly, reactions for which all involved PhysicalEntities (in input, output and catalyst) have a mapped orthologue/paralogue (for complexes at least 75% of components must have a mapping) are inferred to the other species. High level events are also inferred for these events to allow for easier navigation.<p><a href='/electronic_inference_compara.html' target = 'NEW'>More details and caveats of the event inference in Reactome.</a> For details on PANTHER see also: <a href='http://www.pantherdb.org/about.jsp' target='NEW'>http://www.pantherdb.org/about.jsp</a>\", 'isDisease': False, 'disease': False, 'icon': False}, {'dbId': '10848043', 'stId': 'R-D</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<execute>\n",
+      "# Let's also query for immune checkpoint and T cell activation pathways\n",
+      "print(\"\\n=== Querying for immune checkpoint pathways ===\")\n",
+      "checkpoint_pathways = query_reactome(\n",
+      "    prompt=\"Find pathways related to immune checkpoint inhibition, PD-1, CTLA-4, and T cell activation\"\n",
+      ")\n",
+      "print(\"Checkpoint pathways found:\", len(checkpoint_pathways.get('result', {}).get('results', [])))\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>\n",
+      "=== Querying for immune checkpoint pathways ===\n",
+      "Checkpoint pathways found: 10\n",
+      "</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<execute>\n",
+      "# Now let's identify key genes involved in T cell exhaustion from literature and databases\n",
+      "print(\"=== Step 2: Identifying key T cell exhaustion genes ===\")\n",
+      "\n",
+      "# Key categories of genes involved in T cell exhaustion:\n",
+      "# 1. Immune checkpoint receptors and ligands\n",
+      "checkpoint_genes = [\n",
+      "    'PDCD1',  # PD-1\n",
+      "    'CD274',  # PD-L1\n",
+      "    'PDCD1LG2',  # PD-L2\n",
+      "    'CTLA4',  # CTLA-4\n",
+      "    'HAVCR2',  # TIM-3\n",
+      "    'LAG3',   # LAG-3\n",
+      "    'TIGIT',  # TIGIT\n",
+      "    'CD96',   # CD96\n",
+      "    'BTLA',   # BTLA\n",
+      "    'CD160'   # CD160\n",
+      "]\n",
+      "\n",
+      "# 2. Transcription factors regulating exhaustion\n",
+      "transcription_factors = [\n",
+      "    'TOX',    # TOX - master regulator of exhaustion\n",
+      "    'TOX2',   # TOX2\n",
+      "    'EOMES',  # Eomesodermin\n",
+      "    'TBX21',  # T-bet\n",
+      "    'BATF',   # BATF\n",
+      "    'IRF4',   # IRF4\n",
+      "    'NFAT5',  # NFAT5\n",
+      "    'NFATC1', # NFATC1\n",
+      "    'RUNX3',  # RUNX3\n",
+      "    'STAT3'   # STAT3\n",
+      "]\n",
+      "\n",
+      "# 3. Metabolic regulators\n",
+      "metabolic_genes = [\n",
+      "    'PPAR',   # PPAR family\n",
+      "    'HIF1A',  # HIF-1α\n",
+      "    'MYC',    # c-Myc\n",
+      "    'MTOR',   # mTOR\n",
+      "    'AMPK',   # AMPK (PRKAA1)\n",
+      "    'LDHA',   # Lactate dehydrogenase A\n",
+      "    'PKM',    # Pyruvate kinase M\n",
+      "    'GLUT1'   # Glucose transporter 1 (SLC2A1)\n",
+      "]\n",
+      "\n",
+      "# Let's refine the metabolic genes with proper gene symbols\n",
+      "metabolic_genes_refined = [\n",
+      "    'PPARA',   # PPAR alpha\n",
+      "    'HIF1A',   # HIF-1α\n",
+      "    'MYC',     # c-Myc\n",
+      "    'MTOR',    # mTOR\n",
+      "    'PRKAA1',  # AMPK alpha 1\n",
+      "    'LDHA',    # Lactate dehydrogenase A\n",
+      "    'PKM',     # Pyruvate kinase M\n",
+      "    'SLC2A1'   # GLUT1\n",
+      "]\n",
+      "\n",
+      "# 4. TCR signaling components\n",
+      "tcr_signaling_genes = [\n",
+      "    'LCK',    # Lck\n",
+      "    'ZAP70',  # ZAP-70\n",
+      "    'LAT',    # LAT\n",
+      "    'SLP76',  # SLP-76 (LCP2)\n",
+      "    'PLCG1',  # PLCγ1\n",
+      "    'VAV1',   # Vav1\n",
+      "    'ITK',    # Itk\n",
+      "    'CD3E',   # CD3ε\n",
+      "    'CD3G',   # CD3γ\n",
+      "    'CD3D'    # CD3δ\n",
+      "]\n",
+      "\n",
+      "# Refine TCR signaling genes\n",
+      "tcr_signaling_genes_refined = [\n",
+      "    'LCK',\n",
+      "    'ZAP70',\n",
+      "    'LAT',\n",
+      "    'LCP2',   # SLP-76\n",
+      "    'PLCG1',\n",
+      "    'VAV1',\n",
+      "    'ITK',\n",
+      "    'CD3E',\n",
+      "    'CD3G',\n",
+      "    'CD3D'\n",
+      "]\n",
+      "\n",
+      "print(\"Checkpoint genes:\", len(checkpoint_genes))\n",
+      "print(\"Transcription factors:\", len(transcription_factors))\n",
+      "print(\"Metabolic genes:\", len(metabolic_genes_refined))\n",
+      "print(\"TCR signaling genes:\", len(tcr_signaling_genes_refined))\n",
+      "\n",
+      "# Combine all categories\n",
+      "all_candidate_genes = checkpoint_genes + transcription_factors + metabolic_genes_refined + tcr_signaling_genes_refined\n",
+      "print(f\"\\nTotal candidate genes: {len(all_candidate_genes)}\")\n",
+      "print(\"All candidates:\", all_candidate_genes)\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>=== Step 2: Identifying key T cell exhaustion genes ===\n",
+      "Checkpoint genes: 10\n",
+      "Transcription factors: 10\n",
+      "Metabolic genes: 8\n",
+      "TCR signaling genes: 10\n",
+      "\n",
+      "Total candidate genes: 38\n",
+      "All candidates: ['PDCD1', 'CD274', 'PDCD1LG2', 'CTLA4', 'HAVCR2', 'LAG3', 'TIGIT', 'CD96', 'BTLA', 'CD160', 'TOX', 'TOX2', 'EOMES', 'TBX21', 'BATF', 'IRF4', 'NFAT5', 'NFATC1', 'RUNX3', 'STAT3', 'PPARA', 'HIF1A', 'MYC', 'MTOR', 'PRKAA1', 'LDHA', 'PKM', 'SLC2A1', 'LCK', 'ZAP70', 'LAT', 'LCP2', 'PLCG1', 'VAV1', 'ITK', 'CD3E', 'CD3G', 'CD3D']\n",
+      "</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<execute>\n",
+      "# Now let's prioritize and select the most impactful 32 genes\n",
+      "print(\"=== Step 3: Prioritizing genes for maximum perturbation effect ===\")\n",
+      "\n",
+      "# Priority scoring based on:\n",
+      "# 1. Known role in T cell exhaustion (literature evidence)\n",
+      "# 2. Potential for differential effect between acute vs chronic stimulation\n",
+      "# 3. Druggability/therapeutic relevance\n",
+      "\n",
+      "high_priority_genes = {\n",
+      "    # Master regulators of exhaustion (highest priority)\n",
+      "    'TOX': {'priority': 10, 'category': 'Master TF', 'rationale': 'Master regulator of T cell exhaustion'},\n",
+      "    'PDCD1': {'priority': 10, 'category': 'Checkpoint', 'rationale': 'PD-1, primary exhaustion checkpoint'},\n",
+      "    'EOMES': {'priority': 9, 'category': 'TF', 'rationale': 'Key exhaustion transcription factor'},\n",
+      "    'HAVCR2': {'priority': 9, 'category': 'Checkpoint', 'rationale': 'TIM-3, critical exhaustion marker'},\n",
+      "    \n",
+      "    # High impact checkpoint receptors\n",
+      "    'LAG3': {'priority': 9, 'category': 'Checkpoint', 'rationale': 'LAG-3, major exhaustion checkpoint'},\n",
+      "    'TIGIT': {'priority': 8, 'category': 'Checkpoint', 'rationale': 'TIGIT, emerging exhaustion target'},\n",
+      "    'CTLA4': {'priority': 8, 'category': 'Checkpoint', 'rationale': 'CTLA-4, early checkpoint inhibitor'},\n",
+      "    \n",
+      "    # Transcription factors\n",
+      "    'BATF': {'priority': 8, 'category': 'TF', 'rationale': 'BATF, exhaustion-promoting TF'},\n",
+      "    'TBX21': {'priority': 7, 'category': 'TF', 'rationale': 'T-bet, effector vs exhaustion balance'},\n",
+      "    'IRF4': {'priority': 7, 'category': 'TF', 'rationale': 'IRF4, T cell differentiation'},\n",
+      "    'NFATC1': {'priority': 7, 'category': 'TF', 'rationale': 'NFAT, chronic stimulation response'},\n",
+      "    'TOX2': {'priority': 7, 'category': 'TF', 'rationale': 'TOX2, TOX family member'},\n",
+      "    \n",
+      "    # Metabolic regulators (key for chronic vs acute differences)\n",
+      "    'HIF1A': {'priority': 8, 'category': 'Metabolism', 'rationale': 'HIF-1α, hypoxia and exhaustion'},\n",
+      "    'MYC': {'priority': 8, 'category': 'Metabolism', 'rationale': 'c-Myc, metabolic reprogramming'},\n",
+      "    'MTOR': {'priority': 7, 'category': 'Metabolism', 'rationale': 'mTOR, metabolic sensing'},\n",
+      "    'PRKAA1': {'priority': 7, 'category': 'Metabolism', 'rationale': 'AMPK, energy sensing'},\n",
+      "    'LDHA': {'priority': 6, 'category': 'Metabolism', 'rationale': 'Lactate metabolism in exhaustion'},\n",
+      "    \n",
+      "    # TCR signaling (differential between acute/chronic)\n",
+      "    'LCK': {'priority': 8, 'category': 'TCR', 'rationale': 'Lck, proximal TCR signaling'},\n",
+      "    'ZAP70': {'priority': 8, 'category': 'TCR', 'rationale': 'ZAP-70, TCR signal strength'},\n",
+      "    'LAT': {'priority': 7, 'category': 'TCR', 'rationale': 'LAT, TCR signaling hub'},\n",
+      "    'PLCG1': {'priority': 7, 'category': 'TCR', 'rationale': 'PLCγ1, downstream TCR signaling'},\n",
+      "    'LCP2': {'priority': 6, 'category': 'TCR', 'rationale': 'SLP-76, TCR signaling adaptor'},\n",
+      "    \n",
+      "    # Additional checkpoint molecules\n",
+      "    'CD274': {'priority': 6, 'category': 'Checkpoint', 'rationale': 'PD-L1, PD-1 ligand'},\n",
+      "    'BTLA': {'priority': 6, 'category': 'Checkpoint', 'rationale': 'BTLA, inhibitory receptor'},\n",
+      "    'CD96': {'priority': 6, 'category': 'Checkpoint', 'rationale': 'CD96, TIGIT pathway'},\n",
+      "    \n",
+      "    # Additional metabolic/signaling\n",
+      "    'STAT3': {'priority': 7, 'category': 'Signaling', 'rationale': 'STAT3, cytokine signaling'},\n",
+      "    'VAV1': {'priority': 6, 'category': 'TCR', 'rationale': 'Vav1, TCR signaling'},\n",
+      "    'ITK': {'priority': 6, 'category': 'TCR', 'rationale': 'Itk, TCR signaling kinase'},\n",
+      "    'RUNX3': {'priority': 6, 'category': 'TF', 'rationale': 'RUNX3, T cell differentiation'},\n",
+      "    'PKM': {'priority': 5, 'category': 'Metabolism', 'rationale': 'Pyruvate kinase, glycolysis'},\n",
+      "    'SLC2A1': {'priority': 5, 'category': 'Metabolism', 'rationale': 'GLUT1, glucose uptake'},\n",
+      "    'PPARA': {'priority': 5, 'category': 'Metabolism', 'rationale': 'PPARα, fatty acid oxidation'},\n",
+      "    'CD160': {'priority': 5, 'category': 'Checkpoint', 'rationale': 'CD160, inhibitory receptor'}\n",
+      "}\n",
+      "\n",
+      "# Sort by priority and select top 32\n",
+      "sorted_genes = sorted(high_priority_genes.items(), key=lambda x: x[1]['priority'], reverse=True)\n",
+      "selected_32_genes = [gene for gene, info in sorted_genes[:32]]\n",
+      "\n",
+      "print(f\"Selected 32 genes for CRISPR screen:\")\n",
+      "for i, (gene, info) in enumerate(sorted_genes[:32], 1):\n",
+      "    print(f\"{i:2d}. {gene:<8} (Priority: {info['priority']}, {info['category']}) - {info['rationale']}\")\n",
+      "\n",
+      "print(f\"\\nFinal gene list: {selected_32_genes}\")\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>=== Step 3: Prioritizing genes for maximum perturbation effect ===\n",
+      "Selected 32 genes for CRISPR screen:\n",
+      " 1. TOX      (Priority: 10, Master TF) - Master regulator of T cell exhaustion\n",
+      " 2. PDCD1    (Priority: 10, Checkpoint) - PD-1, primary exhaustion checkpoint\n",
+      " 3. EOMES    (Priority: 9, TF) - Key exhaustion transcription factor\n",
+      " 4. HAVCR2   (Priority: 9, Checkpoint) - TIM-3, critical exhaustion marker\n",
+      " 5. LAG3     (Priority: 9, Checkpoint) - LAG-3, major exhaustion checkpoint\n",
+      " 6. TIGIT    (Priority: 8, Checkpoint) - TIGIT, emerging exhaustion target\n",
+      " 7. CTLA4    (Priority: 8, Checkpoint) - CTLA-4, early checkpoint inhibitor\n",
+      " 8. BATF     (Priority: 8, TF) - BATF, exhaustion-promoting TF\n",
+      " 9. HIF1A    (Priority: 8, Metabolism) - HIF-1α, hypoxia and exhaustion\n",
+      "10. MYC      (Priority: 8, Metabolism) - c-Myc, metabolic reprogramming\n",
+      "11. LCK      (Priority: 8, TCR) - Lck, proximal TCR signaling\n",
+      "12. ZAP70    (Priority: 8, TCR) - ZAP-70, TCR signal strength\n",
+      "13. TBX21    (Priority: 7, TF) - T-bet, effector vs exhaustion balance\n",
+      "14. IRF4     (Priority: 7, TF) - IRF4, T cell differentiation\n",
+      "15. NFATC1   (Priority: 7, TF) - NFAT, chronic stimulation response\n",
+      "16. TOX2     (Priority: 7, TF) - TOX2, TOX family member\n",
+      "17. MTOR     (Priority: 7, Metabolism) - mTOR, metabolic sensing\n",
+      "18. PRKAA1   (Priority: 7, Metabolism) - AMPK, energy sensing\n",
+      "19. LAT      (Priority: 7, TCR) - LAT, TCR signaling hub\n",
+      "20. PLCG1    (Priority: 7, TCR) - PLCγ1, downstream TCR signaling\n",
+      "21. STAT3    (Priority: 7, Signaling) - STAT3, cytokine signaling\n",
+      "22. LDHA     (Priority: 6, Metabolism) - Lactate metabolism in exhaustion\n",
+      "23. LCP2     (Priority: 6, TCR) - SLP-76, TCR signaling adaptor\n",
+      "24. CD274    (Priority: 6, Checkpoint) - PD-L1, PD-1 ligand\n",
+      "25. BTLA     (Priority: 6, Checkpoint) - BTLA, inhibitory receptor\n",
+      "26. CD96     (Priority: 6, Checkpoint) - CD96, TIGIT pathway\n",
+      "27. VAV1     (Priority: 6, TCR) - Vav1, TCR signaling\n",
+      "28. ITK      (Priority: 6, TCR) - Itk, TCR signaling kinase\n",
+      "29. RUNX3    (Priority: 6, TF) - RUNX3, T cell differentiation\n",
+      "30. PKM      (Priority: 5, Metabolism) - Pyruvate kinase, glycolysis\n",
+      "31. SLC2A1   (Priority: 5, Metabolism) - GLUT1, glucose uptake\n",
+      "32. PPARA    (Priority: 5, Metabolism) - PPARα, fatty acid oxidation\n",
+      "\n",
+      "Final gene list: ['TOX', 'PDCD1', 'EOMES', 'HAVCR2', 'LAG3', 'TIGIT', 'CTLA4', 'BATF', 'HIF1A', 'MYC', 'LCK', 'ZAP70', 'TBX21', 'IRF4', 'NFATC1', 'TOX2', 'MTOR', 'PRKAA1', 'LAT', 'PLCG1', 'STAT3', 'LDHA', 'LCP2', 'CD274', 'BTLA', 'CD96', 'VAV1', 'ITK', 'RUNX3', 'PKM', 'SLC2A1', 'PPARA']\n",
+      "</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "1. [✓] Research T cell exhaustion biology and identify key pathways (completed)\n",
+      "2. [✓] Query databases for genes involved in T cell exhaustion, TCR signaling, and chronic stimulation (completed)\n",
+      "3. [✓] Identify genes from exhaustion-related pathways (checkpoint inhibitors, metabolic regulators, transcription factors) (completed)\n",
+      "4. [✓] Select genes that are likely to show differential effects between acute vs chronic stimulation (completed)\n",
+      "5. [ ] Design sgRNAs for the selected 32 genes\n",
+      "6. [ ] Validate the gene list and provide experimental design recommendations\n",
+      "\n",
+      "<execute>\n",
+      "# Now let's design sgRNAs for our selected genes\n",
+      "print(\"=== Step 4: Designing sgRNAs for selected genes ===\")\n",
+      "\n",
+      "data_lake_path = \"/dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake\"\n",
+      "\n",
+      "# We'll design sgRNAs for each of our 32 selected genes\n",
+      "selected_genes = ['TOX', 'PDCD1', 'EOMES', 'HAVCR2', 'LAG3', 'TIGIT', 'CTLA4', 'BATF', 'HIF1A', 'MYC', \n",
+      "                 'LCK', 'ZAP70', 'TBX21', 'IRF4', 'NFATC1', 'TOX2', 'MTOR', 'PRKAA1', 'LAT', 'PLCG1', \n",
+      "                 'STAT3', 'LDHA', 'LCP2', 'CD274', 'BTLA', 'CD96', 'VAV1', 'ITK', 'RUNX3', 'PKM', \n",
+      "                 'SLC2A1', 'PPARA']\n",
+      "\n",
+      "print(f\"Designing sgRNAs for {len(selected_genes)} genes...\")\n",
+      "\n",
+      "# Let's try to design sgRNAs for a few key genes as examples\n",
+      "key_genes_for_sgrna = ['TOX', 'PDCD1', 'EOMES', 'HAVCR2', 'LAG3']\n",
+      "\n",
+      "sgrna_results = {}\n",
+      "for gene in key_genes_for_sgrna:\n",
+      "    try:\n",
+      "        print(f\"\\nDesigning sgRNAs for {gene}...\")\n",
+      "        result = design_knockout_sgrna(\n",
+      "            gene_name=gene,\n",
+      "            data_lake_path=data_lake_path,\n",
+      "            species=\"human\",\n",
+      "            num_guides=3  # Get 3 guides per gene for redundancy\n",
+      "        )\n",
+      "        sgrna_results[gene] = result\n",
+      "        print(f\"Successfully designed sgRNAs for {gene}\")\n",
+      "        if result:\n",
+      "            print(f\"Result type: {type(result)}\")\n",
+      "    except Exception as e:\n",
+      "        print(f\"Error designing sgRNAs for {gene}: {str(e)}\")\n",
+      "        sgrna_results[gene] = None\n",
+      "\n",
+      "print(f\"\\nsgRNA design completed for {len(sgrna_results)} genes\")\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>=== Step 4: Designing sgRNAs for selected genes ===\n",
+      "Designing sgRNAs for 32 genes...\n",
+      "\n",
+      "Designing sgRNAs for TOX...\n",
+      "Error designing sgRNAs for TOX: Library file for human not found at path: /dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake/sgRNA/KO_SP_human.txt\n",
+      "\n",
+      "Designing sgRNAs for PDCD1...\n",
+      "Error designing sgRNAs for PDCD1: Library file for human not found at path: /dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake/sgRNA/KO_SP_human.txt\n",
+      "\n",
+      "Designing sgRNAs for EOMES...\n",
+      "Error designing sgRNAs for EOMES: Library file for human not found at path: /dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake/sgRNA/KO_SP_human.txt\n",
+      "\n",
+      "Designing sgRNAs for HAVCR2...\n",
+      "Error designing sgRNAs for HAVCR2: Library file for human not found at path: /dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake/sgRNA/KO_SP_human.txt\n",
+      "\n",
+      "Designing sgRNAs for LAG3...\n",
+      "Error designing sgRNAs for LAG3: Library file for human not found at path: /dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake/sgRNA/KO_SP_human.txt\n",
+      "\n",
+      "sgRNA design completed for 5 genes\n",
+      "</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<execute>\n",
+      "# Let's check what's available in the data lake for sgRNA design\n",
+      "import os\n",
+      "\n",
+      "print(\"=== Checking data lake contents for sgRNA libraries ===\")\n",
+      "data_lake_path = \"/dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake\"\n",
+      "\n",
+      "# Check if the directory exists\n",
+      "if os.path.exists(data_lake_path):\n",
+      "    print(f\"Data lake path exists: {data_lake_path}\")\n",
+      "    \n",
+      "    # List contents\n",
+      "    contents = os.listdir(data_lake_path)\n",
+      "    print(f\"Contents of data lake: {contents}\")\n",
+      "    \n",
+      "    # Check for sgRNA directory\n",
+      "    sgrna_path = os.path.join(data_lake_path, \"sgRNA\")\n",
+      "    if os.path.exists(sgrna_path):\n",
+      "        print(f\"sgRNA directory exists\")\n",
+      "        sgrna_contents = os.listdir(sgrna_path)\n",
+      "        print(f\"sgRNA directory contents: {sgrna_contents}\")\n",
+      "    else:\n",
+      "        print(\"sgRNA directory does not exist\")\n",
+      "        \n",
+      "    # Check for any files that might contain sgRNA data\n",
+      "    for item in contents:\n",
+      "        item_path = os.path.join(data_lake_path, item)\n",
+      "        if os.path.isfile(item_path) and ('sgrna' in item.lower() or 'guide' in item.lower() or 'crispr' in item.lower()):\n",
+      "            print(f\"Found potential sgRNA file: {item}\")\n",
+      "else:\n",
+      "    print(f\"Data lake path does not exist: {data_lake_path}\")\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>=== Checking data lake contents for sgRNA libraries ===\n",
+      "Data lake path exists: /dfs/project/bioagentos/biomni_data_test/biomni_data/data_lake\n",
+      "Contents of data lake: ['co-fractionation.csv', 'Cosmic_CompleteCNA_v101_GRCh38.tsv.gz', 'Cosmic_Breakpoints_v101_GRCh38.csv', 'two-hybrid.csv', 'Cosmic_CompleteGeneExpression_v101_GRCh38.tsv.gz', 'broad_repurposing_hub_phase_moa_target_info.csv', 'hp.obo', 'BindingDB_All_202409.tsv', 'genebass_synonymous_filtered.pkl', 'omim.csv', 'miRTarBase_microRNA_target_interaction.csv', 'gtex_tissue_gene_tpm.csv', 'Cosmic_CompleteDifferentialMethylation_v101_GRCh38.tsv.gz', 'synthetic_lethality.csv', 'proximity_label-ms.csv', 'synthetic_growth_defect.csv', 'broad_repurposing_hub_molecule_with_smiles.csv', 'czi_census_datasets_v4.csv', 'mousemine_mh_hallmark_geneset.csv', 'mousemine_m1_positional_geneset.csv', 'genebass_pLoF_filtered.pkl', 'Virus-Host_PPI_P-HIPSTER_2020.csv', 'msigdb_human_c8_celltype_signature_geneset.csv', 'msigdb_human_c6_oncogenic_signature_geneset.csv', 'Cosmic_CancerGeneCensus_v101_GRCh38.csv', 'gwas_catalog.pkl', 'miRTarBase_microRNA_target_interaction_pubmed_abtract.txt', 'Cosmic_CancerGeneCensusHallmarksOfCancer_v101_GRCh38.csv', 'mousemine_m5_ontology_geneset.csv', 'go-plus.json', 'gene_info.csv', 'msigdb_human_h_hallmark_geneset.csv', 'msigdb_human_c5_ontology_geneset.csv', 'variant_table.csv', 'enamine_cloud_library_smiles.pkl', 'Cosmic_MutantCensus_v101_GRCh38.csv', 'reconstituted_complex.csv', 'DisGeNET.csv', 'msigdb_human_c3_regulatory_target_geneset.csv', 'genebass_missense_LC_filtered.pkl', 'Cosmic_Genes_v101_GRCh38.csv', 'mousemine_m3_regulatory_target_geneset.csv', 'msigdb_human_c1_positional_geneset.csv', 'msigdb_human_c4_computational_geneset.csv', 'miRDB_v6.0_results.csv', 'Cosmic_ResistanceMutations_v101_GRCh38.csv', 'msigdb_human_c2_curated_geneset.csv', 'Cosmic_GenomeScreensMutant_v101_GRCh38.tsv.gz', 'mousemine_m2_curated_geneset.csv', 'affinity_capture-ms.csv', 'msigdb_human_c3_subset_transcription_factor_targets_from_GTRD.csv', 'miRTarBase_MicroRNA_Target_Sites.csv', 'msigdb_human_c7_immunologic_signature_geneset.csv', 'McPAS-TCR.csv', 'dosage_growth_defect.csv', 'Cosmic_Classification_v101_GRCh38.csv', 'affinity_capture-rna.csv', 'proteinatlas.tsv', 'genetic_interaction.csv', 'synthetic_rescue.csv', 'Cosmic_Fusion_v101_GRCh38.csv', 'Cosmic_ClassificationPaper_v101_GRCh38.csv', 'mousemine_m8_celltype_signature_geneset.csv', 'marker_celltype.csv']\n",
+      "sgRNA directory does not exist\n",
+      "</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "5. [✗] Design sgRNAs for the selected 32 genes (failed because sgRNA library not available in data lake)\n",
+      "5. [ ] Provide theoretical sgRNA design recommendations and validate gene selection\n",
+      "6. [ ] Provide comprehensive experimental design recommendations\n",
+      "\n",
+      "<execute>\n",
+      "# Since we don't have access to the sgRNA library, let's provide theoretical sgRNA design recommendations\n",
+      "# and create a comprehensive experimental plan\n",
+      "\n",
+      "print(\"=== Step 5: Theoretical sgRNA Design and Validation ===\")\n",
+      "\n",
+      "selected_genes = ['TOX', 'PDCD1', 'EOMES', 'HAVCR2', 'LAG3', 'TIGIT', 'CTLA4', 'BATF', 'HIF1A', 'MYC', \n",
+      "                 'LCK', 'ZAP70', 'TBX21', 'IRF4', 'NFATC1', 'TOX2', 'MTOR', 'PRKAA1', 'LAT', 'PLCG1', \n",
+      "                 'STAT3', 'LDHA', 'LCP2', 'CD274', 'BTLA', 'CD96', 'VAV1', 'ITK', 'RUNX3', 'PKM', \n",
+      "                 'SLC2A1', 'PPARA']\n",
+      "\n",
+      "# Categorize genes by functional category for analysis\n",
+      "gene_categories = {\n",
+      "    'Immune Checkpoints': ['PDCD1', 'HAVCR2', 'LAG3', 'TIGIT', 'CTLA4', 'CD274', 'BTLA', 'CD96'],\n",
+      "    'Transcription Factors': ['TOX', 'EOMES', 'BATF', 'TBX21', 'IRF4', 'NFATC1', 'TOX2', 'RUNX3'],\n",
+      "    'Metabolic Regulators': ['HIF1A', 'MYC', 'MTOR', 'PRKAA1', 'LDHA', 'PKM', 'SLC2A1', 'PPARA'],\n",
+      "    'TCR Signaling': ['LCK', 'ZAP70', 'LAT', 'PLCG1', 'LCP2', 'VAV1', 'ITK'],\n",
+      "    'Cytokine Signaling': ['STAT3']\n",
+      "}\n",
+      "\n",
+      "print(\"Gene categorization:\")\n",
+      "for category, genes in gene_categories.items():\n",
+      "    print(f\"{category}: {len(genes)} genes\")\n",
+      "    print(f\"  {', '.join(genes)}\")\n",
+      "    print()\n",
+      "\n",
+      "# Expected effects on T cell exhaustion\n",
+      "expected_effects = {\n",
+      "    'TOX': 'KO should reduce exhaustion (master exhaustion TF)',\n",
+      "    'PDCD1': 'KO should reduce exhaustion (remove PD-1 checkpoint)',\n",
+      "    'EOMES': 'KO should reduce exhaustion (exhaustion-promoting TF)',\n",
+      "    'HAVCR2': 'KO should reduce exhaustion (remove TIM-3 checkpoint)',\n",
+      "    'LAG3': 'KO should reduce exhaustion (remove LAG-3 checkpoint)',\n",
+      "    'TIGIT': 'KO should reduce exhaustion (remove TIGIT checkpoint)',\n",
+      "    'CTLA4': 'KO should enhance early activation',\n",
+      "    'BATF': 'KO should reduce exhaustion (exhaustion-promoting TF)',\n",
+      "    'HIF1A': 'KO may reduce exhaustion (metabolic stress response)',\n",
+      "    'MYC': 'KO may increase exhaustion (metabolic reprogramming)',\n",
+      "    'LCK': 'KO should reduce TCR signaling strength',\n",
+      "    'ZAP70': 'KO should reduce TCR signaling strength',\n",
+      "    'TBX21': 'KO should shift toward exhaustion (effector TF)',\n",
+      "    'IRF4': 'KO may affect T cell differentiation balance',\n",
+      "    'NFATC1': 'KO may reduce chronic stimulation response',\n",
+      "    'MTOR': 'KO should affect metabolic reprogramming',\n",
+      "    'STAT3': 'KO should affect cytokine responsiveness'\n",
+      "}\n",
+      "\n",
+      "print(\"Expected functional outcomes:\")\n",
+      "for gene in selected_genes[:17]:  # Show first 17 as examples\n",
+      "    if gene in expected_effects:\n",
+      "        print(f\"{gene}: {expected_effects[gene]}\")\n",
+      "\n",
+      "print(\"\\nsgRNA Design Recommendations:\")\n",
+      "print(\"1. Use 3-4 sgRNAs per gene for redundancy\")\n",
+      "print(\"2. Target early exons to ensure knockout\")\n",
+      "print(\"3. Include non-targeting controls (scrambled guides)\")\n",
+      "print(\"4. Include positive controls (known exhaustion regulators)\")\n",
+      "print(\"5. Use established sgRNA design tools (e.g., Broad GPP portal, CHOPCHOP)\")\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>=== Step 5: Theoretical sgRNA Design and Validation ===\n",
+      "Gene categorization:\n",
+      "Immune Checkpoints: 8 genes\n",
+      "  PDCD1, HAVCR2, LAG3, TIGIT, CTLA4, CD274, BTLA, CD96\n",
+      "\n",
+      "Transcription Factors: 8 genes\n",
+      "  TOX, EOMES, BATF, TBX21, IRF4, NFATC1, TOX2, RUNX3\n",
+      "\n",
+      "Metabolic Regulators: 8 genes\n",
+      "  HIF1A, MYC, MTOR, PRKAA1, LDHA, PKM, SLC2A1, PPARA\n",
+      "\n",
+      "TCR Signaling: 7 genes\n",
+      "  LCK, ZAP70, LAT, PLCG1, LCP2, VAV1, ITK\n",
+      "\n",
+      "Cytokine Signaling: 1 genes\n",
+      "  STAT3\n",
+      "\n",
+      "Expected functional outcomes:\n",
+      "TOX: KO should reduce exhaustion (master exhaustion TF)\n",
+      "PDCD1: KO should reduce exhaustion (remove PD-1 checkpoint)\n",
+      "EOMES: KO should reduce exhaustion (exhaustion-promoting TF)\n",
+      "HAVCR2: KO should reduce exhaustion (remove TIM-3 checkpoint)\n",
+      "LAG3: KO should reduce exhaustion (remove LAG-3 checkpoint)\n",
+      "TIGIT: KO should reduce exhaustion (remove TIGIT checkpoint)\n",
+      "CTLA4: KO should enhance early activation\n",
+      "BATF: KO should reduce exhaustion (exhaustion-promoting TF)\n",
+      "HIF1A: KO may reduce exhaustion (metabolic stress response)\n",
+      "MYC: KO may increase exhaustion (metabolic reprogramming)\n",
+      "LCK: KO should reduce TCR signaling strength\n",
+      "ZAP70: KO should reduce TCR signaling strength\n",
+      "TBX21: KO should shift toward exhaustion (effector TF)\n",
+      "IRF4: KO may affect T cell differentiation balance\n",
+      "NFATC1: KO may reduce chronic stimulation response\n",
+      "MTOR: KO should affect metabolic reprogramming\n",
+      "\n",
+      "sgRNA Design Recommendations:\n",
+      "1. Use 3-4 sgRNAs per gene for redundancy\n",
+      "2. Target early exons to ensure knockout\n",
+      "3. Include non-targeting controls (scrambled guides)\n",
+      "4. Include positive controls (known exhaustion regulators)\n",
+      "5. Use established sgRNA design tools (e.g., Broad GPP portal, CHOPCHOP)\n",
+      "</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<execute>\n",
+      "# Now let's create a comprehensive experimental design\n",
+      "print(\"=== Step 6: Comprehensive Experimental Design for CRISPR Screen ===\")\n",
+      "\n",
+      "experimental_design = {\n",
+      "    'objective': 'Identify genes regulating T cell exhaustion through differential TCR signaling between acute and chronic stimulation',\n",
+      "    'readout': 'TCR signaling strength measured by phospho-flow cytometry, cytokine production, and transcriptional markers',\n",
+      "    'conditions': {\n",
+      "        'acute': 'IL-2 only (maintains T cell survival without chronic stimulation)',\n",
+      "        'chronic': 'Anti-CD3 + IL-2 (chronic TCR stimulation leading to exhaustion)'\n",
+      "    }\n",
+      "}\n",
+      "\n",
+      "print(\"EXPERIMENTAL DESIGN OVERVIEW\")\n",
+      "print(\"=\"*50)\n",
+      "print(f\"Objective: {experimental_design['objective']}\")\n",
+      "print(f\"Primary Readout: {experimental_design['readout']}\")\n",
+      "print()\n",
+      "\n",
+      "print(\"STIMULATION CONDITIONS:\")\n",
+      "print(f\"1. Acute condition: {experimental_design['conditions']['acute']}\")\n",
+      "print(f\"2. Chronic condition: {experimental_design['conditions']['chronic']}\")\n",
+      "print()\n",
+      "\n",
+      "print(\"SELECTED 32 GENES FOR CRISPR SCREEN:\")\n",
+      "print(\"=\"*50)\n",
+      "\n",
+      "# Create a detailed gene table\n",
+      "gene_info = []\n",
+      "for i, gene in enumerate(selected_genes, 1):\n",
+      "    category = None\n",
+      "    for cat, genes in gene_categories.items():\n",
+      "        if gene in genes:\n",
+      "            category = cat\n",
+      "            break\n",
+      "    \n",
+      "    gene_info.append({\n",
+      "        'rank': i,\n",
+      "        'gene': gene,\n",
+      "        'category': category,\n",
+      "        'expected_effect': expected_effects.get(gene, 'To be determined')\n",
+      "    })\n",
+      "\n",
+      "# Print gene table\n",
+      "print(f\"{'Rank':<4} {'Gene':<8} {'Category':<20} {'Expected Effect'}\")\n",
+      "print(\"-\" * 80)\n",
+      "for info in gene_info:\n",
+      "    print(f\"{info['rank']:<4} {info['gene']:<8} {info['category']:<20} {info['expected_effect'][:50]}\")\n",
+      "\n",
+      "print()\n",
+      "print(\"EXPERIMENTAL PROTOCOL:\")\n",
+      "print(\"=\"*50)\n",
+      "\n",
+      "protocol_steps = [\n",
+      "    \"1. T Cell Isolation and Activation\",\n",
+      "    \"   - Isolate primary CD8+ T cells from healthy donors\",\n",
+      "    \"   - Activate with anti-CD3/CD28 for 2-3 days\",\n",
+      "    \"\",\n",
+      "    \"2. CRISPR-Cas9 Delivery\",\n",
+      "    \"   - Electroporate Cas9 RNP complexes with sgRNA library\",\n",
+      "    \"   - 3-4 sgRNAs per gene + non-targeting controls\",\n",
+      "    \"   - Allow 3-5 days for gene knockout\",\n",
+      "    \"\",\n",
+      "    \"3. Stimulation Conditions (7-14 days)\",\n",
+      "    \"   - Acute: IL-2 (100 U/ml) only\",\n",
+      "    \"   - Chronic: Anti-CD3 (1 μg/ml) + IL-2 (100 U/ml)\",\n",
+      "    \"   - Refresh media every 2-3 days\",\n",
+      "    \"\",\n",
+      "    \"4. Readout Measurements\",\n",
+      "    \"   - TCR signaling: Phospho-flow for pZAP70, pERK, pS6\",\n",
+      "    \"   - Exhaustion markers: PD-1, TIM-3, LAG-3 expression\",\n",
+      "    \"   - Function: IFN-γ, TNF-α, IL-2 production\",\n",
+      "    \"   - Transcription: RNA-seq for exhaustion signatures\",\n",
+      "    \"\",\n",
+      "    \"5. Data Analysis\",\n",
+      "    \"   - Calculate perturbation scores for each gene\",\n",
+      "    \"   - Identify genes with differential effects between conditions\",\n",
+      "    \"   - Validate top hits with individual knockouts\"\n",
+      "]\n",
+      "\n",
+      "for step in protocol_steps:\n",
+      "    print(step)\n",
+      "\n",
+      "print()\n",
+      "print(\"KEY CONTROLS:\")\n",
+      "print(\"=\"*20)\n",
+      "controls = [\n",
+      "    \"- Non-targeting sgRNAs (negative control)\",\n",
+      "    \"- Known exhaustion genes (positive control): TOX, PDCD1\",\n",
+      "    \"- Essential genes (toxicity control): RPL23, RPS19\",\n",
+      "    \"- Unstimulated cells (baseline)\",\n",
+      "    \"- Wild-type cells (no CRISPR)\"\n",
+      "]\n",
+      "\n",
+      "for control in controls:\n",
+      "    print(control)\n",
+      "\n",
+      "print()\n",
+      "print(\"EXPECTED OUTCOMES:\")\n",
+      "print(\"=\"*20)\n",
+      "outcomes = [\n",
+      "    \"1. Genes that reduce exhaustion when knocked out:\",\n",
+      "    \"   - Should show enhanced TCR signaling in chronic condition\",\n",
+      "    \"   - Examples: TOX, PDCD1, HAVCR2, LAG3, EOMES\",\n",
+      "    \"\",\n",
+      "    \"2. Genes that promote effector function:\",\n",
+      "    \"   - Should show reduced signaling when knocked out\",\n",
+      "    \"   - Examples: TBX21, MYC (context-dependent)\",\n",
+      "    \"\",\n",
+      "    \"3. Metabolic regulators:\",\n",
+      "    \"   - Should show differential effects on sustained signaling\",\n",
+      "    \"   - Examples: MTOR, HIF1A, PRKAA1\",\n",
+      "    \"\",\n",
+      "    \"4. TCR signaling components:\",\n",
+      "    \"   - Should show proportional effects on signaling strength\",\n",
+      "    \"   - Examples: LCK, ZAP70, LAT\"\n",
+      "]\n",
+      "\n",
+      "for outcome in outcomes:\n",
+      "    print(outcome)\n",
+      "</execute>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "<observation>=== Step 6: Comprehensive Experimental Design for CRISPR Screen ===\n",
+      "EXPERIMENTAL DESIGN OVERVIEW\n",
+      "==================================================\n",
+      "Objective: Identify genes regulating T cell exhaustion through differential TCR signaling between acute and chronic stimulation\n",
+      "Primary Readout: TCR signaling strength measured by phospho-flow cytometry, cytokine production, and transcriptional markers\n",
+      "\n",
+      "STIMULATION CONDITIONS:\n",
+      "1. Acute condition: IL-2 only (maintains T cell survival without chronic stimulation)\n",
+      "2. Chronic condition: Anti-CD3 + IL-2 (chronic TCR stimulation leading to exhaustion)\n",
+      "\n",
+      "SELECTED 32 GENES FOR CRISPR SCREEN:\n",
+      "==================================================\n",
+      "Rank Gene     Category             Expected Effect\n",
+      "--------------------------------------------------------------------------------\n",
+      "1    TOX      Transcription Factors KO should reduce exhaustion (master exhaustion TF)\n",
+      "2    PDCD1    Immune Checkpoints   KO should reduce exhaustion (remove PD-1 checkpoin\n",
+      "3    EOMES    Transcription Factors KO should reduce exhaustion (exhaustion-promoting \n",
+      "4    HAVCR2   Immune Checkpoints   KO should reduce exhaustion (remove TIM-3 checkpoi\n",
+      "5    LAG3     Immune Checkpoints   KO should reduce exhaustion (remove LAG-3 checkpoi\n",
+      "6    TIGIT    Immune Checkpoints   KO should reduce exhaustion (remove TIGIT checkpoi\n",
+      "7    CTLA4    Immune Checkpoints   KO should enhance early activation\n",
+      "8    BATF     Transcription Factors KO should reduce exhaustion (exhaustion-promoting \n",
+      "9    HIF1A    Metabolic Regulators KO may reduce exhaustion (metabolic stress respons\n",
+      "10   MYC      Metabolic Regulators KO may increase exhaustion (metabolic reprogrammin\n",
+      "11   LCK      TCR Signaling        KO should reduce TCR signaling strength\n",
+      "12   ZAP70    TCR Signaling        KO should reduce TCR signaling strength\n",
+      "13   TBX21    Transcription Factors KO should shift toward exhaustion (effector TF)\n",
+      "14   IRF4     Transcription Factors KO may affect T cell differentiation balance\n",
+      "15   NFATC1   Transcription Factors KO may reduce chronic stimulation response\n",
+      "16   TOX2     Transcription Factors To be determined\n",
+      "17   MTOR     Metabolic Regulators KO should affect metabolic reprogramming\n",
+      "18   PRKAA1   Metabolic Regulators To be determined\n",
+      "19   LAT      TCR Signaling        To be determined\n",
+      "20   PLCG1    TCR Signaling        To be determined\n",
+      "21   STAT3    Cytokine Signaling   KO should affect cytokine responsiveness\n",
+      "22   LDHA     Metabolic Regulators To be determined\n",
+      "23   LCP2     TCR Signaling        To be determined\n",
+      "24   CD274    Immune Checkpoints   To be determined\n",
+      "25   BTLA     Immune Checkpoints   To be determined\n",
+      "26   CD96     Immune Checkpoints   To be determined\n",
+      "27   VAV1     TCR Signaling        To be determined\n",
+      "28   ITK      TCR Signaling        To be determined\n",
+      "29   RUNX3    Transcription Factors To be determined\n",
+      "30   PKM      Metabolic Regulators To be determined\n",
+      "31   SLC2A1   Metabolic Regulators To be determined\n",
+      "32   PPARA    Metabolic Regulators To be determined\n",
+      "\n",
+      "EXPERIMENTAL PROTOCOL:\n",
+      "==================================================\n",
+      "1. T Cell Isolation and Activation\n",
+      "   - Isolate primary CD8+ T cells from healthy donors\n",
+      "   - Activate with anti-CD3/CD28 for 2-3 days\n",
+      "\n",
+      "2. CRISPR-Cas9 Delivery\n",
+      "   - Electroporate Cas9 RNP complexes with sgRNA library\n",
+      "   - 3-4 sgRNAs per gene + non-targeting controls\n",
+      "   - Allow 3-5 days for gene knockout\n",
+      "\n",
+      "3. Stimulation Conditions (7-14 days)\n",
+      "   - Acute: IL-2 (100 U/ml) only\n",
+      "   - Chronic: Anti-CD3 (1 μg/ml) + IL-2 (100 U/ml)\n",
+      "   - Refresh media every 2-3 days\n",
+      "\n",
+      "4. Readout Measurements\n",
+      "   - TCR signaling: Phospho-flow for pZAP70, pERK, pS6\n",
+      "   - Exhaustion markers: PD-1, TIM-3, LAG-3 expression\n",
+      "   - Function: IFN-γ, TNF-α, IL-2 production\n",
+      "   - Transcription: RNA-seq for exhaustion signatures\n",
+      "\n",
+      "5. Data Analysis\n",
+      "   - Calculate perturbation scores for each gene\n",
+      "   - Identify genes with differential effects between conditions\n",
+      "   - Validate top hits with individual knockouts\n",
+      "\n",
+      "KEY CONTROLS:\n",
+      "====================\n",
+      "- Non-targeting sgRNAs (negative control)\n",
+      "- Known exhaustion genes (positive control): TOX, PDCD1\n",
+      "- Essential genes (toxicity control): RPL23, RPS19\n",
+      "- Unstimulated cells (baseline)\n",
+      "- Wild-type cells (no CRISPR)\n",
+      "\n",
+      "EXPECTED OUTCOMES:\n",
+      "====================\n",
+      "1. Genes that reduce exhaustion when knocked out:\n",
+      "   - Should show enhanced TCR signaling in chronic condition\n",
+      "   - Examples: TOX, PDCD1, HAVCR2, LAG3, EOMES\n",
+      "\n",
+      "2. Genes that promote effector function:\n",
+      "   - Should show reduced signaling when knocked out\n",
+      "   - Examples: TBX21, MYC (context-dependent)\n",
+      "\n",
+      "3. Metabolic regulators:\n",
+      "   - Should show differential effects on sustained signaling\n",
+      "   - Examples: MTOR, HIF1A, PRKAA1\n",
+      "\n",
+      "4. TCR signaling components:\n",
+      "   - Should show proportional effects on signaling strength\n",
+      "   - Examples: LCK, ZAP70, LAT\n",
+      "</observation>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "5. [✓] Provide theoretical sgRNA design recommendations and validate gene selection (completed)\n",
+      "6. [✓] Provide comprehensive experimental design recommendations (completed)\n",
+      "\n",
+      "<solution>\n",
+      "# CRISPR Screen to Identify T Cell Exhaustion Regulators\n",
+      "\n",
+      "## Selected 32 Genes for Maximum Perturbation Effect\n",
+      "\n",
+      "Based on comprehensive analysis of T cell exhaustion biology, I have identified 32 genes that will maximize perturbation effects in your CRISPR screen measuring differential TCR signaling between acute (IL-2 only) and chronic (anti-CD3 + IL-2) stimulation conditions:\n",
+      "\n",
+      "### Gene List (Ranked by Priority):\n",
+      "\n",
+      "**Immune Checkpoint Molecules (8 genes):**\n",
+      "1. **PDCD1** (PD-1) - Primary exhaustion checkpoint receptor\n",
+      "2. **HAVCR2** (TIM-3) - Critical exhaustion marker and checkpoint\n",
+      "3. **LAG3** - Major exhaustion checkpoint receptor\n",
+      "4. **TIGIT** - Emerging exhaustion checkpoint target\n",
+      "5. **CTLA4** - Early checkpoint inhibitor\n",
+      "6. **CD274** (PD-L1) - PD-1 ligand\n",
+      "7. **BTLA** - Inhibitory receptor\n",
+      "8. **CD96** - TIGIT pathway component\n",
+      "\n",
+      "**Transcription Factors (8 genes):**\n",
+      "9. **TOX** - Master regulator of T cell exhaustion\n",
+      "10. **EOMES** - Key exhaustion-promoting transcription factor\n",
+      "11. **BATF** - Exhaustion-promoting transcription factor\n",
+      "12. **TBX21** (T-bet) - Effector vs exhaustion balance\n",
+      "13. **IRF4** - T cell differentiation regulator\n",
+      "14. **NFATC1** - Chronic stimulation response factor\n",
+      "15. **TOX2** - TOX family member\n",
+      "16. **RUNX3** - T cell differentiation factor\n",
+      "\n",
+      "**Metabolic Regulators (8 genes):**\n",
+      "17. **HIF1A** - Hypoxia and exhaustion regulator\n",
+      "18. **MYC** - Metabolic reprogramming master regulator\n",
+      "19. **MTOR** - Metabolic sensing and signaling\n",
+      "20. **PRKAA1** (AMPK) - Energy sensing kinase\n",
+      "21. **LDHA** - Lactate metabolism in exhaustion\n",
+      "22. **PKM** - Pyruvate kinase, glycolysis regulator\n",
+      "23. **SLC2A1** (GLUT1) - Glucose uptake transporter\n",
+      "24. **PPARA** - Fatty acid oxidation regulator\n",
+      "\n",
+      "**TCR Signaling Components (7 genes):**\n",
+      "25. **LCK** - Proximal TCR signaling kinase\n",
+      "26. **ZAP70** - TCR signal strength regulator\n",
+      "27. **LAT** - TCR signaling hub adaptor\n",
+      "28. **PLCG1** (PLCγ1) - Downstream TCR signaling\n",
+      "29. **LCP2** (SLP-76) - TCR signaling adaptor\n",
+      "30. **VAV1** - TCR signaling regulator\n",
+      "31. **ITK** - TCR signaling kinase\n",
+      "\n",
+      "**Cytokine Signaling (1 gene):**\n",
+      "32. **STAT3** - Cytokine signaling transcription factor\n",
+      "\n",
+      "## Experimental Design Overview\n",
+      "\n",
+      "### Objective:\n",
+      "Identify genes that regulate T cell exhaustion by measuring differential TCR signaling responses between acute and chronic stimulation conditions.\n",
+      "\n",
+      "### Key Features:\n",
+      "- **Balanced gene selection** across 4 major functional categories\n",
+      "- **High-priority targets** based on literature evidence and therapeutic relevance\n",
+      "- **Expected differential effects** between acute vs chronic conditions\n",
+      "- **Multiple readouts** for comprehensive phenotyping\n",
+      "\n",
+      "### Stimulation Conditions:\n",
+      "- **Acute**: IL-2 only (maintains survival without exhaustion)\n",
+      "- **Chronic**: Anti-CD3 + IL-2 (induces exhaustion through chronic TCR stimulation)\n",
+      "\n",
+      "### Primary Readouts:\n",
+      "1. **TCR signaling strength**: Phospho-flow cytometry (pZAP70, pERK, pS6)\n",
+      "2. **Exhaustion markers**: PD-1, TIM-3, LAG-3 surface expression\n",
+      "3. **Functional capacity**: Cytokine production (IFN-γ, TNF-α, IL-2)\n",
+      "4. **Transcriptional state**: RNA-seq for exhaustion gene signatures\n",
+      "\n",
+      "### Expected Outcomes:\n",
+      "- **Checkpoint inhibitors** (PDCD1, HAVCR2, LAG3): KO should enhance signaling in chronic condition\n",
+      "- **Exhaustion TFs** (TOX, EOMES, BATF): KO should reduce exhaustion phenotype\n",
+      "- **Metabolic regulators** (MTOR, HIF1A, MYC): Context-dependent effects on sustained signaling\n",
+      "- **TCR components** (LCK, ZAP70, LAT): Proportional effects on signaling strength\n",
+      "\n",
+      "### sgRNA Design Recommendations:\n",
+      "- Use 3-4 sgRNAs per gene for redundancy\n",
+      "- Include non-targeting controls and positive controls (TOX, PDCD1)\n",
+      "- Target early exons for effective knockouts\n",
+      "- Use established design tools (Broad GPP portal, CHOPCHOP)\n",
+      "\n",
+      "This gene set maximizes the potential to identify novel regulators of T cell exhaustion while covering all major pathways involved in the acute-to-chronic transition of T cell responses.\n",
+      "</solution>\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "5. [✓] Provide theoretical sgRNA design recommendations and validate gene selection (completed)\n",
+      "6. [✓] Provide comprehensive experimental design recommendations (completed)\n",
+      "\n",
+      "<solution>\n",
+      "# CRISPR Screen to Identify T Cell Exhaustion Regulators\n",
+      "\n",
+      "## Selected 32 Genes for Maximum Perturbation Effect\n",
+      "\n",
+      "Based on comprehensive analysis of T cell exhaustion biology, I have identified 32 genes that will maximize perturbation effects in your CRISPR screen measuring differential TCR signaling between acute (IL-2 only) and chronic (anti-CD3 + IL-2) stimulation conditions:\n",
+      "\n",
+      "### Gene List (Ranked by Priority):\n",
+      "\n",
+      "**Immune Checkpoint Molecules (8 genes):**\n",
+      "1. **PDCD1** (PD-1) - Primary exhaustion checkpoint receptor\n",
+      "2. **HAVCR2** (TIM-3) - Critical exhaustion marker and checkpoint\n",
+      "3. **LAG3** - Major exhaustion checkpoint receptor\n",
+      "4. **TIGIT** - Emerging exhaustion checkpoint target\n",
+      "5. **CTLA4** - Early checkpoint inhibitor\n",
+      "6. **CD274** (PD-L1) - PD-1 ligand\n",
+      "7. **BTLA** - Inhibitory receptor\n",
+      "8. **CD96** - TIGIT pathway component\n",
+      "\n",
+      "**Transcription Factors (8 genes):**\n",
+      "9. **TOX** - Master regulator of T cell exhaustion\n",
+      "10. **EOMES** - Key exhaustion-promoting transcription factor\n",
+      "11. **BATF** - Exhaustion-promoting transcription factor\n",
+      "12. **TBX21** (T-bet) - Effector vs exhaustion balance\n",
+      "13. **IRF4** - T cell differentiation regulator\n",
+      "14. **NFATC1** - Chronic stimulation response factor\n",
+      "15. **TOX2** - TOX family member\n",
+      "16. **RUNX3** - T cell differentiation factor\n",
+      "\n",
+      "**Metabolic Regulators (8 genes):**\n",
+      "17. **HIF1A** - Hypoxia and exhaustion regulator\n",
+      "18. **MYC** - Metabolic reprogramming master regulator\n",
+      "19. **MTOR** - Metabolic sensing and signaling\n",
+      "20. **PRKAA1** (AMPK) - Energy sensing kinase\n",
+      "21. **LDHA** - Lactate metabolism in exhaustion\n",
+      "22. **PKM** - Pyruvate kinase, glycolysis regulator\n",
+      "23. **SLC2A1** (GLUT1) - Glucose uptake transporter\n",
+      "24. **PPARA** - Fatty acid oxidation regulator\n",
+      "\n",
+      "**TCR Signaling Components (7 genes):**\n",
+      "25. **LCK** - Proximal TCR signaling kinase\n",
+      "26. **ZAP70** - TCR signal strength regulator\n",
+      "27. **LAT** - TCR signaling hub adaptor\n",
+      "28. **PLCG1** (PLCγ1) - Downstream TCR signaling\n",
+      "29. **LCP2** (SLP-76) - TCR signaling adaptor\n",
+      "30. **VAV1** - TCR signaling regulator\n",
+      "31. **ITK** - TCR signaling kinase\n",
+      "\n",
+      "**Cytokine Signaling (1 gene):**\n",
+      "32. **STAT3** - Cytokine signaling transcription factor\n",
+      "\n",
+      "## Experimental Design Overview\n",
+      "\n",
+      "### Objective:\n",
+      "Identify genes that regulate T cell exhaustion by measuring differential TCR signaling responses between acute and chronic stimulation conditions.\n",
+      "\n",
+      "### Key Features:\n",
+      "- **Balanced gene selection** across 4 major functional categories\n",
+      "- **High-priority targets** based on literature evidence and therapeutic relevance\n",
+      "- **Expected differential effects** between acute vs chronic conditions\n",
+      "- **Multiple readouts** for comprehensive phenotyping\n",
+      "\n",
+      "### Stimulation Conditions:\n",
+      "- **Acute**: IL-2 only (maintains survival without exhaustion)\n",
+      "- **Chronic**: Anti-CD3 + IL-2 (induces exhaustion through chronic TCR stimulation)\n",
+      "\n",
+      "### Primary Readouts:\n",
+      "1. **TCR signaling strength**: Phospho-flow cytometry (pZAP70, pERK, pS6)\n",
+      "2. **Exhaustion markers**: PD-1, TIM-3, LAG-3 surface expression\n",
+      "3. **Functional capacity**: Cytokine production (IFN-γ, TNF-α, IL-2)\n",
+      "4. **Transcriptional state**: RNA-seq for exhaustion gene signatures\n",
+      "\n",
+      "### Expected Outcomes:\n",
+      "- **Checkpoint inhibitors** (PDCD1, HAVCR2, LAG3): KO should enhance signaling in chronic condition\n",
+      "- **Exhaustion TFs** (TOX, EOMES, BATF): KO should reduce exhaustion phenotype\n",
+      "- **Metabolic regulators** (MTOR, HIF1A, MYC): Context-dependent effects on sustained signaling\n",
+      "- **TCR components** (LCK, ZAP70, LAT): Proportional effects on signaling strength\n",
+      "\n",
+      "### sgRNA Design Recommendations:\n",
+      "- Use 3-4 sgRNAs per gene for redundancy\n",
+      "- Include non-targeting controls and positive controls (TOX, PDCD1)\n",
+      "- Target early exons for effective knockouts\n",
+      "- Use established design tools (Broad GPP portal, CHOPCHOP)\n",
+      "\n",
+      "This gene set maximizes the potential to identify novel regulators of T cell exhaustion while covering all major pathways involved in the acute-to-chronic transition of T cell responses.\n",
+      "</solution>\n"
+     ]
+    }
+   ],
+   "source": [
+    "log = agent.go(\"\"\"Plan a CRISPR screen to identify genes that regulate T cell exhaustion,\n",
+    "        measured by the change in T cell receptor (TCR) signaling between acute\n",
+    "        (interleukin-2 [IL-2] only) and chronic (anti-CD3 and IL-2) stimulation conditions.\n",
+    "        Generate 32 genes that maximize the perturbation effect.\"\"\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "biomni_fixed",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}