dependencies: [
    .package(url: "https://github.com/YourUsername/VectorDataStore.git", from: "1.0.0")
]

targets: [
    .target(
        name: "YourApp",
        dependencies: ["VectorDataStore"]
    )
]

import VectorDataStore

struct ResearchPaper: VectorModel, Codable, Equatable {
    let id: String
    let title: String
    let abstract: String
    
    var embeddingText: String {
        "\(title). \(abstract)"
    }
    
    init?(metadata: [String: String]) {
        guard let data = try? JSONSerialization.data(withJSONObject: metadata),
              let decoded = try? JSONDecoder().decode(Self.self, from: data) else {
            return nil
        }
        self = decoded
    }
}

// Configure the store
let config = DataStoreConfiguration<[Float]>(
    storeName: "research",
    schema: .init(vectorDimensions: 1536),
    endpoint: URL(string: "http://localhost:6333"),
    apiKey: nil
)

// Setup embedding provider
let embedder = OpenAIEmbedder(apiKey: "your-openai-api-key")

// Choose your backend
let backend = QdrantBackend<[Float]>(
    endpoint: config.endpoint!,
    collectionName: config.storeName,
    vectorDimensions: config.schema.vectorDimensions
)

// Create collection if needed
try await backend.createCollectionIfNeeded()

// Initialize the store
let store = VectorDataStore(
    configuration: config,
    embedder: embedder,
    backend: backend
)

// Insert documents
let papers = [
    ResearchPaper(id: "1", title: "Attention Is All You Need", 
                 abstract: "We propose a new architecture..."),
    ResearchPaper(id: "2", title: "BERT", 
                 abstract: "Bidirectional transformers...")
]

try await store.execute(DataStoreSaveChangesRequest(papers))

// Semantic search
let results = try await store.execute(
    DataStoreFetchRequest(queryText: "transformer architecture", topK: 5)
)

for paper in results {
    print(paper.title)
}

// For SwiftData-style transactions with PersistentModel
final class Note: PersistentModel, Codable {
    static var schemaVersion: Int { 1 }
    
    var id: String
    var title: String
    var content: String
    
    var embeddingText: String { "\(title). \(content)" }
    
    // ... init methods
}

let swiftDataStore = SwiftDataStyleStore<[Float], Note>(
    configuration: config,
    embedder: embedder,
    backend: backend
)

// Insert via transaction
try await swiftDataStore.transaction { tx in
    let note = Note(id: UUID().uuidString, title: "Swift 6", content: "Concurrency")
    tx.insert(DefaultSnapshot(of: note))
}

// Semantic fetch
let notes = try await swiftDataStore.execute(
    DataStoreFetchRequest(semanticQuery: "concurrency", fetchLimit: 5)
)

let backend = MemoryBackend<[Float]>()

// Local Qdrant instance
let backend = QdrantBackend<[Float]>(
    endpoint: URL(string: "http://localhost:6333")!,
    collectionName: "my_collection",
    vectorDimensions: 1536
)

// Qdrant Cloud
let backend = QdrantBackend<[Float]>(
    endpoint: URL(string: "https://xyz.cloud.qdrant.io:6333")!,
    apiKey: "your-qdrant-api-key",
    collectionName: "my_collection",
    vectorDimensions: 1536
)

public final class MyCustomBackend<Vector: VectorProtocol>: VectorDBBackend {
    public func upsert(_ payloads: [VectorPayload<Vector>]) async throws {
        // Your implementation
    }
    
    public func search(vector: Vector, topK: Int, threshold: Float?) async throws -> [[String: String]] {
        // Your implementation
    }
}

let embedder = OpenAIEmbedder(
    apiKey: "your-api-key",
    model: "text-embedding-3-small" // or "text-embedding-3-large"
)

actor MyEmbedder: EmbeddingModel {
    typealias Vector = [Float]
    
    func embed(texts: [String]) async throws -> [[Float]] {
        // Your embedding logic
    }
}