freshcrate
Skin:/
Language:English/įŽ€äŊ“中文
Home > Databases > VecturaKit

VecturaKit

Swift-based vector database for on-device RAG using MLTensor and MLX Embedders

mlx-swiftragswift
Why this rank:Strong adoptionRelease freshnessHealthy release cadence

Description

Swift-based vector database for on-device RAG using MLTensor and MLX Embedders

README

VecturaKit

VecturaKit is a Swift-based vector database designed for on-device apps through local vector storage and retrieval.

Inspired by Dripfarm's SVDB, VecturaKit uses MLTensor and swift-embeddings for generating and managing embeddings. It features Model2Vec support with the 32M parameter model as default for fast static embeddings, and supports NomicBERT, ModernBERT, RoBERTa, and XLM-RoBERTa models.

The framework offers VecturaKit as the core vector database with pluggable embedding providers. Use SwiftEmbedder for swift-embeddings integration, OpenAICompatibleEmbedder for hosted or local /v1/embeddings providers, NLContextualEmbedder for Apple's NaturalLanguage framework with zero external dependencies, or MLXEmbedder for Apple's MLX framework acceleration (available as a separate package).

It also includes CLI tools (vectura-cli and vectura-oai-cli) for easily trying out the package.

Swift 6.0+iOS 17.0+macOS 14.0+watchOS 10.0+tvOS 17.0+visionOS 1.0+

Learn More

Exploring On-Device AI Book Exploring AI-Assisted Coding BookExplore the following books to understand more about AI and iOS development:

Table of Contents

Features

  • Model2Vec Support: Uses the retrieval 32M parameter Model2Vec model as default for fast static embeddings.
  • NomicBERT Support: Supports Nomic embedding models such as nomic-ai/nomic-embed-text-v1.5.
  • ModernBERT Support: Supports ModernBERT embedding models such as nomic-ai/modernbert-embed-base.
  • RoBERTa/XLM-RoBERTa Support: Supports models such as FacebookAI/roberta-base and FacebookAI/xlm-roberta-base.
  • Auto-Dimension Detection: Automatically detects embedding dimensions from models.
  • On-Device Storage: Stores and manages vector embeddings locally.
  • Hybrid Search: Combines vector similarity with BM25 text search for relevant search results (VecturaKit).
  • Pluggable Search Engines: Implement custom search algorithms by conforming to the VecturaSearchEngine protocol.
  • Batch Processing: Indexes documents in parallel for faster data ingestion.
  • Persistent Storage: Automatically saves and loads document data, preserving the database state across app sessions.
  • Configurable Search: Customizes search behavior with adjustable thresholds, result limits, and hybrid search weights.
  • Custom Storage Location: Specifies a custom directory for database storage.
  • Custom Storage Provider: Implements custom storage backends (SQLite, Core Data, cloud storage) by conforming to the VecturaStorage protocol.
  • Memory Management Strategies: Choose between automatic, full-memory, or indexed modes to optimize performance for datasets ranging from thousands to millions of documents. Learn more
  • MLX Support: GPU-accelerated embedding generation available via the separate VecturaMLXKit package.
  • OpenAI-Compatible Support: Connects to OpenAI-compatible /v1/embeddings endpoints exposed by local servers and hosted providers through OpenAICompatibleEmbedder.
  • NaturalLanguage Support: Uses Apple's NaturalLanguage framework for contextual embeddings with zero external dependencies through NLContextualEmbedder.
  • CLI Tools: Includes vectura-cli and vectura-oai-cli for database management and testing.

Supported Platforms

  • macOS 14.0 or later
  • iOS 17.0 or later
  • tvOS 17.0 or later
  • visionOS 1.0 or later
  • watchOS 10.0 or later

Installation

Swift Package Manager handles the distribution of Swift code and comes built into the Swift compiler.

To integrate VecturaKit into your project using Swift Package Manager, add the following dependency in your Package.swift file:

dependencies: [
    .package(url: "https://github.com/rryam/VecturaKit.git", from: "3.0.0"),
],

Then add the products you want to your target:

