Skip to content
BranchesTags

Repository files navigation

EUREKA: Universal AI-Powered Virtual Research Lab

EUREKA Logo

🔬 Making scientific discovery and advanced research accessible to everyone, everywhere, for free. 🚀

Gemini Powered FastAPI React 19 Three.js

License Stars Forks Issues

📖 Table of Contents

💡 Project Overview & Live View

Below is a visualization of the interactive EUREKA Cyber-Lab Dashboard in action. Built for modern browsers, the dashboard features a glassmorphic dashboard, real-time particle tracking graphs, active voice/gesture status trackers, and a fully interactive 3D rendering canvas.

EUREKA Cyber-Lab Dashboard

🎥 Interactive Video Demo

eureka_demo.1.mp4

EUREKA is an open-source, AI-powered virtual simulation space that bridges physical properties with interactive 3D structures. By feeding Wikipedia structural summaries into the Google Gemini 1.5 Flash API, EUREKA creates realistic, interactive component-level models of mechanical systems, tools, and molecular shapes.

Users can manipulate models using voice controls and hand gestures via their webcam, run real-time physics collisions, compute chemical properties, and download auto-generated research papers.

✨ Key Features Breakdown

🤖 1. Grounded 3D Generation

  • Wikipedia API Context Ingestion: Pre-fetches dimensions, materials, and colors from Wikipedia REST APIs before passing requests to Gemini to guarantee that generated models correspond to physical reality.
  • Gemini 3D Assembly: Dynamically structures complex system graphs (e.g., piston rods positioned inside cylinders) with customized scales and risk indexes.
  • Three.js Custom Wrapper: Features an advanced wrapper using @react-three/drei's useGLTF to dynamically render custom external models alongside procedural geometric components.

🖖 2. Natural User Interfaces (NUI)

  • MediaPipe Hand Tracking: Real-time canvas manipulation using webcam frames:
    • Pinch Fingers: Zoom In / Zoom Out.
    • Clench Fist: Reset Camera and Positions.
    • Point Index: Highlight & Inspect Component.
    • Horizontal Swipe: Switch active tab panel.
  • Web Speech API Integration: Local speech recognition for direct vocal commands (e.g., "ARIA, analyze the engine block") with high-quality synthesized speech replies.

🧪 3. Dual Simulation Engines

  • 3D Verlet Physics: Real-time calculation of particle momentum, kinetic energy tracking, Van der Waals force, and electrostatic Coulomb fields.
  • RDKit Molecular Engine: Determines molecular weights, logP partition coefficients, hydrogen bond donors/acceptors, and automatically predicts chemical reaction routes.

🧠 ARIA & The Multi-Agent Mesh

EUREKA coordinates five specialized sub-agents working under ARIA to provide comprehensive analysis:

graph TD;
    User((User Input)) --> Frontend;
    Frontend --> Nginx[Reverse Proxy];
    Nginx --> ARIA{ARIA Helper\nCoordinator};
    ARIA --> Explainer[🔬 Explainer\nDeconstructs mechanics];
    ARIA --> Analyzer[📊 Analyzer\nComputes properties];
    ARIA --> Thinker[🔮 Thinker\nSimulates What-Ifs];
    ARIA --> Researcher[📚 Researcher\nFinds ArXiv/PubMed docs];
    Explainer --> Output((Grounded\nOutput));
    Analyzer --> Output;
    Thinker --> Output;
    Researcher --> Output;
Loading
Agent Core Objective Key Output Payload
🧠 ARIA (Helper) Command router & user interface coordinator Orchestrates task delegation and compiles final conversational output.
🔬 Explainer Deconstructs highly complex engineering & scientific mechanics Easy-to-read explanations, definitions, and analogies.
📊 Analyzer Computes mathematical properties and handles telemetry Volumes, mass, materials, structural risks, and coordinate transformations.
🔮 Thinker Simulates hypothetical adjustments (What-if logic) Failure predictions, structural vulnerabilities, and risk analysis.
📚 Researcher Searches academic paper repositories for grounding data Extracts and cites DOI references from ArXiv and PubMed.

🏗️ System Architecture & Workflow

Below is the execution flow from the moment a user submits a search query to the rendering of the interactive 3D cyber-lab:

