robin

To run the standard scientific discovery pipeline as described in the research:

1. Launch Jupyter: Navigate to the robin directory and run jupyter notebook or jupyter lab.
2. Open the Notebook: Open robin_demo.ipynb.
3. Configure: Locate the RobinConfiguration cell and set your disease_name and (optionally) API keys.
4. Execute: Run the cells sequentially to perform:
   • Experimental Assay Generation: Generates and ranks potential assays.
   • Therapeutic Candidate Generation: Generates and ranks candidates based on the top assay.
   • Experimental Data Analysis (Optional): If you have experimental data, this step uses the Edison platform to analyze it and refine candidate generation.

To install Robin directly in your local environment:

1. Clone the repository:

   git clone https://github.com/Future-House/robin.git
   cd robin

2. Create and activate a virtual environment: Using uv (recommended):

   uv venv .venv
   source .venv/bin/activate

   Or using standard venv:

   python3 -m venv .robin_env
   source .robin_env/bin/activate

3. Install dependencies: Install the base package and development dependencies (including Jupyter):

   uv pip install -e '.[dev]'
   # OR
   pip install -e '.[dev]'

4. Set API Keys:

   cp .env.example .env
   # Edit .env with your actual keys

Docker is the recommended approach to avoid OS-level dependency conflicts.

1. Build the image:

   docker build -t robin .

2. Set up API keys: Copy the example env file:

   cp .env.example .env

   Edit .env and fill in EDISON_API_KEY and OPENAI_API_KEY. CRITICAL: Do not wrap values in quotes (e.g., use OPENAI_API_KEY=sk-abc123, NOT OPENAI_API_KEY="sk-abc123").

3. Run Jupyter:

   docker run -p 8888:8888 --env-file .env robin

   Use the URL provided in the logs that starts with http://127.0.0.1:8888/.

When the experimental_insights dictionary is passed to therapeutic_candidates, the pipeline modifies its behavior in several ways:

1. Prompt Augmentation: The system messages for query generation and candidate proposal are appended with additional context derived from the insights (analysis_summary, mechanistic_insights, and questions_raised).
2. File Pathing: Output files are saved to directories or with filenames containing the _experimental suffix (e.g., therapeutic_candidates_summary_experimental.txt instead of therapeutic_candidates_summary.txt).
3. Literature Review Storage: Literature review results are saved to .../therapeutic_candidate_literature_reviews_experimental instead of .../therapeutic_candidate_literature_reviews.

The system generates novel, testable drug candidates for a {disease_name}.

1. Candidate Query Generation

Generates {double_queries} research queries to investigate:

• Target Validation: Pathway dysregulation.
• Efficacy in Relevant Models: Evidence in cell/animal models.
• Mechanism Confirmation: Engagement of the target.
• Pharmacokinetics/Safety: ADME and safety profiles.

2. Candidate Generation

Generates {num_candidates} proposals. Output Format: A text block where each proposal is wrapped in <CANDIDATE START> and <CANDIDATE END> tags. Each block must contain:

• CANDIDATE: The specific single-agent drug/therapeutic (including catalog numbers if applicable).
• HYPOTHESIS: A mechanistic hypothesis of how it treats the disease.
• REASONING: Detailed scientific rationale, evidence, and novelty.

Generating therapeutic hypotheses using experimental data requires access to the Finch data analysis agent.

Note: As of the current documentation, Finch is in a closed beta. You must sign up to be a beta tester at bit.ly/finchbeta to use this specific capability.

To initialize Robin, create a RobinConfiguration object by specifying a disease_name. This configuration object is then passed to various Robin modules to define the scope of the scientific discovery task.

It is also recommended to set up a logger named robin with the level logging.INFO to monitor the multi-agent system's progress.

from robin.configuration import RobinConfiguration
import logging

config = RobinConfiguration(disease_name="dry age-related macular degeneration")

logger = logging.getLogger("robin")
logger.setLevel(logging.INFO)

To initialize Robin, create a RobinConfiguration object specifying the target disease and the scale of the discovery process. You must also define the number of assays, candidates, and queries to be generated.

Key configuration parameters:

• disease_name: The target condition (e.g., "Non-alcoholic Steatohepatitis").
• num_assays: The number of experimental assays to generate.
• num_candidates: The number of therapeutic candidates to generate.
• num_queries: The number of queries to perform.

from robin.configuration import RobinConfiguration

config = RobinConfiguration(
    disease_name="Non-alcoholic Steatohepatitis",
    num_assays=10,
    num_candidates=30,
    num_queries=5,
)

A standard drug repurposing workflow in Robin follows a two-step asynchronous process:

1. Experimental Assay Generation: Generate assay goals using experimental_assay.
2. Therapeutic Candidate Generation: Use the output from the first step to generate candidates using therapeutic_candidates.

This sequence allows the system to first determine how to test for biological effects before identifying the specific molecules to test.

# 1. Setup
config = RobinConfiguration(disease_name="CKD", num_assays=10, num_candidates=30, num_queries=5)

# 2. Generate Assays
candidate_generation_goal = await experimental_assay(configuration=config)

# 3. Generate Candidates
await therapeutic_candidates(
    candidate_generation_goal=candidate_generation_goal, 
    configuration=config
)