ExoIntel – AI Exoplanet Discovery Platform

ExoIntel is an AI-driven research platform designed for the systematic analysis of exoplanet datasets to identify candidate planets with a high probability of habitability. By integrating machine learning, astrophysical feature engineering, and explainable AI (XAI), the platform provides a rigorous framework for transforming raw astronomical data into validated research insights.

Project Overview

The search for habitable exoplanets is characterized by the vast scale of observational data and the subtle signatures of potential habitability. ExoIntel addresses this challenge by providing a reproducible, automated pipeline that evaluates confirmed exoplanets based on Earth-like criteria. The platform focuses on:

• Scientific Discovery: Identifying priority targets for further atmospheric and biosignature observation.
• Reproducible Research: Ensuring that discovery rankings and model predictions are backed by auditable feature engineering and explanations.
• Explainability: Utilizing SHAP-based analysis to understand why specific planets are ranked as habitable, bridging the gap between "black-box" ML and astrophysical theory.

Key Capabilities

• Automated Data Ingestion: Seamless retrieval of confirmed exoplanet records from the NASA Exoplanet Archive API.
• Astrophysical Feature Engineering: Calculation of habitability indicators including Equilibrium Temperature, Stellar Flux, and ESI (Earth Similarity Index).
• Machine Learning Habitability Predictions: Gradient Boosting and Random Forest models trained on planetary and stellar parameters to predict habitability indices.
• Explainable AI (XAI): Comprehensive SHAP analysis providing global feature importance and local planet-level explanations.
• Discovery Ranking Engine: A specialized module for scoring and prioritizing the most promising habitable candidates.
• Scientific Analytics: Generation of trend reports and astrophysical visualizations for research dissemination.
• Experiment Tracking: Automated logging of model performance and hyperparameter configurations across research runs.
• Subsystem Metrics: Real-time monitoring of pipeline health and operational efficiency.
• Interactive Discovery Dashboard: A production-ready Streamlit interface for exploring candidate datasets and visualizations.
• Research API: A RESTful service for programmatic access to discovery results and model predictions.

System Architecture

ExoIntel is built on a modular, layered architecture designed for scalability and research integrity:

1. Data Layer: PostgreSQL data warehouse for structured storage of raw NASA data, engineered features, and discovery results.
2. Ingestion & Processing Layer: Python-based modules for API interaction and astrophysical feature enrichment.
3. Modeling Layer: Scikit-learn pipelines for training, evaluating, and persisting habitability prediction models.
4. Intelligence Layer: The Discovery Engine for ranking and the Explainability Engine (SHAP) for generating model interpretations.
5. Analytics Layer: Subsystems that synthesize pipeline outputs into formal research reports and visualizations.
6. Presentation Layer: Streamlit dashboard for interactive exploration and a Research API for external integration.
7. Orchestration Layer: A central management script that coordinates the full discovery workflow with health checks and logging.

Project Structure

The ExoIntel repository is organized into distinct directories to support both scientific development and open-source collaboration:

├── src/                        # Core AI discovery pipeline and backend services (FastAPI/Streamlit)
├── frontend/                   # Interactive web interface (React/Vite)
├── docs/                       # Technical architecture diagrams and internal documentation
├── analysis_outputs/           # High-resolution generated plots (SHAP values, global feature importance)
├── research/                   # Public scientific documentation (methodology, datasets, ML summaries)
├── community/                  # Open-source contribution guides, local setup, and project roadmap
├── datasets/                   # Reference datasets and transformations
├── experiments/                # Model evaluation and benchmarking logs
├── reports/                    # Generated research papers and summaries
└── run_exointel_pipeline.py    # Main pipeline orchestrator executed to rebuild the entire system

Installation and Setup

Prerequisites

• Python 3.9+
• PostgreSQL 14+
• Git

1. Clone the Repository

git clone https://github.com/saiiexd/exo-intel-platform.git
cd exo-intel-platform

2. Environment Configuration

Create a virtual environment and install dependencies:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt

3. Database Setup

Ensure PostgreSQL is running and create the database specified in your environment settings. Initialize the environment variables:

cp .env.example .env
# Edit .env with your PostgreSQL credentials

Running the Platform

Autonomous Discovery Pipeline

The orchestrator manages the full research workflow. Run the following command to execute the production pipeline:

python run_exointel_pipeline.py

To run the full suite including data refresh and research experiments:

python run_exointel_pipeline.py --run-all

Interactive Discovery Dashboard

Launch the visualization frontend to browse candidate planets:

streamlit run src/frontend/app.py

Research API Service

Start the API to access discovery insights programmatically:

python -m src.api.main

Using the Platform

• Candidate Exploration: Use the Streamlit dashboard to filter planets by habitability score, stellar type, or distance. View individual planet "Report Cards" with SHAP explanations.
• Analysis Outputs: Review the analysis_outputs/ directory for high-resolution plots of feature importance and planetary distributions.
• Reporting: Automated summaries and research snapshots are exported to the reports/ folder after each pipeline execution.