target(
    name: "MyApp",
    dependencies: [
        .product(name: "VecturaKit", package: "VecturaKit"),
        .product(name: "VecturaOAIKit", package: "VecturaKit"),
    ]
)

For MLX support, also add the separate VecturaMLXKit package:

dependencies: [
    .package(url: "https://github.com/rryam/VecturaKit.git", from: "3.0.0"),
    .package(url: "https://github.com/rryam/VecturaMLXKit.git", from: "1.0.0"),
],

Dependencies

VecturaKit uses the following Swift packages:

Note: VecturaNLKit and VecturaOAIKit are shipped from this package. The standalone VecturaOAIKit repository is intended to be deprecated after this integration lands. For MLX-based embeddings, see VecturaMLXKit.

Quick Start

Get up and running with VecturaKit in minutes. Here is an example of adding and searching documents:

import VecturaKit

Task {
    do {
        let config = VecturaConfig(name: "my-db")
        let embedder = SwiftEmbedder(modelSource: .default)
        let vectorDB = try await VecturaKit(config: config, embedder: embedder)
        
        // Add documents
        let ids = try await vectorDB.addDocuments(texts: [
            "The quick brown fox jumps over the lazy dog",
            "Swift is a powerful programming language"
        ])
        
        // Search documents
        let results = try await vectorDB.search(query: "programming language", numResults: 5)
        print("Found \(results.count) results!")
    } catch {
        print("Error: \(error)")
    }
}

Usage

Import VecturaKit

import VecturaKit

Create Configuration and Initialize Database

import Foundation
import VecturaKit

let config = VecturaConfig(
    name: "my-vector-db",
    directoryURL: nil,  // Optional custom storage location
    dimension: nil,     // Auto-detect dimension from embedder (recommended)
    searchOptions: VecturaConfig.SearchOptions(
        defaultNumResults: 10,
        minThreshold: 0.7,
        hybridWeight: 0.5,  // Balance between vector and text search
        k1: 1.2,           // BM25 parameters
        b: 0.75,
        bm25NormalizationFactor: 10.0
    )
)

// Create an embedder (SwiftEmbedder uses swift-embeddings library)
let embedder = SwiftEmbedder(modelSource: .default)
let vectorDB = try await VecturaKit(config: config, embedder: embedder)

For large-scale datasets (100K+ documents):

let config = VecturaConfig(
    name: "my-vector-db",
    memoryStrategy: .indexed(candidateMultiplier: 10)
)

let vectorDB = try await VecturaKit(config: config, embedder: embedder)
// Reduced memory footprint with on-demand document loading

💡 Tip: See the Indexed Storage Guide for detailed information on memory strategies and performance optimization for large-scale datasets.

📊 Performance: Check out the Performance Test Results for detailed benchmarking data and recommendations. For documentation index, see Docs/.

Add Documents

Single document:

let text = "Sample text to be embedded"
let documentId = try await vectorDB.addDocument(
    text: text,
    id: UUID()  // Optional, will be generated if not provided
)

Multiple documents in batch:

let texts = [
    "First document text",
    "Second document text",
    "Third document text"
]
let documentIds = try await vectorDB.addDocuments(
    texts: texts,
    ids: nil  // Optional array of UUIDs
)

Search Documents

Search by text (hybrid search):

let results = try await vectorDB.search(
    query: "search query",
    numResults: 5,  // Optional
    threshold: 0.8   // Optional
)

for result in results {
    print("Document ID: \(result.id)")
    print("Text: \(result.text)")
    print("Similarity Score: \(result.score)")
    print("Created At: \(result.createdAt)")
}

Search by vector embedding:

// Using array literal
let results = try await vectorDB.search(
    query: [0.1, 0.2, 0.3, ...],  // Array literal matching config.dimension
    numResults: 5,  // Optional
    threshold: 0.8  // Optional
)

// Or explicitly use SearchQuery enum
let embedding: [Float] = getEmbedding()
let results = try await vectorDB.search(
    query: .vector(embedding),
    numResults: 5,
    threshold: 0.8
)

Document Management

Update document:

try await vectorDB.updateDocument(
    id: documentId,
    newText: "Updated text"
)

Delete documents:

try await vectorDB.deleteDocuments(ids: [documentId1, documentId2])

