🧱 Intellibrix 🧱

AI-Powered Software Component Framework

“Software and cathedrals are much the same; first we build them, then we pray.” --Sam Redwine

Made with ❤️ by Jay Mathis


View Docs Made with TypeScript

Version CircleCI Last Commit Open issues Closed issues

Sponsors Contributors GitHub license PRs Welcome

Followers Watchers Stars


Intellibrix is a software component framework that organizes functionality into Structures and Bricks.

  • A Brick is a software component that provides a specific functionality.

  • A Structure is a collection of Bricks that can coordinate between them.

  • A Brick can interact with its parent Structure via this.structure

  • A Structure can enumerate and interact with its child Bricks via this.bricks

  • A Brick can contain many Programs that provide different related functionality.

  • A Program contains Steps that are executed in sequence to perform a specific task.

  • A Step contains Actions that are executed in sequence to act upon, process, and transform the data.

  • A Brick can also contain Tasks that are scheduled to run at a specific time or interval.

  • A Database can be attached to a Brick to provide database capabilities.

  • An Intelligence can be attached to a Brick to provide AI or other custom processing capabilities.

  • Both Bricks and Structures have an EventEmitter that can be used to emit and listen for events.

  • You aren't limited to using Programs, Databases, and Intelligence - extend a brick and make it work however you want!


npm install --save intellibrix # or your package manager's equivalent


AI Smart Brick Example

import { Brick, Intelligence, Structure } from 'intellibrix'

const structure = new Structure() // We add our bricks to this (optional)'add', ({ brick, structure }) => { // Listen for bricks being added to the structure (optional)
console.log(`Added brick ${} to ${}`)

