Cellexis is an intelligent research platform that leverages advanced AI technologies to make NASA's bioscience research publications more accessible and discoverable. Using RAG (Retrieval-Augmented Generation), knowledge graphs, and natural language processing, Cellexis enables researchers to explore, query, and analyze complex biological datasets from space missions.

• Semantic Search: AI-powered search across NASA bioscience publications
• Question Answering: Natural language queries with contextual answers
• Citation Tracking: Automatic citation generation with relevance scores
• Multi-document Analysis: Cross-reference findings across multiple papers

• Interactive Network: Dynamic visualization of research relationships
• Entity Recognition: Automatic extraction of biological entities and concepts
• Connection Mapping: Discover hidden relationships between research areas
• Fullscreen Mode: Immersive graph exploration experience

• Paper Comparison: Side-by-side analysis with consensus detection
• Smart Bookmarks: Organized research collection with notes
• Export Options: Multiple formats for research findings
• Voice Assistant: Hands-free navigation and search capabilities

• Responsive Design: Optimized for all device sizes
• Real-time Updates: Live search results and graph updates
• Authentication: Secure Firebase-based user management
• Progressive Web App: Install and use offline capabilities

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│    Frontend     │────│   Backend API    │────│   Databases     │
│   React + TS    │    │   FastAPI + AI   │    │ Neo4j + Vector │
└─────────────────┘    └──────────────────┘    └─────────────────┘
         │                       │                       │
         │                       │                       │
         v                       v                       v
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Web Client    │    │   AI Services    │    │  File Storage   │
│ Voice Commands  │    │  Google Gemini   │    │  PDF Documents  │
│ Real-time UI    │    │  Embeddings      │    │  Vector Index   │
└─────────────────┘    └──────────────────┘    └─────────────────┘

Frontend:

• React 18.3.1 with TypeScript
• Vite build system
• Tailwind CSS + shadcn/ui components
• Firebase Authentication
• Cytoscape.js for graph visualization
• Web Speech API for voice commands

Backend:

• FastAPI with Python 3.8+
• Google Gemini AI for text generation
• Sentence Transformers for embeddings
• FAISS for vector similarity search
• Neo4j graph database
• PDFPlumber for document processing

Infrastructure:

• Frontend: Deployed on Netlify/Vercel
• Backend: Deployed on Render
• Database: Neo4j AuraDB (cloud)
• Authentication: Firebase Auth

• Node.js 16+ and npm/pnpm
• Python 3.8+
• Neo4j Database (local or cloud)
• Google AI Studio API Key
• Firebase Project (for authentication)

git clone https://github.com/your-repo/cellexis.git
cd cellexis

cd backend

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Set up environment variables
cp .env.example .env
# Edit .env with your configuration

Required Environment Variables:

# API Keys
GOOGLE_API_KEY=your_google_api_key_here
NEO4J_URI=bolt://localhost:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=your_password

# Optional
OLLAMA_BASE_URL=http://localhost:11434  # If using Ollama

cd ../frontend

# Install dependencies
npm install  # or pnpm install

# Set up environment variables
cp .env.example .env.development
# Edit .env.development with your configuration

Frontend Environment Variables:

# API Configuration
VITE_API_URL=http://localhost:8000

# Firebase Configuration (from your Firebase project)
VITE_FIREBASE_API_KEY=your_api_key
VITE_FIREBASE_AUTH_DOMAIN=your-project.firebaseapp.com
VITE_FIREBASE_PROJECT_ID=your-project-id

Option A: Local Neo4j

# Download and start Neo4j Desktop
# Create a new database with password
# Update NEO4J_* variables in backend/.env

Option B: Neo4j AuraDB (Cloud)

# Create account at neo4j.com/cloud/aura
# Create new instance
# Update connection details in backend/.env

Terminal 1 - Backend:

cd backend
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

Terminal 2 - Frontend:

cd frontend
npm run dev

cd backend

# Create embeddings for sample documents
python create_embeddings.py

# Extract and load entities into Neo4j
python extract_entities.py

