Nomad changes

docs/snippets/swift/utils/chunking.md

@@ -0,0 +1,25 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+let configJson = """
+{
+    "chunking": {
+        "max_characters": 1000,
+        "overlap": 200
+    }
+}
+"""
+
+let config = try extractionConfigFromJson(configJson)
+let result = try extractFileSync("document.pdf", nil, config)
+
+if let chunks = result.chunks() {
+    print("Chunks: \(chunks.count)")
+    for chunk in chunks {
+        let metadata = chunk.metadata()
+        print("Chunk \(metadata.chunk_index() + 1)/\(metadata.total_chunks())")
+    }
+}
+```

docs/snippets/swift/utils/chunking_rag.md

@@ -0,0 +1,35 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+let configJson = """
+{
+    "chunking": {
+        "max_characters": 500,
+        "overlap": 50,
+        "embedding": {
+            "model": {"preset": {"name": "balanced"}},
+            "normalize": true
+        }
+    }
+}
+"""
+
+let config = try extractionConfigFromJson(configJson)
+let result = try extractFileSync("research_paper.pdf", nil, config)
+
+if let chunks = result.chunks() {
+    for chunk in chunks {
+        let metadata = chunk.metadata()
+        let content = chunk.content().toString()
+        let preview = String(content.prefix(100))
+        print("Chunk \(metadata.chunk_index() + 1)/\(metadata.total_chunks())")
+        print("Position: \(metadata.byte_start())-\(metadata.byte_end())")
+        print("Content: \(preview)...")
+        if let embedding = chunk.embedding() {
+            print("Embedding: \(embedding.count) dimensions")
+        }
+    }
+}
+```

docs/snippets/swift/utils/embedding_with_chunking.md

@@ -0,0 +1,32 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+let configJson = """
+{
+    "chunking": {
+        "max_characters": 1024,
+        "overlap": 100,
+        "embedding": {
+            "model": {"preset": {"name": "balanced"}},
+            "normalize": true,
+            "batch_size": 32,
+            "show_download_progress": false
+        }
+    }
+}
+"""
+
+let config = try extractionConfigFromJson(configJson)
+let result = try extractFileSync("document.pdf", nil, config)
+
+if let chunks = result.chunks() {
+    print("Generated \(chunks.count) chunks")
+    for chunk in chunks {
+        if let embedding = chunk.embedding() {
+            print("Chunk \(chunk.metadata().chunk_index()) -> \(embedding.count)-dim embedding")
+        }
+    }
+}
+```

docs/snippets/swift/utils/keyword_extraction_example.md

@@ -0,0 +1,26 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+let configJson = """
+{
+    "keywords": {
+        "algorithm": "yake",
+        "max_keywords": 10,
+        "min_score": 0.3
+    }
+}
+"""
+
+let config = try extractionConfigFromJson(configJson)
+let result = try extractFileSync("research_paper.pdf", nil, config)
+
+if let keywords = result.extracted_keywords() {
+    for keyword in keywords {
+        let text = keyword.text().toString()
+        let score = keyword.score()
+        print("\(text) (score: \(score))")
+    }
+}
+```

docs/snippets/swift/utils/quality_processing_example.md

@@ -0,0 +1,22 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+let configJson = """
+{
+    "enable_quality_processing": true
+}
+"""
+
+let config = try extractionConfigFromJson(configJson)
+let result = try extractFileSync("scanned_document.pdf", nil, config)
+
+if let score = result.quality_score() {
+    if score < 0.5 {
+        print(String(format: "Warning: Low quality extraction (%.2f)", score))
+    } else {
+        print(String(format: "Quality score: %.2f", score))
+    }
+}
+```

docs/snippets/swift/utils/standalone_embed.md

@@ -0,0 +1,21 @@
+<!-- snippet:syntax-only -->
+
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+// Standalone embedding requires constructing an EmbeddingConfig directly.
+// The Swift bindings expose `embedTexts` / `embedTextsAsync`, but
+// EmbeddingConfig is an opaque proxy class — no JSON-config decoding is
+// available. Build it via the generated initializer or use chunking-time
+// embedding via `extractionConfigFromJson` (see embedding_with_chunking).
+let texts = RustVec<RustString>()
+texts.push(value: "Hello, world!".intoRustString())
+texts.push(value: "Kreuzberg is fast".intoRustString())
+
+// `config` here is a fully-constructed EmbeddingConfig built via the
+// generated initializer in RustBridge.
+let embeddings = try embedTexts(texts, config)
+print(embeddings.toString())
+```

docs/snippets/swift/utils/token_reduction.md

@@ -0,0 +1,21 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+let configJson = """
+{
+    "token_reduction": {
+        "mode": "moderate",
+        "preserve_markdown": true,
+        "preserve_code": true,
+        "language_hint": "eng"
+    }
+}
+"""
+
+let config = try extractionConfigFromJson(configJson)
+let result = try extractFileSync("document.pdf", nil, config)
+
+print("Reduced content length: \(result.content().toString().count)")
+```

docs/snippets/swift/utils/token_reduction_example.md

@@ -0,0 +1,23 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+let configJson = """
+{
+    "token_reduction": {
+        "mode": "moderate",
+        "preserve_markdown": true
+    }
+}
+"""
+
+let config = try extractionConfigFromJson(configJson)
+let result = try extractFileSync("verbose_document.pdf", nil, config)
+
+let content = result.content().toString()
+print("Reduced content length: \(content.count)")
+for warning in result.processing_warnings() {
+    print("Warning [\(warning.source().toString())]: \(warning.message().toString())")
+}
+```

docs/snippets/swift/utils/vector_database_integration.md

@@ -0,0 +1,51 @@
+```swift title="Swift"
+import Foundation
+import Kreuzberg
+import RustBridge
+
+struct VectorRecord {
+    let id: String
+    let content: String
+    let embedding: [Float]
+    let metadata: [String: String]
+}
+
+func extractAndVectorize(documentPath: String, documentId: String) throws -> [VectorRecord] {
+    let configJson = """
+    {
+        "chunking": {
+            "max_characters": 512,
+            "overlap": 50,
+            "embedding": {
+                "model": {"preset": {"name": "balanced"}},
+                "normalize": true,
+                "batch_size": 32
+            }
+        }
+    }
+    """
+
+    let config = try extractionConfigFromJson(configJson)
+    let result = try extractFileSync(documentPath, nil, config)
+
+    var records: [VectorRecord] = []
+    if let chunks = result.chunks() {
+        for (index, chunk) in chunks.enumerated() {
+            guard let embedding = chunk.embedding() else { continue }
+            let content = chunk.content().toString()
+            let metadata: [String: String] = [
+                "document_id": documentId,
+                "chunk_index": String(index),
+                "content_length": String(content.count),
+            ]
+            records.append(VectorRecord(
+                id: "\(documentId)_chunk_\(index)",
+                content: content,
+                embedding: embedding.map { $0 },
+                metadata: metadata
+            ))
+        }
+    }
+    return records
+}
+```