const intelligence = new Intelligence({ // Define our intelligence
service: 'openai', // default
model: 'gpt-3.5-turbo', // default
system: 'Respond to every question in the style of Shakespeare', // optional
key: 'OPENAI_API_KEY' // replace with your API key

const brick = new Brick({ intelligence }) // Create the brick, passing our intelligence
structure.add(brick) // Add the brick to the structure (optional)

// This is the core feature of Bricks, they're programmable
brick.program({ // Define a program on our brick
name: 'poem', // Program name
description: 'Generate a poem', // Program description
steps: [ // One or many steps
name: 'step_1', // Step name
description: 'Fetch a response from the OpenAI API', // Step description
actions: [ // One or many actions
name: 'fetch_poem', // Action name
description: 'Fetch a response from the OpenAI API', // Action description
method: async function ({ topic }) { // This is the function that will be executed for this action
return await`Write a poem about ${topic}`) // Ask the AI to answer our question

const { text } = await'poem', { topic: 'TypeScript' })

// You can also access directly
// const { text } = await'Write a poem about TypeScript')
// console.log(text)

Dumb Brick Example

import { Brick, Structure } from 'intellibrix'

const structure = new Structure()
const brick = new Brick()

// This program will return the result of a multi-step calculation with multiple actions
// This is intentionally overcomplicated to show how to chain actions and steps
// name and description are optional, but can be used for easier analysis and debugging later
name: 'calculate',
description: 'Multi-step calculation',
steps: [
name: 'Step 1',
description: 'Add the numbers, then multiply by a random number between 0 and 1',
actions: [
name: 'sum',
description: 'Add two numbers',
method: async function ({ x, y }) {
return x + y
name: 'multiply',
description: 'Multiply a number by a random number between 0 and 1',
method: async function (payload) {
return payload * Math.random()
name: 'Step 2',
description: 'Add a random integer between 10 and 50 to the result and return the floor',
actions: [
name: 'add_random',
description: 'Add a random integer between 10 and 50 to the result',
method: async function (payload) {
return payload + Math.floor(Math.random() * (50 - 10 + 1) + 10)
name: 'floor',
description: 'Round the result down to the nearest integer',
method: async function (payload) {
return Math.floor(payload)

const result = await'calculate', { x: 1, y: 2 })

Database Example

import { Brick, Database, Structure } from 'intellibrix'

const structure = new Structure()
const keyValueDatabase = new Database()
const sqlDatabase = new Database({ service: 'sql', uri: 'sqlite::memory:' })
const keyValueBrick = new Brick({ database: keyValueDatabase })
const sqlBrick = new Brick({ database: sqlDatabase })

keyValueBrick.db.interface.set('foo', 'bar')
const foo = await keyValueBrick.db.interface.get('foo')

// Also access all of Sequelize's power directly with sqlBrick.db.sequelize
await sqlBrick.db.interface.query('CREATE TABLE IF NOT EXISTS `users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `name` TEXT NOT NULL, `rank` TEXT NOT NULL)')
await sqlBrick.db.interface.query('INSERT INTO `users` (`name`, `rank`) VALUES (?, ?)', ['Belisarius Cawl', 'Archmagos'])
const results = await sqlBrick.db.interface.query('SELECT * FROM `users`')

Custom Intelligence Example

import { Brick, Intelligence } from 'intellibrix'

const intelligence = new Intelligence({
service: 'custom',
method: async function ({ name }) {
// You would likely want to do something more interesting here
return `Hello ${name}`

const brick = new Brick({ intelligence })
const response = await{ name: 'Belisarius Cawl' })

Extending a Brick

import { Brick } from 'intellibrix'

class MyBrick extends Brick {
constructor (options) {

myMethod ({ topic }) {
return `${topic} has ${topic.length} characters`

const brick = new MyBrick({ name: 'My Brick' })
const lengthString = brick.myMethod({ topic: 'TypeScript' })


Intellibrix uses Pino for logging in both Bricks and Structures:

import { Brick, Structure } from 'intellibrix'

// To use raw JSON logs, pass { logJSON: true } to the Brick or Structure constructor
// Pass in pinoOptions to override the default transport and logging options
const structure = new Structure({ name: 'My Structure', logLevel: 'debug' })
const brick = new Brick({ name: 'My Brick', logLevel: 'silent' })
structure.add(brick) // Outputs: DEBUG (STRUCTURE:My Structure): Added Brick: My Brick'This is an info message') // Outputs: INFO (STRUCTURE:My Structure): This is an info message
brick.log.fatal('This is a fatal message') // Outputs: Nothing because logLevel is set to silent


Intelligence is a class that provides AI or other custom processing capabilities to a Brick. It can currently utilize the OpenAI API or a custom function to manually process data.

An Intelligence has these methods:

  • ask('Tell me about the biggest event from 1938', context?) - Ask the AI a question and return the response (prompt, context?)
  • image('A shiny red apple', '1024x1024') - Generate an image from a text prompt (prompt, size? = '256x256')

You may pass a context array of the format [{ role: 'user' | 'assistant', content: string }] to ask() to provide context to the AI.

You may also access the openai library directly with

An OpenAI Intelligence supports the function-calling API (see test/function.test.ts):

const intelligence = new Intelligence({
service: 'openai',
model: 'gpt-3.5-turbo-0613',
functions: {
schema: [
name: 'return_answer',
description: 'Test function',
parameters: {
type: 'object',
required: ['answer', 'explanation'],
properties: {
answer: {
type: 'string',
description: 'The answer to the question'
explanation: {
type: 'string',
description: 'The explanation of the answer'

methods: {
return_answer: async (payload) => {
payload.processed = true // This just shows that you can modify the payload
return payload

const brick = new Brick({ intelligence })
const response = await'What is 42 + 42?')


Database is a class that can be attached to a Brick to provide database capabilities. It currently supports in-memory key-value storage as well as various SQL servers via Sequelize.

A Database has these methods, depending on the type of storage:

In-Memory Key-Value Storage:

  • set('foo', 'bar') - Set a key to a value
  • get('foo') - Get a value from a key
  • delete('foo') - Delete a key
  • dump() - Dump the entire database to an object
  • load(data) - Overwrite the entire database with an object

SQL Storage:

  • query('SELECT * FROM users WHERE name="?"', ['Fabius Bile']) - Run a SQL query


Both Structures and Bricks have EventEmitters that can be used to emit and listen for events.

const structure = new Structure()
const brick = new Brick()'foo', () => console.log('foo'))'bar', () => console.log('bar'))'foo')'bar')


Bricks can be assigned scheduled tasks to perform at a certain time or interval. Both cron syntax and Date objects are supported.

Scheduled tasks are powered by node-cron.

const brick = new Brick()

const cronTask = brick.schedule({
name: 'New Year Cron',
description: 'This uses cron syntax and will run on January 1st at 12:00 AM',
schedule: '0 0 1 1 *',
start: true, // Start the task immediately, otherwise you must call task.cronjob.start() manually - this does not execute the task
method: () => console.log('Happy New Year!')

const dateTask = brick.schedule({
name: 'New Year Date',
description: 'This uses a Date object and will run on January 1st at 12:00 AM',
schedule: new Date('January 1, 2022 00:00:00'),
start: false,
method: () => console.log('Happy New Year!')

brick.unschedule('New Year Cron') // Remove a task from the brick's schedule
dateTask.cronjob.start() // Since we didn't use the start option, we must start the task manually or it won't run when the date is reached

Bundled Bricks

The core intellibrix package comes with some bricks that provide basic functionality and serve as examples.

You can also find more complex Bricks under the @intellibrix scope on NPM.

If you would like to contribute a Brick, you may self-publish or if you'd like your Brick to be under the @intellibrix scope, contact

You can instantiate these like any other Brick, passing in the appropriate Intelligence, Database, and options.

  • Express Web Server
    • A brick that provides a basic Express web server
    • import ExpressBrick from 'intellibrix/bricks/express'
      • const routes = [{ method: 'get', path: '/', handler: (req, res) => res.send('Hello World!') }]
      • const brick = new ExpressBrick({ port: 3000, routes })
  • Internationalization
    • A brick that provides internationalization support powered by i18next
    • import I18nBrick from 'intellibrix/bricks/i18n'
      • const brick = new I18nBrick({ defaultLanguage: 'en', resources: { en: { translation: { hello: 'Hello World!' } } } })
      • console.log(brick.t('hello'))
  • Terminal
    • A brick that provides a terminal interface powered by TerminalKit
    • TerminalKit allows for rich UI elements such as progress bars, tables, and more
    • import TerminalBrick from 'intellibrix/bricks/terminal'
      • const brick = new TerminalBrick()
      • brick.print('What is your name? ')
      • const name = await brick.input()
  • Question and Answer
    • Simple question and answer functionality powered by OpenAI
    • import QABrick from 'intellibrix/bricks/qa'
      • const qa = new QABrick({ intelligence })
      • const { text } = await'qa', { question: 'What is the meaning of life?' })
      • You may pass a context array to the payload of this format to provide conversation history to the AI


git clone # or your fork
cd intellibrix
npm install # or your package manager's equivalent

Create an env.js file in the .jest folder containing the following:

process.env.USE_OPENAI=true // Set to false to disable OpenAI tests
process.env.OPENAI_API_KEY="sk-YOUROPENAIAPIKEY" // Your OpenAI API key
process.env.DATABASE_URI="postgresql://user:pass@host:port/dbname" // Your database URI

Then run:

npm run test:watch