The backend requires several services and configurations:

1. Go to Google AI Studio
2. Create an API key
3. Add to .env as GOOGLE_API_KEY

Local Installation:

# Using Docker
docker run \
    --name neo4j \
    -p7474:7474 -p7687:7687 \
    -d \
    -v $HOME/neo4j/data:/data \
    -v $HOME/neo4j/logs:/logs \
    -v $HOME/neo4j/import:/var/lib/neo4j/import \
    -v $HOME/neo4j/plugins:/plugins \
    --env NEO4J_AUTH=neo4j/your-password \
    neo4j:latest

Cloud Setup (Recommended):

1. Visit Neo4j Aura
2. Create free instance
3. Download connection details
4. Update .env with connection URI and credentials

Place your PDF documents in backend/documents/ directory:

backend/
├── documents/
│   ├── NASA_paper_1.pdf
│   ├── NASA_paper_2.pdf
│   └── ...
├── create_embeddings.py
└── extract_entities.py

1. Go to Firebase Console
2. Create new project
3. Enable Authentication
4. Enable Email/Password and Google providers
5. Get configuration object
6. Update frontend .env.development

The project uses Vite with the following key configurations:

// vite.config.ts
export default defineConfig({
  plugins: [react()],
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "./client"),
    },
  },
  server: {
    port: 8080,
    host: true,
  }
})

cellexis/
├── backend/                 # FastAPI backend
│   ├── app/
│   │   ├── main.py         # FastAPI app entry point
│   │   ├── rag_system.py   # RAG implementation
│   │   ├── graph_api.py    # Neo4j graph operations
│   │   └── models.py       # Pydantic models
│   ├── documents/          # PDF documents for processing
│   ├── create_embeddings.py # Vector embeddings creation
│   ├── extract_entities.py # Entity extraction for graph
│   └── requirements.txt
├── frontend/               # React frontend
│   ├── client/
│   │   ├── components/     # React components
│   │   ├── pages/          # Page components
│   │   ├── lib/            # Utilities and API client
│   │   └── contexts/       # React contexts
│   ├── public/            # Static assets
│   └── package.json
└── README.md

The backend provides these main endpoints:

POST /search-rag
- Query: { "query": "string", "top_k": number }
- Response: { "query", "answer", "citations", "chunks_used" }

GET /graph
- Optional: ?filter_type=entity_type
- Response: { "nodes": [...], "edges": [...] }

GET /search?q=query
- Response: { "query", "results": [...] }

GET /health    # Application health
GET /pingdb    # Database connectivity

• Dashboard: Main search and visualization interface
• Login: Firebase authentication
• Features: Feature showcase
• Contact: Contact information

• PaperComparison: Side-by-side paper analysis
• BookmarksNotes: Research organization
• VisualizationEnhancements: Advanced graph features
• ExportShare: Export and sharing functionality
• UserFeedback: User feedback collection

The platform supports voice navigation:

Activation:

• Say "Hey Cellexis" or press Ctrl+Space
• Say "Stop" or press Escape to deactivate

Navigation Commands:

• "Go to search" / "Search"
• "Go to bookmarks" / "Bookmarks"
• "Go to comparison" / "Compare"
• "Go to visualization" / "Visualize"

Panel Commands:

• "Open left panel" / "Close left panel"
• "Open right panel" / "Close right panel"
• "Toggle left" / "Toggle right"

1. Connect Repository

   • Link your GitHub repository to Render
   • Select the backend directory as root

2. Environment Variables

   GOOGLE_API_KEY=your_api_key
   NEO4J_URI=neo4j+s://your-instance.databases.neo4j.io
   NEO4J_USERNAME=neo4j  
   NEO4J_PASSWORD=your_password

3. Build Configuration

   • Build Command: pip install -r requirements.txt
   • Start Command: uvicorn app.main:app --host 0.0.0.0 --port $PORT

1. Build Settings

   • Build Command: npm run build
   • Publish Directory: dist

