Skip to content
BranchesTags

Repository files navigation

AetherData — AI-Powered Data Automation Platform

AetherData is a modern AI-powered data automation platform designed to simplify the creation, visualization, and execution of intelligent data pipelines.

The platform allows users to describe an automation workflow in natural language and generate a structured multi-stage pipeline using Google Gemini. It combines an interactive React frontend with a TypeScript/Express backend to demonstrate AI-assisted workflow generation, data transformation, pipeline execution, and real-time execution insights.

🚀 Overview

Traditional data pipelines often require manually configuring multiple processing stages, integrations, and transformations.

AetherData explores a more intuitive approach:

Describe what you want to automate → Let AI design the pipeline → Visualize and execute the workflow.

The platform supports pipelines consisting of:

  • Data sources
  • AI processing stages
  • Data transformation stages
  • Destination/output stages
  • Connections between pipeline nodes
  • AI-generated configuration parameters
  • Sample input data

The generated pipeline can then be executed through the backend pipeline engine, which produces execution logs, transformed output, and performance metrics.

Key Features

AI-Powered Pipeline Generation

Users can describe a desired automation workflow using natural language.

For example:

Read customer reviews, classify their sentiment,
summarize the results, and send the report to Slack.

AetherData sends the request to Gemini and generates a structured pipeline containing:

  • Pipeline name
  • Pipeline description
  • Source nodes
  • AI processing nodes
  • Transformation nodes
  • Destination nodes
  • Node configurations
  • Node coordinates
  • Pipeline connections
  • Sample input data

Gemini-Powered Data Processing

Pipeline processing nodes can use Google Gemini to analyze and transform incoming data.

The AI processing engine can perform tasks such as:

  • Classification
  • Summarization
  • Sentiment analysis
  • Entity extraction
  • Data interpretation
  • Custom prompt-based processing

The Gemini integration is handled on the backend so that API credentials are not exposed to the frontend.

Pipeline Execution Engine

AetherData includes a backend execution engine that processes pipeline nodes sequentially according to their connections.

The execution engine supports:

Source
   ↓
AI Processing
   ↓
Transformation
   ↓
Destination

During execution, the platform generates detailed logs for each pipeline stage.

Execution results include:

  • Pipeline execution status
  • Node-level logs
  • Processing output
  • Latency
  • Success rate
  • Approximate token consumption
  • Throughput metrics

AI Playground

The platform includes an AI Playground for testing prompts against arbitrary text input.

Users can provide:

  • A custom prompt
  • Input text

The backend sends the request to Gemini and returns the generated response.

This makes it possible to experiment with AI capabilities without creating a complete pipeline first.

Dynamic Multi-Currency Pricing

The platform includes a configuration-driven pricing engine supporting:

  • INR
  • USD
  • EUR
  • Monthly billing
  • Annual billing
  • Automatic annual discount calculation

Pricing calculations are isolated within the pricing component to prevent unnecessary state updates across unrelated sections of the application.

Modern UI & Motion System

AetherData uses a custom visual system featuring:

  • Glassmorphism
  • Gradient borders
  • Aurora-style backgrounds
  • Interactive hover effects
  • Scroll reveal animations
  • Responsive transitions
  • Custom typography
  • CSS-based motion

The project avoids heavy animation libraries and relies primarily on native CSS animations and browser APIs.

Architecture

AetherData follows a frontend/backend architecture:

                     ┌──────────────────────┐
                     │      User Input      │
                     │ Natural Language     │
                     └──────────┬───────────┘
                                │
                                ▼
                     ┌──────────────────────┐
                     │    React Frontend    │
                     │ React + TypeScript   │
                     └──────────┬───────────┘
                                │
                         HTTP API Requests
                                │
                                ▼
                     ┌──────────────────────┐
                     │   Express Backend    │
                     │   Node.js + TS       │
                     └──────────┬───────────┘
                                │
                    ┌───────────┴───────────┐
                    │                       │
                    ▼                       ▼
          ┌──────────────────┐    ┌──────────────────┐
          │   Gemini API     │    │ Pipeline Engine  │
          │ AI Processing    │    │ Execution Logic  │
          └──────────────────┘    └─────────┬────────┘
                                            │
                                            ▼
                                  ┌──────────────────┐
                                  │ Output + Metrics │
                                  │ Logs + Results   │
                                  └──────────────────┘

Tech Stack

Frontend

  • React 19
  • TypeScript
  • Vite
  • Tailwind CSS v4
  • HTML5
  • CSS3

Backend

  • Node.js
  • Express.js
  • TypeScript
  • tsx
  • esbuild

Artificial Intelligence

  • Google Gemini API
  • Google GenAI SDK
  • Prompt-based AI processing
  • Structured JSON generation

