Reaktor

A Reaktor is a deployable unit in the Reaktor AI Engine that encapsulates the code (Reaktor-Definition) and configuration (Reaktor-Blueprint) necessary to define, configure, and execute an Aktor graph via a REST endpoint. It represents the complete, operational entity that can be deployed to process requests or run periodically.

In essence, the Reaktor is the entire deployable AI engine, combining code and configuration to provide a functional, request-driven or scheduled process. As shown in the "Reaktor overview" diagram, it ties together the Reaktor-Definition, Reaktor-Blueprint, REST Endpoint, and Aktor composition into a single, cohesive unit ready for deployment.

This section sets the theoretical background for Reaktors. To see how to create a Reaktor, please refer to the Reaktor Development documentation.

How it works

• Reaktor-Definition: TypeScript code (in a .reaktor.ts file) that defines the Aktor graph—a composition of asynchronous, functional Aktors. It includes a factory function (createReaktor) to create the root Aktor and specifies input/output schemas using Zod.
• Reaktor-Blueprint: Builds on the Reaktor-Definition by providing metadata, settings (stored in Reaktor-Setting), and declaring the Reaktor-REST-Endpoint for execution.
• REST Endpoint: The entry point that, when invoked, uses the ReaktorFactory to create an instance of the Aktor graph, processes the request, and returns the output.
• Aktor Graph: The core logic composed of Aktors, which processes inputs and produces JSON-serializable outputs or streams.

Reaktor Structure

Reaktors are composed of Aktors. Running Reaktors triggers a tree-based execution that runs the leaf-nodes of this structure, the AktorFunctions. Each part of this tree, the Reaktor itself, Aktors, and AktorFunctions, are of type Aktor. A Reaktor is thus just an executable root Aktor that serves as the entry point for a workflow.

Here you can find a simple structure visualizing the Reaktor structure:

A Reaktor has the following properties:

• Metadata: The label, description, group, tags and image of the Reaktor
• inputSchema: The input schema of the Reaktor
• outputSchema: The output schema of the Reaktor
• createReaktor: The function that creates the Reaktor, returning an Aktor

See this example of a Reaktor:

import { z } from 'zod';

registerReaktorDefinition({
    reaktorDefinitionId: 'temperature-by-city',
    label: 'Get Stock Price by Symbol',
    description: 'Gets the stock price of a symbol via Twelve Data',
    inputSchema: z.object({
        symbol: z.string().openapi({ example: 'APPL' }),
    }),
    outputSchema: z.object({
        price: z.string()
    }),
    createReaktor(params) {
        // Reaktor Logic
    },
});

Reaktor Metadata

The metadata of a Reaktor is used to describe the Reaktor and is used in the UI. This includes the label, description, group, tags and image.

Reaktor Inputs

The inputs of a Reaktor are defined in the inputSchema property. This is a Zod schema that defines the expected inputs for the Reaktor. This also includes the required input fields when accessing the Reaktor.

Reaktor Outputs

The outputs of a Reaktor are defined in the outputSchema property. This is a Zod schema that defines the expected outputs for the Reaktor. This also includes the output fields when accessing the Reaktor.

Types of Reaktors

There are different registry options for Reaktor, depending on the use case you plan. They differ in their inputSchema and outputSchema and how they can be accessed. Here is a simple explanation of when to use which.

registerReaktorDefinition

This is the default registration for Reaktors. You will have full control over the schemas and can use it via API in your custom use cases.

registerChatReaktorDefinition

This is our chat Reaktor registration. The schemas are pre-defined and allow the Reaktor to be used with Elara.

registerMailReaktorDefinition

Using this registration, you can use the Reaktor via Email. This allows the Reaktor to be accessed via the /mail endpoint without worrying about the right schemas. It will always provide as the input params all possible parameters from an Email object.

Reaktor-Definition

A Reaktor-Definition is TypeScript code in a .reaktor.ts file (plus dependencies) that defines an Aktor Graph.

• Declaration: Contains a factory function (createReaktor) that creates the root Aktor.
• Declares inputs: Inputs are defined using Zod schemas.
• Declares output: Output are defined using Zod schemas.
• Contents: Metadata with name, description, input/output schemas (using Zod), and a factory function (createReaktor) creating the root Aktor from the declated inputs.
• Settings: Default settings may be derived from the Aktor composition defined in the code.

Reaktor-Setting

Reaktor-Setting configure a Reaktor instance, derived from its Reaktor-Definition:

• Contents: Includes prompts, API keys, etc., with defaults optionally set in the Reaktor-Definition.
• Dynamic Settings: Some settings (e.g., External-API-Keys) vary based on permissions tied to the Reaktor-API-Key used to access the Reaktor.

Reaktor Execution

Running a Reaktor in Operaides works by first deploying a Reaktor from it's blueprint in Reaktor AI Engine, providing necessary settings, and then accessing the Reaktor from the API. From the UI, you can find the required input structure, which is always a JSON object. Running the Reaktor will return a JSON object with the output of the Reaktor defined earlier in the code. You can also use the Execution Tab in the Reaktor AI Engine, to try it out.

Reaktor Deployment

This is an Instance of a Reaktor Definition, which provides a Rest API and can be executed. During the deployment, you can assign a readable but unique name, to identify the instance. Initially, it uses the default settings defined in the definition, however, exposed settings can be changed later on.