2. Environment Variables

   VITE_API_URL=https://your-backend.onrender.com
   VITE_FIREBASE_API_KEY=your_api_key
   VITE_FIREBASE_AUTH_DOMAIN=your-project.firebaseapp.com
   VITE_FIREBASE_PROJECT_ID=your-project-id

Security:

• Use HTTPS for all communications
• Implement rate limiting on API endpoints
• Secure Firebase rules for authentication
• Use environment variables for all secrets

Performance:

• Enable CDN for static assets
• Implement caching strategies
• Monitor API response times
• Optimize bundle sizes

Monitoring:

• Set up error tracking (Sentry)
• Monitor API usage and costs
• Database performance monitoring
• User analytics

// Using the API service
import { apiService } from '@/lib/api';

const results = await apiService.searchRAG(
  "How does microgravity affect immune response?", 
  5
);
console.log(results.answer);
console.log(results.citations);

// Load and render knowledge graph
const graphData = await apiService.getGraph();
// Graph is automatically rendered using Cytoscape.js

// Voice commands are handled automatically
// Users can activate with "Hey Cellexis" or Ctrl+Space
// Commands like "Go to search" navigate to different tabs

We welcome contributions! Please see our contributing guidelines:

1. Fork the repository
2. Create feature branch: git checkout -b feature/amazing-feature
3. Commit changes: git commit -m 'Add amazing feature'
4. Push to branch: git push origin feature/amazing-feature
5. Open Pull Request

Backend:

• Follow PEP 8 style guidelines
• Add type hints to all functions
• Include docstrings for modules and functions
• Write unit tests for new features

Frontend:

• Use TypeScript strictly
• Follow React best practices
• Use consistent naming conventions
• Add JSDoc comments for complex functions

Backend Tests:

cd backend
pytest tests/

Frontend Tests:

cd frontend
npm run test

API Performance:

• Response times for search endpoints
• RAG query processing time
• Graph generation performance
• Database query optimization

User Experience:

• Page load times
• Search result relevance
• Voice command accuracy
• Mobile responsiveness

Resource Usage:

• API rate limiting
• Database connection pooling
• Memory usage optimization
• Vector index efficiency

• Firebase Authentication with email/password
• JWT token validation on backend
• Protected routes for authenticated users
• Session management and refresh tokens

• CORS configuration for frontend domains
• Input validation and sanitization
• Rate limiting to prevent abuse
• Error handling without information disclosure

• Encrypted connections (HTTPS/TLS)
• Secure environment variable handling
• No sensitive data in client-side code
• Regular security audits

Backend Not Starting:

# Check Python version
python --version  # Should be 3.8+

# Verify dependencies
pip install -r requirements.txt

# Check environment variables
cat .env

Frontend Build Errors:

# Clear cache
npm cache clean --force

# Reinstall dependencies
rm -rf node_modules package-lock.json
npm install

# Check TypeScript configuration
npm run typecheck

Database Connection Issues:

# Test Neo4j connection
python -c "from neo4j import GraphDatabase; driver = GraphDatabase.driver('bolt://localhost:7687', auth=('neo4j', 'password')); print('Connected!')"

# Check database status
docker ps  # If using Docker

API Integration Problems:

• Verify CORS settings match frontend domain
• Check API_URL environment variable
• Validate Google API key permissions
• Monitor network requests in browser dev tools

Backend Debug:

# Enable debug logging
export LOG_LEVEL=DEBUG
uvicorn app.main:app --reload --log-level debug

Frontend Debug:

# Development mode with source maps
npm run dev

# Check console for errors
# Use React Developer Tools

• FastAPI Documentation
• React Documentation
• Neo4j Developer Guide
• Firebase Documentation

• LangChain - RAG framework
• Sentence Transformers - Text embeddings
• Cytoscape.js - Graph visualization

This project is licensed under the MIT License - see the LICENSE file for details.

• NASA for providing public access to bioscience research data
• Google AI team for Gemini API access
• Neo4j for graph database technology
• Open source community for the amazing tools and libraries

For support and questions:

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: [email protected]
• Documentation: docs.cellexis.com

Built with ❤️ for the scientific research community