Development & Quality

  • Vite
  • TypeScript
  • Lighthouse
  • Responsive Web Design
  • Semantic HTML
  • Accessibility-focused UI

📂 Project Structure

Atherdata/
│
├── src/
│   ├── components/
│   │   ├── Features.tsx
│   │   ├── Pricing.tsx
│   │   └── ...
│   │
│   ├── config/
│   │   └── ...
│   │
│   ├── icons/
│   │   └── ...
│   │
│   ├── App.tsx
│   └── index.css
│
├── DESIGN.md
├── FB_Round_1.pdf
├── LICENSE
├── README.md
├── colorPallet.pdf
├── demo.mp4
├── fonts.pdf
├── index.html
├── lighthouse.json
├── metadata.json
├── package.json
├── package-lock.json
├── server.ts
├── tsconfig.json
└── vite.config.ts

Application Gallery

1. Hero Section

AetherData Hero Section

The landing-page hero introduces AetherData with a strong visual hierarchy, product messaging, and primary call-to-action.

2. Features Bento Grid

AetherData Features Bento Grid

The responsive Bento Grid presents the platform's primary capabilities using interactive feature cards.

3. Monthly Pricing

AetherData Monthly Pricing

The pricing engine dynamically calculates plan prices for monthly billing and different currencies.

4. Annual Pricing

AetherData Annual Pricing

Annual billing automatically applies the configured 20% subscription discount.

5. Testimonials

AetherData Testimonials

The testimonial section provides social proof through customer-focused review cards.

6. FAQ Section

AetherData FAQ Section

The FAQ section uses interactive accordion components to present commonly requested information.

🔌 Backend API

AetherData exposes several REST API endpoints through the Express backend.

Method Endpoint Description
GET /api/status Returns server and Gemini configuration status
POST /api/pipeline/generate Generates a pipeline from a natural-language request
POST /api/pipeline/run Executes a pipeline and returns logs, output, and metrics
POST /api/playground/test-prompt Tests a Gemini prompt against input text

/api/status

Checks whether the backend is running and whether a Gemini API key is configured.

Example

GET /api/status

Example Response

{
  "status": "ok",
  "hasApiKey": true,
  "timestamp": "2026-08-24T12:00:00.000Z"
}

🤖 Pipeline Generation API

POST /api/pipeline/generate

Generates a structured pipeline from a natural-language request.

Request

{
  "prompt": "Read customer reviews, classify sentiment, summarize the results, and send the report to Slack."
}

Generated Pipeline Structure

{
  "name": "Customer Review Intelligence",
  "description": "Analyzes customer reviews and sends a summarized sentiment report.",
  "sampleInput": "The product is excellent but delivery was delayed.",
  "nodes": [
    {
      "id": "1",
      "type": "source",
      "name": "Review Input"
    },
    {
      "id": "2",
      "type": "process",
      "name": "Gemini Sentiment Classifier"
    },
    {
      "id": "3",
      "type": "transform",
      "name": "Generate Summary"
    },
    {
      "id": "4",
      "type": "destination",
      "name": "Slack Report"
    }
  ],
  "connections": [
    {
      "from": "1",
      "to": "2"
    },
    {
      "from": "2",
      "to": "3"
    },
    {
      "from": "3",
      "to": "4"
    }
  ]
}

Pipeline Execution API

POST /api/pipeline/run

Executes a pipeline using the supplied nodes, connections, and sample input.

Request

{
  "nodes": [],
  "connections": [],
  "sampleInput": "Customer review data..."
}

Response

The endpoint returns:

  • Execution logs
  • Final output
  • Success status
  • Latency
  • Success rate
  • Approximate tokens consumed
  • Throughput

Example:

{
  "success": true,
  "logs": [],
  "output": "{}",
  "metrics": {
    "latencyMs": 1200,
    "successRate": 100,
    "tokensConsumed": 382,
    "throughputMbps": "1.25"
  }
}

🧪 AI Playground API

POST /api/playground/test-prompt

Allows users to test a prompt against input text.

Request

{
  "prompt": "Summarize the following content.",
  "text": "AetherData is an AI-powered data automation platform..."
}

Response

{
  "result": "AetherData is a platform for creating and executing AI-powered data pipelines.",
  "model": "gemini-3.5-flash"
}

If no Gemini API key is configured, the application returns an offline simulation response instead.

Environment Variables

Create a .env file in the project root:

GEMINI_API_KEY=your_gemini_api_key

The API key is read only by the backend.

The application can also operate without a Gemini API key by using its built-in fallback/mock processing mode.

Getting Started

Prerequisites

Make sure the following are installed:

  • Node.js 18 or later
  • npm
  • Git

