Add files using upload-large-folder tool

Biomanus/.env

@@ -0,0 +1 @@
+export DEEPSEEK_API_KEY=sk-06e6154722b84e89b081b1c9571838ef

Biomanus/.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

Biomanus/.gitattributes

@@ -0,0 +1,2 @@
+*.bam filter=lfs diff=lfs merge=lfs -text
+*.h5ad filter=lfs diff=lfs merge=lfs -text

Biomanus/.gitignore

@@ -0,0 +1,236 @@
+.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/
+/paper_reproduction_runs/
+/bioagent-bench-runs/

Biomanus/.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"]

Biomanus/3xTG_AD_metadata.csv

@@ -0,0 +1,7 @@
+sample,condition
+G3R1_Cortex_3xTgAD,3xTG_AD
+G3R3_Cortex_3xTgAD,3xTG_AD
+G3R4_Cortex_3xTgAD,3xTG_AD
+G3R10_Cortex_WT,WT
+G3R7_Cortex_WT,WT
+G3R9_Cortex_WT,WT

Biomanus/5xFAD_metadata.csv

@@ -0,0 +1,21 @@
+sample,condition
+5xFAD;BL6_cortex_8mon_Female_295,5xFAD
+5xFAD;BL6_cortex_8mon_Female_312,5xFAD
+5xFAD;BL6_cortex_8mon_Female_339,5xFAD
+5xFAD;BL6_cortex_8mon_Female_341,5xFAD
+5xFAD;BL6_cortex_8mon_Female_342,5xFAD
+5xFAD;BL6_cortex_8mon_Male_299,5xFAD
+5xFAD;BL6_cortex_8mon_Male_300,5xFAD
+5xFAD;BL6_cortex_8mon_Male_307,5xFAD
+5xFAD;BL6_cortex_8mon_Male_387,5xFAD
+5xFAD;BL6_cortex_8mon_Male_390,5xFAD
+BL6_cortex_8mon_Female_322,WT
+BL6_cortex_8mon_Female_338,WT
+BL6_cortex_8mon_Female_340,WT
+BL6_cortex_8mon_Female_348,WT
+BL6_cortex_8mon_Female_351,WT
+BL6_cortex_8mon_Male_389,WT
+BL6_cortex_8mon_Male_396,WT
+BL6_cortex_8mon_Male_399,WT
+BL6_cortex_8mon_Male_410,WT
+BL6_cortex_8mon_Male_412,WT

Biomanus/ALZHEIMER_BENCHMARK_GUIDE.md

@@ -0,0 +1,261 @@
+# Alzheimer's Disease Mouse Models Benchmark 执行指南
+
+本文档详细说明如何使用Hypo_Bio_OS agent系统运行Alzheimer's Disease mouse models benchmark分析。
+
+## 概述
+
+本benchmark要求对三种不同的Alzheimer's Disease小鼠模型（5xFAD、3xTG-AD和PS3O1S）进行比较分析，识别共享的分子通路。分析包括：
+1. 差异表达分析
+2. 使用KEGG通路进行通路富集分析
+3. 生成包含三个模型共有通路及对应p-value的比较表格
+
+## 文件结构
+
+### 数据文件
+```
+/225040511/project/bioagent-bench/dataset/alzheimer-mouse/data/
+├── GSE168137_countList.txt          # 5xFAD模型数据
+├── GSE161904_Raw_gene_counts_cortex.txt  # 3xTG-AD模型数据
+└── DEA_PS3O1S.csv                   # PS3O1S模型差异表达结果
+```
+
+### 生成的脚本
+```
+/225040511/project/Hypo_Bio_OS/
+├── run_alzheimer_benchmark.py       # 主执行脚本
+├── test_alzheimer_analysis.py       # 测试脚本
+├── verify_data_access.py            # 数据访问验证脚本
+└── ALZHEIMER_BENCHMARK_GUIDE.md     # 本指南
+```
+
+### 结果目录
+```
+/225040511/project/Hypo_Bio_OS/bioagent-bench-results/
+├── README.md                        # 结果说明
+├── template/                        # 目录结构模板
+└── alzheimer_analysis_YYYYMMDD_HHMMSS/  # 每次运行的结果
+```
+
+## 环境要求
+
+### 1. Python环境
+- Python 3.8+
+- 已安装Hypo_Bio_OS依赖
+- 建议使用conda环境 `biomni_e1`
+
+### 2. 生物信息学工具
+- R语言环境（用于部分分析）
+- 必要的R包：DESeq2, clusterProfiler, org.Mm.eg.db等
+- Python生物信息学库：scanpy, mygene, gseapy等
+
+### 3. API密钥
+- DeepSeek API密钥（或其他支持的LLM API密钥）
+- 设置环境变量：`export DEEPSEEK_API_KEY='your_api_key'`
+
+## 执行步骤
+
+### 步骤1：验证数据访问
+```bash
+cd /225040511/project/Hypo_Bio_OS
+python verify_data_access.py
+```
+
+### 步骤2：设置API密钥
+```bash
+# 方法1：设置环境变量
+export DEEPSEEK_API_KEY='your_actual_api_key_here'
+
+# 方法2：在脚本运行时输入
+# 脚本会提示输入API密钥
+```
+
+### 步骤3：运行完整分析
+```bash
+cd /225040511/project/Hypo_Bio_OS
+python run_alzheimer_benchmark.py
+```
+
+## 脚本详细说明
+
+### 1. `run_alzheimer_benchmark.py`
+
+这是主执行脚本，负责：
+- 初始化Hypo_Bio_OS agent
+- 配置MCP工具
+- 执行分析查询
+- 保存结果
+
+**关键配置：**
+```python
+agent_config = {
+    "path": str(DATA_PATH),           # 数据路径
+    "llm": "deepseek-chat",           # 使用的LLM
+    "source": "Custom",               # API源
+    "base_url": "https://api.deepseek.com/v1",  # API地址
+    "api_key": os.getenv("DEEPSEEK_API_KEY", ""),  # API密钥
+    "rewrite_user_query": True,       # 重写查询以优化检索
+    "dynamic_mcp_registration": True, # 动态注册MCP工具
+    "mcp_server_top_k": 20,           # 使用的MCP服务器数量
+    "mcp_tool_top_k": 12,             # 每个服务器的工具数量
+}
+```
+
+### 2. 分析查询
+
+脚本使用以下查询执行分析：
+```
+Perform a comparative analysis of three different Alzheimer's Disease mouse models 
+(5xFAD, 3xTG-AD, and PS3O1S) to identify shared molecular pathways by performing 
+differential expression analysis, conducting pathway enrichment analysis using 
+KEGG pathways for each model and generate a final comparison which contains common 
+pathways present across all three models, corresponding p-values for each 
+pathway-model combination.
+
+Data files available:
+1. GSE168137_countList.txt - 5xFAD mouse model data
+2. GSE161904_Raw_gene_counts_cortex.txt - 3xTG-AD mouse model data  
+3. DEA_PS3O1S.csv - PS3O1S tau transgenic mouse model differential expression results
+
+Requirements:
+1. Load and preprocess each dataset appropriately
+2. Perform differential expression analysis for 5xFAD and 3xTG-AD models
+3. For PS3O1S model, use the provided differential expression results
+4. Perform KEGG pathway enrichment analysis for each model
+5. Identify common pathways across all three models
+6. Generate a comprehensive comparison table with p-values for each pathway-model combination
+7. Save all intermediate results and final outputs
+
+Please provide a detailed summary of the analysis process and findings.
+```
+
+## 预期输出
+
+### 1. 结果文件结构
+每次运行会在`/225040511/project/Hypo_Bio_OS/bioagent-bench-results/`下创建时间戳目录：
+```
+alzheimer_analysis_20260511_143022/
+├── run_metadata.json          # 运行配置和元数据
+├── execution_log.txt          # 详细执行日志
+├── execution_log.json         # JSON格式日志
+├── final_answer.txt           # agent的最终分析报告
+├── processed_data/            # 处理后的数据文件
+├── analysis_results/          # 分析结果
+│   ├── differential_expression/
+│   ├── pathway_enrichment/
+│   └── comparative_analysis/
+├── visualizations/            # 图表文件
+└── reports/                   # 生成报告
+```
+
+### 2. 关键分析结果
+1. **差异表达分析结果**：每个模型的显著差异表达基因列表
+2. **通路富集结果**：每个模型的KEGG通路富集分析结果
+3. **共同通路表格**：三个模型共有的通路及对应p-value
+4. **可视化图表**：火山图、通路富集图、热图等
+5. **综合分析报告**：详细的分析过程、方法和发现总结
+
+## 故障排除
+
+### 常见问题1：API密钥错误
+**症状**：脚本提示API密钥无效或未设置
+**解决**：
+```bash
+# 确认环境变量已设置
+echo $DEEPSEEK_API_KEY
+
+# 重新设置
+export DEEPSEEK_API_KEY='your_actual_api_key'
+```
+
+### 常见问题2：依赖缺失
+**症状**：导入错误或运行时错误
+**解决**：
+```bash
+# 激活conda环境
+conda activate biomni_e1
+
+# 安装缺失包
+pip install pandas numpy scipy statsmodels mygene gseapy
+```
+
+### 常见问题3：权限问题
+**症状**：无法读取数据文件或写入结果
+**解决**：
+```bash
+# 检查文件权限
+ls -la /225040511/project/bioagent-bench/dataset/alzheimer-mouse/data/
+
+# 检查结果目录权限
+ls -la /225040511/project/Hypo_Bio_OS/bioagent-bench-results/
+```
+
+### 常见问题4：内存不足
+**症状**：分析过程中程序崩溃
+**解决**：
+- 减少同时处理的数据量
+- 增加系统内存
+- 使用更高效的数据结构
+
+## 扩展和定制
+
+### 1. 使用不同的LLM
+修改`run_alzheimer_benchmark.py`中的配置：
+```python
+# 使用OpenAI
+agent_config = {
+    "llm": "gpt-4",
+    "source": "OpenAI",
+    "api_key": os.getenv("OPENAI_API_KEY", ""),
+}
+
+# 使用Claude
+agent_config = {
+    "llm": "claude-3-5-sonnet-20241022",
+    "source": "Anthropic",
+    "api_key": os.getenv("ANTHROPIC_API_KEY", ""),
+}
+```
+
+### 2. 添加自定义分析步骤
+在查询中添加特定要求：
+```python
+custom_query = QUERY + """
+
+额外要求：
+1. 执行蛋白质互作网络分析
+2. 识别hub基因
+3. 与人类Alzheimer's Disease数据进行比较
+"""
+```
+
+### 3. 调整输出格式
+修改`save_results`函数以生成特定格式的输出。
+
+## 性能优化建议
+
+1. **数据预处理**：对大型计数矩阵进行适当的下采样或过滤
+2. **并行处理**：对独立分析步骤使用多进程
+3. **缓存中间结果**：避免重复计算
+4. **内存管理**：及时释放不再需要的大型对象
+
+## 参考资源
+
+1. **原始benchmark**：`/225040511/project/bioagent-bench/README.md`
+2. **Hypo_Bio_OS文档**：`/225040511/project/Hypo_Bio_OS/README.md`
+3. **相关论文**：
+   - 5xFAD模型：GSE168137
+   - 3xTG-AD模型：GSE161904
+   - PS3O1S模型：GSE118523
+
+## 支持
+
+如遇问题，请：
+1. 检查日志文件中的详细错误信息
+2. 验证数据文件和权限
+3. 确认API密钥和网络连接
+4. 参考Hypo_Bio_OS系统文档
+
+---
+
+*最后更新：2026年5月11日*
+*作者：Hypo_Bio_OS开发团队*

Biomanus/BENCHMARK_EXECUTION_SUMMARY.md

