Building Research Agents with Claude Agent SDK

// biotech-agent.js
import { Agent } from '@anthropic-ai/claude-agent-sdk';
import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

const agent = new Agent({
  name: 'biotech-researcher',
  model: 'claude-3-5-sonnet-20241022',
  systemPrompt: `You are a biotech research assistant specializing in drug discovery, 
protein analysis, and experimental design. You help researchers by:

1. Searching scientific literature and databases
2. Analyzing experimental data
3. Managing protocols and experimental records
4. Generating research reports and documentation

You have access to scientific databases, analysis tools, and can write code to 
process data and generate visualizations.`,
  
  tools: [
    // Tools will be defined below
  ],
  
  // Enable file system access
  allowFileSystem: true,
  
  // Enable bash commands
  allowBash: true,
});

// tools/literature-search.js
import axios from 'axios';

export const literatureSearchTool = {
  name: 'search_literature',
  description: 'Search scientific literature from PubMed, bioRxiv, and other sources',
  parameters: {
    type: 'object',
    properties: {
      query: {
        type: 'string',
        description: 'Search query (e.g., "protein kinase inhibitors", "CRISPR gene editing")'
      },
      database: {
        type: 'string',
        enum: ['pubmed', 'biorxiv', 'arxiv'],
        description: 'Database to search'
      },
      max_results: {
        type: 'number',
        description: 'Maximum number of results to return',
        default: 10
      }
    },
    required: ['query']
  },
  execute: async ({ query, database = 'pubmed', max_results = 10 }) => {
    try {
      if (database === 'pubmed') {
        // Search PubMed via NCBI E-utilities
        const response = await axios.get('https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi', {
          params: {
            db: 'pubmed',
            term: query,
            retmax: max_results,
            retmode: 'json'
          }
        });
        
        const pmids = response.data.esearchresult.idlist;
        
        // Fetch abstracts
        const fetchResponse = await axios.get('https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi', {
          params: {
            db: 'pubmed',
            id: pmids.join(','),
            retmode: 'xml'
          }
        });
        
        return {
          success: true,
          results: pmids.map((pmid, index) => ({
            pmid,
            title: `Paper ${index + 1}`,
            abstract: 'Abstract text...' // Parse from XML
          })),
          count: pmids.length
        };
      }
      
      // Add other database searches (bioRxiv, etc.)
      return { success: false, error: 'Database not implemented' };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }
};

// tools/protein-search.js
export const proteinSearchTool = {
  name: 'search_protein',
  description: 'Search protein databases (UniProt, PDB) for protein information',
  parameters: {
    type: 'object',
    properties: {
      protein_id: {
        type: 'string',
        description: 'Protein ID (UniProt ID, PDB ID, or gene name)'
      },
      database: {
        type: 'string',
        enum: ['uniprot', 'pdb', 'ncbi'],
        description: 'Database to search'
      }
    },
    required: ['protein_id']
  },
  execute: async ({ protein_id, database = 'uniprot' }) => {
    try {
      if (database === 'uniprot') {
        const response = await axios.get(`https://www.uniprot.org/uniprot/${protein_id}.json`);
        
        return {
          success: true,
          protein: {
            id: response.data.primaryAccession,
            name: response.data.proteinDescription?.recommendedName?.fullName?.value,
            sequence: response.data.sequence?.value,
            function: response.data.comments?.find(c => c.type === 'FUNCTION')?.texts?.[0]?.value,
            domains: response.data.features?.filter(f => f.type === 'domain')?.map(d => ({
              name: d.description,
              start: d.location.start.value,
              end: d.location.end.value
            }))
          }
        };
      }
      
      if (database === 'pdb') {
        const response = await axios.get(`https://data.rcsb.org/rest/v1/core/entry/${protein_id}`);
        return {
          success: true,
          structure: {
            id: response.data.id,
            title: response.data.struct?.title,
            resolution: response.data.rcsb_entry_info?.resolution_combined?.[0]
          }
        };
      }
      
      return { success: false, error: 'Database not implemented' };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }
};

// tools/data-analysis.js
export const dataAnalysisTool = {
  name: 'analyze_experimental_data',
  description: 'Analyze experimental data from assays, generate statistics, and create visualizations',
  parameters: {
    type: 'object',
    properties: {
      data_file: {
        type: 'string',
        description: 'Path to data file (CSV, Excel, or JSON)'
      },
      analysis_type: {
        type: 'string',
        enum: ['dose_response', 'binding_affinity', 'time_series', 'comparative'],
        description: 'Type of analysis to perform'
      },
      output_format: {
        type: 'string',
        enum: ['summary', 'plot', 'table'],
        description: 'Desired output format'
      }
    },
    required: ['data_file', 'analysis_type']
  },
  execute: async ({ data_file, analysis_type, output_format = 'summary' }) => {
    // Agent will write Python code to analyze the data
    // This tool provides the interface, actual analysis happens via code generation
    return {
      success: true,
      message: 'Analysis will be performed via generated Python code',
      data_file,
      analysis_type
    };
  }
};

// tools/protocol-manager.js
import fs from 'fs/promises';
import path from 'path';

export const protocolManagerTool = {
  name: 'manage_protocol',
  description: 'Create, update, or retrieve lab protocols',
  parameters: {
    type: 'object',
    properties: {
      action: {
        type: 'string',
        enum: ['create', 'update', 'retrieve', 'list'],
        description: 'Action to perform'
      },
      protocol_name: {
        type: 'string',
        description: 'Name of the protocol'
      },
      protocol_content: {
        type: 'string',
        description: 'Protocol content (for create/update)'
      }
    },
    required: ['action']
  },
  execute: async ({ action, protocol_name, protocol_content }) => {
    const protocolsDir = path.join(process.cwd(), 'protocols');
    
    try {
      await fs.mkdir(protocolsDir, { recursive: true });
      
      if (action === 'create' || action === 'update') {
        if (!protocol_name || !protocol_content) {
          return { success: false, error: 'Protocol name and content required' };
        }
        
        const filePath = path.join(protocolsDir, `${protocol_name}.md`);
        await fs.writeFile(filePath, protocol_content);
        
        return {
          success: true,
          message: `Protocol ${action}d successfully`,
          path: filePath
        };
      }
      
      if (action === 'retrieve') {
        if (!protocol_name) {
          return { success: false, error: 'Protocol name required' };
        }
        
        const filePath = path.join(protocolsDir, `${protocol_name}.md`);
        const content = await fs.readFile(filePath, 'utf-8');
        
        return {
          success: true,
          protocol_name,
          content
        };
      }
      
      if (action === 'list') {
        const files = await fs.readdir(protocolsDir);
        const protocols = files.filter(f => f.endsWith('.md'));
        
        return {
          success: true,
          protocols: protocols.map(p => p.replace('.md', ''))
        };
      }
      
      return { success: false, error: 'Invalid action' };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }
};

// biotech-agent.js
import { Agent } from '@anthropic-ai/claude-agent-sdk';
import { literatureSearchTool } from './tools/literature-search.js';
import { proteinSearchTool } from './tools/protein-search.js';
import { dataAnalysisTool } from './tools/data-analysis.js';
import { protocolManagerTool } from './tools/protocol-manager.js';

const agent = new Agent({
  name: 'biotech-researcher',
  model: 'claude-3-5-sonnet-20241022',
  systemPrompt: `You are a biotech research assistant with expertise in:

- Drug discovery and development
- Protein structure and function analysis
- Experimental design and data analysis
- Scientific literature review
- Protocol management and compliance

When working with researchers:
1. Always verify data sources and cite references
2. Ensure protocols comply with regulatory requirements
3. Maintain accurate experimental records
4. Generate clear, reproducible analyses

You have access to:
- Scientific databases (PubMed, UniProt, PDB)
- Data analysis capabilities (Python, R)
- Protocol management system
- File system for organizing research data`,
  
  tools: [
    literatureSearchTool,
    proteinSearchTool,
    dataAnalysisTool,
    protocolManagerTool
  ],
  
  allowFileSystem: true,
  allowBash: true,
});

// Run the agent
async function main() {
  const query = process.argv[2] || "Search for recent papers on kinase inhibitors";
  
  const response = await agent.run(query);
  console.log(response);
}

main().catch(console.error);

// The agent can spawn subagents for parallel tasks
const agent = new Agent({
  // ... configuration
  
  // Enable subagents
  allowSubagents: true,
  
  systemPrompt: `... You can use subagents to:
  - Search multiple databases in parallel
  - Analyze different datasets simultaneously
  - Review multiple papers concurrently
  ...`
});

// Agent will generate code like this when analyzing data:

// Example: Agent-generated Python code for dose-response analysis
const analysisCode = `
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load experimental data
data = pd.read_csv('dose_response_data.csv')

# Fit dose-response curve
def hill_equation(x, EC50, nH, bottom, top):
    return bottom + (top - bottom) / (1 + (EC50 / x) ** nH)

params, _ = curve_fit(hill_equation, data['concentration'], data['response'])
EC50 = params[0]

# Generate plot
plt.figure(figsize=(10, 6))
plt.plot(data['concentration'], data['response'], 'o', label='Data')
plt.plot(x_fit, hill_equation(x_fit, *params), label='Fit')
plt.xlabel('Concentration (nM)')
plt.ylabel('Response (%)')
plt.title(f'Dose-Response Curve (EC50 = {EC50:.2f} nM)')
plt.legend()
plt.savefig('dose_response_plot.png')
`;

// tools/quality-control.js
export const qualityControlTool = {
  name: 'validate_experimental_data',
  description: 'Validate experimental data for quality, completeness, and compliance',
  parameters: {
    type: 'object',
    properties: {
      data_file: {
        type: 'string',
        description: 'Path to data file'
      },
      validation_rules: {
        type: 'array',
        items: { type: 'string' },
        description: 'List of validation rules to apply'
      }
    },
    required: ['data_file']
  },
  execute: async ({ data_file, validation_rules = [] }) => {
    // Agent will write validation code
    // This provides structure for quality checks
    return {
      success: true,
      message: 'Validation will be performed via generated code',
      validation_rules
    };
  }
};

// User query
const query = `
I'm researching protein kinase inhibitors for cancer treatment. 
Please:
1. Search PubMed for recent papers (last 2 years)
2. Find relevant protein targets in UniProt
3. Summarize key findings
4. Create a research report
`;

const response = await agent.run(query);

const query = `
Analyze the experimental data in assays/binding_assay_2025_01.csv.
This is a binding affinity assay. Please:
1. Calculate IC50 values
2. Generate dose-response curves
3. Compare results across compounds
4. Create a summary report with visualizations
`;

const response = await agent.run(query);

const query = `
I need to update the "Cell Culture Protocol" with new safety requirements.
Retrieve the current protocol, add the new requirements, and save the updated version.
Also create a compliance checklist.
`;

const response = await agent.run(query);

// Define validation rules for experimental data
const validationRules = {
  requiredFields: ['compound_id', 'concentration', 'response'],
  valueRanges: {
    concentration: { min: 0, max: 10000 },
    response: { min: 0, max: 100 }
  },
  dataQuality: {
    minReplicates: 3,
    maxCV: 0.2
  }
};

// Agent generates Python code
// Run: pylint, mypy, or flake8 for validation

// test-cases.js
const testCases = [
  {
    name: 'Literature search',
    query: 'Find recent papers on CRISPR gene editing',
    expectedTools: ['search_literature'],
    expectedOutput: 'List of papers with abstracts'
  },
  {
    name: 'Protein analysis',
    query: 'Get information about protein P00519 (ABL1)',
    expectedTools: ['search_protein'],
    expectedOutput: 'Protein details including sequence and function'
  },
  {
    name: 'Data analysis',
    query: 'Analyze dose-response data in assays/compound_001.csv',
    expectedTools: ['analyze_experimental_data'],
    expectedOutput: 'IC50 values and dose-response plot'
  }
];

// Run tests
for (const testCase of testCases) {
  const response = await agent.run(testCase.query);
  // Validate response
}