Pipeline Workflow

ExoIntel implements a "Scientific-as-Code" workflow:

1. Ingestion: Fetch latest confirmed exoplanets from NASA.
2. Enrichment: Apply astrophysical formulas for habitability indicators.
3. Inference: Run trained Gradient Boosting models to predict scores.
4. Explain: Generate SHAP values for every inference to ensure theoretical alignment.
5. Rank: Sort candidates and generate the discovery short-list.
6. Disseminate: Produce visual and textual research reports.

Interactive Web Interface

The ExoIntel platform includes a dedicated interactive web interface built with React and TypeScript. This interface provides a robust, component-driven frontend application that enables researchers and users to explore discovery datasets and interact directly with the predictive models.

The frontend integrates seamlessly with the ExoIntel platform by communicating with the backend FastAPI service via RESTful endpoints. This architecture decouples the presentation layer from the data warehouse and machine learning pipelines, ensuring a scalable and maintainable system. All data fetching operations handle loading states and include safe fallbacks in case the backend API is temporarily unavailable.

Running the Frontend Locally

To launch the interactive web interface on your local machine, follow these steps:

1. Clone the repository
2. Navigate to the frontend directory: cd frontend
3. Install dependencies: npm install
4. Run the development server: npm run dev

Interface Features

The application provides the following core pages:

• Home: Displays high-level platform statistics, navigational elements, and an overview of the scientific methodology powering the autonomous discovery engine.
• Discovery Explorer: A comprehensive data table for browsing candidate planets, featuring search capabilities, filtering mechanisms, and detailed habitability scores derived from the backend models.
• Habitability Simulator: An interactive environment where users can manipulate planetary parameters (such as radius, mass, and equilibrium temperature) and invoke the prediction service to receive a habitability consensus score.
• AI Insights: Presents scientific visualizations and global feature importance metrics extracted from the explainable AI (SHAP) layer, illustrating model behavior and correlation patterns.
• Research: Contains formal documentation regarding system architecture, autonomous pipeline workflows, and links to the project's technical documentation.

This frontend application complements the existing Streamlit research dashboard. While the Streamlit dashboard serves as an internal tool optimized for rapid data visualization and direct Python integration during model development, the React frontend delivers a highly responsive, scalable, and user-friendly experience intended for broader external engagement and presentation of final discovery results.

Scientific Outputs

ExoIntel operates as a rigorous, autonomous scientific research framework. The artifacts generated by this system are designed to be reproducible, auditable, and ready for academic presentation.

• Research Manuscript: A complete formal paper detailing the pipeline's astrobiological motivations, machine learning architecture, and discovery findings is available at paper/exointel_research_paper.md.
• Reproducibility Report: Comprehensive documentation guaranteeing the precise replication of the discovery environment and dataset rebuilds is located at research/reproducibility_report.md.
• Visual Demonstrations: Representative graphical outputs, including global feature importance charts (SHAP) and habitability score distributions generated directly by the platform, are stored in the demo_outputs/ directory.

These artifacts represent the definitive scientific output generated by the ExoIntel discovery platform.

Citation and Reproducibility

If you use ExoIntel in your research or wish to reproduce our machine learning habitability discoveries, please adhere to the guides provided in the research/ directory. By running the autonomous orchestration script, you guarantee the generation of the exact datasets and ML models used.

Please cite the platform using the following metadata if it supports your work:

@software{ExoIntel_AI,
  author = {ExoIntel},
  title = {ExoIntel AI Exoplanet Discovery Platform},
  version = {2.0.0},
  date = {2026-03-08},
  url = {https://github.com/ExoIntel/exo-intel-platform}
}

Contributing

We welcome contributions from the astrophysics and machine learning communities.

1. Fork the repository.
2. Create a Feature Branch (git checkout -b feature/AmazingFeature).
3. Commit your changes (git commit -m 'Add some AmazingFeature').
4. Push to the branch (git push origin feature/AmazingFeature).
5. Open a Pull Request.

Ensure that new features include appropriate tests and documentation.

Documentation

The ExoIntel repository now includes a full technical documentation system located in the docs/ directory. This documentation covers the platform's architecture, data ingestion pipelines, machine learning workflows, the discovery ranking engine, explainable AI integrations, interactive interfaces, local installation guides, and detailed reproducibility information. It serves as the primary technical resource for both researchers and contributing engineers.

A full technical report consolidating these documents is available in docs/ExoIntel_Technical_Documentation.pdf.

Project Website

A comprehensive static project website is available in the website/ directory. Once GitHub Pages is enabled for this repository (serving from the website/ folder), the site can be accessed online to explore the platform architecture, key discovery insights, and documentation links.

License

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