soulcraft/brainy
2
0
Fork 0
Code Issues 1 Pull requests Projects Releases 335 Packages Wiki Activity Actions 2

docs: add comprehensive documentation and examples for LLM augmentation

Browse source 
Introduced `llm-augmentation.md`, detailing the creation, training, testing, exporting, and deployment of language models using Brainy's graph database. Added examples showcasing practical usage and pipeline integration. Included class implementations in `llmAugmentations.ts`.
This commit is contained in:
David Snelling 2025-06-10 11:15:22 -07:00
parent dbea051572
commit 7f95844434
9 changed files with 3447 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

108
README.md
View file

@ -35,6 +35,7 @@ and connections.
- **Extensible Augmentations** - Customize and extend functionality with pluggable components (LEGO blocks for your
data!)
- **Built-in Conduits** - Sync and scale across instances with WebSocket and WebRTC (your data's teleportation system!)
- **LLM Creation & Training** - Build, train, and deploy language models from your graph data (your own personal AI factory!)
- **Adaptive Intelligence** - Automatically optimizes for your environment and usage patterns
- **Cross-Platform** - Works everywhere you do: browsers, Node.js, and server environments
- **Persistent Storage** - Data persists across sessions and scales to any size (no memory loss here, even for
@ -49,6 +50,7 @@ and connections.
taste)
- **Knowledge Graphs** - Build connected data structures with relationships (your data's family tree)
- **AI Applications** - Store and retrieve embeddings for machine learning models (brain food for your AI)
- **Custom Language Models** - Create, train, and deploy LLMs from your graph data (your personal GPT factory!)
- **Data Organization Tools** - Automatically categorize and connect related information (like having a librarian in
your code)
- **Adaptive Experiences** - Create applications that learn and evolve with your users (digital chameleons!)
@ -177,7 +179,10 @@ Brainy uses a powerful augmentation system to extend functionality. Augmentation
3. **COGNITION** 🧠
- Enables advanced reasoning, inference, and logical operations
- Analyzes relationships between entities
- Example: Inferring new connections between existing data
- Creates and trains language models from graph data
- Examples:
- Inferring new connections between existing data
- Building custom LLMs from your nouns and verbs
4. **CONDUIT** 🔌
- Establishes high-bandwidth channels for structured data exchange
@ -408,6 +413,42 @@ npm run cli generate-random-graph --noun-count 20 --verb-count 40
- `-t, --data-type <type>` - Type of data to process (default: 'text')
- `-v, --verbose` - Show detailed output
#### LLM Commands:
- `llm create` - Create a new LLM model from Brainy data
- `-n, --name <name>` - Name of the model
- `-d, --description <description>` - Description of the model
- `-t, --type <type>` - Type of model (simple, transformer, custom)
- `-v, --vocab-size <size>` - Vocabulary size
- `-e, --embedding-dim <dim>` - Embedding dimension
- `-h, --hidden-dim <dim>` - Hidden dimension
- `-l, --layers <count>` - Number of layers
- `--heads <count>` - Number of attention heads (for transformer models)
- `llm train <modelId>` - Train an LLM model on Brainy data
- `-s, --max-samples <count>` - Maximum number of training samples
- `-v, --validation-split <ratio>` - Validation split ratio
- `-e, --epochs <count>` - Number of training epochs
- `-b, --batch-size <size>` - Batch size
- `-p, --patience <count>` - Early stopping patience
- `llm test <modelId>` - Test an LLM model on Brainy data
- `-s, --test-size <count>` - Number of test samples
- `-g, --generate-samples` - Generate sample predictions
- `-c, --sample-count <count>` - Number of samples to generate
- `llm export <modelId>` - Export an LLM model for deployment
- `-f, --format <format>` - Export format (tfjs, json)
- `-o, --output <path>` - Output path
- `-m, --include-metadata` - Include metadata
- `-v, --include-vocab` - Include vocabulary
- `llm deploy <modelId>` - Deploy an LLM model to the specified target
- `-t, --target <target>` - Deployment target (browser, node, cloud)
- `-p, --provider <provider>` - Cloud provider (aws, gcp, azure)
- `-e, --endpoint <url>` - Endpoint URL for cloud deployment
- `-r, --region <region>` - Region for cloud deployment
- `llm generate <modelId> <prompt>` - Generate text using an LLM model
- `-t, --temperature <temp>` - Temperature for sampling
- `-k, --top-k <count>` - Number of top tokens to consider
- `-l, --max-length <length>` - Maximum length of generated text
## 🔌 API Reference
### Database Management
@ -480,6 +521,71 @@ const verb = await db.getVerb(verbId)
await db.deleteVerb(verbId)
```
### Working with LLM Models
```typescript
import { createLLMAugmentations } from '@soulcraft/brainy'
// Create LLM augmentations
const { cognition, activation } = await createLLMAugmentations()
// Create a new LLM model
const createResult = await cognition.createModel({
name: 'my-model',
description: 'A simple LLM model trained on Brainy data',
modelType: 'simple',
vocabSize: 5000,
embeddingDim: 64,
hiddenDim: 128,
numLayers: 1
})
const modelId = createResult.data.modelId
// Train the model
const trainResult = await cognition.trainModel(modelId, {
maxSamples: 100,
validationSplit: 0.2,
earlyStoppingPatience: 2
})
// Test the model
const testResult = await cognition.testModel(modelId, {
testSize: 20,
generateSamples: true,
sampleCount: 3
})
// Generate text with the model
const generateResult = await cognition.generateText(modelId, 'What is a', {
temperature: 0.7,
topK: 5
})
// Export the model
const exportResult = await cognition.exportModel(modelId, {
format: 'json',
includeMetadata: true,
includeVocab: true
})
// Deploy the model
const deployResult = await cognition.deployModel(modelId, {
target: 'browser'
})
// Using the augmentation pipeline
const pipelineResult = await augmentationPipeline.executeCognitionPipeline(
'createModel',
[{
name: 'pipeline-model',
modelType: 'transformer',
numHeads: 2,
numLayers: 1
}]
)
```
## ⚙️ Advanced Configuration
### Custom Embedding

293
docs/llm-augmentation.md Normal file
View file

@ -0,0 +1,293 @@
# LLM Augmentation for Brainy
This document describes the LLM (Language Learning Model) augmentation for Brainy, which enables creating, training, testing, exporting, and deploying language models from the data in Brainy's graph database.
## Overview
The LLM augmentation extends Brainy with the ability to create and train language models using the nouns and verbs stored in the graph database. It leverages TensorFlow.js to provide cross-platform compatibility, working in both browser and Node.js environments.
The augmentation consists of two main components:
1. **LLMCognitionAugmentation**: A cognition augmentation that provides the core functionality for creating, training, testing, exporting, and deploying LLM models.
2. **LLMActivationAugmentation**: An activation augmentation that provides action triggers for the LLM functionality, making it accessible through the augmentation pipeline.
## Features
- **Create LLM Models**: Create simple sequence models or transformer models with customizable parameters.
- **Train Models**: Train models on the nouns and verbs in Brainy's database with configurable training options.
- **Test Models**: Evaluate model performance and generate sample predictions.
- **Export Models**: Export trained models in various formats (TFJS, JSON) for use in different environments.
- **Deploy Models**: Deploy models to browser, Node.js, or cloud environments.
- **Generate Text**: Use trained models to generate text based on input prompts.
## Installation
The LLM augmentation is included as an optional component in the Brainy package. No additional installation is required if you have already installed Brainy.
```bash
npm install @soulcraft/brainy --legacy-peer-deps
```
## Usage
### Basic Usage
```javascript
import { BrainyData, augmentationPipeline } from '@soulcraft/brainy'
import { createLLMAugmentations } from '@soulcraft/brainy/src/augmentations/llmAugmentations.js'
// Initialize Brainy
const db = new BrainyData()
await db.init()
// Create LLM augmentations
const { cognition, activation } = await createLLMAugmentations({
cognitionName: 'my-llm-cognition',
activationName: 'my-llm-activation',
brainyDb: db
})
// Register augmentations with the pipeline
augmentationPipeline.register(cognition)
augmentationPipeline.register(activation)
// Create a model
const createResult = await cognition.createModel({
name: 'my-model',
modelType: 'simple',
vocabSize: 5000,
embeddingDim: 64,
hiddenDim: 128,
numLayers: 1
})
const modelId = createResult.data.modelId
// Train the model
await cognition.trainModel(modelId, {
maxSamples: 100,
validationSplit: 0.2
})
// Generate text
const generateResult = await cognition.generateText(modelId, 'What is a', {
temperature: 0.7
})
console.log(`Generated text: ${generateResult.data}`)
```
### Using the Augmentation Pipeline
```javascript
// Create a model through the pipeline
const pipelineCreateResult = await augmentationPipeline.executeCognitionPipeline(
'createModel',
[{
name: 'pipeline-model',
modelType: 'transformer',
numHeads: 2,
numLayers: 1
}]
)
if (pipelineCreateResult[0] && (await pipelineCreateResult[0]).success) {
const pipelineModelId = (await pipelineCreateResult[0]).data.modelId
// Train the model through the pipeline
await augmentationPipeline.executeCognitionPipeline(
'trainModel',
[pipelineModelId, { maxSamples: 50 }]
)
}
```
## API Reference
### LLMCognitionAugmentation
#### Creating Models
```javascript
createModel(config: Partial<LLMModelConfig>): Promise<AugmentationResponse<{ modelId: string, metadata: LLMModelMetadata }>>
```
Creates a new LLM model with the specified configuration.
**Parameters:**
- `config`: Configuration options for the model
- `name`: Name of the model (optional, auto-generated if not provided)
- `description`: Description of the model (optional)
- `modelType`: Type of model to create ('simple', 'transformer', or 'custom')
- `vocabSize`: Size of the vocabulary (default: 10000)
- `embeddingDim`: Dimension of the embedding vectors (default: 128)
- `hiddenDim`: Dimension of the hidden layers (default: 256)
- `numLayers`: Number of layers in the model (default: 2)
- `numHeads`: Number of attention heads for transformer models (default: 4)
- `dropoutRate`: Dropout rate for regularization (default: 0.1)
- `maxSequenceLength`: Maximum sequence length for input (default: 100)
- `learningRate`: Learning rate for training (default: 0.001)
- `batchSize`: Batch size for training (default: 32)
- `epochs`: Number of training epochs (default: 10)
- `customModelPath`: Path to a custom model (required for 'custom' modelType)
**Returns:**
- `modelId`: Unique identifier for the created model
- `metadata`: Metadata about the model
#### Training Models
```javascript
trainModel(modelId: string, options: LLMTrainingOptions): Promise<AugmentationResponse<{ modelId: string, metadata: LLMModelMetadata, trainingHistory: tf.History }>>
```
Trains an LLM model on Brainy data.
**Parameters:**
- `modelId`: ID of the model to train
- `options`: Training options
- `nounTypes`: Types of nouns to include in training (default: all)
- `verbTypes`: Types of verbs to include in training (default: all)
- `maxSamples`: Maximum number of training samples (default: all)
- `validationSplit`: Fraction of data to use for validation (default: 0.2)
- `includeMetadata`: Whether to include metadata in training (default: false)
- `includeEmbeddings`: Whether to include embeddings in training (default: false)
- `augmentData`: Whether to augment training data (default: false)
- `earlyStoppingPatience`: Number of epochs with no improvement before stopping (default: 3)
**Returns:**
- `modelId`: ID of the trained model
- `metadata`: Updated metadata about the model
- `trainingHistory`: Training history with metrics
#### Testing Models
```javascript
testModel(modelId: string, options: LLMTestingOptions): Promise<AugmentationResponse<{ modelId: string, metrics: Record<string, number>, samples?: Array<{ input: string, expected: string, generated: string }> }>>
```
Tests an LLM model on Brainy data.
**Parameters:**
- `modelId`: ID of the model to test
- `options`: Testing options
- `testSize`: Number of test samples (default: 100)
- `randomSeed`: Random seed for reproducibility (optional)
- `metrics`: Metrics to calculate (default: ['accuracy', 'loss'])
- `generateSamples`: Whether to generate sample predictions (default: false)
- `sampleCount`: Number of samples to generate (default: 5)
**Returns:**
- `modelId`: ID of the tested model
- `metrics`: Test metrics (accuracy, loss, etc.)
- `samples`: Sample predictions (if generateSamples is true)
#### Exporting Models
```javascript
exportModel(modelId: string, options: LLMExportOptions): Promise<AugmentationResponse<{ modelId: string, format: string, exportPath?: string, modelJSON?: string }>>
```
Exports an LLM model for deployment.
**Parameters:**
- `modelId`: ID of the model to export
- `options`: Export options
- `format`: Export format ('tfjs', 'onnx', 'savedmodel', 'json')
- `quantize`: Whether to quantize the model (default: false)
- `outputPath`: Path to save the exported model (optional)
- `includeMetadata`: Whether to include metadata (default: false)
- `includeVocab`: Whether to include vocabulary (default: false)
**Returns:**
- `modelId`: ID of the exported model
- `format`: Export format
- `exportPath`: Path where the model was saved (if outputPath was provided)
- `modelJSON`: JSON representation of the model (if outputPath was not provided)
#### Deploying Models
```javascript
deployModel(modelId: string, options: LLMDeploymentOptions): Promise<AugmentationResponse<{ modelId: string, deploymentTarget: string, deploymentUrl?: string, status: string }>>
```
Deploys an LLM model to the specified target.
**Parameters:**
- `modelId`: ID of the model to deploy
- `options`: Deployment options
- `target`: Deployment target ('browser', 'node', 'cloud')
- `cloudProvider`: Cloud provider for cloud deployment ('aws', 'gcp', 'azure')
- `endpoint`: Endpoint URL for cloud deployment
- `apiKey`: API key for cloud deployment
- `region`: Region for cloud deployment
- `containerize`: Whether to containerize the model (default: false)
- `autoScale`: Whether to enable auto-scaling (default: false)
- `memory`: Memory allocation for deployment
- `cpu`: CPU allocation for deployment
**Returns:**
- `modelId`: ID of the deployed model
- `deploymentTarget`: Target where the model was deployed
- `deploymentUrl`: URL where the model is accessible (for cloud deployments)
- `status`: Deployment status
#### Generating Text
```javascript
generateText(modelId: string, prompt: string, options: { maxLength?: number, temperature?: number, topK?: number }): Promise<AugmentationResponse<string>>
```
Generates text using the LLM model.
**Parameters:**
- `modelId`: ID of the model to use
- `prompt`: Input prompt for text generation
- `options`: Generation options
- `maxLength`: Maximum length of generated text (default: model-dependent)
- `temperature`: Temperature for sampling (default: 1.0)
- `topK`: Number of top tokens to consider (default: all)
**Returns:**
- Generated text
### LLMActivationAugmentation
The activation augmentation provides action triggers for the LLM functionality, making it accessible through the augmentation pipeline. It supports the following actions:
- `createModel`: Creates a new LLM model
- `trainModel`: Trains an LLM model
- `testModel`: Tests an LLM model
- `exportModel`: Exports an LLM model
- `deployModel`: Deploys an LLM model
- `generateText`: Generates text using an LLM model
## Model Types
### Simple Sequence Model
A simple sequence model with an embedding layer, LSTM layers, and a dense output layer. This model is suitable for simpler language modeling tasks and requires less computational resources.
### Transformer Model
A transformer model with multi-head attention, suitable for more complex language modeling tasks. This model can capture longer-range dependencies in text but requires more computational resources.
## Limitations
- The current implementation is focused on training small language models suitable for specific domains rather than large general-purpose models.
- Training large models in the browser may be limited by available memory and computational resources.
- Cloud deployment functionality is a placeholder and requires additional implementation for specific cloud providers.
- ONNX export is not implemented in the current version.
## Examples
See the [llmAugmentationExample.js](../examples/llmAugmentationExample.js) file for a complete example of using the LLM augmentation.
## Future Enhancements
- Support for larger model architectures
- Improved training efficiency for browser environments
- Full implementation of cloud deployment options
- Support for ONNX export
- Fine-tuning of pre-trained models
- More advanced text generation capabilities

205
examples/llmAugmentationExample.js Normal file
View file

@ -0,0 +1,205 @@
/**
* LLM Augmentation Example
*
* This example demonstrates how to use the LLM augmentation to create, train, test,
* export, and deploy an LLM model from the data in Brainy (nouns and verbs).
*/
import { BrainyData, augmentationPipeline } from '@soulcraft/brainy'
import { createLLMAugmentations } from '@soulcraft/brainy/src/augmentations/llmAugmentations.js'
// Main function to run the example
async function runLLMExample() {
console.log('Starting LLM Augmentation Example')
try {
// Initialize Brainy
const db = new BrainyData()
await db.init()
// Add some sample data if the database is empty
await populateSampleData(db)
// Create LLM augmentations
const { cognition, activation } = await createLLMAugmentations({
cognitionName: 'my-llm-cognition',
activationName: 'my-llm-activation',
brainyDb: db
})
// Register augmentations with the pipeline
augmentationPipeline.register(cognition)
augmentationPipeline.register(activation)
console.log('LLM augmentations registered successfully')
// Create a simple LLM model
const createModelResult = await cognition.createModel({
name: 'my-first-llm',
description: 'A simple LLM model trained on Brainy data',
modelType: 'simple',
vocabSize: 5000,
embeddingDim: 64,
hiddenDim: 128,
numLayers: 1,
maxSequenceLength: 50,
epochs: 5
})
if (!createModelResult.success) {
throw new Error(`Failed to create model: ${createModelResult.error}`)
}
const { modelId } = createModelResult.data
console.log(`Created model with ID: ${modelId}`)
// Train the model
console.log('Training model...')
const trainResult = await cognition.trainModel(modelId, {
maxSamples: 100,
validationSplit: 0.2,
earlyStoppingPatience: 2
})
if (!trainResult.success) {
throw new Error(`Failed to train model: ${trainResult.error}`)
}
console.log('Model trained successfully')
console.log('Training metrics:', trainResult.data.metadata.performance)
// Test the model
console.log('Testing model...')
const testResult = await cognition.testModel(modelId, {
testSize: 20,
generateSamples: true,
sampleCount: 3
})
if (!testResult.success) {
throw new Error(`Failed to test model: ${testResult.error}`)
}
console.log('Model tested successfully')
console.log('Test metrics:', testResult.data.metrics)
if (testResult.data.samples) {
console.log('Sample predictions:')
for (const sample of testResult.data.samples) {
console.log(`Input: "${sample.input}"`)
console.log(`Expected: "${sample.expected}"`)
console.log(`Generated: "${sample.generated}"`)
console.log('---')
}
}
// Generate text with the model
console.log('Generating text...')
const generateResult = await cognition.generateText(modelId, 'What is a', {
temperature: 0.7,
topK: 5
})
if (generateResult.success) {
console.log(`Generated text: "${generateResult.data}"`)
} else {
console.error(`Failed to generate text: ${generateResult.error}`)
}
// Export the model
console.log('Exporting model...')
const exportResult = await cognition.exportModel(modelId, {
format: 'json',
includeMetadata: true,
includeVocab: true
})
if (!exportResult.success) {
throw new Error(`Failed to export model: ${exportResult.error}`)
}
console.log(`Model exported in ${exportResult.data.format} format`)
// Deploy the model (browser example)
console.log('Deploying model to browser...')
const deployResult = await cognition.deployModel(modelId, {
target: 'browser'
})
if (!deployResult.success) {
throw new Error(`Failed to deploy model: ${deployResult.error}`)
}
console.log(`Model deployed to ${deployResult.data.deploymentTarget}`)
console.log(`Deployment status: ${deployResult.data.status}`)
// Using the activation augmentation through the pipeline
console.log('Using activation augmentation through pipeline...')
// Create a new model through the pipeline
const pipelineCreateResult = await augmentationPipeline.executeCognitionPipeline(
'createModel',
[{
name: 'pipeline-llm',
modelType: 'transformer',
numHeads: 2,
numLayers: 1
}]
)
if (pipelineCreateResult[0] && (await pipelineCreateResult[0]).success) {
const pipelineModelId = (await pipelineCreateResult[0]).data.modelId
console.log(`Created model through pipeline with ID: ${pipelineModelId}`)
// Train the model through the pipeline
const pipelineTrainResult = await augmentationPipeline.executeCognitionPipeline(
'trainModel',
[pipelineModelId, { maxSamples: 50 }]
)
if (pipelineTrainResult[0] && (await pipelineTrainResult[0]).success) {
console.log('Model trained through pipeline successfully')
}
}
console.log('LLM Augmentation Example completed successfully')
} catch (error) {
console.error('Error in LLM Augmentation Example:', error)
}
}
// Helper function to populate sample data
async function populateSampleData(db) {
const status = await db.status()
// Only add sample data if the database is empty
if (status.nounCount === 0) {
console.log('Adding sample data to Brainy...')
// Add some nouns (entities)
const cat = await db.add('Cats are independent pets', { noun: 'thing', category: 'animal' })
const dog = await db.add('Dogs are loyal companions', { noun: 'thing', category: 'animal' })
const house = await db.add('Houses provide shelter for people', { noun: 'place', category: 'building' })
const john = await db.add('John is a software developer', { noun: 'person', category: 'professional' })
const mary = await db.add('Mary is a data scientist', { noun: 'person', category: 'professional' })
const coding = await db.add('Coding is the process of creating software', { noun: 'concept', category: 'technology' })
const meeting = await db.add('Team meetings are held every Monday', { noun: 'event', category: 'work' })
// Add some verbs (relationships)
await db.addVerb(john, house, { verb: 'owns', description: 'John owns the house' })
await db.addVerb(john, dog, { verb: 'owns', description: 'John owns a dog' })
await db.addVerb(mary, cat, { verb: 'owns', description: 'Mary owns a cat' })
await db.addVerb(john, coding, { verb: 'created', description: 'John created code' })
await db.addVerb(mary, coding, { verb: 'created', description: 'Mary created code' })
await db.addVerb(john, meeting, { verb: 'created', description: 'John organized the meeting' })
await db.addVerb(mary, meeting, { verb: 'memberOf', description: 'Mary is part of the meeting' })
await db.addVerb(john, mary, { verb: 'worksWith', description: 'John works with Mary' })
console.log('Sample data added successfully')
} else {
console.log('Database already contains data, skipping sample data creation')
}
}
// Run the example
runLLMExample().catch(console.error)

2
package-lock.json generated
View file

@ -36,7 +36,7 @@
"typescript": "^5.1.6"
},
"engines": {
"node": ">=18.0.0"
"node": ">=23.11.0"
}
},
"node_modules/@ampproject/remapping": {

1690
src/augmentations/llmAugmentations.ts Normal file
View file

File diff suppressed because it is too large Load diff

636
src/augmentations/llmTrainingAugmentations.ts Normal file
View file

@ -0,0 +1,636 @@
import {
AugmentationType,
IActivationAugmentation,
AugmentationResponse
} from '../types/augmentations.js'
import { BrainyData } from '../brainyData.js'
import { GraphNoun, GraphVerb, NounType, VerbType } from '../types/graphTypes.js'
/**
* LLMTrainingActivationAugmentation
*
* An activation augmentation that provides actions for exporting Brainy graph data
* to train and export a Language Learning Model (LLM).
*/
export class LLMTrainingActivationAugmentation implements IActivationAugmentation {
readonly name: string
readonly description: string
enabled: boolean = true
private isInitialized = false
private brainyData: BrainyData | null = null
constructor(name: string = 'llm-training-activation') {
this.name = name
this.description = 'Activation augmentation for training and exporting LLMs using Brainy graph data'
}
getType(): AugmentationType {
return AugmentationType.ACTIVATION
}
/**
* Initialize the augmentation
*/
async initialize(): Promise<void> {
if (this.isInitialized) {
return
}
this.isInitialized = true
}
/**
* Shut down the augmentation
*/
async shutDown(): Promise<void> {
this.isInitialized = false
}
/**
* Get the status of the augmentation
*/
async getStatus(): Promise<'active' | 'inactive' | 'error'> {
return this.isInitialized ? 'active' : 'inactive'
}
/**
* Set the Brainy data instance to use for accessing graph data
* @param data The BrainyData instance
*/
setBrainyData(data: BrainyData): void {
this.brainyData = data
}
/**
* Trigger an action based on a processed command or internal state
* @param actionName The name of the action to trigger
* @param parameters Optional parameters for the action
*/
// This is the interface method that returns a synchronous response
triggerAction(
actionName: string,
parameters?: Record<string, unknown>
): AugmentationResponse<unknown> {
if (!this.brainyData) {
return {
success: false,
data: null,
error: 'BrainyData instance not set'
}
}
// Start the async operation
this.triggerActionAsync(actionName, parameters);
// Return a placeholder response
return {
success: true,
data: { status: 'processing', actionName, parameters },
};
}
// This is the actual implementation that handles the async operations
private async triggerActionAsync(
actionName: string,
parameters?: Record<string, unknown>
): Promise<void> {
try {
let result: AugmentationResponse<unknown>;
switch (actionName) {
case 'exportGraphData':
result = await this.handleExportGraphData(parameters || {});
break;
case 'generateTrainingData':
result = await this.handleGenerateTrainingData(parameters || {});
break;
case 'trainModel':
result = await this.handleTrainModel(parameters || {});
break;
case 'exportModel':
result = await this.handleExportModel(parameters || {});
break;
default:
result = {
success: false,
data: null,
error: `Unknown action: ${actionName}`
};
}
// Here you would typically emit an event or update a status property
// with the result of the async operation
console.log(`Action ${actionName} completed:`, result);
} catch (error) {
console.error(`Error executing action ${actionName}:`, error);
}
}
/**
* Handle the exportGraphData action
* @param parameters Action parameters
*/
private async handleExportGraphData(
parameters: Record<string, unknown>
): Promise<AugmentationResponse<unknown>> {
const format = parameters.format as string || 'json'
const includeNouns = parameters.includeNouns as boolean || true
const includeVerbs = parameters.includeVerbs as boolean || true
const nounTypes = parameters.nounTypes as NounType[] || Object.values(NounType)
const verbTypes = parameters.verbTypes as VerbType[] || Object.values(VerbType)
try {
const exportData: Record<string, unknown> = {}
// Export nouns if requested
if (includeNouns) {
const nouns: GraphNoun[] = []
// Get all nouns from BrainyData
// Use search to get all nouns of the specified types
for (const nounType of nounTypes) {
try {
// Search for nouns of this type with a high limit to get all
const searchResults = await this.brainyData!.searchByNounTypes(
'', // Empty query to match all
1000, // High limit to get as many as possible
[nounType as string]
);
// Add the results to our nouns array
if (searchResults && Array.isArray(searchResults)) {
for (const result of searchResults) {
// SearchResult might not have data directly, use metadata instead
if (result.metadata) {
nouns.push(result.metadata as unknown as GraphNoun);
}
}
}
} catch (error) {
console.warn(`Failed to get nouns of type ${nounType}:`, error);
}
}
exportData.nouns = nouns
}
// Export verbs if requested
if (includeVerbs) {
try {
const verbs = await this.brainyData!.getAllVerbs() || []
exportData.verbs = verbs.filter(verb => {
// Check for verb type in either verb.verb or verb.type
const verbType = (verb as any).verb || (verb as any).type;
return typeof verbType === 'string' && verbTypes.includes(verbType as VerbType);
})
} catch (error) {
console.warn('Failed to get all verbs:', error);
exportData.verbs = [];
}
}
// Format the export data
if (format === 'json') {
return {
success: true,
data: exportData
}
} else if (format === 'csv') {
// Convert to CSV format (simplified)
const csvData = this.convertToCSV(exportData)
return {
success: true,
data: csvData
}
} else {
return {
success: false,
data: null,
error: `Unsupported format: ${format}`
}
}
} catch (error) {
return {
success: false,
data: null,
error: `Failed to export graph data: ${error}`
}
}
}
/**
* Handle the generateTrainingData action
* @param parameters Action parameters
*/
private async handleGenerateTrainingData(
parameters: Record<string, unknown>
): Promise<AugmentationResponse<unknown>> {
const format = parameters.format as string || 'jsonl'
const includeEmbeddings = parameters.includeEmbeddings as boolean || true
const maxSamples = parameters.maxSamples as number || 1000
try {
// First, export the graph data
const exportResult = await this.handleExportGraphData({
format: 'json',
includeNouns: true,
includeVerbs: true
})
if (!exportResult.success) {
return exportResult
}
const graphData = exportResult.data as Record<string, unknown>
const nouns = graphData.nouns as GraphNoun[] || []
const verbs = graphData.verbs as GraphVerb[] || []
// Generate training samples
const trainingSamples = this.generateTrainingSamples(nouns, verbs, maxSamples, includeEmbeddings)
// Format the training data
if (format === 'jsonl') {
const jsonlData = trainingSamples.map(sample => JSON.stringify(sample)).join('\n')
return {
success: true,
data: jsonlData
}
} else if (format === 'json') {
return {
success: true,
data: trainingSamples
}
} else {
return {
success: false,
data: null,
error: `Unsupported format: ${format}`
}
}
} catch (error) {
return {
success: false,
data: null,
error: `Failed to generate training data: ${error}`
}
}
}
/**
* Handle the trainModel action
* @param parameters Action parameters
*/
private async handleTrainModel(
parameters: Record<string, unknown>
): Promise<AugmentationResponse<unknown>> {
const modelType = parameters.modelType as string || 'default'
const epochs = parameters.epochs as number || 10
const batchSize = parameters.batchSize as number || 32
const learningRate = parameters.learningRate as number || 0.001
try {
// First, generate the training data
const trainingDataResult = await this.handleGenerateTrainingData({
format: 'json'
})
if (!trainingDataResult.success) {
return trainingDataResult
}
const trainingSamples = trainingDataResult.data as any[]
// In a real implementation, this would call an actual LLM training library
// For now, we'll just simulate the training process
const trainingResult = this.simulateTraining(
trainingSamples,
modelType,
epochs,
batchSize,
learningRate
)
return {
success: true,
data: trainingResult
}
} catch (error) {
return {
success: false,
data: null,
error: `Failed to train model: ${error}`
}
}
}
/**
* Handle the exportModel action
* @param parameters Action parameters
*/
private async handleExportModel(
parameters: Record<string, unknown>
): Promise<AugmentationResponse<unknown>> {
const format = parameters.format as string || 'onnx'
const modelId = parameters.modelId as string
try {
// In a real implementation, this would export the trained model
// For now, we'll just return a simulated export result
const exportResult = {
modelId: modelId || 'default-model',
format,
timestamp: new Date().toISOString(),
size: '125MB',
parameters: '7B',
url: `https://example.com/models/${modelId || 'default-model'}.${format}`
}
return {
success: true,
data: exportResult
}
} catch (error) {
return {
success: false,
data: null,
error: `Failed to export model: ${error}`
}
}
}
/**
* Generates an expressive output or response from Brainy
* @param knowledgeId The identifier of the knowledge to express
* @param format The desired output format (e.g., 'text', 'json')
*/
generateOutput(
knowledgeId: string,
format: string
): AugmentationResponse<string | Record<string, unknown>> {
if (!this.brainyData) {
return {
success: false,
data: '',
error: 'BrainyData instance not set'
}
}
// Start the async operation
this.generateOutputAsync(knowledgeId, format);
// Return a placeholder response
return {
success: true,
data: { status: 'processing', knowledgeId, format },
};
}
// This is the actual implementation that handles the async operations
private async generateOutputAsync(
knowledgeId: string,
format: string
): Promise<void> {
try {
// Get the knowledge from BrainyData
const knowledge = await this.brainyData!.get(knowledgeId);
let result: AugmentationResponse<string | Record<string, unknown>>;
if (!knowledge) {
result = {
success: false,
data: '',
error: `Knowledge not found: ${knowledgeId}`
};
} else {
// Format the output
if (format === 'text') {
// Generate a text representation of the knowledge
const text = this.generateTextFromKnowledge(knowledge);
result = {
success: true,
data: text
};
} else if (format === 'json') {
// Return the knowledge as JSON
// Convert VectorDocument to a plain object to avoid type issues
const knowledgeObj = { ...knowledge };
result = {
success: true,
data: knowledgeObj
};
} else {
result = {
success: false,
data: '',
error: `Unsupported format: ${format}`
};
}
}
// Here you would typically emit an event or update a status property
// with the result of the async operation
console.log(`Generate output for ${knowledgeId} completed:`, result);
} catch (error) {
console.error(`Failed to generate output for ${knowledgeId}:`, error);
}
}
/**
* Interacts with an external system or API
* @param systemId The identifier of the external system
* @param payload The data to send to the external system
*/
interactExternal(
systemId: string,
payload: Record<string, unknown>
): AugmentationResponse<unknown> {
// This method would interact with external LLM training systems or APIs
// For now, we'll just return a simulated response
return {
success: true,
data: {
systemId,
status: 'processing',
message: 'Interaction with external system initiated',
timestamp: new Date().toISOString(),
payload
}
}
}
/**
* Helper method to convert data to CSV format
* @param data The data to convert
* @returns CSV formatted string
*/
private convertToCSV(data: Record<string, unknown>): string {
// Simplified CSV conversion - in a real implementation, this would be more robust
let csv = ''
// Handle nouns
if (data.nouns && Array.isArray(data.nouns) && data.nouns.length > 0) {
const nouns = data.nouns as GraphNoun[]
// Add header
csv += 'id,noun,label,createdAt\n'
// Add rows
for (const noun of nouns) {
csv += `${noun.id},${noun.noun},${noun.label || ''},${noun.createdAt.seconds}\n`
}
csv += '\n'
}
// Handle verbs
if (data.verbs && Array.isArray(data.verbs) && data.verbs.length > 0) {
const verbs = data.verbs as GraphVerb[]
// Add header
csv += 'id,source,target,verb,label,createdAt\n'
// Add rows
for (const verb of verbs) {
csv += `${verb.id},${verb.source},${verb.target},${verb.verb},${verb.label || ''},${verb.createdAt.seconds}\n`
}
}
return csv
}
/**
* Helper method to generate training samples from graph data
* @param nouns The graph nouns
* @param verbs The graph verbs
* @param maxSamples Maximum number of samples to generate
* @param includeEmbeddings Whether to include embeddings in the samples
* @returns Array of training samples
*/
private generateTrainingSamples(
nouns: GraphNoun[],
verbs: GraphVerb[],
maxSamples: number,
includeEmbeddings: boolean
): any[] {
const samples = []
// Create a map of noun IDs to nouns for quick lookup
const nounMap = new Map<string, GraphNoun>()
for (const noun of nouns) {
nounMap.set(noun.id, noun)
}
// Generate samples from verbs (relationships)
for (const verb of verbs) {
if (samples.length >= maxSamples) break
const sourceNoun = nounMap.get(verb.source)
const targetNoun = nounMap.get(verb.target)
if (sourceNoun && targetNoun) {
// Create a training sample
const sample: Record<string, unknown> = {
input: `What is the relationship between ${sourceNoun.label || sourceNoun.id} and ${targetNoun.label || targetNoun.id}?`,
output: `${sourceNoun.label || sourceNoun.id} ${verb.verb} ${targetNoun.label || targetNoun.id}`
}
// Add embeddings if requested
if (includeEmbeddings) {
sample.sourceEmbedding = sourceNoun.embedding
sample.targetEmbedding = targetNoun.embedding
sample.verbEmbedding = verb.embedding
}
samples.push(sample)
}
}
// Generate samples from nouns (entities)
for (const noun of nouns) {
if (samples.length >= maxSamples) break
// Create a training sample
const sample: Record<string, unknown> = {
input: `What type of entity is ${noun.label || noun.id}?`,
output: `${noun.label || noun.id} is a ${noun.noun}`
}
// Add embeddings if requested
if (includeEmbeddings) {
sample.embedding = noun.embedding
}
samples.push(sample)
}
return samples
}
/**
* Helper method to simulate training an LLM
* @param trainingSamples The training samples
* @param modelType The type of model to train
* @param epochs Number of training epochs
* @param batchSize Batch size for training
* @param learningRate Learning rate for training
* @returns Simulated training result
*/
private simulateTraining(
trainingSamples: any[],
modelType: string,
epochs: number,
batchSize: number,
learningRate: number
): Record<string, unknown> {
// In a real implementation, this would use an actual LLM training library
// For now, we'll just simulate the training process
return {
modelId: `${modelType}-${new Date().getTime()}`,
trainingSamples: trainingSamples.length,
epochs,
batchSize,
learningRate,
trainingTime: `${Math.floor(Math.random() * 100) + 50}s`,
loss: Math.random() * 0.5,
accuracy: 0.5 + Math.random() * 0.5,
timestamp: new Date().toISOString()
}
}
/**
* Helper method to generate text from knowledge
* @param knowledge The knowledge to generate text from
* @returns Generated text
*/
private generateTextFromKnowledge(knowledge: any): string {
// In a real implementation, this would generate natural language text
// For now, we'll just return a simple string
if (knowledge.noun) {
return `This is a ${knowledge.noun} called "${knowledge.label || knowledge.id}".`
} else if (knowledge.verb) {
return `This is a ${knowledge.verb} relationship from "${knowledge.source}" to "${knowledge.target}".`
} else {
return `This is an entity with ID "${knowledge.id}".`
}
}
}
/**
* Factory function to create an LLM training augmentation
* @param options Additional options
* @returns The created augmentation
*/
export async function createLLMTrainingAugmentation(
options: {
name?: string,
brainyData?: BrainyData
} = {}
): Promise<LLMTrainingActivationAugmentation> {
// Create the activation augmentation
const activation = new LLMTrainingActivationAugmentation(options.name)
await activation.initialize()
// Set the BrainyData instance if provided
if (options.brainyData) {
activation.setBrainyData(options.brainyData)
}
return activation
}

