GenNet

GenNet Cloud Platform

**Gene Regulatory Network Analysis

AI-Powered Health Predictions

Cloud-Native Platform**

A cutting-edge, cloud-native platform for multi-scale Gene Regulatory Network (GRN) analysis, incorporating modern AI/ML, high-performance computing, and collaborative science capabilities. Perfect for researchers, bioinformaticians, and healthcare professionals seeking advanced genomic analysis tools.

🚀 Quick Start

One-Command Deployment

# Local deployment (development)
./scripts/deploy.sh local

# Production deployment
./scripts/deploy.sh production

The deployment script automatically:

✅ Checks prerequisites
✅ Installs all dependencies
✅ Builds Docker images
✅ Starts all services
✅ Validates deployment

Manual Setup (Alternative)

# Validate setup
./scripts/validate_setup.sh

# Start local development environment
make dev-up

# Run tests
make test

📋 Overview

GenNet Cloud Platform is an advanced, cloud-native evolution of the legacy GenNet tool, providing:

Multi-Scale GRN Analysis: From single-cell to tissue-level analysis
AI/ML Integration: Automated GRN inference, parameter prediction, and pattern recognition
High-Performance Computing: Kubernetes-based orchestration with GPU support
Collaborative Science: Real-time collaboration, version control, and shared workspaces
Modern Architecture: Microservices-based, scalable, and cloud-native

Keywords: gene regulatory networks, GRN analysis, bioinformatics platform, AI healthcare, personalized medicine, genomic analysis, computational biology

🎯 Scope and Use Cases

GenNet Cloud Platform empowers researchers and clinicians to:

Analyze Gene Regulatory Networks: Understand gene interactions and regulatory mechanisms across biological scales
Predict Disease Outcomes: Use ML models to forecast disease progression and treatment responses
Collaborate in Real-Time: Enable multi-user editing and sharing of GRN models and analysis results
Scale Computations: Leverage HPC resources for large-scale simulations and data processing
Integrate Multi-Omics Data: Combine genomics, transcriptomics, and proteomics data for comprehensive analysis

Target Users: Biologists, bioinformaticians, computational biologists, medical researchers, and healthcare professionals.

🔄 System Flow

High-Level Data Flow

graph TD
    A[User Interface] --> B[API Gateway]
    B --> C[Authentication Service]
    C --> D{Authorized?}
    D -->|Yes| E[Workflow Service]
    D -->|No| F[Access Denied]
    E --> G[GRN Service]
    G --> H[Neo4j Graph DB]
    E --> I[Analysis Services]
    I --> J[HPC Orchestrator]
    J --> K[Kubernetes Cluster]
    K --> L[Results Storage]
    L --> M[S3/InfluxDB]
    M --> N[Real-time Updates]
    N --> A

User Workflow

Authentication: Users log in via JWT-based auth
Network Management: Create or import GRN networks from various formats
Workflow Creation: Define analysis workflows (qualitative, hybrid, ML)
Execution: Submit jobs to HPC cluster for processing
Collaboration: Share workspaces and collaborate in real-time
Results Visualization: View and download analysis results

🏗️ Architecture Overview

graph TB
    subgraph "Client Layer"
        UI[Web UI - Next.js]
        SDK[Python SDK]
    end
    
    subgraph "API Layer"
        GW[API Gateway - Kong]
        GQL[GraphQL Service]
    end
    
    subgraph "Core Services"
        AUTH[Auth Service]
        GRN[GRN Service]
        WF[Workflow Service]
        COLLAB[Collaboration Service]
    end
    
    subgraph "Analysis Services"
        QUAL[Qualitative Service]
        HYB[Hybrid Service]
        ML[ML Service]
    end
    
    subgraph "Infrastructure"
        HPC[HPC Orchestrator]
        META[Metadata Service]
    end
    
    subgraph "Data Layer"
        PG[PostgreSQL]
        NEO[Neo4j]
        REDIS[Redis]
        INF[InfluxDB]
        S3[S3]
    end
    
    UI --> GW
    SDK --> GW
    GW --> AUTH
    GW --> GQL
    GQL --> GRN
    GQL --> WF
    AUTH --> PG
    GRN --> NEO
    WF --> REDIS
    COLLAB --> REDIS
    QUAL --> HPC
    HYB --> HPC
    ML --> HPC
    HPC --> K8S[Kubernetes]
    META --> PG
    WF --> INF
    WF --> S3

See ARCHITECTURE.md for detailed architecture documentation.

Core Services

API Gateway: Kong-based routing and authentication
Auth Service: JWT-based authentication and RBAC
GRN Service: Network management with Neo4j graph storage
Workflow Service: Orchestration of analysis pipelines
Collaboration Service: Real-time WebSocket-based collaboration

Analysis Services

Qualitative Service: SMBioNet integration for CTL verification
Hybrid Service: HyTech integration for time delay computation
ML Service: GRN inference (ARACNE, GENIE3, GRNBoost2), parameter prediction

🛠️ Technology Stack

Backend: Python 3.11+, Go 1.21+, FastAPI, gRPC
Frontend: Next.js 14+, TypeScript, React Flow/Cytoscape.js
Infrastructure: AWS (EKS, RDS, Neptune, S3, ElastiCache), Kubernetes, Terraform
Databases: PostgreSQL, Neo4j/Neptune, Redis, InfluxDB
ML/AI: PyTorch, TensorFlow, MLflow, scikit-learn

📖 Usage Examples

