ai-database 0.0.0-development

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AI Primitives
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# ai-database
+
+[![npm version](https://badge.fury.io/js/ai-database.svg)](https://badge.fury.io/js/ai-database)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+AI-native database abstraction with hybrid vector search capabilities for synthetic data, tool-calling, and RAG applications.
+
+## Features
+- Hybrid vector search optimized for AI workloads
+- Synthetic data generation and management
+- Tool-calling interface compatible with major AI SDKs
+- Built-in support for RAG (Retrieval Augmented Generation)
+- Seamless integration with mdxdb for document storage
+
+## Installation
+```bash
+npm install ai-database
+# or
+pnpm add ai-database
+# or
+yarn add ai-database
+```
+
+## Quick Start
+```typescript
+import { createDatabase } from 'ai-database'
+
+// Initialize database with vector search capabilities
+const db = createDatabase({
+  namespace: 'my-app',
+  vectorSearch: true
+})
+
+// Store documents with embeddings
+await db.collection('documents').store({
+  content: 'Example document',
+  embeddings: [0.1, 0.2, 0.3]
+})
+
+// Perform hybrid search
+const results = await db.collection('documents').search({
+  query: 'example',
+  vector: [0.1, 0.2, 0.3],
+  threshold: 0.8
+})
+```
+
+## Tool Integration
+ai-database exports AI-compatible tools that work with any LLM supporting function calling:
+
+```typescript
+import { tools } from 'ai-database'
+
+// Use with any AI SDK (Vercel AI, LangChain, etc)
+const searchTool = tools.vectorSearch({
+  collection: 'documents',
+  namespace: 'my-app'
+})
+```
+
+## Integration with AI Primitives
+ai-database is designed to work seamlessly with other AI Primitives packages:
+
+- **ai-functions**: Provides database operations as callable AI functions
+- **ai-workflows**: Enables database integration in AI workflow definitions
+- **ai-agents**: Offers database access tools for AI agents
+
+## API Reference
+[API documentation link]
+
+## Dependencies
+Built on top of [mdxdb](https://github.com/ai-primitives/mdxdb) for robust document storage and vector search capabilities.

package/dist/types/database.d.ts

@@ -0,0 +1,46 @@
+import { AIDocument } from './document';
+import { AIVectorSearchOptions } from './vector';
+/**
+ * Configuration options for the AI-native database
+ */
+export interface DatabaseConfig {
+    /**
+     * Database name or identifier
+     */
+    name: string;
+    /**
+     * Optional vector search configuration
+     */
+    vectorSearch?: {
+        /**
+         * Dimensions for vector embeddings
+         */
+        dimensions?: number;
+        /**
+         * Model to use for embeddings
+         */
+        model?: string;
+    };
+    /**
+     * Optional synthetic data generation configuration
+     */
+    synthetic?: {
+        /**
+         * Model to use for synthetic data generation
+         */
+        model?: string;
+    };
+}
+/**
+ * Database provider interface
+ */
+export interface DatabaseProvider {
+    /**
+     * Query documents using AI-powered vector search
+     */
+    query(options: AIVectorSearchOptions): Promise<AIDocument[]>;
+    /**
+     * Insert a document into the database
+     */
+    insert(document: AIDocument): Promise<void>;
+}

package/dist/types/document.d.ts

@@ -0,0 +1,15 @@
+import type { Document } from './mdxdb/types';
+export interface AIDocument extends Document {
+    metadata?: {
+        model?: string;
+        temperature?: number;
+        tokens?: number;
+        provider?: string;
+    };
+    synthetic?: boolean;
+    toolCalls?: Array<{
+        name: string;
+        arguments: Record<string, unknown>;
+        result?: unknown;
+    }>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './document';
+export * from './vector';
+export * from './tools';
+export * from './synthetic';
+export * from './database';

package/dist/types/mdxdb/embedding.d.ts

@@ -0,0 +1,7 @@
+export interface EmbeddingOptions {
+    dimensions?: number;
+    model?: string;
+}
+export interface EmbeddingProvider {
+    embed(text: string, options?: EmbeddingOptions): Promise<number[]>;
+}

package/dist/types/mdxdb/types.d.ts

@@ -0,0 +1,59 @@
+import type { MDXLD } from 'mdxld';
+export interface Document extends MDXLD {
+    embeddings?: number[];
+    collections?: string[];
+}
+export interface VectorSearchOptions {
+    vector?: number[];
+    query?: string;
+    filter?: Record<string, unknown>;
+    k?: number;
+    threshold?: number;
+}
+export interface NamespaceOptions {
+    defaultNamespace?: string;
+    enforceHttps?: boolean;
+    maxPathDepth?: number;
+    allowSubdomains?: boolean;
+}
+export interface DatabaseOptions {
+    namespace: string;
+    baseUrl?: string;
+    options?: NamespaceOptions;
+}
+export interface CollectionOptions {
+    path: string;
+    database: DatabaseProvider;
+}
+export interface DatabaseProvider<T extends Document = Document> {
+    namespace: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    list(): Promise<string[]>;
+    collection(name: string): CollectionProvider<T>;
+    [key: string]: DatabaseProvider<T> | CollectionProvider<T> | string | (() => Promise<void>) | (() => Promise<string[]>) | ((name: string) => CollectionProvider<T>);
+}
+export type FilterQuery<T> = {
+    [K in keyof T]?: T[K] | {
+        $eq?: T[K];
+        $gt?: T[K];
+        $gte?: T[K];
+        $lt?: T[K];
+        $lte?: T[K];
+        $in?: T[K][];
+        $nin?: T[K][];
+    };
+};
+export interface SearchOptions<T extends Document = Document> {
+    filter?: FilterQuery<T>;
+    threshold?: number;
+    limit?: number;
+    offset?: number;
+    includeVectors?: boolean;
+}
+export interface CollectionProvider<T extends Document = Document> {
+    path: string;
+    find(filter: FilterQuery<T>, options?: SearchOptions<T>): Promise<T[]>;
+    search(query: string, options?: SearchOptions<T>): Promise<T[]>;
+    vectorSearch(options: VectorSearchOptions & SearchOptions<T>): Promise<T[]>;
+}

package/dist/types/synthetic.d.ts

@@ -0,0 +1,9 @@
+export interface SyntheticDataOptions {
+    schema: Record<string, unknown>;
+    count: number;
+    model?: string;
+    temperature?: number;
+}
+export interface SyntheticDataProvider {
+    generate(options: SyntheticDataOptions): Promise<unknown[]>;
+}

package/dist/types/tools.d.ts

@@ -0,0 +1,10 @@
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    returns: Record<string, unknown>;
+}
+export interface ToolProvider {
+    namespace: string;
+    tools: ToolDefinition[];
+}

package/dist/types/vector.d.ts

@@ -0,0 +1,16 @@
+import type { VectorSearchOptions } from './mdxdb/types';
+import type { EmbeddingOptions, EmbeddingProvider } from './mdxdb/embedding';
+export interface AIVectorSearchOptions extends VectorSearchOptions {
+    rerank?: boolean;
+    hybridWeight?: number;
+    contextWindow?: number;
+}
+export interface AIEmbeddingOptions extends EmbeddingOptions {
+    provider?: string;
+    batchSize?: number;
+    normalize?: boolean;
+}
+export interface AIEmbeddingProvider extends EmbeddingProvider {
+    batchEmbed?(texts: string[], options?: AIEmbeddingOptions): Promise<number[][]>;
+    normalize?(vector: number[]): number[];
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "ai-database",
+  "version": "0.0.0-development",
+  "description": "AI-native database abstraction with hybrid vector search for synthetic data and RAG applications. Currently using local mdxdb types until @mdxdb/types is published.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist/types"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "lint": "eslint .",
+    "format": "prettier --write ."
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^9.0.0",
+    "mdxld": "^0.1.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^1.0.8",
+    "ai": "^2.2.37",
+    "openai": "^4.76.3"
+  }
+}