@@ -0,0 +1,183 @@
+# Alzheimer's Disease Mouse Models Benchmark 执行总结
+
+## 项目概述
+
+成功创建了使用Hypo_Bio_OS agent系统执行Alzheimer's Disease mouse models benchmark分析的完整解决方案。该方案能够自动执行三个小鼠模型（5xFAD、3xTG-AD、PS3O1S）的比较分析，识别共享分子通路。
+
+## 完成的工作
+
+### 1. 系统分析
+- ✅ 分析了bioagent-bench benchmark的结构
+- ✅ 研究了Alzheimer's mouse数据文件格式
+- ✅ 理解了Hypo_Bio_OS agent系统的架构
+- ✅ 掌握了agent调用接口和配置方法
+
+### 2. 代码开发
+- ✅ 创建了主执行脚本 `run_alzheimer_benchmark.py`
+- ✅ 开发了测试脚本 `test_alzheimer_analysis.py`
+- ✅ 实现了数据访问验证脚本 `verify_data_access.py`
+- ✅ 编写了Shell执行脚本 `run_benchmark.sh`
+
+### 3. 配置设置
+- ✅ 设置了结果保存路径 `/225040511/project/Hypo_Bio_OS/bioagent-bench-results`
+- ✅ 配置了MCP工具集成
+- ✅ 定义了标准化的输出格式
+- ✅ 创建了目录结构模板
+
+### 4. 文档编写
+- ✅ 编写了详细执行指南 `ALZHEIMER_BENCHMARK_GUIDE.md`
+- ✅ 创建了结果目录说明 `README.md`
+- ✅ 提供了故障排除指南
+- ✅ 记录了性能优化建议
+
+## 技术架构
+
+### 核心组件
+1. **Hypo_Bio_OS Agent**：基于LangGraph的智能体系统
+2. **MCP工具集成**：通过strata_mcp_config_shim.yaml配置
+3. **数据分析管道**：差异表达分析 + 通路富集分析
+4. **结果管理系统**：结构化输出和元数据记录
+
+### 数据流程
+```
+原始数据文件 → 数据预处理 → 差异表达分析 → 
+通路富集分析 → 比较分析 → 结果生成 → 报告输出
+```
+
+### 支持的数据集
+1. **5xFAD模型**：GSE168137_countList.txt
+2. **3xTG-AD模型**：GSE161904_Raw_gene_counts_cortex.txt
+3. **PS3O1S模型**：DEA_PS3O1S.csv（已包含差异表达结果）
+
+## 功能特性
+
+### 1. 自动化分析
+- 自动加载和预处理三个数据集
+- 执行差异表达分析（5xFAD和3xTG-AD）
+- 利用现有差异表达结果（PS3O1S）
+- 进行KEGG通路富集分析
+- 识别共有通路并生成比较表格
+
+### 2. 智能配置
+- 支持多种LLM（DeepSeek、OpenAI、Claude等）
+- 动态MCP工具注册和选择
+- 可配置的分析参数
+- 灵活的输出格式
+
+### 3. 结果管理
+- 时间戳目录自动创建
+- 完整的元数据记录
+- 结构化文件存储
+- 可视化图表生成
+
+### 4. 错误处理
+- 数据文件验证
+- API密钥检查
+- 依赖缺失检测
+- 详细错误日志
+
+## 使用方法
+
+### 快速开始
+```bash
+cd /225040511/project/Hypo_Bio_OS
+
+# 设置API密钥
+export DEEPSEEK_API_KEY='your_api_key'
+
+# 运行分析
+./run_benchmark.sh
+```
+
+### 分步执行
+```bash
+# 1. 验证数据访问
+python verify_data_access.py
+
+# 2. 运行完整分析
+python run_alzheimer_benchmark.py
+
+# 3. 查看结果
+ls -la /225040511/project/Hypo_Bio_OS/bioagent-bench-results/
+```
+
+## 预期输出
+
+### 分析结果
+1. **差异表达基因列表**：每个模型的显著差异表达基因
+2. **通路富集结果**：KEGG通路富集分析结果
+3. **共同通路表格**：三个模型共有的通路及p-value
+4. **可视化图表**：火山图、富集图、热图等
+
+### 报告文件
+1. **技术报告**：详细的分析方法和过程
+2. **结果摘要**：关键发现和结论
+3. **元数据文件**：运行配置和环境信息
+4. **执行日志**：完整的运行记录
+
+## 扩展能力
+
+### 自定义分析
+- 添加新的分析步骤
+- 修改分析参数
+- 集成额外数据源
+- 生成定制化报告
+
+### 性能优化
+- 并行处理支持
+- 内存管理优化
+- 缓存机制
+- 增量分析
+
+### 集成扩展
+- 与其他生物信息学工具集成
+- 支持更多数据格式
+- 云平台部署
+- 工作流自动化
+
+## 验证状态
+
+### 已验证的功能
+- ✅ 数据文件访问权限
+- ✅ Python环境兼容性
+- ✅ 脚本基本功能
+- ✅ 目录结构创建
+
+### 待验证的功能
+- ⏳ 完整agent执行（需要API密钥）
+- ⏳ 实际分析结果质量
+- ⏳ 大规模数据处理性能
+- ⏳ 错误恢复机制
+
+## 后续建议
+
+### 短期改进
+1. 添加更多测试用例
+2. 优化内存使用
+3. 改进错误消息
+4. 增加进度指示
+
+### 长期规划
+1. 支持更多小鼠模型
+2. 集成单细胞分析
+3. 添加机器学习组件
+4. 开发Web界面
+
+## 贡献指南
+
+欢迎通过以下方式贡献：
+1. 报告问题和建议
+2. 提交代码改进
+3. 添加新的分析功能
+4. 完善文档和示例
+
+## 联系信息
+
+- 项目位置：`/225040511/project/Hypo_Bio_OS`
+- 数据源：`/225040511/project/bioagent-bench`
+- 结果目录：`/225040511/project/Hypo_Bio_OS/bioagent-bench-results`
+
+---
+
+*执行总结生成时间：2026年5月11日*
+*系统状态：就绪，等待API密钥执行完整分析*

Biomanus/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.

Biomanus/LMX1B.meme

@@ -0,0 +1,19 @@
+MEME version 4
+
+ALPHABET= ACGT
+
+strands: + -
+
+Background letter frequencies
+A 0.25 C 0.25 G 0.25 T 0.25
+
+MOTIF LMX1B
+letter-probability matrix: alength= 4 w= 8 nsites= 4101 E= 0
+  0.211220  0.235366  0.239512  0.313902
+  0.111735  0.294216  0.034956  0.559093
+  0.791088  0.059028  0.063465  0.086420
+  0.935021  0.013680  0.009804  0.041496
+  0.070230  0.002460  0.010065  0.917244
+  0.214912  0.065318  0.066433  0.653338
+  0.871811  0.019983  0.004252  0.103954
+  0.513171  0.161463  0.197317  0.128049

Biomanus/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

Biomanus/README.md