Creating and Analyzing a GRN Network

from gennet import GenNetClient

# Initialize client
client = GenNetClient(
    base_url="https://api.gennet.cloud",
    api_key="your-api-key"
)

# Create a new GRN network
network = client.create_network(
    name="Sample GRN",
    description="Example gene regulatory network",
    nodes=[
        {"id": "gene1", "type": "gene", "expression": 0.5},
        {"id": "gene2", "type": "gene", "expression": 0.3}
    ],
    edges=[
        {"source": "gene1", "target": "gene2", "weight": 0.8}
    ]
)

# Run qualitative analysis
workflow = client.create_workflow(
    name="Qualitative Analysis",
    workflow_type="qualitative",
    network_id=network["id"],
    parameters={
        "ctl_formula": "AG(g1 > 0.5)",
        "k_parameter_range": [1, 10]
    }
)

# Monitor progress
status = client.get_workflow_status(workflow["id"])
while status["state"] != "completed":
    time.sleep(5)
    status = client.get_workflow_status(workflow["id"])

# Retrieve results
results = client.get_workflow_results(workflow["id"])
print("Analysis Results:", results)

Collaborative Analysis Session

import { GenNetCollaboration } from 'gennet-sdk';

const collab = new GenNetCollaboration('wss://api.gennet.cloud/ws');

// Join a workspace
collab.joinWorkspace('workspace-123');

// Listen for real-time updates
collab.on('network-update', (update) => {
    console.log('Network updated:', update);
});

// Make changes
collab.updateNode('gene1', { expression: 0.7 });

REST API Usage

# Get authentication token
TOKEN=$(curl -X POST https://api.gennet.cloud/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username":"user","password":"pass"}' | jq -r '.token')

# List networks
curl -H "Authorization: Bearer $TOKEN" \
  https://api.gennet.cloud/api/v1/networks

# Create workflow
curl -X POST https://api.gennet.cloud/api/v1/workflows \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ML Analysis",
    "workflow_type": "ml",
    "network_id": "net-123",
    "parameters": {"algorithm": "GENIE3"}
  }'

🧪 Testing

# Run all tests
make test

# Unit tests only
make test-unit

# Integration tests
make test-integration

# With coverage
make test-coverage

See TESTING.md for detailed testing documentation.

📦 Project Structure

gennet-platform/
├── infrastructure/          # Terraform, Kubernetes manifests
├── services/                # Microservices
│   ├── api-gateway/
│   ├── auth-service/
│   ├── grn-service/
│   ├── workflow-service/
│   ├── qualitative-service/
│   ├── hybrid-service/
│   ├── ml-service/
│   ├── collaboration-service/
│   ├── metadata-service/
│   ├── graphql-service/
│   └── hpc-orchestrator/
├── frontend/                # Next.js web application
├── libraries/               # Python SDK
├── tools/                   # Data ingestion, migration tools
├── tests/                   # Integration and E2E tests
└── docs/                    # Documentation

🔐 Security

JWT-based authentication
Password hashing (bcrypt)
Encryption utilities
Audit logging
Input validation
CORS configuration

📈 Features

GRN Management

Create, edit, and visualize GRN networks
Import from multiple formats (SBML, BioPAX, CSV, JSON)
Network validation and consistency checking
Graph-based storage with Neo4j

Analysis Workflows

Qualitative Modeling: CTL verification, K-parameter generation, state graph analysis
Hybrid Modeling: Time delay computation, trajectory analysis
ML/AI Analysis: GRN inference, parameter prediction, anomaly detection, disease prediction

Collaboration

Real-time collaborative editing
Presence tracking
Version control
Shared workspaces

HPC Integration

Kubernetes-based job orchestration
GPU cluster support
Distributed computing (Ray, Dask)
Batch processing

🚢 Deployment

Quick Deploy

Docker-only (Recommended - no Python venv needed):

SKIP_VENV=true ./scripts/deploy.sh local

Full local deployment (requires python3-venv):

./scripts/deploy.sh local

Production deployment:

./scripts/deploy.sh production

Note: If you encounter python3-venv errors, either install it (sudo apt install python3.12-venv) or use SKIP_VENV=true for Docker-only deployment.

The deployment script automatically handles:

Prerequisite checking
Dependency installation
Docker image building
Service startup
Health validation
Error handling

See DEPLOYMENT_QUICKSTART.md for quick reference or docs/DEPLOYMENT_GUIDE.md for detailed instructions.

Local Development

# Start services with Docker Compose
make dev-up

# Run individual services
cd services/auth-service
uvicorn main:app --reload

Production

# Deploy infrastructure
cd infrastructure/terraform
terraform apply

# Deploy services to Kubernetes
kubectl apply -f infrastructure/kubernetes/

📖 API Usage

Python SDK

from gennet import GenNetClient

client = GenNetClient(base_url="https://api.gennet.com", api_key="your-key")

# List networks
networks = client.list_networks()

# Create workflow
workflow = client.create_workflow(
    name="My Analysis",
    workflow_type="qualitative",
    network_id="network-123"
)

REST API

See API.md for complete API documentation.

Postman Collection

Import docs/API.postman_collection.json into Postman for interactive API testing.

🤝 Contributing

[Contributing guidelines to be added]

📄 License

[To be determined]

✅ Status

Status: ✅ COMPLETE - All planned features implemented and tested.

See COMPLETION_SUMMARY.md for detailed implementation status.

For questions or support, please refer to the documentation or open an issue.