@soulcraft/brainy 0.26.0 → 0.27.0

package/README.md

@@ -598,6 +598,37 @@ await db.deleteVerb(verbId)
 
 ## Advanced Configuration
 
+### Database Modes
+
+Brainy supports special operational modes that restrict certain operations:
+
+```typescript
+import { BrainyData } from '@soulcraft/brainy'
+
+// Create and initialize the database
+const db = new BrainyData()
+await db.init()
+
+// Set the database to read-only mode (prevents write operations)
+db.setReadOnly(true)
+
+// Check if the database is in read-only mode
+const isReadOnly = db.isReadOnly() // Returns true
+
+// Set the database to write-only mode (prevents search operations)
+db.setWriteOnly(true)
+
+// Check if the database is in write-only mode
+const isWriteOnly = db.isWriteOnly() // Returns true
+
+// Reset to normal mode (allows both read and write operations)
+db.setReadOnly(false)
+db.setWriteOnly(false)
+```
+
+- **Read-Only Mode**: When enabled, prevents all write operations (add, update, delete). Useful for deployment scenarios where you want to prevent modifications to the database.
+- **Write-Only Mode**: When enabled, prevents all search operations. Useful for initial data loading or when you want to optimize for write performance.
+
 ### Embedding
 
 ```typescript

package/dist/brainyData.d.ts

@@ -65,6 +65,12 @@ export interface BrainyDataConfig {
      * When true, all write operations will throw an error
      */
     readOnly?: boolean;
+    /**
+     * Set the database to write-only mode
+     * When true, the index is not loaded into memory and search operations will throw an error
+     * This is useful for data ingestion scenarios where only write operations are needed
+     */
+    writeOnly?: boolean;
     /**
      * Remote server configuration for search operations
      */
@@ -177,6 +183,7 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     private distanceFunction;
     private requestPersistentStorage;
     private readOnly;
+    private writeOnly;
     private storageConfig;
     private useOptimizedIndex;
     private _dimensions;
@@ -211,6 +218,11 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @throws Error if the database is in read-only mode
      */
     private checkReadOnly;
+    /**
+     * Check if the database is in write-only mode and throw an error if it is
+     * @throws Error if the database is in write-only mode
+     */
+    private checkWriteOnly;
     /**
      * Start real-time updates if enabled in the configuration
      * This will periodically check for new data in storage and update the in-memory index and statistics
@@ -573,6 +585,16 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param readOnly True to set the database to read-only mode, false to allow writes
      */
     setReadOnly(readOnly: boolean): void;
+    /**
+     * Check if the database is in write-only mode
+     * @returns True if the database is in write-only mode, false otherwise
+     */
+    isWriteOnly(): boolean;
+    /**
+     * Set the database to write-only mode
+     * @param writeOnly True to set the database to write-only mode, false to allow searches
+     */
+    setWriteOnly(writeOnly: boolean): void;
     /**
      * Embed text or data into a vector using the same embedding function used by this instance
      * This allows clients to use the same TensorFlow Universal Sentence Encoder throughout their application

package/dist/index.d.ts

@@ -29,19 +29,19 @@ import { MemoryStorageAugmentation, FileSystemStorageAugmentation, OPFSStorageAu
 import { WebSocketConduitAugmentation, WebRTCConduitAugmentation, createConduitAugmentation } from './augmentations/conduitAugmentations.js';
 import { ServerSearchConduitAugmentation, ServerSearchActivationAugmentation, createServerSearchAugmentations } from './augmentations/serverSearchAugmentations.js';
 export { MemoryStorageAugmentation, FileSystemStorageAugmentation, OPFSStorageAugmentation, createMemoryAugmentation, WebSocketConduitAugmentation, WebRTCConduitAugmentation, createConduitAugmentation, ServerSearchConduitAugmentation, ServerSearchActivationAugmentation, createServerSearchAugmentations };
-import type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, GraphVerb, HNSWConfig, StorageAdapter } from './coreTypes.js';
+import type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWConfig, StorageAdapter } from './coreTypes.js';
 import { HNSWIndex } from './hnsw/hnswIndex.js';
 import { HNSWIndexOptimized, HNSWOptimizedConfig } from './hnsw/hnswIndexOptimized.js';
 export { HNSWIndex, HNSWIndexOptimized };
-export type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, GraphVerb, HNSWConfig, HNSWOptimizedConfig, StorageAdapter };
+export type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWConfig, HNSWOptimizedConfig, StorageAdapter };
 import type { IAugmentation, AugmentationResponse, IWebSocketSupport, ISenseAugmentation, IConduitAugmentation, ICognitionAugmentation, IMemoryAugmentation, IPerceptionAugmentation, IDialogAugmentation, IActivationAugmentation } from './types/augmentations.js';
 import { AugmentationType, BrainyAugmentations } from './types/augmentations.js';
 export type { IAugmentation, AugmentationResponse, IWebSocketSupport };
 export { AugmentationType, BrainyAugmentations, ISenseAugmentation, IConduitAugmentation, ICognitionAugmentation, IMemoryAugmentation, IPerceptionAugmentation, IDialogAugmentation, IActivationAugmentation };
 export type { IWebSocketCognitionAugmentation, IWebSocketSenseAugmentation, IWebSocketPerceptionAugmentation, IWebSocketActivationAugmentation, IWebSocketDialogAugmentation, IWebSocketConduitAugmentation, IWebSocketMemoryAugmentation } from './types/augmentations.js';
-import type { GraphNoun, EmbeddedGraphVerb, Person, Place, Thing, Event, Concept, Content } from './types/graphTypes.js';
+import type { GraphNoun, GraphVerb, EmbeddedGraphVerb, Person, Location, Thing, Event, Concept, Content, Collection, Organization, Document, Media, File, Message, Dataset, Product, Service, User, Task, Project, Process, State, Role, Topic, Language, Currency, Measurement } from './types/graphTypes.js';
 import { NounType, VerbType } from './types/graphTypes.js';
-export type { GraphNoun, EmbeddedGraphVerb, Person, Place, Thing, Event, Concept, Content };
+export type { GraphNoun, GraphVerb, EmbeddedGraphVerb, Person, Location, Thing, Event, Concept, Content, Collection, Organization, Document, Media, File, Message, Dataset, Product, Service, User, Task, Project, Process, State, Role, Topic, Language, Currency, Measurement };
 export { NounType, VerbType };
 import { BrainyMCPAdapter, MCPAugmentationToolset, BrainyMCPService } from './mcp/index.js';
 import { MCPRequest, MCPResponse, MCPDataAccessRequest, MCPToolExecutionRequest, MCPSystemInfoRequest, MCPAuthenticationRequest, MCPRequestType, MCPServiceOptions, MCPTool, MCP_VERSION } from './types/mcpTypes.js';

package/dist/types/graphTypes.d.ts

@@ -1,3 +1,165 @@
+/**
+ * Graph Types - Standardized Noun and Verb Type System
+ *
+ * This module defines a comprehensive, standardized set of noun and verb types
+ * that can be used to model any kind of graph, semantic network, or data model.
+ *
+ * ## Purpose and Design Philosophy
+ *
+ * The type system is designed to be:
+ * - **Universal**: Capable of representing any domain or use case
+ * - **Hierarchical**: Organized into logical categories for easy navigation
+ * - **Extensible**: Additional metadata can be attached to any entity or relationship
+ * - **Semantic**: Types carry meaning that can be used for reasoning and inference
+ *
+ * ## Noun Types (Entities)
+ *
+ * Noun types represent entities in the graph and are organized into categories:
+ *
+ * ### Core Entity Types
+ * - **Person**: Human entities and individuals
+ * - **Organization**: Formal organizations, companies, institutions
+ * - **Location**: Geographic locations, places, addresses
+ * - **Thing**: Physical objects and tangible items
+ * - **Concept**: Abstract ideas, concepts, and intangible entities
+ * - **Event**: Occurrences with time and place dimensions
+ *
+ * ### Digital/Content Types
+ * - **Document**: Text-based files and documents
+ * - **Media**: Non-text media files (images, videos, audio)
+ * - **File**: Generic digital files
+ * - **Message**: Communication content
+ * - **Content**: Generic content that doesn't fit other categories
+ *
+ * ### Collection Types
+ * - **Collection**: Generic groupings of items
+ * - **Dataset**: Structured collections of data
+ *
+ * ### Business/Application Types
+ * - **Product**: Commercial products and offerings
+ * - **Service**: Services and offerings
+ * - **User**: User accounts and profiles
+ * - **Task**: Actions, todos, and workflow items
+ * - **Project**: Organized initiatives with goals and timelines
+ *
+ * ### Descriptive Types
+ * - **Process**: Workflows, procedures, and sequences
+ * - **State**: States, conditions, or statuses
+ * - **Role**: Roles, positions, or responsibilities
+ * - **Topic**: Subjects or themes
+ * - **Language**: Languages or linguistic entities
+ * - **Currency**: Currencies and monetary units
+ * - **Measurement**: Measurements, metrics, or quantities
+ *
+ * ## Verb Types (Relationships)
+ *
+ * Verb types represent relationships between entities and are organized into categories:
+ *
+ * ### Core Relationship Types
+ * - **RelatedTo**: Generic relationship (default fallback)
+ * - **Contains**: Containment relationship
+ * - **PartOf**: Part-whole relationship
+ * - **LocatedAt**: Spatial relationship
+ * - **References**: Reference or citation relationship
+ *
+ * ### Temporal/Causal Types
+ * - **Precedes/Succeeds**: Temporal sequence relationships
+ * - **Causes**: Causal relationships
+ * - **DependsOn**: Dependency relationships
+ * - **Requires**: Necessity relationships
+ *
+ * ### Creation/Transformation Types
+ * - **Creates**: Creation relationships
+ * - **Transforms**: Transformation relationships
+ * - **Becomes**: State change relationships
+ * - **Modifies**: Modification relationships
+ * - **Consumes**: Consumption relationships
+ *
+ * ### Ownership/Attribution Types
+ * - **Owns**: Ownership relationships
+ * - **AttributedTo**: Attribution or authorship
+ * - **CreatedBy**: Creation attribution
+ * - **BelongsTo**: Belonging relationships
+ *
+ * ### Social/Organizational Types
+ * - **MemberOf**: Membership or affiliation
+ * - **WorksWith**: Professional relationships
+ * - **FriendOf**: Friendship relationships
+ * - **Follows**: Following relationships
+ * - **Likes**: Liking relationships
+ * - **ReportsTo**: Reporting relationships
+ * - **Supervises**: Supervisory relationships
+ * - **Mentors**: Mentorship relationships
+ * - **Communicates**: Communication relationships
+ *
+ * ### Descriptive/Functional Types
+ * - **Describes**: Descriptive relationships
+ * - **Defines**: Definition relationships
+ * - **Categorizes**: Categorization relationships
+ * - **Measures**: Measurement relationships
+ * - **Evaluates**: Evaluation or assessment relationships
+ * - **Uses**: Utilization relationships
+ * - **Implements**: Implementation relationships
+ * - **Extends**: Extension relationships
+ *
+ * ## Usage with Additional Metadata
+ *
+ * While the type system provides a standardized vocabulary, additional metadata
+ * can be attached to any entity or relationship to capture domain-specific
+ * information:
+ *
+ * ```typescript
+ * const person: GraphNoun = {
+ *   id: 'person-123',
+ *   noun: NounType.Person,
+ *   data: {
+ *     name: 'John Doe',
+ *     age: 30,
+ *     profession: 'Engineer'
+ *   }
+ * }
+ *
+ * const worksFor: GraphVerb = {
+ *   id: 'verb-456',
+ *   source: 'person-123',
+ *   target: 'org-789',
+ *   verb: VerbType.MemberOf,
+ *   data: {
+ *     role: 'Senior Engineer',
+ *     startDate: '2020-01-01',
+ *     department: 'Engineering'
+ *   }
+ * }
+ * ```
+ *
+ * ## Modeling Different Graph Types
+ *
+ * This type system can model various graph structures:
+ *
+ * ### Knowledge Graphs
+ * Use Person, Organization, Location, Concept entities with semantic relationships
+ * like AttributedTo, LocatedAt, RelatedTo
+ *
+ * ### Social Networks
+ * Use Person, User entities with social relationships like FriendOf, Follows,
+ * WorksWith, Communicates
+ *
+ * ### Content Networks
+ * Use Document, Media, Content entities with relationships like References,
+ * CreatedBy, Contains, Categorizes
+ *
+ * ### Business Process Models
+ * Use Task, Process, Role entities with relationships like Precedes, Requires,
+ * DependsOn, Transforms
+ *
+ * ### Organizational Charts
+ * Use Person, Role, Organization entities with relationships like ReportsTo,
+ * Supervises, MemberOf
+ *
+ * The flexibility of this system allows it to represent any domain while
+ * maintaining semantic consistency and enabling powerful graph operations
+ * and reasoning capabilities.
+ */
 /**
  * Represents a high-precision timestamp with seconds and nanoseconds
  * Used for tracking creation and update times of graph elements
@@ -61,8 +223,8 @@ export interface Person extends GraphNoun {
 /**
  * Represents a physical location in the graph
  */
-export interface Place extends GraphNoun {
-    noun: typeof NounType.Place;
+export interface Location extends GraphNoun {
+    noun: typeof NounType.Location;
 }
 /**
  * Represents a physical or virtual object in the graph
@@ -82,11 +244,62 @@ export interface Event extends GraphNoun {
 export interface Concept extends GraphNoun {
     noun: typeof NounType.Concept;
 }
-export interface Group extends GraphNoun {
-    noun: typeof NounType.Group;
+export interface Collection extends GraphNoun {
+    noun: typeof NounType.Collection;
+}
+export interface Organization extends GraphNoun {
+    noun: typeof NounType.Organization;
+}
+export interface Document extends GraphNoun {
+    noun: typeof NounType.Document;
+}
+export interface Media extends GraphNoun {
+    noun: typeof NounType.Media;
+}
+export interface File extends GraphNoun {
+    noun: typeof NounType.File;
+}
+export interface Message extends GraphNoun {
+    noun: typeof NounType.Message;
+}
+export interface Dataset extends GraphNoun {
+    noun: typeof NounType.Dataset;
+}
+export interface Product extends GraphNoun {
+    noun: typeof NounType.Product;
+}
+export interface Service extends GraphNoun {
+    noun: typeof NounType.Service;
+}
+export interface User extends GraphNoun {
+    noun: typeof NounType.User;
+}
+export interface Task extends GraphNoun {
+    noun: typeof NounType.Task;
+}
+export interface Project extends GraphNoun {
+    noun: typeof NounType.Project;
+}
+export interface Process extends GraphNoun {
+    noun: typeof NounType.Process;
+}
+export interface State extends GraphNoun {
+    noun: typeof NounType.State;
 }
-export interface List extends GraphNoun {
-    noun: typeof NounType.List;
+export interface Role extends GraphNoun {
+    noun: typeof NounType.Role;
+}
+export interface Topic extends GraphNoun {
+    noun: typeof NounType.Topic;
+}
+export interface Language extends GraphNoun {
+    noun: typeof NounType.Language;
+}
+export interface Currency extends GraphNoun {
+    noun: typeof NounType.Currency;
+}
+export interface Measurement extends GraphNoun {
+    noun: typeof NounType.Measurement;
 }
 /**
  * Represents content (text, media, etc.) in the graph
@@ -100,14 +313,30 @@ export interface Content extends GraphNoun {
  */
 export declare const NounType: {
     readonly Person: "person";
-    readonly Place: "place";
+    readonly Organization: "organization";
+    readonly Location: "location";
     readonly Thing: "thing";
-    readonly Event: "event";
     readonly Concept: "concept";
+    readonly Event: "event";
+    readonly Document: "document";
+    readonly Media: "media";
+    readonly File: "file";
+    readonly Message: "message";
     readonly Content: "content";
-    readonly Group: "group";
-    readonly List: "list";
-    readonly Category: "category";
+    readonly Collection: "collection";
+    readonly Dataset: "dataset";
+    readonly Product: "product";
+    readonly Service: "service";
+    readonly User: "user";
+    readonly Task: "task";
+    readonly Project: "project";
+    readonly Process: "process";
+    readonly State: "state";
+    readonly Role: "role";
+    readonly Topic: "topic";
+    readonly Language: "language";
+    readonly Currency: "currency";
+    readonly Measurement: "measurement";
 };
 export type NounType = (typeof NounType)[keyof typeof NounType];
 /**
@@ -115,20 +344,42 @@ export type NounType = (typeof NounType)[keyof typeof NounType];
  * Used for categorizing different types of connections
  */
 export declare const VerbType: {
-    readonly AttributedTo: "attributedTo";
-    readonly Controls: "controls";
-    readonly Created: "created";
-    readonly Earned: "earned";
+    readonly RelatedTo: "relatedTo";
+    readonly Contains: "contains";
+    readonly PartOf: "partOf";
+    readonly LocatedAt: "locatedAt";
+    readonly References: "references";
+    readonly Precedes: "precedes";
+    readonly Succeeds: "succeeds";
+    readonly Causes: "causes";
+    readonly DependsOn: "dependsOn";
+    readonly Requires: "requires";
+    readonly Creates: "creates";
+    readonly Transforms: "transforms";
+    readonly Becomes: "becomes";
+    readonly Modifies: "modifies";
+    readonly Consumes: "consumes";
     readonly Owns: "owns";
+    readonly AttributedTo: "attributedTo";
+    readonly CreatedBy: "createdBy";
+    readonly BelongsTo: "belongsTo";
     readonly MemberOf: "memberOf";
-    readonly RelatedTo: "relatedTo";
     readonly WorksWith: "worksWith";
     readonly FriendOf: "friendOf";
+    readonly Follows: "follows";
+    readonly Likes: "likes";
     readonly ReportsTo: "reportsTo";
     readonly Supervises: "supervises";
     readonly Mentors: "mentors";
-    readonly Follows: "follows";
-    readonly Likes: "likes";
+    readonly Communicates: "communicates";
+    readonly Describes: "describes";
+    readonly Defines: "defines";
+    readonly Categorizes: "categorizes";
+    readonly Measures: "measures";
+    readonly Evaluates: "evaluates";
+    readonly Uses: "uses";
+    readonly Implements: "implements";
+    readonly Extends: "extends";
 };
 export type VerbType = (typeof VerbType)[keyof typeof VerbType];
 export {};

package/dist/types/graphTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphTypes.d.ts","sourceRoot":"","sources":["../../src/types/graphTypes.ts"],"names":[],"mappings":"AACA;;;GAGG;AACH,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;GAGG;AACH,UAAU,eAAe;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,eAAe,CAAA;IAC1B,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,EAAE,SAAS,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC1B,aAAa,CAAC,EAAE,iBAAiB,EAAE,CAAA;IACnC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,EAAE,eAAe,CAAA;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;AAIzD;;GAEG;AACH,MAAM,WAAW,MAAO,SAAQ,SAAS;IACvC,IAAI,EAAE,OAAO,QAAQ,CAAC,MAAM,CAAA;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,KAAM,SAAQ,SAAS;IACtC,IAAI,EAAE,OAAO,QAAQ,CAAC,KAAK,CAAA;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,KAAM,SAAQ,SAAS;IACtC,IAAI,EAAE,OAAO,QAAQ,CAAC,KAAK,CAAA;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,KAAM,SAAQ,SAAS;IACtC,IAAI,EAAE,OAAO,QAAQ,CAAC,KAAK,CAAA;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,IAAI,EAAE,OAAO,QAAQ,CAAC,OAAO,CAAA;CAC9B;AAED,MAAM,WAAW,KAAM,SAAQ,SAAS;IACtC,IAAI,EAAE,OAAO,QAAQ,CAAC,KAAK,CAAA;CAC5B;AAED,MAAM,WAAW,IAAK,SAAQ,SAAS;IACrC,IAAI,EAAE,OAAO,QAAQ,CAAC,IAAI,CAAA;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,IAAI,EAAE,OAAO,QAAQ,CAAC,OAAO,CAAA;CAC9B;AAED;;;GAGG;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;CAUX,CAAA;AACV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAA;AAE/D;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;CAeX,CAAA;AACV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"graphTypes.d.ts","sourceRoot":"","sources":["../../src/types/graphTypes.ts"],"names":[],"mappings":"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"}