For live AI functionality:

  • Google Gemini API key

1. Clone the Repository

git clone https://github.com/rishav8877/Atherdata.git

2. Enter the Project Directory

cd Atherdata

3. Install Dependencies

npm install

4. Configure Environment Variables

Create:

.env

Add:

GEMINI_API_KEY=your_gemini_api_key

5. Start Development Server

npm run dev

The development server runs on:

http://localhost:3000

6. Build for Production

npm run build

7. Start Production Server

npm run start

8. Run TypeScript Validation

npm run lint

Available NPM Scripts

Command Purpose
npm run dev Start the development server
npm run build Build the frontend and bundle the backend
npm run start Start the production server
npm run clean Remove generated build files
npm run lint Run TypeScript type checking

♿ Accessibility

AetherData includes several accessibility-focused improvements:

  • Semantic HTML5 elements
  • Skip-to-content navigation
  • Keyboard-accessible focus states
  • :focus-visible styling
  • Reduced-motion support
  • Responsive layouts
  • Accessible interactive components

The project is designed to provide a usable experience across desktop and mobile screen sizes.

SEO

The application includes:

  • Page metadata
  • Open Graph metadata
  • Twitter card metadata
  • Structured JSON-LD data
  • Semantic HTML structure
  • Descriptive page content

These features improve the discoverability and shareability of the application.

Lighthouse Performance

The recorded Lighthouse audit currently reports:

Category Score
Best Practices 100/100
Accessibility 96/100
SEO 92/100
Performance 57/100

Lighthouse scores can vary between runs depending on CPU usage, browser conditions, network conditions, and the local environment. These values represent the recorded project audit snapshot.

🧠 AI Processing Flow

The AI pipeline generation workflow can be summarized as:

Natural Language Request
          │
          ▼
   Express API Server
          │
          ▼
      Gemini API
          │
          ▼
 Structured JSON Pipeline
          │
          ▼
   Pipeline Visualization
          │
          ▼
    Execution Engine
          │
          ▼
 Logs + Output + Metrics

Pipeline Execution Flow

┌───────────────┐
│ Data Source   │
└───────┬───────┘
        │
        ▼
┌───────────────┐
│ AI Processing │
│    Gemini     │
└───────┬───────┘
        │
        ▼
┌───────────────┐
│ Transformation│
└───────┬───────┘
        │
        ▼
┌───────────────┐
│ Destination   │
└───────────────┘

Each stage generates execution information that can be surfaced through the application's execution interface.

Fallback & Offline Mode

AetherData is designed to remain usable even when the Gemini API key is unavailable.

When no API key is configured:

  • Pipeline generation uses a mock pipeline
  • AI processing uses simulated output
  • Playground requests return offline responses
  • The rest of the application remains functional

This makes the project easier to demonstrate and test locally without requiring live AI credentials.

Project Objectives

AetherData was designed to demonstrate the combination of:

  • Modern frontend engineering
  • Backend API development
  • AI API integration
  • Natural-language interfaces
  • Structured JSON generation
  • Pipeline orchestration
  • Data transformation
  • Responsive UI development
  • Accessibility
  • SEO optimization
  • Performance auditing

The project explores how AI can reduce the complexity of designing traditional data-processing workflows.

Future Improvements

Potential future enhancements include:

  • User authentication
  • Persistent pipeline storage
  • Pipeline version history
  • Database-backed execution history
  • Drag-and-drop pipeline builder
  • More source and destination integrations
  • Webhook triggers
  • Scheduled pipeline execution
  • Real-time execution streaming
  • Advanced pipeline branching
  • Conditional workflow execution
  • Multiple AI model providers
  • Team workspaces
  • Role-based access control
  • Production monitoring and observability
  • Lighthouse performance optimization

Why AetherData?

AetherData combines AI + automation + data processing + modern web engineering into a single product concept.

Instead of manually configuring every stage of a data workflow, users can describe their requirements in natural language and allow AI to generate the initial pipeline structure.

This approach creates a foundation for more accessible and intelligent workflow automation.

License

This project is licensed under the MIT License.

See the LICENSE file for more information.

⭐ Acknowledgements

Built using modern web technologies and Google's Gemini AI capabilities.

AetherData — Describe it. Generate it. Automate it.

About

AI-powered data automation platform that generates, visualizes, and executes intelligent data pipelines using Google Gemini, React, TypeScript, Node.js, and Express.

Topics

aiai-automationartificial-intelligencedata-automationdata-pipelinedata-processingexpressgemini-apigenerative-aigoogle-gemininodejspipeline-orchestrationreacttypescriptworkflow-automation

Resources

Readme
MIT license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages