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

**remove: delete LLM augmentations implementation**

Browse source 
### Changes:
- Removed the `src/augmentations/llmAugmentations.ts` file:
  - Contained cognition augmentations for creating, testing, exporting, and deploying LLM models.
  - Included TensorFlow.js-based model configuration, training, testing, and deployment functionalities.
  - Implemented various presets (`tiny`, `small`, `medium`, `large`) for simplified LLM model creation.

### Purpose:
This change removes legacy LLM-related augmentations and functionalities no longer relevant to the project's current focus, in alignment with the recent transition to TensorFlow-based embedding workflows. Cleaning up eliminates unused code and maintains a streamlined, up-to-date codebase.
This commit is contained in:
David Snelling 2025-06-19 15:00:26 -07:00
parent cfe1fd9e22
commit cbc007b6cf
3 changed files with 0 additions and 2642 deletions
Download patch file Download diff file Expand all files Collapse all files

1943
src/augmentations/llmAugmentations.ts
View file

File diff suppressed because it is too large Load diff

636
src/augmentations/llmTrainingAugmentations.ts
View file

@ -1,636 +0,0 @@
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
}

63
test/validateTypes.js
View file

@ -1,63 +0,0 @@
// Test script to verify type validation in BrainyData
import { BrainyData } from '../src/brainyData.js';
import { NounType, VerbType } from '../src/types/graphTypes.js';
async function testTypeValidation() {
console.log('Testing type validation in BrainyData...');
// Create a new BrainyData instance
const brainy = new BrainyData();
await brainy.init();
console.log('Testing node with valid noun type...');
const validNodeId = await brainy.add([0.1, 0.2, 0.3], {
noun: NounType.Person,
label: 'Test Person'
});
console.log(`Added node with valid noun type: ${validNodeId}`);
console.log('Testing node with invalid noun type...');
const invalidNodeId = await brainy.add([0.4, 0.5, 0.6], {
noun: 'invalid_type',
label: 'Test Invalid'
});
console.log(`Added node with invalid noun type (should be converted to default): ${invalidNodeId}`);
// Get the metadata to verify it was corrected
const invalidNodeMetadata = await brainy.get(invalidNodeId);
console.log('Metadata for node with invalid type:', invalidNodeMetadata);
console.log('Testing edge with valid verb type...');
const validEdgeId = await brainy.addEdge(validNodeId, invalidNodeId, undefined, {
type: VerbType.RelatedTo,
metadata: { label: 'Test Relation' }
});
console.log(`Added edge with valid verb type: ${validEdgeId}`);
console.log('Testing edge with invalid verb type...');
const invalidEdgeId = await brainy.addEdge(validNodeId, invalidNodeId, undefined, {
type: 'invalid_relation',
metadata: { label: 'Test Invalid Relation' }
});
console.log(`Added edge with invalid verb type (should be converted to default): ${invalidEdgeId}`);
// Get the edge to verify it was corrected
const invalidEdge = await brainy.getEdge(invalidEdgeId);
console.log('Edge with invalid type:', invalidEdge);
console.log('Testing updateMetadata with invalid noun type...');
await brainy.updateMetadata(validNodeId, {
noun: 'another_invalid_type',
label: 'Updated Test'
});
// Get the metadata to verify it was corrected
const updatedMetadata = await brainy.get(validNodeId);
console.log('Updated metadata (should have corrected noun type):', updatedMetadata);
console.log('All tests completed.');
}
testTypeValidation().catch(error => {
console.error('Test failed:', error);
});