Fetch a single document by ID:

let document = try await vectorDB.getDocument(id: documentId)
print(document?.text ?? "Document not found")

Check whether a document exists:

let exists = try await vectorDB.documentExists(id: documentId)
print("Exists: \(exists)")

Load all persisted documents:

let documents = try await vectorDB.getAllDocuments()
print("Loaded \(documents.count) documents")

Reset database:

try await vectorDB.reset()

Database Information

Get document count:

let count = await vectorDB.documentCount
print("Database contains \(count) documents")

Custom Storage Provider

VecturaKit allows you to implement your own storage backend by conforming to the VecturaStorage protocol. This is useful for integrating with different storage systems like SQLite, Core Data, or cloud storage.

Define a custom storage provider:

import Foundation
import VecturaKit

final class MyCustomStorageProvider: VecturaStorage {
    private var documents: [UUID: VecturaDocument] = [:]

    func createStorageDirectoryIfNeeded() async throws {
        // Initialize your storage system
    }

    func loadDocuments() async throws -> [VecturaDocument] {
        // Load documents from your storage
        return Array(documents.values)
    }

    func saveDocument(_ document: VecturaDocument) async throws {
        // Save document to your storage
        documents[document.id] = document
    }

    func deleteDocument(withID id: UUID) async throws {
        // Delete document from your storage
        documents.removeValue(forKey: id)
    }

    func updateDocument(_ document: VecturaDocument) async throws {
        // Update document in your storage
        documents[document.id] = document
    }

    func getTotalDocumentCount() async throws -> Int {
        // Return total count (optional - protocol provides default implementation)
        return documents.count
    }
}

Use the custom storage provider:

let config = VecturaConfig(name: "my-db")
let customStorage = MyCustomStorageProvider()
let vectorDB = try await VecturaKit(
    config: config,
    storageProvider: customStorage
)

// Use vectorDB normally - all storage operations will use your custom provider
let documentId = try await vectorDB.addDocument(text: "Sample text")

VecturaStorage also provides default getDocument(id:) and documentExists(id:) implementations. Custom providers can override them for more efficient single-document lookups when their backend supports it.

Custom Search Engine

VecturaKit supports custom search engine implementations by conforming to the VecturaSearchEngine protocol. This allows you to implement specialized search algorithms (pure vector, pure text, custom hybrid, or other ranking methods).

Define a custom search engine:

import Foundation
import VecturaKit

struct MyCustomSearchEngine: VecturaSearchEngine {

    func search(
        query: SearchQuery,
        storage: VecturaStorage,
        options: SearchOptions
    ) async throws -> [VecturaSearchResult] {
        // Load documents from storage
        let documents = try await storage.loadDocuments()

        // Implement your custom search logic
        // This example does a simple exact text match
        guard case .text(let queryText) = query else {
            return []
        }

        let results = documents.filter { doc in
            doc.text.lowercased().contains(queryText.lowercased())
        }.map { doc in
            VecturaSearchResult(
                id: doc.id,
                text: doc.text,
                score: 1.0,
                createdAt: doc.createdAt
            )
        }

        return Array(results.prefix(options.numResults))
    }

    func indexDocument(_ document: VecturaDocument) async throws {
        // Optional: Update your search engine's internal index
    }

    func removeDocument(id: UUID) async throws {
        // Optional: Remove from your search engine's internal index
    }
}

Use the custom search engine:

let config = VecturaConfig(name: "my-db")
let embedder = SwiftEmbedder(modelSource: .default)
let customEngine = MyCustomSearchEngine()

let vectorDB = try await VecturaKit(
    config: config,
    embedder: embedder,
    searchEngine: customEngine
)

// All searches will use your custom search engine
let results = try await vectorDB.search(query: "search query")

MLX Integration

For GPU-accelerated embeddings using Apple's MLX framework, see the separate VecturaMLXKit package. It provides MLXEmbedder, a drop-in VecturaEmbedder implementation, plus the vectura-mlx-cli command-line tool.

// Add both packages to your dependencies:
.package(url: "https://github.com/rryam/VecturaKit.git", from: "3.0.0"),
.package(url: "https://github.com/rryam/VecturaMLXKit.git", from: "1.0.0"),

