Claude's Corner: CellType — Teaching LLMs to Speak Biology

# Build Guide: Cloning CellType with Claude Code

**Goal:** Build a minimal agentic drug discovery platform that uses LLMs to predict drug responses from single-cell gene expression data.

**Estimated time:** 4-6 weeks solo with Claude Code assistance
**Cost to get running:** ~$2,000-$10,000 (GPU compute for training, data access)

---

## Step 1: Data Pipeline — Acquire and Process scRNA-seq Data

**What you need:** Single-cell RNA sequencing datasets with drug perturbation labels.

- Download the **LINCS L1000** dataset (gene expression after drug perturbation across 978 landmark genes) from lincsproject.org — free, ~100GB
- Optionally supplement with **CELLxGENE** (cellxgene.cziscience.com) for diverse cell types
- Write a Cell2Sentence tokenizer:

```python
def cell_to_sentence(gene_expression_vector: dict[str, float], top_n: int = 200) -> str:
    """Convert a gene expression profile to a ranked gene sentence."""
    ranked = sorted(gene_expression_vector.items(), key=lambda x: x[1], reverse=True)
    return " ".join(gene for gene, _ in ranked[:top_n])
```

- Output format: `cell_id | cell_type | drug | dose | cell_sentence`
- Target corpus: 10M+ cell sentences minimum for meaningful training signal

**DB schema (PostgreSQL):**
```sql
CREATE TABLE cells (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  cell_type TEXT NOT NULL,
  tissue TEXT,
  disease_state TEXT,
  cell_sentence TEXT NOT NULL,  -- ranked gene names
  metadata JSONB
);

CREATE TABLE drug_perturbations (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  cell_id UUID REFERENCES cells(id),
  drug_name TEXT NOT NULL,
  smiles TEXT,                    -- molecular structure
  dose_nm FLOAT,
  perturbed_sentence TEXT NOT NULL,  -- cell sentence post-treatment
  delta_genes JSONB               -- genes that shifted significantly
);
```

---

## Step 2: Fine-Tune an LLM on Cell Sentences

**Start small:** Use Gemma 7B (not 27B) to validate the approach before spending on compute.

- Use HuggingFace `transformers` + `trl` library for SFT (Supervised Fine-Tuning)
- Training objective: next-token prediction on cell sentences (standard causal LM)
- Key training tasks to include:
  1. **Cell type prediction**: Given cell sentence → predict cell type label
  2. **Drug response prediction**: Given cell sentence + drug → predict perturbed sentence
  3. **Q&A pairs**: "Is this cell cancerous?" / "What drug would activate antigen presentation?"

```python
# Fine-tuning config (QLoRA for memory efficiency)
from trl import SFTTrainer
from peft import LoraConfig

lora_config = LoraConfig(r=64, lora_alpha=128, target_modules=["q_proj", "v_proj"])
trainer = SFTTrainer(
    model="google/gemma-7b",
    train_dataset=cell_sentence_dataset,
    peft_config=lora_config,
    dataset_text_field="text",
    max_seq_length=512,
)
trainer.train()
```

- **Compute budget:** 7B model × 10M samples ≈ 4× A100 × ~48h ≈ ~$800 on Lambda Labs
- Checkpoint frequently; evaluate on held-out drug perturbations

---

## Step 3: Build the Drug Response Prediction API

Wrap the fine-tuned model in a FastAPI service that pharma researchers can query.

```python
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class PredictionRequest(BaseModel):
    cell_sentence: str      # pre-treatment cell state
    drug_smiles: str        # molecular structure
    question: str           # "Will this enhance antigen presentation?"

@app.post("/predict")
async def predict_drug_response(req: PredictionRequest):
    prompt = f"""Cell state: {req.cell_sentence}
Drug: {req.drug_smiles}
Question: {req.question}
Answer:"""
    response = model.generate(prompt, max_new_tokens=200)
    return {"prediction": response, "confidence": extract_confidence(response)}
```

- Add a `/screen` endpoint that accepts a list of drug SMILES and a target cell state, returns ranked candidates
- Cache common cell state + drug combinations in Redis
- Rate-limit by API key; each pharma customer gets a key

---

## Step 4: Build the Agentic Discovery Pipeline

Chain multiple prediction steps into an autonomous workflow using LangGraph.

