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
  • Cloud Data APIs
  • Neurelo Information Architecture
  • Organizations
  • Members
  • Projects
  • Data sources
  • Data Definitions
  • Schemas
  • Auto-Generated APIs and API Docs
  • Custom Queries
  • Environments
  • Runners
  1. Introduction

Core Concepts

PreviousIntroductionNextKey Features

Last updated 1 year ago

This is the guide for the vocabulary and key concepts used in Neurelo to help with building a strong understanding of Neurelo's features and capabilities.

Cloud Data APIs

Cloud Data APIs (Application Programming Interfaces) refer to an interface that allows applications to interact with and access data from data sources such as databases. Cloud Data APIs enable seamless communication between applications and data sources, allowing for the retrieval, manipulation, and management of data over the network.

Neurelo supports REST and GraphQL API protocols. Instead of running on a local server or infrastructure, these APIs are automatically deployed and managed on Neurelo's Cloud Platform.

This approach allows developers to integrate various functionalities and services into their applications without the need to manage the underlying infrastructure, while offering several advantages including scalability, options to securely access the data with different deployment strategies and the ability to collaborate on and extend data in their data sources.

Neurelo Information Architecture

Organizations

A company or a large division within a company would be an organization in Neurelo. Organization is the highest level entity in the Neurelo information hierarchy. Every Neurelo account belongs to one or more organizations.

Members

A team member is an individual who is part of a group or team, collaborating with others to achieve common goals or objectives. A member belongs inside an organization. Every member in Neurelo has their own Neurelo account.

Projects

A project is an application (or software or workload) that developers build and run with Neurelo. A project can be a front-end application, back-end application, a monolith or a micro-service, etc. A project is the primary “working” entity where all things start inside Neurelo. A project would exist inside an Organization and has its own set of entities such as dashboards, data definitions, environments, data sources, etc. that belong to that project.

Data sources

A database such as PostgreSQL, MongoDB, MySQL. One ore more data sources can be added to projects inside Neurelo. Data sources can include cloud-provider databases (e.g. AWS RDS, Aiven, MongoDB Atlas, etc.), self-managed instances, and local databases

Data Definitions

Neurelo's data definition comprises of three key elements - Schema, Auto-Generated APIs and Custom Queries. Definitions exist inside a project and are scoped to that particular project. Different projects will have their own definitions.

Schemas

Neurelo Schema is the representation of data models that define the shape and structure of the data for applications. Schema captures different characteristics of data such as the name of data field (label), type of data field (integer, string, datetime), what can be done with that data (read, write), relationships across data, and more.

Neurelo Schema supports both Visual (Schema Builder) and codified (JSON and YAML) editing experiences and provides Git-like branches, commits and version control for the definitions.

Auto-Generated APIs and API Docs

Neurelo instantly generates Data APIs in both REST and GraphQL formats from the specified schema (data model). These APIs efficiently manage a large spectrum of operations encompassing Create, Read, Update, and Delete (CRUD) functionalities across individual entities (Tables/Collections) as well as handling JOIN queries across multiple entities against the underlying database. Neurelo offers comprehensive API documentation and version control that further enhance the ability to collaborate across building an application, and the accessibility and maintainability of these APIs.

Custom Queries

A custom query refers to User-Defined complex query for retrieving or updating specific information from the database. These queries are typically used for very advanced data operations and may involve multiple criteria, conditions, or operations to extract specific and nuanced information from the database, beyond what can be done with the auto-generated APIs.

Neurelo offers users the ability to write and test custom queries against their data sources in a project and to create API endpoints from these custom queries. This capability allows users to extend Neurelo's APIs and to have complete flexibility to query and update the data from their data sources.

Environments

An environment is a run-time workspace that allows users to run their Neurelo APIs using a specific version (commit), of their definitions and custom queries, against a specific data source. Neurelo environments are built to be naturally aligned to typical Software Development LifeCycles (SDLCs) as applications are developed, tested, deployed, and operated. This encompasses various stages, including:

  1. Development (Dev) Environments: Environments in which developers build, extend, and debug code.

  2. Test Environments: Typically a separate environment where software is tested. This includes environments which be run as part of pipelines, regression test suites, continuous test environments, performance tests, long running tests, etc.

  3. Staging Environments: A pre-production environment where the software is deployed for final validations before release.

  4. Production Environments: The final live environment where the application is deployed for end-users.

Runners

A runner in Neurelo is the main component that executes and manages all API calls. In Neurelo's Cloud Data Access Platform, a runner is a part of every environment inside a project. Runners need to be started for the application to be able to handle API requests and process them against the configured data source within an environment.