OpenAI-Compatible Integration

VecturaKit supports OpenAI-compatible embedding APIs through OpenAICompatibleEmbedder. This is useful for local servers such as Ollama, LM Studio, llama.cpp-compatible servers, vLLM, and hosted providers that expose /v1/embeddings.

Import OpenAI-Compatible Support

import VecturaKit
import VecturaOAIKit

Initialize Database with OpenAI-Compatible Embeddings

let config = VecturaConfig(
  name: "my-oai-vector-db",
  dimension: nil
)

let embedder = OpenAICompatibleEmbedder(
  baseURL: "http://localhost:1234/v1",
  model: "text-embedding-model",
  apiKey: nil,
  timeoutInterval: 120,
  retryAttempts: 2,
  retryBaseDelaySeconds: 1
)

let vectorDB = try await VecturaKit(config: config, embedder: embedder)

The embedder:

  • Sends batched requests to POST <baseURL>/embeddings
  • Adds Authorization: Bearer ... when an API key is configured
  • Retries HTTP 429 responses and honors Retry-After when present
  • Detects embedding dimension automatically on first use

NaturalLanguage Integration

VecturaKit supports Apple's NaturalLanguage framework through the NLContextualEmbedder for contextual embeddings with zero external dependencies.

Import NaturalLanguage Support

import VecturaKit
import VecturaNLKit

Initialize Database with NLContextualEmbedding

let config = VecturaConfig(
  name: "my-nl-vector-db",
  dimension: nil  // Auto-detect dimension from NL embedder
)

// Create NLContextualEmbedder
let embedder = try await NLContextualEmbedder(
  language: .english
)
let vectorDB = try await VecturaKit(config: config, embedder: embedder)

Available Options:

// Initialize with specific language
let embedder = try await NLContextualEmbedder(
  language: .spanish
)

// Get model information
let modelInfo = await embedder.modelInfo
print("Language: \(modelInfo.language)")
if let dimension = modelInfo.dimension {
  print("Dimension: \(dimension)")
} else {
  print("Dimension: Not yet determined")
}

Add Documents

let texts = [
  "Natural language understanding is fascinating",
  "Swift makes iOS development enjoyable",
  "Machine learning on device preserves privacy"
]
let documentIds = try await vectorDB.addDocuments(texts: texts)

Search Documents

let results = try await vectorDB.search(
    query: "iOS programming",
    numResults: 5,      // Optional
    threshold: 0.7     // Optional
)

for result in results {
    print("Document ID: \(result.id)")
    print("Text: \(result.text)")
    print("Similarity Score: \(result.score)")
    print("Created At: \(result.createdAt)")
}

Document Management

Update document:

try await vectorDB.updateDocument(
     id: documentId,
     newText: "Updated text"
 )

Delete documents:

try await vectorDB.deleteDocuments(ids: [documentId1, documentId2])

Reset database:

try await vectorDB.reset()

Key Features:

  • Zero External Dependencies: Uses only Apple's native NaturalLanguage framework
  • Contextual Embeddings: Considers surrounding context for more accurate semantic understanding
  • Privacy-First: All processing happens on-device
  • Language Support: Supports multiple languages (English, Spanish, French, German, Italian, Portuguese, and more)
  • Auto-Detection: Automatically detects embedding dimensions

Performance Characteristics:

  • Speed: Moderate (slower than Model2Vec, comparable to MLX)
  • Accuracy: High contextual understanding for supported languages
  • Memory: Efficient on-device processing
  • Use Cases: Ideal for apps requiring semantic search without external dependencies

Platform Requirements:

  • iOS 17.0+ / macOS 14.0+ / tvOS 17.0+ / visionOS 1.0+ / watchOS 10.0+
  • NaturalLanguage framework (included with OS)

Command Line Interface

VecturaKit includes command-line tools for database management with different embedding backends.

Swift CLI Tool (vectura-cli)

# Add documents (dimension auto-detected from model)
vectura add "First document" "Second document" "Third document" \
  --db-name "my-vector-db"