sequenceDiagram
    autonumber
    actor User as Researcher / Student
    participant FE as EUREKA Frontend (React + R3F)
    participant BE as EUREKA Backend (FastAPI)
    participant Wiki as Wikipedia API
    participant Gemini as Gemini 1.5 Flash
    
    User->>FE: Enter Search Query (e.g., "Telescope")
    FE->>BE: GET /api/objects/generate?q=Telescope
    Note over BE: Query intercept & WebResearchService check
    BE->>Wiki: Fetch structural metadata and articles
    Wiki-->>BE: Return page summaries, image links, & details
    BE->>Gemini: Request 3D Component Hierarchy JSON (grounded with Wiki context)
    Note over Gemini: Evaluate positions, scales,<br/>colors, and materials
    Gemini-->>BE: Return valid ExplorableObject JSON
    BE-->>FE: Send payload (ExplorableObject)
    Note over FE: R3F Canvas / GltfModelWrapper parse
    FE->>FE: Render 3D Model on WebGL viewport
    User->>FE: Use Hand Gestures (MediaPipe) / Speak (Web Speech)
    FE->>User: Perform action (Zoom/Analyze) & ARIA replies verbally
Loading

💻 Language & Technology Breakdown

EUREKA leverages a multi-tier programming model. The following breakdown maps the repository's codebase statistics (detected by GitHub) directly to their operational roles and under-the-hood machine acceleration technologies:

Language Repository % Role & Component Area Under-the-Hood Technologies
🐍 Python 73.2% FastAPI Server, AI Multi-Agent Core, Verlet 3D Physics Simulator C++ (RDKit chemistry bindings), Cython (uvloop high-concurrency event loops)
🔷 TypeScript 20.6% Cyber-lab Dashboard (React 19), Automation Scraper (BullMQ, Node.js) WebAssembly (Wasm) (MediaPipe deep learning), GLSL (GPU shaders via R3F/Three.js)
🎨 CSS 4.7% Dashboard glassmorphism, responsive grids, and cyber-lab visual effects Flexbox, CSS variables, hardware-accelerated filters
🐚 Shell 1.0% Setup Automation, deployment scripts, and local model loaders Bash (Linux) & PowerShell (Windows) scripting
🐳 Dockerfile 0.3% Container build scripts for database, Redis, frontend, and backend Multi-stage secure build, unprivileged user execution boundaries
💛 JavaScript 0.1% Web Speech API wrappers, config loaders, and bundling hooks Browser Web Speech Recognition & Web Audio APIs
🧡 HTML 0.1% Main single-page web template & meta search engine optimization tags Semantic HTML5 structure

⚙️ Under-the-Hood Performance Engines

