qtoolsAiTwoStepSample

A simple example application demonstrating the qtools-ai-framework with a two-step AI processing pipeline.

Overview

This application demonstrates how to create a minimal AI processing application using the qtools-ai-framework. It processes user input through two sequential steps:

1. Create Something - Takes a user prompt and generates initial content
2. Revise That Thing - Takes the generated content and modifies it based on a revision prompt

Installation

npm install

Usage

node qtoolsAiTwoStepSample.js --creatingPrompt="tell me a one sentence story" --revisingPrompt="Make it talk like a pirate"

Parameters

• --creatingPrompt (required) - The initial prompt for content creation
• --revisingPrompt (required) - The prompt for revising the created content
• --debug (optional) - Enable debug logging to see intermediate steps

Examples

Basic usage:

node qtoolsAiTwoStepSample.js --creatingPrompt="write a haiku about coffee" --revisingPrompt="make it rhyme better"

With debug output:

node qtoolsAiTwoStepSample.js --creatingPrompt="describe a sunset" --revisingPrompt="make it more poetic" --debug

Sample Output:

Once upon a fine time, th' scurvyre be a fine brave knight who saved th' scurvy kingdom, arrr! Yo ho ho!

Environment Variables

Note: The current implementation uses simple text transformations instead of actual AI calls. To use real AI, you would need to:

1. Set your OpenAI API key:

export OPENAI_API_KEY=your_api_key_here

2. Update the thinkers to use the provided promptGenerator and accessSmartyPants functions instead of the simplified text transformations.

Architecture

The application follows the qtools-ai-framework pattern with wisdom-bus architecture:

• Main Application (qtoolsAiTwoStepSample.js) - Entry point and CLI handling
• Configuration (qtoolsAiTwoStepSample.ini) - Thought process and thinker definitions
• Thinkers (lib/thinkers/) - Processing modules using wisdom-bus for data flow
• Prompt Library (lib/prompt-library/) - AI prompt templates
• Wisdom-Bus - Thread-safe data management system for sharing data between thinkers

Project Structure

qtoolsAiTwoStepSample/
├── qtoolsAiTwoStepSample.js      # Main application
├── qtoolsAiTwoStepSample.ini     # Configuration
├── package.json                   # Dependencies
├── README.md                      # This file
└── lib/
    ├── thinkers/
    │   ├── create-something/
    │   │   └── create-something.js
    │   └── revise-that-thing/
    │       └── revise-that-thing.js
    └── prompt-library/
        ├── onlyPrompts.js
        └── prompts.d/
            └── onlyPrompts/
                ├── create-something.js
                └── revise-that-thing.js

How It Works

1. User provides creating and revising prompts via command line
2. Framework initializes with configuration from .ini file and creates wisdom-bus
3. Initial prompts are stored in wisdom-bus as initialThinkerData
4. create-something thinker:
   • Reads creatingPrompt from wisdom-bus using wisdomBus.getAll()
   • Generates content using AI
   • Stores result as lastAiResponse using wisdomBus.add()
5. revise-that-thing thinker:
   • Reads both lastAiResponse and revisingPrompt from wisdom-bus
   • Processes revision using AI
   • Updates lastAiResponse with revised content
6. Final consolidated wisdom is output to stdout via xLog.result()

Wisdom-Bus Data Flow

The wisdom-bus ensures thread-safe data sharing between thinkers:

// Thinker reads data
const currentWisdom = wisdomBus.getAll();
const inputData = currentWisdom.someKey;

// Thinker processes and adds results  
const result = processData(inputData);
wisdomBus.add('outputKey', result);

Each thinker gets its own namespaced accessor, preventing data collisions while allowing access to shared data from previous thinkers.

This serves as a template for building more complex AI processing applications with the qtools-ai-framework wisdom-bus architecture.