# Search documents
vectura search "search query" \
  --db-name "my-vector-db" \
  --threshold 0.7 \
  --num-results 5

# Update document
vectura update <document-uuid> "Updated text content" \
  --db-name "my-vector-db"

# Delete documents
vectura delete <document-uuid-1> <document-uuid-2> \
  --db-name "my-vector-db"

# Reset database
vectura reset \
  --db-name "my-vector-db"

# Run demo with sample data
vectura mock \
  --db-name "my-vector-db" \
  --threshold 0.7 \
  --num-results 10

Common options for vectura-cli:

  • --db-name, -d: Database name (default: "vectura-cli-db")
  • --dimension, -v: Vector dimension (auto-detected by default)
  • --threshold, -t: Minimum similarity threshold (default: 0.7)
  • --num-results, -n: Number of results to return (default: 10)
  • --model-id, -m: Model ID for embeddings (default: "minishlab/potion-base-4M")

OpenAI-Compatible CLI Tool (vectura-oai-cli)

Set VECTURA_OAI_BASE_URL and VECTURA_OAI_MODEL, or pass --base-url and --model directly.

vectura-oai add "First document" "Second document" --model text-embedding-model
vectura-oai search "search query" --model text-embedding-model --threshold 0.7 --num-results 5
vectura-oai update <document-uuid> "Updated text" --model text-embedding-model
vectura-oai delete <document-uuid-1> <document-uuid-2> --model text-embedding-model
vectura-oai reset --model text-embedding-model
vectura-oai mock --model text-embedding-model

Common options for vectura-oai-cli:

  • --db-name, -d: Database name (default: "vectura-oai-cli-db")
  • --directory: Database directory (optional)
  • --base-url: OpenAI-compatible base URL
  • --model: Embedding model identifier
  • --api-key: Optional API key
  • --timeout: Request timeout in seconds
  • --retry-attempts: HTTP 429 retry attempts
  • --retry-base-delay: Base retry delay in seconds
  • --threshold, -t: Minimum similarity threshold (default: 0.7)
  • --num-results, -n: Number of results to return (default: 10)

License

VecturaKit is released under the MIT License. See the LICENSE file for more information. Copyright (c) 2025 Rudrank Riyam.

Contributing

Contributions are welcome! Please fork the repository and submit a pull request with your improvements.

Development Setup

  1. Clone the repository
  2. Open Package.swift in Xcode or VS Code
  3. Run tests to ensure everything works: swift test
  4. Run performance benchmarks (optional): swift test --filter BenchmarkSuite — see Performance Tests
  5. Make your changes and test them

Code Style

  • Follow SwiftLint rules (run swiftlint lint)
  • Use Swift 6.0+ features where appropriate
  • Maintain backward compatibility when possible
  • Document public APIs with DocC comments

Support

Star History Chart

Release History