While the primary code repository consists of Python and TypeScript, EUREKA's runtime environment is accelerated by high-performance compiled engines operating at a native level:

  1. C++ (Machine-Level Simulation & Graph Solving):

    • RDKit Engine: Performs complex molecular structural analysis, property calculations, and chemical reaction pathway estimations natively in C++ for maximum throughput.
    • MediaPipe Backend: Hand gesture detection algorithms and coordinate extraction are compiled as highly-optimized C++ libraries.

  2. WebAssembly / Wasm (In-Browser Neural Execution):

    • MediaPipe's deep learning hand tracking models are executed directly within the browser using WebAssembly compiled binaries, allowing for 60FPS gesture interactions without sending video frames to any remote server.

  3. GLSL - OpenGL Shading Language (Direct GPU Graphics):

    • The interactive 3D virtual viewport communicates directly with the GPU. Realistic rendering, shadows, metallic materials, and glowing particle collisions are compiled into native WebGL fragment and vertex shaders.

  4. Cython & libuv (High-Concurrency Server Loop):

    • The FastAPI backend utilizes uvloop (a Cython-compiled execution loop built on Node's libuv system), giving the Python backend network performance metrics comparable to Go (Golang) and native Node.js.

📂 Detailed Project Structure

EUREKA/
├── eureka-backend/             # FastAPI Backend Service (Python 3.11+)
│   ├── app/
│   │   ├── agents/             # AI agent files (helper.py, explainer.py, thinker.py, etc.)
│   │   ├── api/                # API controllers (objects.py, ws.py, auth.py)
│   │   ├── services/           # Core calculations (gemini_3d_service.py, physics_engine.py, rdkit)
│   │   └── data/               # Procedural templates & demo objects (e.g., car_engine.json)
│   ├── tests/                  # Backend unit & integration test files
│   └── main.py                 # Core entry point
│
├── eureka-frontend/            # React Client Application (React 19 + TypeScript + Vite)
│   ├── src/
│   │   ├── components/         # Canvas3D.tsx, GltfWrapper.tsx, CameraFeed.tsx, ARIAAssistant.tsx
│   │   ├── pages/              # CyberDashboard.tsx, Settings.tsx
│   │   └── App.tsx             # Main router, state machine, and MediaPipe mapping loop
│   └── package.json
│
├── eureka-automation/          # TypeScript scrapers & background queues
│   ├── src/
│   │   ├── scrapers/           # Academic crawling engines (ArXiv, PubMed)
│   │   └── queue/              # BullMQ message queue setup
│   └── package.json
│
├── kubernetes/                 # Production orchestration manifests
├── helm/                       # Configurable Helm charts for cloud rollouts
├── monitoring/                 # Prometheus dashboards and Grafana metrics config
└── docker-compose.yml          # Container configuration for all services

🚀 Installation & Setup

Environment Configuration

Create a .env file in the root directory before launching:

Parameter Default Value Description
GEMINI_API_KEY Required API Key from Google AI Studio.
DATABASE_URL postgresql://user:pass@db:5432/eureka PostgreSQL connection string.
REDIS_URL redis://redis:6379/0 Redis cache and queue address.
OLLAMA_HOST http://ollama:11434 Endpoint for local model fallbacks.

Option 1: Multi-Container Launch via Docker Compose (Recommended)

# Clone the repository
git clone https://github.com/Minato95-ayu/EUREKA.git
cd EUREKA

# Launch all services in background mode
docker-compose up --build -d

# Initialize local fallback model (Ollama)
docker-compose exec ollama ollama pull llama3

Option 2: Local Manual Setup (Development Mode)

1. Backend Server Setup

Ensure Python 3.11+ and C++ headers (for RDKit) are configured locally:

cd eureka-backend
python -m venv venv

# Activate Environment
# Windows:
.\venv\Scripts\activate
# Linux/macOS:
source venv/bin/activate

# Install libraries
pip install -r requirements.txt

# Run server
python main.py

2. Frontend Client Setup

cd ../eureka-frontend
npm install
npm run dev

🗺️ Project Roadmap

EUREKA is actively evolving. Here is the current progress towards the full JARVIS-style vision:

  • Phase 1: Cyber-Lab Dashboard Shell & Procedural 3D.
  • Phase 2: Voice Input & MediaPipe Hand Gesture Controls.
  • Phase 3: Curated "Search-to-3D" Object Schema & Hierarchy.
  • Phase 4: Real-time Interactive What-If Simulation Engine.
  • Phase 5: RAG-style Context Assembly (ArXiv/PubMed citations on screen).
  • Phase 6: Hybrid Cloud/Colab Architecture Optimization.
  • Phase 7: Fully Autonomous Batch Experimentation Workflows.

🛡️ Security & Compliance

EUREKA follows strict data safety and deployment patterns to protect server resources:

  • DDOS Shield: Integrated with slowapi to limit excessive client calls on computational-heavy 3D generation endpoints.
  • Secure Session Sign-In: Powered by stateless JWT (HS256) keys with automatic 24-hour cookie decay.
  • HTTP Strict Transport security: Nginx configurations enforce TLS 1.3 and block cross-frame scripting (XSS) via customized policy headers.
  • Isolation: Docker runtimes execute frontend/backend processes under non-privileged unprivileged user definitions.

🧪 Automated Test Suite

We maintain an active unit testing standard across simulation engines and AI routing networks.

# Go to backend folder
cd eureka-backend

# Execute tests with code coverage metrics
pytest -v --cov=app

👑 Founder & Developer

Ayush Kaushik

Ayush Kaushik

Lead Architect & Creator of EUREKA

  • 💻 Role: Full-Stack AI Engineer & System Designer
  • 🎓 Status: Developer & Creator | Google Hackathon Participant (IIT Delhi)
  • 🌐 GitHub: @Minato95-ayu
  • ✉️ Email: ayushkaushik1441@gmail.com

"EUREKA was built to democratize access to advanced scientific research interfaces. By combining spatial computing, voice controls, and LLM-driven generation, we enable students and researchers to visualize and experiment with complex structures without expensive laboratory setups."

📄 License & Citation

Distributed under the MIT License. See LICENSE for details.

If you leverage EUREKA in an academic context, please cite the project:

@software{eureka2026,
  title={EUREKA: Universal AI-Powered Virtual Research Lab},
  author={Kaushik, Ayush},
  year={2026},
  url={https://github.com/Minato95-ayu/EUREKA}
}

Made with ❤️ for scientific education and global research.
EUREKA — Where Discovery Begins. 🔬🚀

About

No description or website provided.

Topics

aiartificial-intelligencedeveloper-toolsinnovationmachine-learningnextjsopen-sourcepythonreactstartuptailwindcssweb-development

Resources

Readme
MIT license

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages