Neurelo Build Docs
Neurelo Build Docs
  • Introduction
    • Core Concepts
    • Key Features
  • Getting Started
    • Sign-in/Sign-up
    • Dashboard
      • Collapsible Sidebar
      • Light/Dark Mode
      • Account Settings
      • Audit Events
      • User Management
        • Permissions (Member v/s Admin)
      • Org Settings
    • Starting your Neurelo Project
      • Quick Start Guide
      • Step 1 - Add a Data Source
      • Step 2 - Build Definitions
      • Step 3 - Create an Environment
      • Step 4 - Create an API Key
      • Step 5 - Start Runners
      • Try your Neurelo APIs
  • "How to" Videos
    • Product Overview
    • Neurelo APIs & SDKs
    • Project Setup
    • Definitions
    • Environments
    • Data Sources
    • Organization Management
    • Creating and Using Custom Queries
    • Using the Schema Builder to build Relationships
    • Mock Data Generation
  • Definitions
    • Neurelo Schema Editor
      • Schema Builder
      • JSON/YAML Editor
      • Schema Visualization: Entity-Relationship Diagram (ERD)
    • Custom APIs for Complex Queries
      • Write and Commit Custom Queries
      • AI-Assisted Query Generation
      • Deploying Custom API Endpoints
      • Using Variables in your Custom Query
    • Branches and Commits
    • API Docs
  • Environments
    • Creating a new Environment
    • API Playground
    • Observability
    • Migrations
    • API Keys
  • Data Sources
    • PostgreSQL
    • MySQL
    • MongoDB
  • Guides
    • Provisioning Cloud Databases for using with Neurelo
      • PostgreSQL
        • AWS RDS (PostgreSQL)
      • MySQL
        • AWS RDS (MySQL)
      • MongoDB Atlas
    • Mock Data Generation
    • Wipe Data Source
    • Remote Git Repository for Definitions
      • Connecting a Remote Git Repo
      • Creating Commits from Neurelo
      • Syncing Branches
    • Data Viewer
    • Environment/Data Source Tags
    • How to work with Embedded documents and References in MongoDB
    • How to download and use the Postman Collection for your Project
    • Building Python applications with Postgres and FastAPI
    • CI Integration using Neurelo CLI
    • Schema Migrations
    • Schema AI Assist
    • Auto-Introspection
    • Access Policies
    • User Auth
      • Google
      • GitHub
      • GitLab
    • MongoDB Atlas - Migrate GraphQL to Neurelo
    • MongoDB Atlas - Migrate REST Data APIs to Neurelo
  • MongoDB Atlas - Migrate REST Data APIs to Neurelo
  • MongoDB Atlas - Migrate GraphQL APIs to Neurelo
  • Neurelo Schema Language (NSL)
    • Example 1 - DVD Rentals
    • Example 2 - Simple "Posts" App
    • Example 3 - Bookstore
  • Neurelo API Reference (REST)
    • Examples of Neurelo Auto-Generated REST API endpoints
      • Example 1 - Simple “Posts” application
      • Example 2 - "DVD Rentals" application
      • Example 3 - "Bookstore” application
      • cURL API Examples
  • Neurelo API Reference (GraphQL)
  • SDKs
    • TypeScript / JavaScript SDK
    • Go SDK
    • Python SDK
      • Python SDK Tutorial -- News Application
        • News Application using Neurelo’s Python SDKs
  • CLI (Preview Version)
  • Self-Hosted Neurelo Gateways
  • Tutorials
    • Building a Real Time Chat Application with Neurelo and MongoDB using Python
    • Building A Financial Terminal with Neurelo and MongoDB in Rust
    • Building a Restaurant Management System with Neurelo and MongoDB using GraphQL in just a few minutes
    • Bringing Neurelo’s Data APIs to Life Instantly with MySQL
  • Project Examples
  • References
    • Supported Databases
    • Supported OS and Browsers
  • Support
Powered by GitBook
On this page
  • Overview
  • Automated Definition Building with an Existing Database:
  • Manual Definition Building without Existing Database Definitions:
  1. Getting Started
  2. Starting your Neurelo Project

Step 2 - Build Definitions

PreviousStep 1 - Add a Data SourceNextStep 3 - Create an Environment

Last updated 1 year ago

Overview

Neurelo's data definition comprises of three key elements - Schema, Auto-Generated APIs and Custom Queries. Definitions existing inside a project and are scoped to that particular project. Different projects will have their own definitions. Step 2 of the project onboarding process is to build the definitions (in particular, the schema) to be used for the project.

The "Build Definitions" phase in Neurelo plays a pivotal role in shaping how your project interacts with data. This step varies depending on your database setup and the presence of existing definitions. Here's what you need to know:

Automated Definition Building with an Existing Database:

  • When you linked a database as a data source in Step 1 of the onboarding and it contains pre-defined schemas or definitions, Neurelo automates the building of your project definitions. In this case, you will typically see the following processes completed automatically:

    • Neurelo Schema Added: The platform successfully integrates your existing schema into the Neurelo environment.

    • REST and GraphQL Data Access APIs Generated: Neurelo automatically generates REST and GraphQL APIs based on your existing database schema, facilitating easy data access.

    • API Documentation Generated: Alongside API generation, Neurelo creates comprehensive documentation for these APIs, enhancing usability and understanding.

If a valid schema was identified, Step 2 of the onboarding process is complete and the user can proceed to Step 3 (Creating an Environment).

If the introspected schema has errors, or Neurelo could not identify a valid schema then users will need to fix or build the schema by going to the editor

Manual Definition Building without Existing Database Definitions:

  • In scenarios where your database doesn’t have pre-defined schemas, you will encounter a different interface, with a prompt to go to the Neurelo definitions editor interface

  • This option leads you to a interface where you can:

    • Manage Database Schemas: Directly interact with and modify your database schema using branches and commits.

    • Customize Definitions: Perform customization and set up definitions according to your project requirements.

    • Additional Customization Settings: Access various settings to further tailor the definitions to your needs.

  • For more detailed actions and capabilities within the editor, refer to the following sections in this document

Once the definitions have been built, users can now proceed to Step 3 (Create an Environment).

Whether your project involves integrating existing definitions or creating new ones from scratch, the "Build Definitions" step in Neurelo ensures that your data models and APIs are precisely aligned with your project's needs.

Neurelo Schema Editor
Neurelo Schema Language (NSL)