Neural Nexus - AI Model Hub

Star the Repo⭐

The Ultimate Hub for AI Innovators

Welcome to Neural Nexus

Welcome to Neural Nexus, a comprehensive AI model hub where you can upload, sell, and transfer ownership of your AI creations using various payment methods including cryptocurrency, UPI, PayPal, and net banking. We focus on building a vibrant community of creators and innovators shaping the future of AI, emphasizing innovation and collaboration.

We're inspired by the 'Radio on the Internet' concept for AI—powered by strategic partnerships and a commitment to open access. Our mission is to democratize AI by providing free models and data, inspired by the Transformers library from Hugging Face, while also offering premium content for advanced users.

Features

• Upload AI Models: Share your models with the world
• Secure Payments: Process payments via Stripe, Razorpay (UPI), or Cryptocurrency (MetaMask)
• Modern Authentication: Sign in with Google, GitHub, email, or cryptocurrency wallets
• Ownership Transfer: Transfer model ownership with blockchain security
• Open Source Models: Access a comprehensive library of free models inspired by Transformers
• Premium Marketplace: Buy and sell premium models and datasets for advanced projects
• Modern UI: Responsive design with smooth animations and contemporary aesthetics
• Email Notifications: Receive important updates via email using SendGrid integration

Technology Stack

• Next.js: React framework for high-performance applications
• Tailwind CSS: Utility-first CSS framework for modern styling
• Framer Motion: Animation library for enhanced user experience
• Supabase: Open-source Firebase alternative for authentication and database management
• Stripe & Razorpay: Payment processing solutions
• SendGrid: Email delivery service for transactional emails
• Edge Functions: Lightweight serverless functions for optimal performance

  # In a new terminal, initialize the database (one-time setup)
  curl "http://localhost:3000/api/supabase-setup?setup_key=YOUR_SETUP_KEY_FROM_ENV"
  ```

      node test-sendgrid.js [email protected]

npm run dev

Neural Nexus NPM Package

A modern, TypeScript-first toolkit for connecting with AI models on the Neural Nexus platform. Effortlessly deploy, manage, and share models, integrate with a marketplace, and handle authentication and payments—all with a single, powerful npm package.

Official NPM: neural-nexus

npm install neural-nexus

npm install neural-nexus@v1

API Key Management & Usage

All API requests require authentication using an API key. You can generate and manage your API keys from your Neural Nexus dashboard.

Authorization: Bearer YOUR_API_KEY

const response = await fetch('https://api.neuralnexus.biz/v1/models', {
  headers: {
    'Authorization': `Bearer ${process.env.NEURAL_NEXUS_API_KEY}`
  }
});
const data = await response.json();

import { NeuralNexus } from 'neural-nexus';
const nexus = new NeuralNexus({
  apiKey: process.env.NEURAL_NEXUS_API_KEY,
  environment: 'production'
});

async function createApiKey() {
  const API_KEY = process.env.NEURAL_NEXUS_API_KEY;
  const response = await fetch('https://api.neuralnexus.biz/v1/api-keys', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'My Development Key',
      type: 'development'
    })
  });
  const data = await response.json();
  console.log('New API key created:', data);
  console.log('IMPORTANT: Save this key now as it won\'t be shown again!');
  return data;
}

For more details, see the official npm package page.

Supabase Data Model

CREATE TABLE user_profiles (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  first_name TEXT,
  last_name TEXT,
  display_name TEXT,
  email TEXT,
  bio TEXT,
  avatar_url TEXT,
  website TEXT,
  social_links JSONB,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE models (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  name TEXT NOT NULL,
  description TEXT,
  price DECIMAL(10, 2) DEFAULT 0,
  category TEXT,
  tags TEXT[],
  file_url TEXT,
  file_path TEXT,
  file_size BIGINT,
  file_type TEXT,
  thumbnail_url TEXT,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  downloads INTEGER DEFAULT 0,
  rating DECIMAL(3, 2) DEFAULT 0,
  is_public BOOLEAN DEFAULT true,
  status TEXT DEFAULT 'active'
);

4. For direct access to wallet state, use the `useSimpleCrypto` hook:
```tsx
import { useSimpleCrypto } from '@/providers/SimpleCryptoProvider';

function MyComponent() {
  const { activeWallet, connectWallet, disconnectWallet } = useSimpleCrypto();

  return (
    <div>
      {activeWallet ? (
        <div>Connected to: {activeWallet}</div>
      ) : (
        <button onClick={() => connectWallet('MetaMask')}>Connect</button>
      )}
    </div>
  );
}