```python
from langgraph.graph import StateGraph

def build_discovery_pipeline():
    graph = StateGraph(DiscoveryState)
    
    # Node 1: Load disease cell state from DB
    graph.add_node("load_disease_state", load_patient_cell_profile)
    
    # Node 2: Screen compound library (top 1000 candidates by embedding similarity)
    graph.add_node("screen_compounds", screen_compound_library)
    
    # Node 3: Predict top-20 responses in detail
    graph.add_node("predict_responses", predict_drug_responses)
    
    # Node 4: Filter by toxicity / off-target predictions
    graph.add_node("filter_toxicity", run_toxicity_screen)
    
    # Node 5: Generate hypothesis report
    graph.add_node("generate_report", generate_scientific_report)
    
    graph.set_entry_point("load_disease_state")
    graph.add_edge("load_disease_state", "screen_compounds")
    graph.add_edge("screen_compounds", "predict_responses")
    graph.add_edge("predict_responses", "filter_toxicity")
    graph.add_edge("filter_toxicity", "generate_report")
    
    return graph.compile()
```

- Run pipelines as background jobs (Celery + Redis); pharma teams submit jobs and get email/webhook when done
- Store all pipeline runs, inputs, and outputs for reproducibility

---

## Step 5: Build the Pharma Researcher Dashboard (Next.js)

Simple but useful — researchers need to submit jobs, browse results, and export reports.

**Key pages:**
1. **Job submission** — upload a target cell profile (CSV scRNA-seq), select a compound library, set the question
2. **Results viewer** — ranked compound list, per-compound predicted response, confidence scores, downloadable report
3. **Compound explorer** — search your compound library, view molecular structure (using RDKit), see historical predictions

```typescript
// Example: Job submission form
interface DiscoveryJob {
  diseaseState: File;      // scRNA-seq CSV
  compoundLibrary: string; // "FDA-approved" | "custom" | user upload
  targetQuestion: string;  // free text
  notifyEmail: string;
}
```

- Auth: NextAuth with Google OAuth (pharma IT will insist on SSO — add SAML next)
- Deploy on Vercel; keep the UI fast, pharma researchers are not patient

---

## Step 6: Database Schema and Experiment Tracking

Track every prediction for reproducibility and model improvement.

```sql
-- Core tables
CREATE TABLE experiments (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  org_id UUID NOT NULL,
  disease_state JSONB NOT NULL,
  compound_library TEXT NOT NULL,
  target_question TEXT NOT NULL,
  status TEXT DEFAULT 'queued',  -- queued | running | complete | failed
  submitted_at TIMESTAMPTZ DEFAULT now(),
  completed_at TIMESTAMPTZ,
  result_summary JSONB
);

CREATE TABLE compound_predictions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  experiment_id UUID REFERENCES experiments(id),
  compound_smiles TEXT NOT NULL,
  compound_name TEXT,
  predicted_response TEXT NOT NULL,
  confidence_score FLOAT,
  rank_in_experiment INT,
  model_version TEXT NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- For learning: track which predictions got wet-lab validation
CREATE TABLE wet_lab_validations (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  compound_prediction_id UUID REFERENCES compound_predictions(id),
  validated_by TEXT,
  outcome TEXT,  -- 'confirmed' | 'refuted' | 'partial'
  effect_size FLOAT,
  notes TEXT,
  validated_at TIMESTAMPTZ
);
```

- Feed confirmed validations back into the training pipeline to continuously improve the model
- This is the flywheel: more predictions → more validations → better model → more pharma customers

---

## Step 7: Deployment — GPU Infrastructure and Scale

Serving a 7B+ model in production requires attention to cost and latency.

**Inference serving:**
- Use **Modal** (modal.com) for on-demand GPU inference — you pay per second, cold starts in ~30s
- For high-traffic: deploy on A10G instances behind a load balancer
- Model quantization: INT8 via bitsandbytes cuts GPU memory in half with <2% accuracy loss

```python
import modal

app = modal.App("celltype-inference")

@app.function(gpu="A10G", memory=40960)
def predict(cell_sentence: str, drug: str, question: str) -> str:
    model = load_model_from_volume()  # cached on Modal Volume
    return run_inference(model, cell_sentence, drug, question)
```

**Monitoring:**
- Log every inference call with model version, latency, and output length
- Track prediction confidence distributions over time — drift means your biology data has shifted
- Set up alerts if pipeline jobs fail > 5% of the time

**Cost at scale:**
- 1,000 pharma predictions/day on A10G ≈ ~$50/day inference cost
- Justifiable at $500-$5,000/experiment pharma pricing

**The wet-lab validation loop:**
- Partner with a CRO (contract research organization) or academic lab early
- Even one validated prediction per quarter is worth more than 1,000 unvalidated ones
- Document the validation pipeline rigorously — pharma due diligence will ask for it