VersionChangesUrgencyDate
6.1.0## What's Changed * Restore the NaturalLanguage-backed vectura-cli and TestExamples executable. * Add CLI README coverage and Codemagic smoke validation. * Add NLContextualEmbedder adapter coverage for vector queries. * Count file-backed documents from disk so partially loaded caches do not report stale totals. **Full Changelog**: https://github.com/rryam/VecturaKit/compare/6.0.0...6.1.0High4/30/2026
6.0.0## What's Changed * [codex] Remove swift-embeddings backend from core by @rudrankriyam in https://github.com/rryam/VecturaKit/pull/83 **Full Changelog**: https://github.com/rryam/VecturaKit/compare/5.3.0...6.0.0High4/29/2026
5.3.0## What's Changed * Add VecturaOAIKit as a package target by @subsriram in https://github.com/rryam/VecturaKit/pull/81 **Full Changelog**: https://github.com/rryam/VecturaKit/compare/5.2.1...5.3.0High4/4/2026
5.2.1## What's Changed * [codex] Pin swift-embeddings to stable 0.0.26 by @rudrankriyam in https://github.com/rryam/VecturaKit/pull/80 **Full Changelog**: https://github.com/rryam/VecturaKit/compare/5.2.0...5.2.1Medium4/2/2026
5.2.0## What's Changed * Add getDocument, documentExists API and fix delete no-op bug by @thatswiftguy in https://github.com/rryam/VecturaKit/pull/77 ## New Contributors * @thatswiftguy made their first contribution in https://github.com/rryam/VecturaKit/pull/77 **Full Changelog**: https://github.com/rryam/VecturaKit/compare/5.1.0...5.2.0Low3/15/2026
5.1.0## What's Changed * Improve storage and BM25 search performance by @rudrankriyam in https://github.com/rryam/VecturaKit/pull/74 * Use bounded top-K selection to avoid full result sorting by @rudrankriyam in https://github.com/rryam/VecturaKit/pull/75 * Add realistic workload benchmark profile and optional CI stage by @rudrankriyam in https://github.com/rryam/VecturaKit/pull/76 **Full Changelog**: https://github.com/rryam/VecturaKit/compare/5.0.0...5.1.0Low3/5/2026
5.0.0## Highlights - Add core SwiftEmbedder model-family resolution refactor and static embedding dimension handling improvements. - Add ModernBERT support in SwiftEmbedder. - Add RoBERTa and XLM-RoBERTa support in SwiftEmbedder. - Add embedder validation and BERT fallback robustness fixes. - Align package platform minimums with runtime requirements and clean up redundant availability guardrails. ## Included pull requests - #69 Refactor SwiftEmbedder core model resolution - #70 Add ModernBELow2/12/2026
4.0.0## Breaking Changes - **VecturaMLXKit extracted to separate repository:** `VecturaMLXKit`, `VecturaMLXCLI`, and MLX-related tests have been moved to [rryam/VecturaMLXKit](https://github.com/rryam/VecturaMLXKit). This removes the need for Package Traits (SE-0450). - **Package Traits removed:** The `MLX` trait no longer exists. MLX users should add `VecturaMLXKit` as a separate dependency. - **swift-tools-version reverted to 6.0:** Swift 6.1 is no longer required for this package. - **mlx-swift-lLow2/5/2026
3.0.0## Highlights - **Package Traits (SE-0450)**: MLX dependencies are now optional. Consumers using only `VecturaKit` or `VecturaNLKit` no longer download the heavy `mlx-swift-lm` package, significantly improving build times. - **Swift 6.1+ Required**: Bumped `swift-tools-version` to 6.1 for Package Traits support. - **Smaller Default Model**: Switched from `potion-retrieval-32M` to `potion-base-4M` for faster downloads and CI. ## Breaking Changes - **Swift 6.1+ / Xcode 16.3+ required** - **MLX Low1/29/2026
2.5.3## Highlights - Hardened add/index rollback to restore overwritten documents and keep storage/search consistent. - Stricter config/input validation (DB name, search options, embedder inputs); BM25 handles empty queries safely. - Performance suites now default to a deterministic embedder for faster runs (opt-in real embeddings via `VECTURA_PERF_USE_SWIFT_EMBEDDER=1`). - Updated MLX dependencies to latest mlx-swift-lm (2.30.3 / mlx-swift 0.30.3). - CLI vector dimension is auto-detected by default;Low1/26/2026
v2.5.2- Fix SwiftLint trailing whitespace failures in MLXEmbedder.\n- Update the README installation snippet to 2.5.2.Low1/16/2026
v2.5.1Release 2.5.1: Throttled concurrency for file operations Fixes potential file descriptor exhaustion and memory pressure when working with large document collections. Changes: - Add ConcurrencyExtensions.swift with concurrentMap, concurrentForEach, orderedConcurrentMap, and chunked utilities - Replace unbounded parallel file loading in FileStorageProvider with throttled concurrentMap (max 50 concurrent operations) - Add saveDocuments batch method to VecturaStorage protocol - Implement saveDocumLow12/8/2025
v2.5.0Release 2.5.0: NaturalLanguage framework support via VecturaNLKit Adds support for Apple's NaturalLanguage framework through a new VecturaNLKit module, providing contextual sentence embeddings with zero external dependencies.Low11/11/2025
v2.4.0Release 2.4.0: Package dependency updates and StaticEmbeddings model supportLow11/11/2025
2.3.1Release 2.3.1: Input validation, error handling improvements, and code quality fixesLow11/6/2025
2.3.0## Overview This release introduces a major architectural refactoring with pluggable search engines, memory management strategies for large datasets, and significant performance optimizations. VecturaKit now supports three distinct search engines (vector, BM25, hybrid) with intelligent memory strategies that can handle datasets from small to very large scale. ## New Features ### Pluggable Search Engine Architecture - Introduced `VecturaSearchEngine` protocol as a unified interface for search Low11/4/2025
2.2.0## Overview This release introduces a complete architectural overhaul with protocol-based embedding providers, Swift 6 actor concurrency model, and improved performance. This is a major version release with breaking changes that require code migration. ## New Features ### Protocol-Based Embedding Architecture - Introduced `VecturaEmbedder` protocol as a unified interface for embedding providers - Enables dependency injection and custom embedder implementations - Eliminates code duplication beLow10/29/2025
1.1.0Release 1.1.0 ## Changes - Optimized FileStorageProvider JSONDecoder usage - Fixed Swift 6 concurrency issues - Improved performance with sequential document saving - Enhanced custom storage provider support ## Pull Requests - #39: Add Custom Storage Provider Support (@rakuyoMo) ## Contributors - @rakuyoMo (Rakuyo) - @rudrankriyam (Rudrank Riyam)Low10/29/2025
v1.0.2## Highlights - migrate VecturaKit and VecturaMLXKit test suites to the Swift Testing framework for better isolation - add SwiftLint configuration and enforce linting via repository guidelines - refresh contribution guidance in AGENTS.md to reflect the new testing workflow ## Verification - swift test - swiftlintLow10/11/2025
v1.0.1# New in this release - Fix SwiftPM dependency conflicts by updating swift-embeddings to 0.0.21 (swift-transformers 1.0.0) - Refresh Package.resolved pins, including swift-jinja and latest mlx-swift-examples mainLow10/10/2025
v1.0.0First stable release with Model2Vec support using 32M parameter model and automatic dimension detectionLow9/23/2025
v0.4.1# New in this release Update version of Swift Argument ParserLow4/5/2025
v0.4.0## What's Changed * Better performance using Accelerate by @rudrankriyam in https://github.com/rryam/VecturaKit/pull/9 **Full Changelog**: https://github.com/rryam/VecturaKit/compare/v0.3.1...v0.4.0Low2/1/2025
v0.3.1# Version 0.3.1 ## What's Changed - Add vectura-mlx-cli target to play around in XcodeLow1/29/2025
v0.3.0Version 0.3.0 ## What's Changed - Add VecturaMLXKit with MLXEmbeddersLow1/29/2025
v0.2.1# Version 0.2.1 Some more improvements that I forgot to merge, thanks to @insidegui!Low1/28/2025
v0.2.0# Version 0.2.0 Some more changes + improvements from @insidegui. 🎉Low1/28/2025
v0.1.0# Version 0.1.0 Initial release. Enjoy!Low1/18/2025

Dependencies & License Audit

Loading dependencies...

Similar Packages

mem9Enable AI agents to retain memory across sessions using persistent storage designed for continuous context retention.main@2026-06-05
rag-chatbotRAG (Retrieval-augmented generation) ChatBot that provides answers based on contextual information extracted from a collection of Markdown files.main@2026-06-04
HelixTransform Claude into a local AI assistant for Mac that controls apps, manages tasks, and remembers context across sessions.main@2026-06-04
bigragSelf-hostable RAG platform - document ingestion, embedding, and vector search behind a simple REST APImain@2026-06-03
consolidation-memoryStore, consolidate, and recall coding agent memories with provenance tracking using SQLite and FAISS for fast, structured knowledge access.main@2026-06-03

More in Databases

milvusMilvus is a high-performance, cloud-native vector database built for scalable vector ANN search
WeKnoraLLM-powered framework for deep document understanding, semantic retrieval, and context-aware answers using RAG paradigm.
ai-real-estate-assistantAdvanced AI Real Estate Assistant using RAG, LLMs, and Python. Features market analysis, property valuation, and intelligent search.
alibabacloud-adb20211201Alibaba Cloud adb (20211201) SDK Library for Python