@@ -0,0 +1,383 @@
+# HypoBioOS
+
+Step-by-step guide for setting up Biomni and running the generic paper reproduction workflow in this repository.
+
+This repository is developed based on the open-source Biomni codebase from [snap-stanford/biomni](https://github.com/snap-stanford/biomni). We extend the original Biomni agent framework with MCP server generation, graph-guided tool retrieval, dynamic MCP routing, and benchmark-oriented experiment runners.
+
+## 1. Goal
+
+This document explains how to:
+
+- set up the Biomni runtime environment,
+- configure the LLM endpoint used by the reproduction script,
+- verify MCP servers are discoverable,
+- run the generic reproduction runner,
+- reproduce the built-in FOXJ1 example,
+- run the same workflow on a different paper.
+
+The main script covered here is:
+
+```text
+/225040511/project/Biomni/reproduce_foxj1_paper.py
+```
+
+Although the filename still contains `foxj1`, the script is now a generic runner.
+
+## 2. Prerequisites
+
+Before you start, make sure you have:
+
+- access to this Biomni repository,
+- Conda installed,
+- a working Python environment compatible with Biomni,
+- an API key for a model endpoint,
+- generated MCP server directories under `biomni_web/backend/data/mcp_generated/`.
+
+## 3. Enter The Repository
+
+```bash
+cd /225040511/project/Biomni
+```
+
+## 4. Build The Biomni Environment
+
+Follow the environment setup instructions in:
+
+```text
+biomni_env/README.md
+```
+
+After the environment is created, activate it:
+
+```bash
+conda activate biomni_e1
+```
+
+If you are running Biomni from source, install the current repository into the environment:
+
+```bash
+pip install -e .
+```
+
+If you prefer the upstream GitHub version instead:
+
+```bash
+pip install git+https://github.com/snap-stanford/Biomni.git@main
+```
+
+## 5. Configure The Model Endpoint
+
+The current `reproduce_foxj1_paper.py` script creates the agent with:
+
+```python
+source="Custom"
+```
+
+This means the script is using an OpenAI-compatible HTTP endpoint through Biomni's custom backend path.
+
+The current code reads credentials in this order:
+
+1. `DEEPSEEK_API_KEY`
+2. `OPENAI_API_KEY`
+3. fallback to `"EMPTY"`
+
+The current code also reads:
+
+- `DEEPSEEK_BASE_URL`
+- `DEEPSEEK_MODEL_NAME`
+
+So if you want to use OpenAI, you should not only set `OPENAI_API_KEY`, but also point `DEEPSEEK_BASE_URL` to the OpenAI API endpoint and set `DEEPSEEK_MODEL_NAME` to an OpenAI model name.
+
+### Option A. Use DeepSeek
+
+Set these environment variables:
+
+```bash
+export DEEPSEEK_API_KEY="your_api_key"
+export DEEPSEEK_BASE_URL="https://api.deepseek.com/v1"
+export DEEPSEEK_MODEL_NAME="deepseek-chat"
+```
+
+### Option B. Use OpenAI API Key
+
+Use the OpenAI key as the authentication source, but still set the endpoint and model through the same runtime variables used by the script:
+
+```bash
+export OPENAI_API_KEY="your_openai_api_key"
+export DEEPSEEK_BASE_URL="https://api.openai.com/v1"
+export DEEPSEEK_MODEL_NAME="gpt-4.1-mini"
+```
+
+You can replace `gpt-4.1-mini` with another OpenAI model that your account can access, for example:
+
+```bash
+export DEEPSEEK_MODEL_NAME="gpt-4.1"
+```
+
+### Option C. Use Another OpenAI-Compatible Endpoint
+
+If you use another OpenAI-compatible endpoint, point the same variables to your own service:
+
+```bash
+export OPENAI_API_KEY="your_custom_endpoint_key"
+export DEEPSEEK_BASE_URL="http://your-endpoint/v1"
+export DEEPSEEK_MODEL_NAME="your-model-name"
+```
+
+### Quick Check
+
+After exporting the variables, you can confirm they are set:
+
+```bash
+echo "$DEEPSEEK_BASE_URL"
+echo "$DEEPSEEK_MODEL_NAME"
+```
+
+If you are using OpenAI:
+
+```bash
+echo "$OPENAI_API_KEY"
+```
+
+You do not need to print the full key in shared logs. It is enough to verify that the variable is non-empty.
+
+Optional but recommended:
+
+```bash
+export BIOMNI_MCP_PYTHON="$(which python)"
+```
+
+This ensures the generated MCP config uses the Python interpreter from your active Biomni environment.
+
+## 6. Verify MCP Servers Exist
+
+The script discovers MCP servers from:
+
+```text
+biomni_web/backend/data/mcp_generated/
+```
+
+Each server is expected to look like:
+
+```text
+mcp_<server_name>/app/*_shim_server.py
+```
+
+or:
+
+```text
+mcp_<server_name>/app/*_server.py
+```
+
+You can inspect what the script currently finds:
+
+```bash
+python reproduce_foxj1_paper.py --list-servers
+```
+
+If the list is empty or missing expected servers, check whether the corresponding generated directories exist under:
+
+```text
+/225040511/project/Biomni/biomni_web/backend/data/mcp_generated/
+```
+
+## 7. Understand What The Script Does
+
+The script performs these high-level steps:
+
+1. parses your paper title, context, query, input files, and requested MCP servers,
+2. discovers available MCP server directories,
+3. builds an MCP config YAML file for the selected servers,
+4. creates a run directory under `paper_reproduction_runs/`,
+5. writes prompt, query, and plan files,
+6. initializes `A1`,
+7. loads the MCP config,
+8. asks Biomni to plan the reproduction steps from your query,
+9. lets Biomni select suitable MCP tools during execution,
+10. saves logs, final answer, and report files.
+
+## 8. Do A Dry Run First
+
+Before running the full workflow, do a preparation-only run:
+
+```bash
+python reproduce_foxj1_paper.py \
+  --dataset-profile foxj1 \
+  --prepare-only
+```
+
+This does not call the model. It only prepares:
+
+- the run directory,
+- the MCP config,
+- the query file,
+- the prompt file,
+- the execution plan file.
+
+The output will be written under:
+
+```text
+paper_reproduction_runs/
+```
+
+## 9. Run The Built-In FOXJ1 Example
+
+Use the built-in dataset profile if you want to reproduce the FOXJ1 example workflow.
+
+Command:
+
+```bash
+python reproduce_foxj1_paper.py \
+  --dataset-profile foxj1 \
+  --query "Firstly, whether FOXJ1 and GMNC were up-regulated in LuCaP35CR, then whether ABCB1 was up-regulated in LuCaP70CR, and finally the enrichment analysis of pathways related to cilia/microtubules was performed"
+```
+
+What this does:
+
+1. loads the built-in FOXJ1 profile,
+2. downloads the associated GEO processed files if needed,
+3. selects the preferred MCP server set for that profile,
+4. builds the execution prompt from your natural-language query,
+5. runs Biomni with MCP enabled,
+6. writes logs and outputs into the run directory.
+
+## 10. Run A Different Paper
+
+If you want to run another paper, provide your own paper metadata and inputs.
+
+Minimal example:
+
+```bash
+python reproduce_foxj1_paper.py \
+  --paper-title "Your Paper Title" \
+  --context-file /path/to/paper_summary.md \
+  --input-file /path/to/data1.csv \
+  --input-file /path/to/data2.tsv \
+  --query "Reproduce the main findings, choose suitable MCP tools, run the feasible analyses, and summarize what is supported by the provided data." \
+  --server jq \
+  --server bioconductor-clusterprofiler \
+  --server gseapy
+```
+
+You can also pass entire directories:
+
+```bash
+python reproduce_foxj1_paper.py \
+  --paper-title "Another Paper" \
+  --paper-context "Short summary of the paper and the results you want to reproduce." \
+  --input-dir /path/to/input_folder \
+  --query "Check differential patterns and enrichment results." \
+  --server all
+```
+
+## 11. Important Command Options
+
+Common options supported by the script:
+
+- `--paper-title`: title of the paper for this run.
+- `--paper-context`: short context text passed directly on the command line.
+- `--context-file`: markdown or text file containing paper context.
+- `--query`: natural-language reproduction request.
+- `--input-file`: input file to include, can be used multiple times.
+- `--input-dir`: input directory to include, can be used multiple times.
+- `--dataset-profile foxj1`: use the built-in FOXJ1 example profile.
+- `--server`: choose MCP servers explicitly.
+- `--server all`: register all discovered MCP servers.
+- `--prepare-only`: generate files without running the model.
+- `--list-servers`: print discovered MCP servers and exit.
+
+## 12. What Files You Should Expect
+
+For each run, the script creates a folder like:
+
+```text
+paper_reproduction_runs/<run_name>/
+```
+
+Inside it, you should see files such as:
+
+```text
+mcp_config.yaml
+paper_context.md
+reproduction_query.txt
+execution_plan.md
+reproduction_prompt.txt
+results/biomni_execution_log_*.txt
+results/biomni_execution_log_*.json
+results/biomni_final_answer_*.txt
+results/biomni_run_metadata_*.json
+results/biomni_conversation_*.md
+results/reproduction_report.md
+```
+
+## 13. Recommended First-Time Workflow
+
+If this is your first time running the script, use this exact order:
+
+1. `cd /225040511/project/Biomni`
+2. `conda activate biomni_e1`
+3. `pip install -e .`
+4. export `DEEPSEEK_API_KEY`
+5. export `DEEPSEEK_BASE_URL`
+6. export `DEEPSEEK_MODEL_NAME`
+7. optionally export `BIOMNI_MCP_PYTHON="$(which python)"`
+8. run `python reproduce_foxj1_paper.py --list-servers`
+9. run `python reproduce_foxj1_paper.py --dataset-profile foxj1 --prepare-only`
+10. run the full FOXJ1 example command
+
+## 14. Troubleshooting
+
+If the script does not run, check these items one by one.
+
+### Environment Problems
+
+- Make sure the Conda environment is activated.
+- Make sure `pip install -e .` completed successfully.
+- Make sure the same Python is used by both Biomni and MCP config generation.
+
+### Model Problems
+
+- Make sure `DEEPSEEK_API_KEY` is set.
+- Make sure `DEEPSEEK_BASE_URL` points to a reachable OpenAI-compatible endpoint.
+- Make sure `DEEPSEEK_MODEL_NAME` matches a model served by that endpoint.
+
+### MCP Problems
+
+- Run `python reproduce_foxj1_paper.py --list-servers`.
+- Confirm the required `mcp_<name>` directories exist.
+- Confirm each selected MCP server has an `app/` directory with a `*_shim_server.py` or `*_server.py` file.
+
+### Input Problems
+
+- Confirm all `--input-file` paths exist.
+- Confirm all `--input-dir` paths exist.
+- If using the `foxj1` profile, let the script finish downloading the GEO processed files.
+
+### Dry Run Problems
+
+- If a full run fails, first retry with `--prepare-only`.
+- Check whether the prompt and MCP config are generated correctly before debugging model execution.
+
+## 15. One-Line Reference Commands
+
+List MCP servers:
+
+```bash
+python reproduce_foxj1_paper.py --list-servers
+```
+
+Prepare only:
+
+```bash
+python reproduce_foxj1_paper.py --dataset-profile foxj1 --prepare-only
+```
+
+Run FOXJ1:
+
+```bash
+python reproduce_foxj1_paper.py --dataset-profile foxj1 --query "Firstly, whether FOXJ1 and GMNC were up-regulated in LuCaP35CR, then whether ABCB1 was up-regulated in LuCaP70CR, and finally the enrichment analysis of pathways related to cilia/microtubules was performed"
+```
+
+## 16. Acknowledgements
+
+This work builds on the open-source Biomni project by the Stanford SNAP group: [snap-stanford/biomni](https://github.com/snap-stanford/biomni). We gratefully acknowledge the Biomni authors and contributors for releasing their codebase and biomedical agent framework, which provided the foundation for this development.

Biomanus/article.xml

@@ -0,0 +1 @@
+<full-text-retrieval-response xmlns="http://www.elsevier.com/xml/svapi/article/dtd" xmlns:bk="http://www.elsevier.com/xml/bk/dtd" xmlns:cals="http://www.elsevier.com/xml/common/cals/dtd" xmlns:ce="http://www.elsevier.com/xml/common/dtd" xmlns:ja="http://www.elsevier.com/xml/ja/dtd" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:sa="http://www.elsevier.com/xml/common/struct-aff/dtd" xmlns:sb="http://www.elsevier.com/xml/common/struct-bib/dtd" xmlns:tb="http://www.elsevier.com/xml/common/table/dtd" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xocs="http://www.elsevier.com/xml/xocs/dtd" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:prism="http://prismstandard.org/namespaces/basic/2.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><coredata><prism:url>https://api.elsevier.com/content/article/pii/S0092867419308931</prism:url><dc:identifier>doi:10.1016/j.cell.2019.08.005</dc:identifier><eid>1-s2.0-S0092867419308931</eid><prism:doi>10.1016/j.cell.2019.08.005</prism:doi><pii>S0092-8674(19)30893-1</pii><dc:title>A Structure-Informed Atlas of Human-Virus Interactions </dc:title><prism:publicationName>Cell</prism:publicationName><prism:aggregationType>Journal</prism:aggregationType><prism:issn>00928674</prism:issn><prism:coverDate>2019-09-05</prism:coverDate><prism:coverDisplayDate>5 September 2019</prism:coverDisplayDate><openaccess>1</openaccess><openaccessArticle>true</openaccessArticle><openaccessType>Full</openaccessType><openArchiveArticle>true</openArchiveArticle><openaccessSponsorName/><openaccessSponsorType>ElsevierBranded</openaccessSponsorType><openaccessUserLicense>http://www.elsevier.com/open-access/userlicense/1.0/</openaccessUserLicense><link href="https://api.elsevier.com/content/article/pii/S0092867419308931" rel="self"/><link href="https://www.sciencedirect.com/science/article/pii/S0092867419308931" rel="scidir"/></coredata></full-text-retrieval-response>

Biomanus/biomni.md

@@ -0,0 +1,558 @@
+<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/).
+
+### Run The Generic Paper Reproduction Script
+
+This repository also includes a reusable paper reproduction runner at [`reproduce_foxj1_paper.py`](./reproduce_foxj1_paper.py). Despite the filename, the script is now a generic template: you can provide a paper title, paper context, local input files, and a natural-language query, and Biomni will plan the reproduction steps and select suitable MCP tools from the registered server set.
+
+#### 1. Base Environment
+
+Follow the installation steps above first, then activate the Biomni environment:
+
+```bash
+conda activate biomni_e1
+```
+
+If you are working from source, install Biomni from the current repository or from GitHub:
+
+```bash
+pip install -e .
+# or
+pip install git+https://github.com/snap-stanford/Biomni.git@main
+```
+
+#### 2. LLM Configuration For This Script
+
+The current implementation of `reproduce_foxj1_paper.py` builds the agent with `source="Custom"`, so the simplest working setup is to provide a DeepSeek-compatible endpoint:
+
+```bash
+export DEEPSEEK_API_KEY="your_api_key"
+export DEEPSEEK_BASE_URL="https://api.deepseek.com/v1"
+export DEEPSEEK_MODEL_NAME="deepseek-chat"
+```
+
+If you use another OpenAI-compatible endpoint, point the script to that endpoint instead:
+
+```bash
+export DEEPSEEK_API_KEY="your_custom_endpoint_key"
+export DEEPSEEK_BASE_URL="http://your-openai-compatible-endpoint/v1"
+export DEEPSEEK_MODEL_NAME="your-model-name"
+```
+
+Optional:
+
+```bash
+export BIOMNI_MCP_PYTHON="$(which python)"
+```
+
+This helps ensure the generated MCP config uses the same Python interpreter as your active Biomni environment.
+
+#### 3. MCP Server Availability
+
+The script discovers MCP servers from:
+
+```text
+biomni_web/backend/data/mcp_generated/
+```
+
+For each selected server, it looks for:
+
+- `mcp_<server_name>/app/*_shim_server.py`
+- or `mcp_<server_name>/app/*_server.py`
+
+For example, the following generated servers should exist if you want to run the bundled FOXJ1 example:
+
+- `mcp_jq`
+- `mcp_bioconductor-clusterprofiler`
+- `mcp_bioconductor-fgsea`
+- `mcp_bioconductor-qvalue`
+- `mcp_gseapy`
+
+You can inspect what the script currently discovers with:
+
+```bash
+python reproduce_foxj1_paper.py --list-servers
+```
+
+#### 4. Minimal Dry Run
+
+To only generate the run directory, prompt, plan, and MCP config without calling the model:
+
+```bash
+python reproduce_foxj1_paper.py \
+  --dataset-profile foxj1 \
+  --prepare-only
+```
+
+This creates a run folder under:
+
+```text
+paper_reproduction_runs/
+```
+
+#### 5. Run The FOXJ1 Example
+
+The built-in `foxj1` profile downloads the GEO processed files used by the original example and registers the preferred MCP server set automatically:
+
+```bash
+python reproduce_foxj1_paper.py \
+  --dataset-profile foxj1 \
+  --query "Firstly, whether FOXJ1 and GMNC were up-regulated in LuCaP35CR, then whether ABCB1 was up-regulated in LuCaP70CR, and finally the enrichment analysis of pathways related to cilia/microtubules was performed"
+```
+
+#### 6. Run A Different Paper
+
+For a different paper, provide your own metadata and inputs:
+
+```bash
+python reproduce_foxj1_paper.py \
+  --paper-title "Your Paper Title" \
+  --context-file /path/to/paper_summary.md \
+  --input-file /path/to/data1.csv \
+  --input-file /path/to/data2.tsv \
+  --query "Reproduce the main findings, run the feasible analyses, and summarize what is supported by the provided data." \
+  --server jq \
+  --server bioconductor-clusterprofiler \
+  --server gseapy
+```
+
+#### 7. What The Script Produces
+
+Each run writes artifacts under `paper_reproduction_runs/<run_name>/`, including:
+
+- `mcp_config.yaml`
+- `paper_context.md`
+- `reproduction_query.txt`
+- `execution_plan.md`
+- `reproduction_prompt.txt`
+- `results/biomni_execution_log_*.txt`
+- `results/biomni_final_answer_*.txt`
+- `results/reproduction_report.md`
+
+#### 8. Common Checks
+
+If the run fails early, check the following first:
+
+- Your Biomni environment is activated.
+- `DEEPSEEK_API_KEY` and related endpoint variables are set.
+- The requested MCP servers actually exist under `biomni_web/backend/data/mcp_generated/`.
+- `python reproduce_foxj1_paper.py --list-servers` returns the servers you expect.
+- `--prepare-only` works before attempting a full run.
+
+
+## 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}
+}
+```

Biomanus/biomni/__init__.py

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

Biomanus/biomni/agent/__init__.py

@@ -0,0 +1 @@
+from biomni.agent.a1 import A1  # noqa: F401

Biomanus/biomni/agent/env_collection.py

@@ -0,0 +1,313 @@
+import json
+import os
+import re
+from typing import Any
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+from biomni.agent.base_agent import base_agent
+
+
+class PaperTaskExtractor(base_agent):
+    """Agent that extracts generalizable tasks/experiments from academic papers.
+    It processes papers in chunks and identifies common research tasks that could be shared across papers.
+    """
+
+    def __init__(
+        self,
+        llm="claude-3-7-sonnet-20250219",
+        cheap_llm=None,
+        tools=None,
+        chunk_size=4000,
+        chunk_overlap=400,
+    ):
+        """Initialize the PaperTaskExtractor agent.
+
+        Args:
+            llm (str): The LLM model to use
+            cheap_llm (str, optional): A cheaper LLM for simpler tasks
+            tools (list, optional): Any tools to use (not needed for this agent)
+            chunk_size (int): Size of text chunks for processing
+            chunk_overlap (int): Overlap between chunks
+
+        """
+        super().__init__(llm, cheap_llm, tools)
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.log = []
+        self.configure()
+
+    def configure(self):
+        """Configure the agent with appropriate prompts."""
+        # Prompt for analyzing paper chunks
+        self.chunk_analysis_prompt = """You are a research methodology expert specializing in identifying computational tasks and data analysis procedures in academic papers.
+
+Your job is to analyze chunks of academic papers and identify ONLY the most common, generalizable computational tasks that are widely used across biomedical research and can be implemented with Python or Linux code.
+
+STRICT GUIDELINES:
+1. ONLY extract tasks that are extremely common and standard in computational biomedical research
+2. Each task MUST have clear, well-defined inputs and outputs
+3. Tasks MUST be generalizable across many different papers and research questions
+4. Be VERY selective - only include tasks that appear in hundreds of papers
+5. If a task is specific to this paper, unclear, or not widely used, DO NOT include it
+6. Focus on computational tasks that can be implemented with Python or Linux code
+7. Each task should be something that could be implemented as a function with clear inputs/outputs
+8. Also identify commonly used databases and software packages mentioned in the text
+9. Tasks MUST be CONCRETE and SPECIFIC - include exact methodological details
+10. Avoid vague task names like "Statistical Analysis" - instead use specific protocol names like "Two-way ANOVA with Tukey's Post-hoc Test using SciPy"
+11. DO NOT include wet lab procedures that cannot be implemented computationally
+12. ONLY include tasks that could be automated with code
+
+For the following chunk of text from an academic paper, provide:
+1. A list of ONLY the most common, generalizable COMPUTATIONAL tasks identified (be extremely selective)
+2. For each task, clearly define:
+   - Task name: A SPECIFIC and CONCRETE name with methodological details (e.g., "RNA-seq Differential Expression Analysis with DESeq2" instead of just "Gene Expression Analysis")
+   - Input: What SPECIFIC data or parameters the task requires
+   - Output: What SPECIFIC data or results the task produces
+   - Code implementation: How this task could be implemented with Python or Linux code, including key libraries/packages
+   - Frequency: How common this computational task is in biomedical research
+   - Standard methods: The established computational techniques used to perform this task
+   - Example: A brief description of how THIS specific paper uses this task (with specific details from the paper)
+3. A list of commonly used databases mentioned in the text (if any)
+4. A list of commonly used software packages/tools mentioned in the text (if any)
+
+PAPER CHUNK:
+{chunk_text}
+
+Remember, it's better to return NO tasks than to include tasks that aren't extremely common, generalizable, and implementable with code. Quality over quantity is essential. Tasks MUST be CONCRETE with SPECIFIC methodological details and MUST be implementable with Python or Linux code.
+"""
+
+        # Prompt for consolidating tasks
+        self.consolidation_prompt = """You are a research methodology expert. Your task is to consolidate lists of computational research tasks extracted from different chunks of an academic paper.
+
+BE EXTREMELY SELECTIVE. Only include tasks that are:
+1. Fundamental to computational biomedical research
+2. Used in hundreds of papers across different subfields
+3. Have clear, well-defined inputs and outputs
+4. Represent standard computational approaches
+5. Could be implemented as a function with specific inputs and outputs
+6. Are CONCRETE and SPECIFIC with exact methodological details
+7. Can be implemented with Python or Linux code
+8. Are computational in nature, not wet lab procedures
+
+REMOVE any tasks that:
+- Are specific to a particular paper or dataset
+- Lack clear inputs or outputs
+- Are not widely used across biomedical research
+- Are vague or poorly defined
+- Represent niche or specialized techniques
+- Have generic names without specific methodological details
+- Cannot be implemented with code
+- Require physical lab equipment or manual intervention
+
+The output should be a JSON object with three main keys:
+1. "tasks": A list of task objects, where each task has:
+   - "task_name": A SPECIFIC and CONCRETE name with methodological details (e.g., "Single-cell RNA-seq Clustering with Seurat" instead of just "Cell Clustering")
+   - "description": A clear description of what the computational task does
+   - "inputs": SPECIFIC data types or parameters the task requires
+   - "outputs": SPECIFIC data types or results the task produces
+   - "code_implementation": How this task could be implemented with Python or Linux code, including key libraries/packages and a brief pseudocode example
+   - "frequency": How common this computational task is in biomedical research
+   - "standard_methods": The established computational techniques used to perform this task
+   - "example": A specific example from THIS paper showing how the task was used (with concrete details)
+
+2. "databases": A list of database objects, where each database has:
+   - "name": The name of the database
+   - "description": A brief description of what the database contains
+   - "url": The URL of the database (if mentioned)
+   - "usage": How the database is commonly used in computational biomedical research
+   - "example": How this specific paper uses the database
+
+3. "software": A list of software package objects, where each package has:
+   - "name": The name of the software package
+   - "description": A brief description of what the software does
+   - "url": The URL or reference to the software (if mentioned)
+   - "usage": How the software is commonly used in computational biomedical research
+   - "example": How this specific paper uses the software
+
+EXTRACTED INFORMATION FROM PAPER CHUNKS:
+{task_lists}
+
+Be ruthless in filtering - it's better to return a few truly common computational tasks than many that aren't universal or implementable with code.
+Respond with only a valid JSON object containing the three lists described above.
+"""
+
+    def process_paper(self, paper_text: str) -> dict[str, list[dict[str, Any]]]:
+        """Process a paper and extract generalizable tasks/experiments, databases, and software.
+
+        Args:
+            paper_text (str): The full text of the paper
+
+        Returns:
+            Dict[str, List[Dict[str, Any]]]: A dictionary with tasks, databases, and software
+
+        """
+        # Split the paper into chunks
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=self.chunk_size,
+            chunk_overlap=self.chunk_overlap,
+            length_function=len,
+            separators=["\n\n", "\n", ". ", " ", ""],
+        )
+        chunks = text_splitter.split_text(paper_text)
+
+        # Process each chunk to extract tasks
+        chunk_results = []
+        for i, chunk in enumerate(chunks):
+            print(f"Processing chunk {i + 1}/{len(chunks)}...")
+            chunk_tasks = self._process_chunk(chunk)
+            chunk_results.append(chunk_tasks)
+
+        # Consolidate tasks from all chunks
+        consolidated_results = self._consolidate_tasks(chunk_results)
+        return consolidated_results
+
+    def _process_chunk(self, chunk_text: str) -> str:
+        """Process a single chunk of the paper to extract tasks.
+
+        Args:
+            chunk_text (str): The chunk text to process
+
+        Returns:
+            str: Extracted tasks from this chunk
+
+        """
+        prompt = self.chunk_analysis_prompt.format(chunk_text=chunk_text)
+        message = self.llm.invoke(prompt)
+        return message.content
+
+    def _consolidate_tasks(self, chunk_results: list[str]) -> dict[str, list[dict[str, Any]]]:
+        """Consolidate tasks, databases, and software extracted from different chunks into a unified structure.
+
+        Args:
+            chunk_results (List[str]): Results from each chunk
+
+        Returns:
+            Dict[str, List[Dict[str, Any]]]: Consolidated information with tasks, databases, and software
+
+        """
+        # Combine all chunk results
+        all_tasks = "\n\n===== CHUNK SEPARATOR =====\n\n".join(chunk_results)
+
+        # Use the consolidation prompt to merge and organize tasks
+        prompt = self.consolidation_prompt.format(task_lists=all_tasks)
+        response = self.llm.invoke(prompt)
+
+        # Extract the JSON from the response
+        try:
+            # Try to parse the entire response as JSON
+            result = json.loads(response.content)
+        except json.JSONDecodeError:
+            # If that fails, try to extract JSON from the text
+            try:
+                # Look for JSON-like content between triple backticks
+                json_match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", response.content)
+                if json_match:
+                    result = json.loads(json_match.group(1))
+                else:
+                    # Fallback: just return the text response
+                    return {
+                        "tasks": [
+                            {
+                                "error": "Could not parse JSON",
+                                "raw_response": response.content,
+                            }
+                        ],
+                        "databases": [],
+                        "software": [],
+                    }
+            except Exception:
+                return {
+                    "tasks": [
+                        {
+                            "error": "Could not parse JSON",
+                            "raw_response": response.content,
+                        }
+                    ],
+                    "databases": [],
+                    "software": [],
+                }
+
+        # Ensure the result has the expected structure
+        if not isinstance(result, dict):
+            result = {
+                "tasks": result if isinstance(result, list) else [],
+                "databases": [],
+                "software": [],
+            }
+
+        # Ensure all required keys exist
+        for key in ["tasks", "databases", "software"]:
+            if key not in result:
+                result[key] = []
+
+        return result
+
+    def go(self, paper_text: str):
+        """Process a paper and return the extracted tasks, databases, and software.
+
+        Args:
+            paper_text (str): The full text of the paper
+
+        Returns:
+            tuple: (log, results) where log is a list of processing steps and results is the final result
+
+        """
+        self.log = []
+        self.log.append(
+            (
+                "user",
+                "Extract only the most common and generalizable biomedical research tasks, databases, and software from this paper",
+            )
+        )
+
+        results = self.process_paper(paper_text)
+
+        result_str = json.dumps(results, indent=2)
+        self.log.append(("assistant", result_str))
+
+        return self.log, results
+
+    def save_results(self, results: dict[str, list[dict[str, Any]]], output_path: str):
+        """Save the extracted tasks, databases, and software to a JSON file.
+
+        Args:
+            results (Dict[str, List[Dict[str, Any]]]): The extracted tasks, databases, and software
+            output_path (str): Path to save the results
+
+        """
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        with open(output_path, "w") as f:
+            json.dump(results, f, indent=2)
+        print(f"Results saved to {output_path}")
+
+    def result_formatting(self, output_class, task_intention):
+        """Format the results according to a specific output class.
+
+        Args:
+            output_class: The class to format the output as
+            task_intention: Description of the task
+
+        Returns:
+            The formatted result
+
+        """
+        format_check_prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    (
+                        "You are evaluateGPT, tasked with extract and parse the task output based on the history of an agent. "
+                        "Review the entire history of messages provided. "
+                        "Here is the task output requirement: \n"
+                        f"'{task_intention.replace('{', '{{').replace('}', '}}')}'.\n"
+                    ),
+                ),
+                ("placeholder", "{messages}"),
+            ]
+        )
+
+        checker_llm = format_check_prompt | self.llm.with_structured_output(output_class)
+        result = checker_llm.invoke({"messages": [("user", str(self.log))]}).dict()
+        return result

Biomanus/biomni/agent/function_generator.py

@@ -0,0 +1,119 @@
+import re
+
+from biomni.llm import get_llm
+
+
+class base_agent:
+    def __init__(self, llm="claude-3-haiku-20240307", cheap_llm=None, tools=None, temperature=0.7):
+        self.tools = tools
+        self.llm = get_llm(llm, temperature)
+        if cheap_llm is None:
+            self.cheap_llm = llm
+        else:
+            self.cheap_llm = cheap_llm
+
+    def configure(self):
+        pass
+
+    def go(self, input):
+        pass
+
+
+class FunctionGenerator(base_agent):
+    """Agent that generates executable Python code scripts given a task description."""
+
+    def __init__(self, llm="claude-3-7-sonnet-20250219", cheap_llm=None, temperature=0.7):
+        """Initialize the PaperTaskExtractor agent.
+
+        Args:
+            llm (str): The LLM model to use
+            cheap_llm (str, optional): A cheaper LLM for simpler tasks
+        """
+        super().__init__(llm, cheap_llm, temperature)
+        self.log = []
+        self.configure()
+
+    def configure(self):
+        """Configure the agent with appropriate prompts."""
+        # Prompt for Python code generation
+        self.system_prompt = """You are a senior Python engineer. Generate robust, idiomatic Python code that solves the user's task. Requirements:
+        1. Output ONLY Python code, ideally inside a single triple-backtick code block.
+        2. Include minimal inline comments and a small docstring.
+        3. Add a `main()` and an `if __name__ == '__main__':` guard when appropriate.
+        4. Avoid external dependencies unless necessary; if used, show `pip` installs in comments.
+        5. Do not include prose before or after the code.
+        6. When applicable, prioritize the use of codes on public repositories, such as HuggingFace or Github
+
+        Generate Python codes for the following task:
+        {task}
+"""
+
+    def _generate_code(self, task_description: str) -> str:
+        """Generate codes given a task description.
+        Args:
+            task_description (str): task descriptions (possibly generated from previous steps)
+
+        Returns:
+            str: generated code string
+
+        """
+        prompt = self.system_prompt.format(task=task_description)
+        message = self.llm.invoke(prompt)
+        return message.content
+
+    def _generate_script_filename(self, task_description: str, max_words: int = 6) -> str:
+        """
+        Generate a safe, meaningful Python script filename from a task description.
+        Poised for update: may ask the agent to suggest meaningful names.
+
+        Parameters:
+        -----------
+        task_description (str): task descriptions (possibly generated from previous steps)
+
+        max_words : int
+            Maximum number of words to include in the filename.
+
+        Returns:
+        --------
+            str
+            A lowercase, hyphen-free, safe filename ending in '.py'.
+        """
+        # Lowercase and remove non-alphanumeric (allow spaces for splitting)
+        cleaned = re.sub(r"[^a-zA-Z0-9\s]", "", task_description.lower())
+
+        # Tokenize and select top words
+        words = cleaned.split()
+        selected_words = words[:max_words] if words else ["script"]
+
+        # Join with underscores
+        base_name = "_".join(selected_words)
+        return f"{base_name}.py"
+
+    def go(self, task_description: str):
+        """Implement the inherited function to get the tasks done.
+
+        Args:
+            task_description (str): task descriptions (possibly generated from previous steps)
+
+        Returns:
+            tuple: (script_filename, results) where script_filename is a generated name for script file and results is the generated codes
+
+        """
+        self.log = []
+        self.log.append(
+            (
+                "user",
+                "Generate Python codes given a task description",
+            )
+        )
+
+        script_filename = self._generate_script_filename(task_description)
+        results = self._generate_code(task_description)
+        return script_filename, self._extract_code_block(results)
+
+    def _extract_code_block(self, s: str) -> str:
+        """
+        Extract the first fenced code block (``` or ```python) from s.
+        """
+        m = re.search(r"```(?:python)?\s*(.+?)\s*```", s, flags=re.DOTALL | re.IGNORECASE)
+        return m.group(1).strip() if m else None

Biomanus/biomni/agent/qa_llm.py

@@ -0,0 +1,50 @@
+from langchain_core.prompts import ChatPromptTemplate
+
+from biomni.llm import get_llm
+
+
+class qa_llm:
+    def __init__(self, path="./data", llm="claude-3-haiku-20240307", lab_bench_reproduce=False):
+        self.path = path
+        self.llm = get_llm(llm)
+
+        if lab_bench_reproduce:
+            self.prompt_modifier = """
+The following is a multiple choice question about biology.
+Please answer by responding with the letter of the correct answer.
+
+Think step by step. \n
+            """
+        else:
+            self.prompt_modifier = ""
+        self.log = []
+
+    def configure(self):
+        pass
+
+    def go(self, input):
+        self.log = []
+        self.log.append(("user", input))
+        message = self.llm.invoke(self.prompt_modifier + input)
+        self.log.append(("assistant", message.content))
+        return [message.content], message.content
+
+    def result_formatting(self, output_class, task_intention):
+        self.format_check_prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    (
+                        "You are evaluateGPT, tasked with extract and parse the task output based on the history of an agent. "
+                        "Review the entire history of messages provided. "
+                        "Here is the task output requirement: \n"
+                        f"'{task_intention.replace('{', '{{').replace('}', '}}')}'.\n"
+                    ),
+                ),
+                ("placeholder", "{messages}"),
+            ]
+        )
+
+        checker_llm = self.format_check_prompt | self.llm.with_structured_output(output_class)
+        result = checker_llm.invoke({"messages": [("user", str(self.log))]}).dict()
+        return result

Biomanus/biomni/agent/react.py

@@ -0,0 +1,465 @@
+import glob
+import inspect
+import json
+import os
+import signal
+from collections.abc import Sequence
+from functools import wraps
+from multiprocessing import Process, Queue
+from typing import Annotated, TypedDict
+
+from langchain_core.messages import BaseMessage, SystemMessage, ToolMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables import RunnableConfig
+from langgraph.graph import END, StateGraph
+from langgraph.graph.message import add_messages
+
+from biomni.config import default_config
+from biomni.env_desc import data_lake_dict, library_content_dict
+from biomni.llm import get_llm
+from biomni.model.retriever import ToolRetriever
+from biomni.tool.tool_registry import ToolRegistry
+from biomni.utils import (
+    api_schema_to_langchain_tool,
+    function_to_api_schema,
+    pretty_print,
+    read_module2api,
+)
+
+
+# Define the AgentState TypedDict for our custom implementation
+class AgentState(TypedDict):
+    """The state of the agent."""
+
+    # add_messages is a reducer that combines message sequences
+    messages: Annotated[Sequence[BaseMessage], add_messages]
+
+
+class react:
+    def __init__(
+        self,
+        path: str | None = None,
+        llm: str | None = None,
+        use_tool_retriever: bool | None = None,
+        timeout_seconds: int | None = None,
+    ):
+        # Use default_config values for unspecified parameters
+        if path is None:
+            path = default_config.path
+        if llm is None:
+            llm = default_config.llm
+        if use_tool_retriever is None:
+            use_tool_retriever = default_config.use_tool_retriever
+        if timeout_seconds is None:
+            timeout_seconds = default_config.timeout_seconds
+
+        self.path = path
+        if not os.path.exists(path):
+            os.makedirs(path)
+            print(f"Created directory: {path}")
+            ### TODO: Download the data
+        else:
+            print(f"Data directory already exists: {path}, loading...")
+
+        module2api = read_module2api()
+
+        self.llm = get_llm(llm, config=default_config)
+        tools = []
+        for module, api_list in module2api.items():
+            print("Registering tools from module:", module)
+            tools += [api_schema_to_langchain_tool(api, mode="custom_tool", module_name=module) for api in api_list]
+        self.tools = tools
+        self.module2api = module2api
+        self.use_tool_retriever = use_tool_retriever
+
+        # Store dictionaries for data lake and library content
+        self.data_lake_dict = data_lake_dict
+        self.library_content_dict = library_content_dict
+
+        if self.use_tool_retriever:
+            self.tool_registry = ToolRegistry(module2api)
+            self.retriever = ToolRetriever()
+
+        self.timeout_seconds = timeout_seconds  # 10 minutes default timeout
+
+        # When wrapping tools with timeout
+        self.tools = self._add_timeout_to_tools(self.tools)
+        self.prompt = ""
+        self.system_prompt = ""
+
+    def _add_timeout_to_tools(self, tools):
+        """Apply timeout wrapper to all tool functions using multiprocessing."""
+
+        def create_timed_func(original_func, timeout):
+            """Factory function that creates a unique timed function for each tool."""
+            tool_name = getattr(original_func, "__name__", "unknown")
+            # print(f"Applying timeout wrapper to tool: {tool_name}")
+
+            def process_func(func, args, kwargs, result_queue):
+                """Function to run in a separate process."""
+                try:
+                    result = func(*args, **kwargs)
+                    result_queue.put(("success", result))
+                except Exception as e:
+                    result_queue.put(("error", str(e)))
+
+            @wraps(original_func)
+            def timed_func(*args, **kwargs):
+                # print(f"Executing tool with timeout: {tool_name}")
+                result_queue = Queue()
+
+                # Start a separate process
+                proc = Process(
+                    target=process_func,
+                    args=(original_func, args, kwargs, result_queue),
+                )
+                proc.start()
+
+                # Wait for the specified timeout
+                proc.join(timeout)
+
+                # Check if the process is still running after timeout
+                if proc.is_alive():
+                    print(f"TIMEOUT: Tool {tool_name} execution timed out after {timeout} seconds")
+                    # Force terminate the process
+                    proc.terminate()
+                    proc.join(1)  # Give it a second to terminate
+
+                    # If it's still not dead, kill it with more force
+                    if proc.is_alive():
+                        os.kill(proc.pid, signal.SIGKILL)
+
+                    return f"ERROR: Tool 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 not result_queue.empty():
+                    status, result = result_queue.get()
+                    if status == "success":
+                        return result
+                    else:
+                        return f"Error in tool execution: {result}"
+
+                return "Error: Tool execution completed but no result was returned"
+
+            return timed_func
+
+        wrapped_tools = []
+        for tool in tools:
+            wrapped_tool = tool
+            wrapped_tool.func = create_timed_func(tool.func, self.timeout_seconds)
+            wrapped_tools.append(wrapped_tool)
+
+        return wrapped_tools
+
+    def add_tool(self, api):
+        function_code = inspect.getsource(api)
+        schema = function_to_api_schema(function_code, self.llm)
+        new_tool = api_schema_to_langchain_tool(schema, mode="custom_tool", module_name=api.__module__)
+
+        # Create a single wrapped tool using the existing _add_timeout_to_tools method
+        wrapped_tools = self._add_timeout_to_tools([new_tool])
+
+        # Get the wrapped tool and add it to our tools list
+        if wrapped_tools:
+            self.tools.append(wrapped_tools[0])
+
+    def configure(
+        self,
+        plan=False,
+        reflect=False,
+        data_lake=False,
+        react_code_search=False,
+        library_access=False,
+    ):
+        data_lake_path = self.path + "/data_lake"
+        data_lake_content = glob.glob(data_lake_path + "/*")
+        data_lake_items = [x.split("/")[-1] for x in data_lake_content]
+
+        if react_code_search:
+            tools = [i for i in self.tools if i.name in ["run_python_repl", "search_google"]]
+
+            prompt_modifier = """
+You are a helpful biomedical assistant assigned with the task of problem-solving.
+
+You have access to two tools:
+1) run_python_repl: to write and run python code
+2) search_google: to search google for information
+
+You can use them to solve the problem.
+            """
+        else:
+            tools = self.tools
+            if (not plan) and (not reflect):
+                prompt_modifier = """You are a helpful biologist and expert geneticist.
+                """
+            elif plan and (not reflect):
+                prompt_modifier = """You are a helpful biologist and expert geneticist.
+                Given the question from the user,
+                - First, come up with a high level plan based on your understanding of the problem and available tools and record it in the Research Plan and Status. You can revise the plan later.
+                - Research Plan and Status should well organized and succinctly keep track of 1) high level plan (can be revised), 2) what steps have been done and what steps are in progress, 3) short results and conclusions of each step after it has been performed. Do not perform action in research plan.
+                - Research Plan and Status must only include progress that has been made by previous steps. It should not include results not directly confirmed by the previous observation.
+                - Follow the plan and try to achieve the goal as straightforwardly as possible. Use tools as necessary.
+                """
+            elif (not plan) and reflect:
+                prompt_modifier = """You are a helpful biologist and expert geneticist.
+                In each round after the tool is used, conduct "reflection" step: reflect on the current state of the problem and the results of the last round. What does the observation mean? If there is an error, what caused the error and how to debug?
+                """
+            else:
+                prompt_modifier = """You are a helpful biologist and expert geneticist.
+                Given the question from the user,
+                - First, come up with a high level plan based on your understanding of the problem and available tools and record it in the Research Plan and Status. You can revise the plan later.
+                - Research Plan and Status should well organized and succinctly keep track of 1) high level plan (can be revised), 2) what steps have been done and what steps are in progress, 3) short results and conclusions of each step after it has been performed. Do not perform action in research plan.
+                - Research Plan and Status must only include progress that has been made by previous steps. It should not include results not directly confirmed by the previous observation.
+                - Follow the plan and try to achieve the goal as straightforwardly as possible. Use tools as necessary.
+                In each round after the tool is used, conduct "reflection" step: reflect on the current state of the problem and the results of the last round. What does the observation mean? If there is an error, what caused the error and how to debug?
+                You have access to write_python_code and run_python_repl tool to write and run your own code if tools fail, or if the given tools are not enough. Please always make sure to write code when dealing with substantial data, including finding the length of long sequences or elements at different positions.
+                """
+
+        if data_lake:
+            # Format data lake items with descriptions
+            data_lake_formatted = []
+            for item in data_lake_items:
+                description = data_lake_dict.get(item, f"Data lake item: {item}")
+                data_lake_formatted.append(f"{item}: {description}")
+
+            prompt_modifier += """
+You can also access a biological data lake at the following path: {data_lake_path}. You can use the run_python_repl tool to write code to understand the data, process and utilize it for the task.
+Here is the list of datasets with their descriptions:
+----
+{data_lake_formatted}
+----
+            """.format(
+                data_lake_path=data_lake_path,
+                data_lake_formatted="\n".join(data_lake_formatted),
+            )
+
+        if library_access:
+            # Format library content with descriptions
+            library_formatted = []
+            for lib_name, lib_desc in library_content_dict.items():
+                library_formatted.append(f"{lib_name}: {lib_desc}")
+
+            prompt_modifier += """
+You also have access to a list of software packages that can be used to perform various tasks.
+You can use the run_python_repl tool to write code to access and utilize the library for the task.
+Don't forget the import statement.
+Here is the list of available libraries with their descriptions:
+----
+{library_formatted}
+----
+            """.format(library_formatted="\n".join(library_formatted))
+
+        print("=" * 25 + "System Prompt" + "=" * 25)
+        print(prompt_modifier)
+        self.system_prompt = prompt_modifier
+        self.prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", prompt_modifier),
+                MessagesPlaceholder(variable_name="messages"),
+            ]
+        )
+
+        # Store the tools for later use
+        self.active_tools = tools
+
+        # Create a custom implementation of the ReAct agent using LangGraph
+        self.app = self._create_custom_react_agent(self.llm, tools, self.prompt)
+
+    def _create_custom_react_agent(self, llm, tools, prompt):
+        """Create a custom ReAct agent using LangGraph."""
+        # Create a dictionary mapping tool names to tool objects for easy lookup
+        tools_by_name = {tool.name: tool for tool in tools}
+
+        # Bind the tools to the language model
+        llm_with_tools = llm.bind_tools(tools)
+
+        # Define the node that calls the model
+        def call_model(state: AgentState, config: RunnableConfig = None):
+            """Node that calls the language model to get the next action."""
+            system_message = SystemMessage(content=self.system_prompt)
+            messages = [system_message] + state["messages"]
+            response = llm_with_tools.invoke(messages, config=config)
+            return {"messages": [response]}
+
+        # Define the node that executes tools
+        def tool_node(state: AgentState):
+            """Node that executes tools based on the LLM's decisions."""
+            outputs = []
+            for tool_call in state["messages"][-1].tool_calls:
+                try:
+                    tool_result = tools_by_name[tool_call["name"]].invoke(tool_call["args"])
+                    outputs.append(
+                        ToolMessage(
+                            content=json.dumps(tool_result),
+                            name=tool_call["name"],
+                            tool_call_id=tool_call["id"],
+                        )
+                    )
+                except Exception as e:
+                    # Handle any errors that occur during tool execution
+                    outputs.append(
+                        ToolMessage(
+                            content=json.dumps({"error": str(e)}),
+                            name=tool_call["name"],
+                            tool_call_id=tool_call["id"],
+                        )
+                    )
+            return {"messages": outputs}
+
+        # Define the conditional edge that determines whether to continue or not
+        def should_continue(state: AgentState):
+            """Determine if we should continue running the graph or finish."""
+            messages = state["messages"]
+            last_message = messages[-1]
+            # If there is no tool call, then we finish
+            if not hasattr(last_message, "tool_calls") or not last_message.tool_calls:
+                return "end"
+            # Otherwise if there is, we continue
+            else:
+                return "continue"
+
+        # Define a new graph
+        workflow = StateGraph(AgentState)
+
+        # Define the two nodes we will cycle between
+        workflow.add_node("agent", call_model)
+        workflow.add_node("tools", tool_node)
+
+        # Set the entrypoint as `agent`
+        workflow.set_entry_point("agent")
+
+        # Add conditional edges
+        workflow.add_conditional_edges(
+            "agent",
+            should_continue,
+            {
+                "continue": "tools",
+                "end": END,
+            },
+        )
+
+        # Add edge from tools back to agent
+        workflow.add_edge("tools", "agent")
+
+        # Compile the graph
+        return workflow.compile()
+
+    def go(self, prompt):
+        """Execute the agent with the given prompt.
+
+        Args:
+            prompt: The user's query
+
+        """
+        if self.use_tool_retriever:
+            # Gather all available tools from the registry
+            all_tools = self.tool_registry.tools if hasattr(self, "tool_registry") else []
+
+            # Get data lake items with descriptions
+            data_lake_path = self.path + "/data_lake"
+            data_lake_content = glob.glob(data_lake_path + "/*")
+            data_lake_items = [x.split("/")[-1] for x in data_lake_content]
+
+            # Create data lake descriptions for retrieval
+            data_lake_descriptions = []
+            for item in data_lake_items:
+                description = self.data_lake_dict.get(item, f"Data lake item: {item}")
+                data_lake_descriptions.append({"name": item, "description": description})
+
+            # Libraries with descriptions
+            library_descriptions = []
+            for lib_name, lib_desc in self.library_content_dict.items():
+                library_descriptions.append({"name": lib_name, "description": lib_desc})
+
+            # Prepare resources for retrieval
+            resources = {
+                "tools": all_tools,
+                "data_lake": data_lake_descriptions,
+                "libraries": library_descriptions,
+            }
+
+            # Use prompt-based retrieval with the agent's LLM
+            selected_resources = self.retriever.prompt_based_retrieval(prompt, resources, llm=self.llm)
+            print("Using prompt-based retrieval with the agent's LLM")
+
+            # If we're using prompt or embedding based retrieval, print the selected resources
+            print("\nSelected tools:")
+            for tool in selected_resources["tools"]:
+                if isinstance(tool, dict):
+                    print(f"- {tool.get('name', 'Unknown')}: {tool.get('description', '')}")
+                else:
+                    print(f"- {getattr(tool, 'name', str(tool))}: {getattr(tool, 'description', '')}")
+
+            print("\nSelected data lake items:")
+            for item in selected_resources["data_lake"]:
+                if isinstance(item, dict):
+                    name = item.get("name", "Unknown")
+                    description = self.data_lake_dict.get(name, f"Data lake item: {name}")
+                    print(f"- {name}: {description}")
+                elif isinstance(item, str) and ": " in item:
+                    # If the item already has a description, print it as is
+                    print(f"- {item}")
+                else:
+                    description = self.data_lake_dict.get(item, f"Data lake item: {item}")
+                    print(f"- {item}: {description}")
+
+            print("\nSelected libraries:")
+            for lib in selected_resources["libraries"]:
+                if isinstance(lib, dict):
+                    print(f"- {lib.get('name', 'Unknown')}: {lib.get('description', '')}")
+                else:
+                    print(f"- {lib}")
+
+            # Convert selected tools to langchain tool objects
+            tool_names = [
+                tool["name"] if isinstance(tool, dict) else getattr(tool, "name", str(tool))
+                for tool in selected_resources["tools"]
+            ]
+            retrieved_list_of_tools = []
+
+            # Get the tool objects by name
+            for tool_name in tool_names:
+                # Find the tool in the original tools list
+                matching_tools = [t for t in self.tools if getattr(t, "name", None) == tool_name]
+                if matching_tools:
+                    retrieved_list_of_tools.append(matching_tools[0])
+
+            # Add back coding tool if not already included
+            if len([i for i in retrieved_list_of_tools if i.name == "run_python_repl"]) == 0:
+                retrieved_list_of_tools = retrieved_list_of_tools + [
+                    i for i in self.tools if i.name == "run_python_repl"
+                ]
+
+            print("Retrieved tools: \n" + "\n".join([l.name + ": " + l.description for l in retrieved_list_of_tools]))
+            # Recreate the custom agent with the retrieved tools
+            self.app = self._create_custom_react_agent(self.llm, retrieved_list_of_tools, self.prompt)
+
+        # Default behavior (no tool retriever or retrieval_method is 'none')
+        config = {"recursion_limit": 50}
+        inputs = {"messages": [("user", prompt)]}
+        self.log = []
+        for s in self.app.stream(inputs, stream_mode="values", config=config):
+            message = s["messages"][-1]
+            out = pretty_print(message)
+            self.log.append(out)
+        return self.log, s["messages"][-1].content
+
+    def result_formatting(self, output_class, task_intention):
+        self.format_check_prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    (
+                        "You are evaluateGPT, tasked with extract and parse the task output based on the history of an agent. "
+                        "Review the entire history of messages provided. "
+                        "Here is the task output requirement: \n"
+                        f"'{task_intention.replace('{', '{{').replace('}', '}}')}'.\n"
+                    ),
+                ),
+                ("placeholder", "{messages}"),
+            ]
+        )
+
+        checker_llm = self.format_check_prompt | self.llm.with_structured_output(output_class)
+        result = checker_llm.invoke({"messages": [("user", str(self.log))]}).dict()
+        return result

Biomanus/biomni/biorxiv_scripts/extract_biorxiv_tasks.py

@@ -0,0 +1,404 @@
+#!/usr/bin/env python3
+"""Script to extract common tasks, databases, and software from bioRxiv papers
+using the PaperTaskExtractor and existing metadata CSV.
+"""
+
+import argparse
+import io
+import json
+import os
+import random
+import sys
+import time
+from typing import Any
+
+import pandas as pd
+import PyPDF2
+import requests
+from tqdm import tqdm
+
+# Add the parent directory to the path so we can import the bioagentos package
+sys.path.append("../../")
+from biomni.agent.env_collection import PaperTaskExtractor
+
+
+def parse_arguments():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Extract tasks from bioRxiv papers in a specific subject area.")
+    parser.add_argument(
+        "--subject",
+        type=str,
+        required=True,
+        help='Subject area to search for papers (e.g., "neuroscience", "bioinformatics")',
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=10,
+        help="Maximum number of papers to process (default: 10)",
+    )
+    parser.add_argument(
+        "--metadata-path",
+        type=str,
+        default="/dfs/user/kexinh/BioAgentOS/data/biorxiv_metadata.csv",
+        help="Path to bioRxiv metadata CSV file (default: data/biorxiv_metadata.csv)",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=None,
+        help="Directory to save results (default: ./biorxiv_results_{subject}_{limit})",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="claude-3-haiku-20240307",
+        help="LLM model to use for extraction (default: claude-3-haiku-20240307)",
+    )
+    parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=4000,
+        help="Chunk size for text processing (default: 4000)",
+    )
+    parser.add_argument(
+        "--chunk-overlap",
+        type=int,
+        default=400,
+        help="Chunk overlap for text processing (default: 400)",
+    )
+    parser.add_argument(
+        "--max-paper-length",
+        type=int,
+        default=200000,
+        help="Maximum paper length in characters (default: 200000)",
+    )
+    parser.add_argument("--save-pdfs", action="store_true", help="Save downloaded PDFs (default: False)")
+    parser.add_argument(
+        "--random-sample",
+        action="store_true",
+        help="Randomly sample papers instead of taking the first N (default: False)",
+    )
+    return parser.parse_args()
+
+
+def load_papers_from_csv(metadata_path: str, subject: str, limit: int, random_sample: bool) -> pd.DataFrame:
+    """Load papers from bioRxiv metadata CSV file.
+
+    Args:
+        metadata_path: Path to the metadata CSV file
+        subject: Subject area to filter by
+        limit: Maximum number of papers to return
+        random_sample: Whether to randomly sample papers
+
+    Returns:
+        DataFrame of filtered papers
+
+    """
+    try:
+        # Load the metadata CSV
+        df_biorxiv = pd.read_csv(metadata_path)
+
+        # Filter published papers in the specified subject
+        if subject.lower() == "all":
+            filtered_df = df_biorxiv[df_biorxiv.published != "NA"]
+        else:
+            filtered_df = df_biorxiv[
+                (df_biorxiv.published != "NA") & (df_biorxiv.category.str.lower() == subject.lower())
+            ]
+
+        # Sample papers
+        if len(filtered_df) > limit:
+            filtered_df = filtered_df.sample(limit, random_state=42) if random_sample else filtered_df.head(limit)
+
+        print(f"Loaded {len(filtered_df)} papers in subject: {subject}")
+        return filtered_df
+
+    except Exception as e:
+        print(f"Error loading papers from CSV: {e}")
+        return pd.DataFrame()
+
+
+def download_pdf(paper_doi: str, save_path: str | None = None) -> str | None:
+    """Download PDF for a given paper DOI.
+
+    Args:
+        paper_doi: DOI of the paper
+        save_path: Path to save the PDF (if None, won't save to disk)
+
+    Returns:
+        PDF text content or None if download failed
+
+    """
+    # Construct PDF URL from DOI
+    pdf_url = f"https://www.biorxiv.org/content/{paper_doi}v1.full.pdf"
+
+    try:
+        # Add random delay to avoid rate limiting
+        time.sleep(random.uniform(1, 3))
+
+        response = requests.get(pdf_url, stream=True)
+        response.raise_for_status()
+
+        # Save PDF if requested
+        if save_path:
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            with open(save_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+
+        # Extract text from PDF
+        pdf_text = extract_text_from_pdf(io.BytesIO(response.content))
+        return pdf_text
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error downloading PDF for {paper_doi}: {e}")
+        return None
+
+
+def extract_text_from_pdf(pdf_file) -> str:
+    """Extract text content from a PDF file.
+
+    Args:
+        pdf_file: File-like object containing PDF data
+
+    Returns:
+        Extracted text content
+
+    """
+    try:
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        text = ""
+        for page_num in range(len(pdf_reader.pages)):
+            page = pdf_reader.pages[page_num]
+            text += page.extract_text() + "\n\n"
+        return text
+    except Exception as e:
+        print(f"Error extracting text from PDF: {e}")
+        return ""
+
+
+def truncate_text(text: str, max_length: int) -> str:
+    """Truncate text to a maximum length while preserving complete sentences.
+
+    Args:
+        text: The text to truncate
+        max_length: Maximum length in characters
+
+    Returns:
+        Truncated text
+
+    """
+    if len(text) <= max_length:
+        return text
+
+    # Find the last sentence boundary before max_length
+    truncated = text[:max_length]
+    last_period = truncated.rfind(".")
+    last_question = truncated.rfind("?")
+    last_exclamation = truncated.rfind("!")
+
+    # Find the last sentence boundary
+    last_boundary = max(last_period, last_question, last_exclamation)
+
+    if last_boundary > 0:
+        return text[: last_boundary + 1]
+    else:
+        # If no sentence boundary found, just truncate at max_length
+        return truncated
+
+
+def process_papers(papers_df: pd.DataFrame, args) -> list[dict[str, Any]]:
+    """Process papers using PaperTaskExtractor.
+
+    Args:
+        papers_df: DataFrame of paper metadata
+        args: Command line arguments
+
+    Returns:
+        List of papers with extracted tasks, databases, and software
+
+    """
+    # Initialize the task extractor
+    extractor = PaperTaskExtractor(llm=args.model, chunk_size=args.chunk_size, chunk_overlap=args.chunk_overlap)
+
+    results = []
+
+    for _, paper in tqdm(papers_df.iterrows(), total=len(papers_df), desc="Processing papers"):
+        paper_doi = paper.get("doi")
+        if not paper_doi:
+            continue
+
+        print(f"\nProcessing paper: {paper.get('title')} (DOI: {paper_doi})")
+
+        # Create paths
+        pdf_path = None
+        if args.save_pdfs:
+            pdf_path = os.path.join(args.output_dir, "pdfs", f"{paper_doi.replace('/', '_')}.pdf")
+
+        result_path = os.path.join(args.output_dir, "results", f"{paper_doi.replace('/', '_')}.json")
+
+        # Skip if already processed
+        if os.path.exists(result_path):
+            print(f"Paper already processed, loading from {result_path}")
+            with open(result_path) as f:
+                paper_result = json.load(f)
+                results.append(paper_result)
+            continue
+
+        # Download and process PDF
+        pdf_text = download_pdf(paper_doi, pdf_path)
+        if not pdf_text:
+            print(f"Failed to download or extract text from {paper_doi}")
+            continue
+
+        # Truncate text if it exceeds max length
+        if len(pdf_text) > args.max_paper_length:
+            original_length = len(pdf_text)
+            pdf_text = truncate_text(pdf_text, args.max_paper_length)
+            print(f"Truncated paper from {original_length} to {len(pdf_text)} characters")
+
+        # Extract tasks, databases, and software
+        try:
+            _, extraction_results = extractor.go(pdf_text)
+
+            # Add paper metadata to results
+            paper_result = {
+                "metadata": {
+                    "doi": paper.get("doi"),
+                    "title": paper.get("title"),
+                    "authors": paper.get("authors", ""),
+                    "abstract": paper.get("abstract", ""),
+                    "date": paper.get("date", ""),
+                    "category": paper.get("category", ""),
+                    "text_length": len(pdf_text),
+                },
+                "extraction": extraction_results,
+            }
+
+            # Save results
+            os.makedirs(os.path.dirname(result_path), exist_ok=True)
+            with open(result_path, "w") as f:
+                json.dump(paper_result, f, indent=2)
+
+            results.append(paper_result)
+
+        except Exception as e:
+            print(f"Error processing paper {paper_doi}: {e}")
+
+    return results
+
+
+def generate_summary(results: list[dict[str, Any]], output_dir: str):
+    """Generate summary of extracted tasks, databases, and software.
+
+    Args:
+        results: List of papers with extraction results
+        output_dir: Directory to save summary
+
+    """
+    # Collect all tasks, databases, and software
+    all_tasks = []
+    all_databases = []
+    all_software = []
+
+    for paper in results:
+        extraction = paper.get("extraction", {})
+
+        # Add paper metadata to each item
+        paper_meta = paper.get("metadata", {})
+        paper_id = f"{paper_meta.get('title')} ({paper_meta.get('doi')})"
+
+        # Process tasks
+        for task in extraction.get("tasks", []):
+            task["paper"] = paper_id
+            all_tasks.append(task)
+
+        # Process databases
+        for db in extraction.get("databases", []):
+            db["paper"] = paper_id
+            all_databases.append(db)
+
+        # Process software
+        for sw in extraction.get("software", []):
+            sw["paper"] = paper_id
+            all_software.append(sw)
+
+    # Create summary dataframes
+    if all_tasks:
+        tasks_df = pd.DataFrame(all_tasks)
+        tasks_df.to_csv(os.path.join(output_dir, "tasks_summary.csv"), index=False)
+
+    if all_databases:
+        db_df = pd.DataFrame(all_databases)
+        db_df.to_csv(os.path.join(output_dir, "databases_summary.csv"), index=False)
+
+    if all_software:
+        sw_df = pd.DataFrame(all_software)
+        sw_df.to_csv(os.path.join(output_dir, "software_summary.csv"), index=False)
+
+    # Generate frequency counts
+    task_counts = {}
+    for task in all_tasks:
+        task_name = task.get("task_name")
+        if task_name:
+            task_counts[task_name] = task_counts.get(task_name, 0) + 1
+
+    db_counts = {}
+    for db in all_databases:
+        db_name = db.get("name")
+        if db_name:
+            db_counts[db_name] = db_counts.get(db_name, 0) + 1
+
+    sw_counts = {}
+    for sw in all_software:
+        sw_name = sw.get("name")
+        if sw_name:
+            sw_counts[sw_name] = sw_counts.get(sw_name, 0) + 1
+
+    # Save frequency counts
+    with open(os.path.join(output_dir, "frequency_summary.json"), "w") as f:
+        json.dump(
+            {"tasks": task_counts, "databases": db_counts, "software": sw_counts},
+            f,
+            indent=2,
+        )
+
+    print(f"Summary files saved to {output_dir}")
+
+
+def main():
+    """Main function to run the script."""
+    args = parse_arguments()
+
+    # Set default output directory if not specified
+    if args.output_dir is None:
+        # Clean subject name for directory name (replace spaces with underscores, lowercase)
+        clean_subject = args.subject.lower().replace(" ", "_").replace("/", "_")
+        args.output_dir = f"./biorxiv_results_{clean_subject}_{args.limit}"
+
+    # Create output directories
+    os.makedirs(args.output_dir, exist_ok=True)
+    os.makedirs(os.path.join(args.output_dir, "results"), exist_ok=True)
+    if args.save_pdfs:
+        os.makedirs(os.path.join(args.output_dir, "pdfs"), exist_ok=True)
+
+    # Load papers from CSV
+    print(f"Loading papers from {args.metadata_path} in subject area: {args.subject}")
+    papers_df = load_papers_from_csv(args.metadata_path, args.subject, args.limit, args.random_sample)
+
+    if len(papers_df) == 0:
+        print(f"No papers found for subject: {args.subject}")
+        return
+
+    # Process papers
+    results = process_papers(papers_df, args)
+
+    # Generate summary
+    generate_summary(results, args.output_dir)
+
+    print("Done!")
+
+
+if __name__ == "__main__":
+    main()

Biomanus/biomni/biorxiv_scripts/generate_function.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Command-line tool to generate Python functions from task descriptions using the function_generator agent."""
+
+import argparse
+import json
+import os
+
+from biomni.agent.function_generator import FunctionGenerator
+from tqdm import tqdm
+
+
+def main():
+    """Main function for the command-line tool."""
+    parser = argparse.ArgumentParser(description="Generate Python functions given task descriptions")
+    parser.add_argument(
+        "--task",
+        "-t",
+        type=str,
+        help="JSON file containing a list of task descriptions",
+    )
+    parser.add_argument(
+        "--output-dir",
+        "-o",
+        type=str,
+        default="generated_functions",
+        help="Directory to save the generated functions (default: generated_functions)",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        default="claude-3-7-sonnet-latest",
+        help="LLM model to use (default: claude-3-7-sonnet-latest)",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.7,
+        help="Temperature setting for the LLM (default: 0.7)",
+    )
+
+    args = parser.parse_args()
+
+    with open(args.task) as f_tasks:
+        task_list = json.load(f_tasks)
+        task_descriptions = list(task_list["tasks"])
+
+    # Create the output directory if it doesn't exist
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Initialize the function generator agent
+    function_generator = FunctionGenerator(llm=args.model, temperature=args.temperature)
+
+    if not task_list:
+        print("No tasks found.")
+    else:
+        # tqdm shows a progress bar, file names as description
+        for _i, desc in enumerate(tqdm(task_descriptions, desc="Generating Python scripts given task descriptions"), 1):
+            generated_script_name, generated_codes = function_generator.go(desc)
+
+            # Save results
+            result_path = os.path.join(args.output_dir, generated_script_name)
+
+            os.makedirs(os.path.dirname(result_path), exist_ok=True)
+            with open(result_path, "w") as f:
+                f.write(generated_codes)
+
+        print("DONE")
+
+
+if __name__ == "__main__":
+    main()

Biomanus/biomni/biorxiv_scripts/process_all_subjects.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""Script to process all bioRxiv subjects and extract computational tasks from the top 100 papers in each."""
+
+import argparse
+import os
+import subprocess
+import sys
+import time
+
+import pandas as pd
+from tqdm import tqdm
+
+# Add the parent directory to the path so we can import the bioagentos package
+sys.path.append("/dfs/user/kexinh/BioAgentOS/")
+
+# List of all bioRxiv subjects
+BIORXIV_SUBJECTS = [
+    "evolutionary biology",
+    "ecology",
+    "neuroscience",
+    "developmental biology",
+    "plant biology",
+    "microbiology",
+    "cancer biology",
+    "immunology",
+    "cell biology",
+    "biochemistry",
+    "genetics",
+    "bioinformatics",
+    "animal behavior and cognition",
+    "biophysics",
+    "genomics",
+    "systems biology",
+    "bioengineering",
+    "molecular biology",
+    "physiology",
+    "zoology",
+    "scientific communication and education",
+    "pathology",
+    "synthetic biology",
+    "paleontology",
+    "pharmacology and toxicology",
+]
+
+
+def parse_arguments():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Process all bioRxiv subjects and extract tasks from papers.")
+    parser.add_argument(
+        "--papers-per-subject",
+        type=int,
+        default=100,
+        help="Number of papers to process per subject (default: 100)",
+    )
+    parser.add_argument(
+        "--metadata-path",
+        type=str,
+        default="/dfs/user/kexinh/BioAgentOS/data/biorxiv_metadata.csv",
+        help="Path to bioRxiv metadata CSV file (default: data/biorxiv_metadata.csv)",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default="./biorxiv_all_subjects",
+        help="Base directory to save results (default: ./biorxiv_all_subjects)",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="claude-3-haiku-20240307",
+        help="LLM model to use for extraction (default: claude-3-haiku-20240307)",
+    )
+    parser.add_argument(
+        "--max-paper-length",
+        type=int,
+        default=200000,
+        help="Maximum paper length in characters (default: 200000)",
+    )
+    parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=10000,
+        help="Chunk size for text processing (default: 10000)",
+    )
+    parser.add_argument(
+        "--chunk-overlap",
+        type=int,
+        default=400,
+        help="Chunk overlap for text processing (default: 400)",
+    )
+    parser.add_argument("--save-pdfs", action="store_true", help="Save downloaded PDFs (default: False)")
+    parser.add_argument(
+        "--random-sample",
+        action="store_true",
+        help="Randomly sample papers instead of taking the first N (default: False)",
+    )
+    parser.add_argument(
+        "--subjects",
+        type=str,
+        nargs="+",
+        help="Specific subjects to process (default: all subjects)",
+    )
+    parser.add_argument(
+        "--delay",
+        type=int,
+        default=60,
+        help="Delay in seconds between processing subjects (default: 60)",
+    )
+    parser.add_argument(
+        "--summary-only",
+        action="store_true",
+        help="Only generate the combined summary (default: False)",
+    )
+    return parser.parse_args()
+
+
+def check_subject_availability(metadata_path, subjects):
+    """Check which subjects have papers available in the metadata.
+
+    Args:
+        metadata_path: Path to the metadata CSV file
+        subjects: List of subjects to check
+
+    Returns:
+        List of subjects with available papers
+
+    """
+    try:
+        df_biorxiv = pd.read_csv(metadata_path)
+        available_subjects = []
+
+        for subject in subjects:
+            count = len(
+                df_biorxiv[(df_biorxiv.published != "NA") & (df_biorxiv.category.str.lower() == subject.lower())]
+            )
+            if count > 0:
+                available_subjects.append((subject, count))
+                print(f"Subject '{subject}' has {count} papers available")
+            else:
+                print(f"Subject '{subject}' has no papers available")
+
+        return available_subjects
+    except Exception as e:
+        print(f"Error checking subject availability: {e}")
+        return []
+
+
+def process_subject(subject, args):
+    """Process a single subject by calling the extract_biorxiv_tasks.py script.
+
+    Args:
+        subject: Subject to process
+        args: Command line arguments
+
+    """
+    # Clean subject name for command line
+    subject.replace(" ", "\\ ")
+
+    # Build command
+    cmd = [
+        "python",
+        "BioAgentOS/bioagentos/scripts/extract_biorxiv_tasks.py",
+        "--subject",
+        f'"{subject}"',
+        "--limit",
+        str(args.papers_per_subject),
+        "--metadata-path",
+        args.metadata_path,
+        "--model",
+        args.model,
+        "--max-paper-length",
+        str(args.max_paper_length),
+        "--chunk-size",
+        str(args.chunk_size),
+        "--chunk-overlap",
+        str(args.chunk_overlap),
+    ]
+
+    # Add optional arguments
+    if args.save_pdfs:
+        cmd.append("--save-pdfs")
+    if args.random_sample:
+        cmd.append("--random-sample")
+
+    # Convert command list to string
+    cmd_str = " ".join(cmd)
+
+    print(f"\n{'=' * 80}\nProcessing subject: {subject}\n{'=' * 80}")
+    print(f"Running command: {cmd_str}")
+
+    # Execute command
+    try:
+        subprocess.run(cmd_str, shell=True, check=True)
+        print(f"Successfully processed subject: {subject}")
+    except subprocess.CalledProcessError as e:
+        print(f"Error processing subject '{subject}': {e}")
+
+
+def combine_summaries(base_dir, subjects, papers_per_subject):
+    """Combine frequency summaries from all subjects into a single summary.
+
+    Args:
+        base_dir: Base directory containing subject results
+        subjects: List of subjects that were processed
+        papers_per_subject: Number of papers processed per subject
+
+    """
+    all_tasks = {}
+    all_databases = {}
+    all_software = {}
+
+    for subject, _ in subjects:
+        # Clean subject name for directory name
+        clean_subject = subject.lower().replace(" ", "_").replace("/", "_")
+        subject_dir = f"biorxiv_results_{clean_subject}_{papers_per_subject}"
+        summary_path = os.path.join(subject_dir, "frequency_summary.json")
+
+        try:
+            if os.path.exists(summary_path):
+                with open(summary_path) as f:
+                    summary = json.load(f)
+
+                    # Merge tasks
+                    for task, count in summary.get("tasks", {}).items():
+                        if task in all_tasks:
+                            all_tasks[task] += count
+                        else:
+                            all_tasks[task] = count
+
+                    # Merge databases
+                    for db, count in summary.get("databases", {}).items():
+                        if db in all_databases:
+                            all_databases[db] += count
+                        else:
+                            all_databases[db] = count
+
+                    # Merge software
+                    for sw, count in summary.get("software", {}).items():
+                        if sw in all_software:
+                            all_software[sw] += count
+                        else:
+                            all_software[sw] = count
+            else:
+                print(f"Warning: Summary file not found for subject '{subject}'")
+        except Exception as e:
+            print(f"Error processing summary for subject '{subject}': {e}")
+
+    # Sort by frequency (descending)
+    all_tasks = dict(sorted(all_tasks.items(), key=lambda item: item[1], reverse=True))
+    all_databases = dict(sorted(all_databases.items(), key=lambda item: item[1], reverse=True))
+    all_software = dict(sorted(all_software.items(), key=lambda item: item[1], reverse=True))
+
+    # Create combined summary
+    combined_summary = {
+        "tasks": all_tasks,
+        "databases": all_databases,
+        "software": all_software,
+    }
+
+    # Save combined summary
+    combined_path = os.path.join(base_dir, "combined_summary.json")
+    os.makedirs(base_dir, exist_ok=True)
+
+    with open(combined_path, "w") as f:
+        json.dump(combined_summary, f, indent=2)
+
+    print(f"Combined summary saved to {combined_path}")
+
+    # Create CSV files for each category
+    tasks_df = pd.DataFrame(list(all_tasks.items()), columns=["Task", "Frequency"])
+    tasks_df.to_csv(os.path.join(base_dir, "tasks_frequency.csv"), index=False)
+
+    db_df = pd.DataFrame(list(all_databases.items()), columns=["Database", "Frequency"])
+    db_df.to_csv(os.path.join(base_dir, "databases_frequency.csv"), index=False)
+
+    sw_df = pd.DataFrame(list(all_software.items()), columns=["Software", "Frequency"])
+    sw_df.to_csv(os.path.join(base_dir, "software_frequency.csv"), index=False)
+
+    print(f"CSV summaries saved to {base_dir}")
+
+
+def main():
+    """Main function to run the script."""
+    args = parse_arguments()
+
+    # Determine which subjects to process
+    subjects_to_process = args.subjects if args.subjects else BIORXIV_SUBJECTS
+
+    # Check which subjects have papers available
+    available_subjects = check_subject_availability(args.metadata_path, subjects_to_process)
+
+    if not available_subjects:
+        print("No subjects with available papers found. Exiting.")
+        return
+
+    if not args.summary_only:
+        # Process each subject
+        for subject, _count in tqdm(available_subjects, desc="Processing subjects"):
+            process_subject(subject, args)
+
+            # Add delay between subjects to avoid rate limiting
+            if args.delay > 0:
+                print(f"Waiting {args.delay} seconds before processing the next subject...")
+                time.sleep(args.delay)
+
+    # Combine summaries from all subjects
+    combine_summaries(args.output_dir, available_subjects, args.papers_per_subject)
+
+    print("All subjects processed successfully!")
+
+
+if __name__ == "__main__":
+    import json  # Import here to avoid circular import with the main script
+
+    main()