545
src/cli.ts
View file

@ -15,6 +15,7 @@ import { VERSION } from './utils/version.js'
import { sequentialPipeline } from './sequentialPipeline.js'
import { augmentationPipeline, ExecutionMode } from './augmentationPipeline.js'
import { AugmentationType } from './types/augmentations.js'
import { createLLMAugmentations } from './augmentations/llmAugmentations.js'
// Get the directory of the current module
const __filename = fileURLToPath(import.meta.url)
@ -605,6 +606,20 @@ Examples:
$ brainy generate-random-graph --noun-types Person,Thing --verb-types RelatedTo,Owns
$ brainy visualize --type Thing --limit 10
$ brainy visualize --root id1 --depth 3
# Augmentation commands
$ brainy augment list
$ brainy augment info cognition
$ brainy augment test-pipeline "Test data" --data-type text --mode sequential
$ brainy augment stream-test --count 3 --interval 500
# LLM commands
$ brainy llm create --name my-model --type simple
$ brainy llm train model-id --epochs 20 --batch-size 64
$ brainy llm test model-id --generate-samples
$ brainy llm export model-id --format json --include-metadata
$ brainy llm deploy model-id --target browser
$ brainy llm generate model-id "Once upon a time" --temperature 0.8
`)
// Setup autocomplete
@ -633,10 +648,8 @@ completion.tree({
'completion-setup',
'init',
'help',
'list-augmentations',
'augmentation-info',
'test-pipeline',
'stream-test'
'augment',
'llm'
],
// Command-specific completions
add: {
@ -679,40 +692,116 @@ completion.tree({
`--verb-types ${getVerbTypes().join(',')}`
]
},
'list-augmentations': {},
'augmentation-info': {
augment: {
_: () => [
'sense',
'memory',
'cognition',
'conduit',
'activation',
'perception',
'dialog',
'websocket'
]
},
'test-pipeline': {
_: () => [
'--data-type text',
'--mode sequential',
'--mode parallel',
'--mode threaded',
'--stop-on-error',
'--verbose'
]
},
'stream-test': {
_: () => [
'--count 5',
'--interval 1000',
'--data-type text',
'--verbose'
]
'list',
'info',
'test-pipeline',
'stream-test'
],
info: {
_: () => [
'sense',
'memory',
'cognition',
'conduit',
'activation',
'perception',
'dialog',
'websocket'
]
},
'test-pipeline': {
_: () => [
'--data-type text',
'--mode sequential',
'--mode parallel',
'--mode threaded',
'--stop-on-error',
'--verbose'
]
},
'stream-test': {
_: () => [
'--count 5',
'--interval 1000',
'--data-type text',
'--verbose'
]
}
},
'completion-setup': {},
init: {},
help: {}
help: {},
llm: {
_: () => [
'create',
'train',
'test',
'export',
'deploy',
'generate'
],
create: {
_: () => [
'--name my-model',
'--description "My custom LLM model"',
'--type simple',
'--type transformer',
'--vocab-size 5000',
'--embedding-dim 64',
'--hidden-dim 128',
'--layers 2',
'--heads 4',
'--dropout 0.1',
'--max-seq-length 100'
]
},
train: {
_: () => [
'--max-samples 1000',
'--validation-split 0.2',
'--epochs 10',
'--batch-size 32',
'--patience 3'
]
},
test: {
_: () => [
'--test-size 100',
'--generate-samples',
'--sample-count 5'
]
},
export: {
_: () => [
'--format json',
'--format tfjs',
'--output ./models',
'--include-metadata',
'--include-vocab'
]
},
deploy: {
_: () => [
'--target browser',
'--target node',
'--target cloud',
'--provider aws',
'--provider gcp',
'--provider azure',
'--endpoint https://example.com/api',
'--region us-east-1'
]
},
generate: {
_: () => [
'--temperature 0.7',
'--top-k 5',
'--max-length 100'
]
}
}
})
// Initialize autocomplete
@ -726,8 +815,11 @@ if (process.argv.includes('--completion-setup')) {
}
// Pipeline and Augmentation Commands
program
.command('list-augmentations')
const augmentCommand = new Command('augment')
.description('Augmentation pipeline operations')
augmentCommand
.command('list')
.description('List all available augmentation types and registered augmentations')
.action(async () => {
try {
@ -773,7 +865,7 @@ program
}
})
program
augmentCommand
.command('test-pipeline')
.description('Test the sequential pipeline with sample data')
.argument('[text]', 'Sample text to process through the pipeline', 'This is a test of the Brainy pipeline')
@ -855,7 +947,7 @@ program
}
})
program
augmentCommand
.command('stream-test')
.description('Test streaming data through the pipeline (simulated)')
.option('-c, --count <number>', 'Number of data items to stream', '5')
@ -949,8 +1041,8 @@ program
}
})
program
.command('augmentation-info')
augmentCommand
.command('info')
.description('Get detailed information about a specific augmentation type')
.argument('<type>', 'Augmentation type (sense, memory, cognition, conduit, activation, perception, dialog, websocket)')
.action(async (typeArg) => {
@ -1045,6 +1137,9 @@ program
}
})
// Add the augment command to the program
program.addCommand(augmentCommand)
// Add a command for setting up autocomplete
program
.command('completion-setup')
@ -1055,4 +1150,374 @@ program
})
// Parse command line arguments
// LLM Commands
const llmCommand = new Command('llm')
.description('LLM (Language Learning Model) operations')
llmCommand
.command('create')
.description('Create a new LLM model from Brainy data')
.option('-n, --name <name>', 'Name of the model')
.option('-d, --description <description>', 'Description of the model')
.option('-t, --type <type>', 'Type of model (simple, transformer, custom)', 'simple')
.option('-v, --vocab-size <size>', 'Vocabulary size', '5000')
.option('-e, --embedding-dim <dim>', 'Embedding dimension', '64')
.option('-h, --hidden-dim <dim>', 'Hidden dimension', '128')
.option('-l, --layers <count>', 'Number of layers', '2')
.option('--heads <count>', 'Number of attention heads (for transformer models)', '4')
.option('--dropout <rate>', 'Dropout rate', '0.1')
.option('--max-seq-length <length>', 'Maximum sequence length', '100')
.action(async (options) => {
try {
const db = createDb()
await db.init()
console.log('Creating LLM model...')
// Initialize LLM augmentations
const { cognition, activation } = await createLLMAugmentations()
// Set the database for the cognition augmentation
cognition.setBrainyDb(db)
// Parse options
const config = {
name: options.name || 'model-' + Date.now(),
description: options.description || 'Created via CLI',
modelType: options.type,
vocabSize: parseInt(options.vocabSize, 10),
embeddingDim: parseInt(options.embeddingDim, 10),
hiddenDim: parseInt(options.hiddenDim, 10),
layers: parseInt(options.layers, 10),
heads: parseInt(options.heads, 10),
dropout: parseFloat(options.dropout),
maxSeqLength: parseInt(options.maxSeqLength, 10)
}
// Create the model
const result = await cognition.createModel(config)
if (result.success) {
console.log(`Model created successfully with ID: ${result.data.modelId}`)
console.log(`Model type: ${config.modelType}`)
console.log(`Vocabulary size: ${config.vocabSize}`)
} else {
console.error(`Failed to create model: ${result.error}`)
}
} catch (error) {
console.error('Error:', (error as Error).message)
process.exit(1)
}
})
llmCommand
.command('train')
.description('Train an LLM model on Brainy data')
.argument('<modelId>', 'ID of the model to train')
.option('-s, --max-samples <count>', 'Maximum number of training samples')
.option('-v, --validation-split <ratio>', 'Validation split ratio', '0.2')
.option('-e, --epochs <count>', 'Number of training epochs', '10')
.option('-b, --batch-size <size>', 'Batch size', '32')
.option('-p, --patience <count>', 'Early stopping patience', '3')
.action(async (modelId, options) => {
try {
const db = createDb()
await db.init()
console.log(`Training LLM model ${modelId}...`)
// Initialize LLM augmentations
const { cognition, activation } = await createLLMAugmentations()
// Set the database for the cognition augmentation
cognition.setBrainyDb(db)
// Parse options
const trainingOptions = {
maxSamples: options.maxSamples ? parseInt(options.maxSamples, 10) : undefined,
validationSplit: parseFloat(options.validationSplit),
epochs: parseInt(options.epochs, 10),
batchSize: parseInt(options.batchSize, 10),
patience: parseInt(options.patience, 10)
}
console.log('Training with options:')
console.log(` Max samples: ${trainingOptions.maxSamples || 'All available'}`)
console.log(` Validation split: ${trainingOptions.validationSplit}`)
console.log(` Epochs: ${trainingOptions.epochs}`)
console.log(` Batch size: ${trainingOptions.batchSize}`)
console.log(` Early stopping patience: ${trainingOptions.patience}`)
// Train the model
const result = await cognition.trainModel(modelId, trainingOptions)
if (result.success) {
console.log(`\nModel ${modelId} trained successfully!`)
console.log(`Training metrics:`)
if (result.data.metrics) {
console.log(` Final loss: ${result.data.metrics.loss.toFixed(4)}`)
console.log(` Final accuracy: ${result.data.metrics.accuracy.toFixed(4)}`)
console.log(` Epochs completed: ${result.data.metrics.epochs}`)
}
} else {
console.error(`\nFailed to train model: ${result.error}`)
}
} catch (error) {
console.error('Error:', (error as Error).message)
process.exit(1)
}
})
llmCommand
.command('test')
.description('Test an LLM model on Brainy data')
.argument('<modelId>', 'ID of the model to test')
.option('-s, --test-size <count>', 'Number of test samples', '100')
.option('-g, --generate-samples', 'Generate sample predictions')
.option('-c, --sample-count <count>', 'Number of samples to generate', '5')
.action(async (modelId, options) => {
try {
const db = createDb()
await db.init()
console.log(`Testing LLM model ${modelId}...`)
// Initialize LLM augmentations
const { cognition, activation } = await createLLMAugmentations()
// Set the database for the cognition augmentation
cognition.setBrainyDb(db)
// Parse options
const testingOptions = {
testSize: parseInt(options.testSize, 10),
generateSamples: options.generateSamples,
sampleCount: parseInt(options.sampleCount, 10)
}
console.log('Testing with options:')
console.log(` Test size: ${testingOptions.testSize}`)
console.log(` Generate samples: ${testingOptions.generateSamples ? 'Yes' : 'No'}`)
if (testingOptions.generateSamples) {
console.log(` Sample count: ${testingOptions.sampleCount}`)
}
// Test the model
const result = await cognition.testModel(modelId, testingOptions)
if (result.success) {
console.log(`\nModel ${modelId} tested successfully!`)
console.log(`Test metrics:`)
if (result.data.metrics) {
console.log(` Test loss: ${result.data.metrics.loss.toFixed(4)}`)
console.log(` Test accuracy: ${result.data.metrics.accuracy.toFixed(4)}`)
console.log(` Test samples: ${result.data.metrics.samples}`)
}
// Display generated samples if available
if (result.data.samples && result.data.samples.length > 0) {
console.log(`\nGenerated samples:`)
result.data.samples.forEach((sample: { input: string; expected: string; generated: string }, index: number) => {
console.log(`\nSample ${index + 1}:`)
console.log(` Input: ${sample.input}`)
console.log(` Predicted: ${sample.generated}`)
if (sample.expected) {
console.log(` Actual: ${sample.expected}`)
}
})
}
} else {
console.error(`\nFailed to test model: ${result.error}`)
}
} catch (error) {
console.error('Error:', (error as Error).message)
process.exit(1)
}
})
llmCommand
.command('export')
.description('Export an LLM model for deployment')
.argument('<modelId>', 'ID of the model to export')
.option('-f, --format <format>', 'Export format (tfjs, json)', 'json')
.option('-o, --output <path>', 'Output path')
.option('-m, --include-metadata', 'Include metadata')
.option('-v, --include-vocab', 'Include vocabulary')
.action(async (modelId, options) => {
try {
const db = createDb()
await db.init()
console.log(`Exporting LLM model ${modelId}...`)
// Initialize LLM augmentations
const { cognition, activation } = await createLLMAugmentations()
// Set the database for the cognition augmentation
cognition.setBrainyDb(db)
// Parse options
const exportOptions = {
format: options.format,
outputPath: options.output,
includeMetadata: options.includeMetadata,
includeVocab: options.includeVocab
}
console.log('Exporting with options:')
console.log(` Format: ${exportOptions.format}`)
if (exportOptions.outputPath) {
console.log(` Output path: ${exportOptions.outputPath}`)
}
console.log(` Include metadata: ${exportOptions.includeMetadata ? 'Yes' : 'No'}`)
console.log(` Include vocabulary: ${exportOptions.includeVocab ? 'Yes' : 'No'}`)
// Export the model
const result = await cognition.exportModel(modelId, exportOptions)
if (result.success) {
console.log(`\nModel ${modelId} exported successfully!`)
if (result.data.path) {
console.log(`Exported to: ${result.data.path}`)
}
if (result.data.size) {
console.log(`Export size: ${(result.data.size / 1024).toFixed(2)} KB`)
}
} else {
console.error(`\nFailed to export model: ${result.error}`)
}
} catch (error) {
console.error('Error:', (error as Error).message)
process.exit(1)
}
})
llmCommand
.command('deploy')
.description('Deploy an LLM model to the specified target')
.argument('<modelId>', 'ID of the model to deploy')
.option('-t, --target <target>', 'Deployment target (browser, node, cloud)', 'browser')
.option('-p, --provider <provider>', 'Cloud provider (aws, gcp, azure)')
.option('-e, --endpoint <url>', 'Endpoint URL for cloud deployment')
.option('-r, --region <region>', 'Region for cloud deployment')
.action(async (modelId, options) => {
try {
const db = createDb()
await db.init()
console.log(`Deploying LLM model ${modelId} to ${options.target}...`)
// Initialize LLM augmentations
const { cognition, activation } = await createLLMAugmentations()
// Set the database for the cognition augmentation
cognition.setBrainyDb(db)
// Parse options
const deploymentOptions = {
target: options.target,
provider: options.provider,
endpoint: options.endpoint,
region: options.region
}
console.log('Deploying with options:')
console.log(` Target: ${deploymentOptions.target}`)
if (deploymentOptions.provider) {
console.log(` Provider: ${deploymentOptions.provider}`)
}
if (deploymentOptions.endpoint) {
console.log(` Endpoint: ${deploymentOptions.endpoint}`)
}
if (deploymentOptions.region) {
console.log(` Region: ${deploymentOptions.region}`)
}
// Deploy the model
const result = await cognition.deployModel(modelId, deploymentOptions)
if (result.success) {
console.log(`\nModel ${modelId} deployed successfully!`)
if (result.data.url) {
console.log(`Deployment URL: ${result.data.url}`)
}
if (result.data.deploymentId) {
console.log(`Deployment ID: ${result.data.deploymentId}`)
}
} else {
console.error(`\nFailed to deploy model: ${result.error}`)
}
} catch (error) {
console.error('Error:', (error as Error).message)
process.exit(1)
}
})
llmCommand
.command('generate')
.description('Generate text using an LLM model')
.argument('<modelId>', 'ID of the model to use')
.argument('<prompt>', 'Input prompt for text generation')
.option('-t, --temperature <temp>', 'Temperature for sampling', '0.7')
.option('-k, --top-k <count>', 'Number of top tokens to consider', '5')
.option('-l, --max-length <length>', 'Maximum length of generated text', '100')
.action(async (modelId, prompt, options) => {
try {
const db = createDb()
await db.init()
console.log(`Generating text using LLM model ${modelId}...`)
console.log(`Prompt: "${prompt}"`)
// Initialize LLM augmentations
const { cognition, activation } = await createLLMAugmentations()
// Set the database for the cognition augmentation
cognition.setBrainyDb(db)
// Parse options
const generateOptions = {
temperature: parseFloat(options.temperature),
topK: parseInt(options.topK, 10),
maxLength: parseInt(options.maxLength, 10)
}
console.log('Generation options:')
console.log(` Temperature: ${generateOptions.temperature}`)
console.log(` Top-K: ${generateOptions.topK}`)
console.log(` Max length: ${generateOptions.maxLength}`)
// Generate text
const result = await cognition.generateText(modelId, prompt, generateOptions)
if (result.success) {
console.log(`\nGenerated text:`)
console.log(`--------------`)
console.log(result.data.text)
console.log(`--------------`)
if (result.data.tokens) {
console.log(`\nTokens generated: ${result.data.tokens}`)
}
if (result.data.timeMs) {
console.log(`Generation time: ${result.data.timeMs}ms`)
}
} else {
console.error(`\nFailed to generate text: ${result.error}`)
}
} catch (error) {
console.error('Error:', (error as Error).message)
process.exit(1)
}
})
// Add the LLM command to the program
program.addCommand(llmCommand)
program.parse()

10
src/index.ts
View file

@ -141,6 +141,11 @@ import {
ServerSearchActivationAugmentation,
createServerSearchAugmentations
} from './augmentations/serverSearchAugmentations.js'
import {
LLMCognitionAugmentation,
LLMActivationAugmentation,
createLLMAugmentations
} from './augmentations/llmAugmentations.js'
export {
MemoryStorageAugmentation,
@ -152,7 +157,10 @@ export {
createConduitAugmentation,
ServerSearchConduitAugmentation,
ServerSearchActivationAugmentation,
createServerSearchAugmentations
createServerSearchAugmentations,
LLMCognitionAugmentation,
LLMActivationAugmentation,
createLLMAugmentations
}

2
src/utils/version.ts
View file

@ -3,4 +3,4 @@
* Do not modify this file directly.
*/
export const VERSION = '0.7.6';
export const VERSION = '0.7.7';