Lurawi - An Agent Workflow Orchestration Engine

Table of Contents

• Introduction
• Key Features
• Quick Start
• Installation
  • Prerequisites
  • Pulling the Lurawi Docker Image
  • Launching the Lurawi Docker Container
• Working with the Lurawi Agent Workflow Visual Editor
  • Loading an Example Workflow
  • Dispatching the Workflow
  • Viewing Generated Code
  • Testing the Workflow
  • Saving the Workflow
• Next Steps
• Notes

Introduction

Lurawi is a NoCode/LowCode development environment designed for building sophisticated agent-based workflows. It empowers Machine Learning (ML) and Generative AI (GenAI) engineers to interactively design, experiment with, and implement complex workflows with minimal effort. The output of this process is an XML/JSON-based data file, ready for deployment and execution on the Lurawi runtime engine within a container image. This containerized solution can be seamlessly deployed in cloud environments such as AWS.

Key Features

• Visual Workflow Design: Compose workflows intuitively using a drag-and-drop interface on a canvas.
• Minimal Coding: Leverage visual construction to build workflows, significantly reducing the need for traditional programming.
• Modular and Extensible Architecture: Extend system capabilities by encapsulating functionalities within modular custom function classes.
• Unified REST API Specification: Access a comprehensive, out-of-the-box REST API. Refer to the API Specifications for details.
• Cloud-Ready Deployment: Easily deploy workflows as Docker containers in environments like AWS.
• Lurawi-in-a-Box: A self-contained Docker image providing a fully functional Lurawi system for local execution, requiring only Docker Desktop.
• Lurawi Agent: Run Lurawi as an agent that can run either independently or integrate with popular agent ecosystems.

The following sections provide detailed instructions on how to experiment with Lurawi using the prebuilt Docker image.

Quick Start

Use Local Code Repository

git clone https://github.com/kunle12/lurawi.git

cd lurawi
source .env.example
bin/lurawi dev

Use Prebuilt Docker Image

docker pull kunle12/lurawi:latest

docker run -d \
  -p 3031:3031 \
  -p 8081:8081 \
  -e PROJECT_NAME={YOUR_PROJECT_NAME} \
  -e PROJECT_ACCESS_KEY={YOUR_ACCESS_KEY} \
  kunle12/lurawi:latest

Replace {YOUR_PROJECT_NAME} and {YOUR_ACCESS_KEY} with your registered project details.

Fast forward to use visual editor to build workflow section.

Installation

NOTE: For advanced setup, including a VS Code Development Container configuration, please refer to Lurawi setup as VS Code Dev Container.

Prerequisites

Ensure your workstation supports virtualization and has Docker Desktop installed.

Pulling the Lurawi Docker Image

To obtain the latest Lurawi Docker image, execute the following command:

docker pull kunle12/lurawi:latest

Upon successful download, the kunle12/lurawi:latest image will be available in your Docker Desktop environment.

Launching the Lurawi Docker Container

To launch the Lurawi container, you can use the Docker Desktop UI by clicking the "Play" button under "Actions" for the kunle12/lurawi:latest image.

Important:

• Bind your local machine ports 3031 and 8081 to the container's respective ports.
• Set the PROJECT_NAME and PROJECT_ACCESS_KEY environment variables to your registered project name and access key.

After launching, you should observe container logs in Docker Desktop similar to the example below, indicating a successful startup:

Working with the Lurawi Agent Workflow Visual Editor

Open your preferred web browser and navigate to http://localhost:3031 to access the Lurawi Agent Workflow Visual Editor:

Loading an Example Workflow

Download the example workflow file: lurawi_example.xml.

In the visual editor, click the button to load this file. The editor will then display the example workflow. Remember to update the model name (highlighted in red in Fig. 4) to a model assigned to your project.

Dispatching the Workflow

To dispatch the current workflow to the Lurawi runtime server (running in the Docker container) for testing, click the button.

Viewing Generated Code

Navigate to the Code tab (Fig. 6) to view the JSON-based code dynamically generated from the visual blocks in the Blocks tab. The visual blocks serve as the source code, while the JSON code represents the compiled, executable program. If the visual block program contains errors, the Code tab will display error messages instead of valid JSON. In such cases, switch back to the Blocks tab to rectify the errors, then return to the Code tab for validation.

Testing the Workflow

Click the button to open a new tab to the Lurawi test console (Fig. 7) and begin interacting with your workflow by typing questions or messages.

Note on Test Console Payload: This test console is specifically designed for the following input payload structure:

{
  "uid": "client/user id",
  "name": "client name",
  "session_id": "optional client provided session id",
  "data" : {
    "message": "a text prompt message"
  }
}

If you modify the data payload structure within your workflow, the test console may no longer function as expected. For workflows with custom data structures, use curl or other REST API testing tools to call the endpoint at http://localhost:8081/projects/{your_project_name}/message.

Saving the Workflow

Click the button to download the finalized workflow from the visual editor. You can download two files: an XML file from the Blocks tab (containing the visual block code) and a JSON program code file from the Code tab (used by Lurawi for execution).

It is recommended to save both files in a version-controlled repository, such as GitHub. With a properly configured CI/CD pipeline (e.g., GitHub Actions), a custom Docker image can be automatically built and deployed to production environments.

Next Steps

The Lurawi agent workflow visual editor is built upon Google Blockly. If you are new to block-based coding, it is highly recommended to familiarize yourself with its mechanics through tutorials, such as those provided by Scratch.

Once comfortable with block-based programming, delve into:

• Lurawi Specific Block Concepts for an understanding of core Lurawi block principles.

• Lurawi Prebuilt Custom Blocks for detailed descriptions of prebuilt custom function blocks.

• Advanced: RAG Reference Implementation in Lurawi for a concrete example of a Retrieval-Augmented Generation (RAG) implementation.

• Advanced: LurawiAgent for running Lurawi workflow as an independent agent.

Lurawi's capabilities are extensible via a plug-in mechanism, allowing integration with third-party systems. Explore Advanced: How to Create Lurawi Custom Action Primitives to learn more.

Finally, review the Advanced: End-to-end Lurawi Development example for a comprehensive development cycle overview.

Notes

1. Lurawi Code Repository: https://github.com/kunle12/lurawi
2. Luwari Examples Repository: https://github.com/kunle12/lurawi-code-examples for more examples.