# Step 1: Use our custom build script that patches the auth pages
npm run custom-build

# Step 2: Start the application using our custom server
npm run custom-start

# Run the custom build script that handles auth page issues
npm run custom-build

# Start the custom server that handles auth pages
npm run custom-start

Community & Support

Join our active community to get help, share ideas, and connect with other developers!

Supabase Data Model

The application uses the following Supabase tables:

user_profiles

CREATE TABLE user_profiles (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  first_name TEXT,
  last_name TEXT,
  display_name TEXT,
  email TEXT,
  bio TEXT,
  avatar_url TEXT,
  website TEXT,
  social_links JSONB,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

models

CREATE TABLE models (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  name TEXT NOT NULL,
  description TEXT,
  price DECIMAL(10, 2) DEFAULT 0,
  category TEXT,
  tags TEXT[],
  file_url TEXT,
  file_path TEXT,
  file_size BIGINT,
  file_type TEXT,
  thumbnail_url TEXT,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  downloads INTEGER DEFAULT 0,
  rating DECIMAL(3, 2) DEFAULT 0,
  is_public BOOLEAN DEFAULT true,
  status TEXT DEFAULT 'active'
);

Deployment on Vercel

1. Push your code to a GitHub repository
2. Go to Vercel and create a new project
3. Connect your GitHub repository
4. Set all the environment variables from your .env.local file in the Vercel dashboard
5. Deploy your application

Setting Up Environment Variables on Vercel

• Go to your project settings in Vercel
• Navigate to Environment Variables
• Add all the variables from your .env.local file
• Make sure to set NEXT_PUBLIC_APP_ENV=production
• Redeploy your application to apply the changes

MongoDB Configuration for Production

• In your Vercel deployment, ensure MongoDB connection string is correctly set
• Add MONGODB_URI and MONGODB_DB_NAME to your environment variables
• If users report profile update errors, check the following:
  • MongoDB connection string should be clean without unnecessary parameters
  • The IP allowlist in MongoDB Atlas should include Vercel's deployment IPs
  • The application includes fallback in-memory storage if the database connection fails
  • User profiles will be stored temporarily and sync when the database connection is restored
• For persistent database issues, consider using MongoDB Realm/Atlas App Services for better connectivity

Monitoring and Analytics

Both Supabase and Firebase provide tools to monitor your application:

1. Supabase Dashboard: Track database usage, API calls, and authentication
2. Firebase Analytics (if using): Track user engagement and app usage
3. Vercel Analytics: Monitor page performance and user metrics

Edge Functions vs. Serverless Functions

This app uses both Edge Functions (for lightweight operations) and standard serverless functions (for heavier processing):

• Edge Functions: Fast, lightweight API routes that run globally close to users
• Serverless Functions: More powerful Node.js environments for database operations and complex processing

Web3 Wallet Integration

Neural Nexus includes a lightweight wallet connection system through the SimpleCryptoProvider. This replaces the previous TonConnect implementation.

Enabling the Wallet Connection

To enable wallet connection in your application:

1. Set the feature flag in your .env.local file:

   NEXT_PUBLIC_ENABLE_SIMPLE_CRYPTO=true

2. The wallet connect button will automatically appear in the navbar when the feature flag is enabled.

3. For custom integration, you can use the SimpleCryptoButton component:

   
   import dynamic from 'next/dynamic';

// Import with dynamic to avoid SSR issues const SimpleCryptoButton = dynamic( () => import('@/components/SimpleCryptoButton'), { ssr: false } );

// Then use it in your component function MyComponent() { return ; }

4. For direct access to wallet state, use the `useSimpleCrypto` hook:
```tsx
import { useSimpleCrypto } from '@/providers/SimpleCryptoProvider';

function MyComponent() {
  const { activeWallet, connectWallet, disconnectWallet } = useSimpleCrypto();

  return (
    <div>
      {activeWallet ? (
        <div>Connected to: {activeWallet}</div>
      ) : (
        <button onClick={() => connectWallet('MetaMask')}>Connect</button>
      )}
    </div>
  );
}

Policies & Documentation

We maintain comprehensive documentation on how we handle data, models, and content. Please review our policies for complete transparency:

• Privacy Policy: Learn how we protect your data and maintain information security. Read More
• Content Policy: Keep the vibes positive! Understand what content is cool to share on Neural Nexus. Read More
• Model Policies: Rules for uploading and sharing AI models. Let's keep the AI game fair and innovative. Read More
• Cookie Policy: We use cookies to make your experience smoother than butter. Find out how. Read More
• Updates & Changelog: Stay updated with the latest changes and features. We're always leveling up! Read More

These docs are here to ensure we're all on the same page, building a safe and creative space for AI innovation. Got questions? Hit us up! 💬

Build Instructions

When building the project for production, you might encounter "document is not defined" errors for authentication pages. This is a common issue with Next.js when client-side features are used during static site generation.

To solve this issue, use our custom build and start scripts:

# Step 1: Use our custom build script that patches the auth pages
npm run custom-build

# Step 2: Start the application using our custom server
npm run custom-start

Our custom build script (build-with-cleanup.sh) handles the following:

1. Cleans up previous build artifacts
2. Runs the Next.js build process
3. If auth page errors occur, it patches the build by:
   • Creating fallback static HTML files for problematic routes
   • Copying these files to the appropriate output directories

The custom server (dev-server.js) then:

1. Serves the static HTML fallbacks for auth routes
2. Handles all other requests normally through Next.js

This approach ensures that authentication pages work correctly in production without the "document is not defined" errors.

Build Instructions for Auth Pages

Next.js has challenges with client-side authentication pages during static site generation, often resulting in "document is not defined" errors. This project includes special handling to resolve these issues:

Using the Custom Build Process

# Run the custom build script that handles auth page issues
npm run custom-build

This script:

1. Cleans previous build artifacts
2. Creates static HTML fallbacks for auth pages if needed
3. Runs the build with proper environment variables
4. Patches the generated files to ensure auth pages work correctly

Using the Custom Server

After building the project, start it with:

# Start the custom server that handles auth pages
npm run custom-start

This custom server serves static HTML fallbacks for authentication pages, preventing issues with client-side code during the initial page load.

How It Works

The solution uses multiple techniques:

• Middleware detection for build vs. runtime environments
• Static HTML fallbacks for auth pages
• Custom server for serving static content
• Next.js configuration to properly handle client-only pages

If you modify auth-related pages, ensure the build process is aware of these pages by updating the configuration in:

• middleware.ts
• next.config.js
• build-with-cleanup.sh

Overview

Neural Nexus is a powerful platform for AI model deployment, collaboration, and marketplace. It integrates modern web technologies with AI capabilities to provide a seamless experience for researchers, developers, and users.

Key Features

• 🧠 AI model marketplace and deployment
• 🔒 Secure authentication with multiple providers
• 💰 Payment processing with Stripe and Web3
• 📊 Advanced analytics dashboard
• 🚀 Fast, modern UI built with Next.js and Tailwind CSS

Tech Stack

• Frontend: Next.js, React, Tailwind CSS
• Authentication: Supabase Auth, NextAuth.js
• Database: Supabase PostgreSQL
• Payment: Stripe, Coinbase SDK
• Deployment: Vercel/Netlify compatible

Getting Started

Prerequisites

• Node.js 18+
• npm or yarn

Installation

# Clone the repository
git clone https://github.com/Drago-03/neural-nexus.git
cd neural-nexus

# Install dependencies
npm install

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

# Start development server
npm run dev

Build Instructions

When building the project for production, you might encounter "document is not defined" errors for authentication pages. This is a common issue with Next.js when client-side features are used during static site generation.

For the best production build experience, use our custom build scripts:

# Standard build with patching
npm run build

# OR for a more thorough approach with cleanup
npm run custom-build

The build process includes:

1. Pre-build preparation of static HTML fallbacks
2. The main Next.js build
3. Post-build patching to ensure all files are present

Running in Production

# Standard Next.js server
npm run start

# Custom server with enhanced handling of auth pages
npm run custom-start

Troubleshooting Common Issues

"document is not defined" Errors

These errors occur during server-side rendering of pages that use client-side browser objects. Our build process automatically handles this by:

1. Using static HTML fallbacks for auth pages
2. Patching build artifacts post-build
3. Setting proper runtime configurations

Edge Runtime Configuration

We use the experimental edge runtime for authentication pages. If you encounter issues:

# Check that your next.config.js has the correct settings
# Ensure each auth page exports the runtime configuration
export const runtime = "experimental-edge";

Missing Build Artifacts

If your deployment is missing critical files:

# Run the patch script manually
node ./scripts/patch-build.js

Contributing

Contributions are welcome! Please check out our Contributing Guide for details.

Open Bounties

Get paid to contribute! Check out our open bounties and earn rewards for your contributions.

License

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

GitHub Workflows and Automation

This repository uses several GitHub Actions workflows to automate processes and improve collaboration:

Automatic PR Labeling

Pull requests are automatically labeled based on the files changed:

• frontend: Changes to app, src, components, or public directories
• backend: Changes to lib, api, server, or providers directories
• documentation: Changes to markdown files or docs directory
• config: Changes to configuration files
• dependencies: Changes to package.json or lock files
• testing: Changes to test files
• ui: Changes to CSS, styles, or UI components
• auth: Changes to authentication-related code
• feature: Changes to feature-specific directories

PRs are also labeled by size:

• XS: < 10 lines
• S: 10-99 lines
• M: 100-299 lines
• L: 300-499 lines
• XL: 500-999 lines
• XXL: 1000+ lines

Issue Labeling

Issues are automatically labeled based on their title and content:

• bug: Issues reporting bugs or problems
• enhancement: Feature requests and improvements
• documentation: Documentation-related issues
• question: Questions and help requests
• performance: Performance-related issues
• security: Security-related issues
• ui: UI/UX-related issues
• auth: Authentication-related issues
• good first issue: Issues suitable for newcomers

Dependency Management

Dependabot automatically creates PRs for dependency updates:

• NPM dependencies are checked weekly
• GitHub Actions are checked weekly
• All updates require manual review and approval

Stale Issue Management

Issues and PRs with no activity for 30 days are marked as stale and closed after 7 more days of inactivity. Issues labeled as bug, security, enhancement, documentation, or good first issue are exempt.

Code Ownership

The CODEOWNERS file automatically assigns reviewers to PRs based on the files changed.

Sponsors

We're grateful to our sponsors who make this project possible.

Storage Service

The Neural Nexus application includes a flexible storage service that can operate in two modes:

1. Google Cloud Storage (Production): When properly configured with Google Cloud credentials, the application will use Google Cloud Storage for file uploads and data storage.

2. Local Fallback (Development): If Google Cloud credentials are missing or invalid, the application will automatically fall back to local file system storage, which is ideal for development and testing.

Configuration

To use Google Cloud Storage, set the following environment variables:

GOOGLE_CLOUD_PROJECT_ID=your-project-id
GOOGLE_CLOUD_STORAGE_BUCKET=your-bucket-name
GOOGLE_CLOUD_ACCESS_KEY=your-access-key
GOOGLE_CLOUD_SECRET_KEY=your-secret-key

If these variables are not set, the system will automatically use the local storage fallback.

Testing Storage

You can test the storage implementation using the provided test scripts:

# Test local storage fallback
node test-storage-fallback.js

The storage service is used for:

• Storing model files
• Uploading model thumbnails
• Storing user assets
• Managing application data

User Profiles with Google Cloud Storage

Neural Nexus now supports storing user profiles and avatars on Google Cloud Storage. This includes:

• Profile Data Storage: User profiles are stored in Google Cloud Storage with automatic fallback to in-memory storage for development.
• Avatar Upload: Users can upload, update, and delete their profile pictures, which are stored in Google Cloud Storage.
• Email Notifications: Users receive email notifications when their profiles are updated (if enabled in preferences).

Setting Up Google Cloud Storage

1. Create a Google Cloud Storage bucket for your user profiles and avatars
2. Add the following environment variables to your .env.local file:

   GOOGLE_CLOUD_PROJECT_ID=your_project_id
   GOOGLE_CLOUD_STORAGE_BUCKET=your_bucket_name
   GOOGLE_CLOUD_ACCESS_KEY=your_access_key
   GOOGLE_CLOUD_SECRET_KEY=your_secret_key
   GOOGLE_CLOUD_CLIENT_EMAIL=your_client_email

3. Ensure your storage bucket has proper CORS configuration to allow uploads from your domain

User Profile Features

• Profile Editing: Edit your profile at /profile/edit
• Profile Viewing: View your profile at /profile
• Avatar Management: Upload, update, and delete your avatar
• Social Links: Add links to your social media profiles
• Customizable Settings: Manage email notification preferences

For more details, see the User Profiles Documentation.

Contributing

Got ideas to make this even more lit? Drop a PR or issue. Let's build this together! 💡

Contributors

Thanks to all our awesome contributors who are helping build Neural Nexus! 🔥

"The future belongs to those who believe in the beauty of their code."

— Neural-Nexus Team

License

© 2025 Indie Hub. All rights reserved. Keep it real, fam! ✌️

GitAds Sponsored