kreuzberg 4.2.1 → 4.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '010412940492f83bc170a4a4efc644ac7e3818502734035523796287837a3893'
-  data.tar.gz: af24cba007cc58283d678d4b15251ebae3a5740f60ade9a54cc19973a2022a82
+  metadata.gz: 1765714785cbe89567dcb13ed0c1e1b79c2da7a2143a0d0b4653c5578a3ada84
+  data.tar.gz: 64d6db5e4d88992920f37fe9a3e28ab08b5bdd0b28385da570e8207e67d90f34
 SHA512:
-  metadata.gz: ad67348bec54a01ca3592ed72e9b2b8bc9e711a37e11b40ada31466c67f834132fc0de278c53a1c014fa6751da7abebae934cff2a9cc1835f7e056c895a273cb
-  data.tar.gz: ca2cdb076a5d1af67f0e807978a966d1a391cc286bcdf5499544e3403196140918a54674beab77ea09fc0e8bc7ab66f357da5d984326a511b1d21643a3d6cf41
+  metadata.gz: cbb71395a285ddb1a74101fc935ebb8266b81c6172043a128721ab37fad583c7202e559f9e8cb2534bf110721bf20e2d0cbe6838554c772831c56bc09583bf75
+  data.tar.gz: b752cf56da8810211e5efd5e5d69f136eb7d0a3d5e27e985b81dff18bde442f0033b15962823ad7e3c5a27e080d02b6a6df1726bffe4aa21eaf89f56a5c6b56f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kreuzberg (4.2.1)
+    kreuzberg (4.2.2)
 
 GEM
   remote: https://rubygems.org/
@@ -207,7 +207,7 @@ CHECKSUMS
   i18n (1.14.8) sha256=285778639134865c5e0f6269e0b818256017e8cde89993fdfcbfb64d088824a5
   io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
   json (2.18.0) sha256=b10506aee4183f5cf49e0efc48073d7b75843ce3782c68dbeb763351c08fd505
-  kreuzberg (4.2.1)
+  kreuzberg (4.2.2)
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
   listen (3.10.0) sha256=c6e182db62143aeccc2e1960033bebe7445309c7272061979bb098d03760c9d2

data/README.md

@@ -22,7 +22,7 @@
     <img src="https://img.shields.io/maven-central/v/dev.kreuzberg/kreuzberg?label=Java&color=007ec6" alt="Java">
   </a>
   <a href="https://github.com/kreuzberg-dev/kreuzberg/releases">
-    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.2.1" alt="Go">
+    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.2.2" alt="Go">
   </a>
   <a href="https://www.nuget.org/packages/Kreuzberg/">
     <img src="https://img.shields.io/nuget/v/Kreuzberg?label=C%23&color=007ec6" alt="C#">

data/lib/kreuzberg/config.rb

@@ -684,13 +684,6 @@ module Kreuzberg
     #   image = Config::ImageExtraction.new(extract_images: true, target_dpi: 600)
     #   config = Extraction.new(image_extraction: image)
     #
-    # @example With preprocessing
-    #   preprocessing = Config::ImagePreprocessing.new(
-    #     binarization_method: "sauvola",
-    #     denoise: true
-    #   )
-    #   config = Extraction.new(image_preprocessing: preprocessing)
-    #
     # @example With post-processing
     #   postprocessor = Config::PostProcessor.new(
     #     enabled: true,
@@ -708,14 +701,13 @@ module Kreuzberg
     #     language_detection: Config::LanguageDetection.new(enabled: true),
     #     pdf_options: Config::PDF.new(extract_images: true, passwords: ["secret"]),
     #     image_extraction: Config::ImageExtraction.new(target_dpi: 600),
-    #     image_preprocessing: Config::ImagePreprocessing.new(denoise: true),
     #     postprocessor: Config::PostProcessor.new(enabled: true)
     #   )
     #
     class Extraction
       attr_reader :use_cache, :enable_quality_processing, :force_ocr,
                   :ocr, :chunking, :language_detection, :pdf_options,
-                  :images, :image_preprocessing, :postprocessor,
+                  :images, :postprocessor,
                   :token_reduction, :keywords, :html_options, :pages,
                   :max_concurrent_extractions, :output_format, :result_format
 
@@ -739,7 +731,7 @@ module Kreuzberg
       # Keys that are allowed in the Extraction config
       ALLOWED_KEYS = %i[
         use_cache enable_quality_processing force_ocr ocr chunking
-        language_detection pdf_options image_extraction image_preprocessing
+        language_detection pdf_options image_extraction
         postprocessor token_reduction keywords html_options pages
         max_concurrent_extractions output_format result_format
       ].freeze
@@ -800,14 +792,13 @@ module Kreuzberg
 
       def initialize(hash = nil,
                      use_cache: true,
-                     enable_quality_processing: false,
+                     enable_quality_processing: true,
                      force_ocr: false,
                      ocr: nil,
                      chunking: nil,
                      language_detection: nil,
                      pdf_options: nil,
                      image_extraction: nil,
-                     image_preprocessing: nil,
                      postprocessor: nil,
                      token_reduction: nil,
                      keywords: nil,
@@ -820,7 +811,7 @@ module Kreuzberg
           use_cache: use_cache, enable_quality_processing: enable_quality_processing,
           force_ocr: force_ocr, ocr: ocr, chunking: chunking, language_detection: language_detection,
           pdf_options: pdf_options, image_extraction: image_extraction,
-          image_preprocessing: image_preprocessing, postprocessor: postprocessor,
+          postprocessor: postprocessor,
           token_reduction: token_reduction, keywords: keywords, html_options: html_options,
           pages: pages, max_concurrent_extractions: max_concurrent_extractions,
           output_format: output_format, result_format: result_format
@@ -846,7 +837,6 @@ module Kreuzberg
         @language_detection = normalize_config(params[:language_detection], LanguageDetection)
         @pdf_options = normalize_config(params[:pdf_options], PDF)
         @images = normalize_config(params[:image_extraction], ImageExtraction)
-        @image_preprocessing = normalize_config(params[:image_preprocessing], ImagePreprocessing)
         @postprocessor = normalize_config(params[:postprocessor], PostProcessor)
         @token_reduction = normalize_config(params[:token_reduction], TokenReduction)
         @keywords = normalize_config(params[:keywords], Keywords)
@@ -878,7 +868,6 @@ module Kreuzberg
       end
 
       # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/MethodLength
       def to_h
         {
           use_cache: @use_cache,
@@ -889,7 +878,6 @@ module Kreuzberg
           language_detection: @language_detection&.to_h,
           pdf_options: @pdf_options&.to_h,
           images: @images&.to_h,
-          image_preprocessing: @image_preprocessing&.to_h,
           postprocessor: @postprocessor&.to_h,
           token_reduction: @token_reduction&.to_h,
           keywords: @keywords&.to_h,
@@ -900,7 +888,6 @@ module Kreuzberg
           result_format: @result_format
         }.compact
       end
-      # rubocop:enable Metrics/MethodLength
       # rubocop:enable Metrics/CyclomaticComplexity
 
       # Serialize configuration to JSON string
@@ -1025,8 +1012,6 @@ module Kreuzberg
           @pdf_options = normalize_config(value, PDF)
         when :image_extraction
           @images = normalize_config(value, ImageExtraction)
-        when :image_preprocessing
-          @image_preprocessing = normalize_config(value, ImagePreprocessing)
         when :postprocessor
           @postprocessor = normalize_config(value, PostProcessor)
         when :token_reduction
@@ -1101,7 +1086,6 @@ module Kreuzberg
         @language_detection = merged.language_detection
         @pdf_options = merged.pdf_options
         @images = merged.image_extraction
-        @image_preprocessing = merged.image_preprocessing
         @postprocessor = merged.postprocessor
         @token_reduction = merged.token_reduction
         @keywords = merged.keywords

data/lib/kreuzberg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kreuzberg
-  VERSION = '4.2.1'
+  VERSION = '4.2.2'
 end

data/spec/binding/config_spec.rb

@@ -309,7 +309,7 @@ RSpec.describe Kreuzberg::Config do
       config = described_class.new
 
       expect(config.use_cache).to be true
-      expect(config.enable_quality_processing).to be false
+      expect(config.enable_quality_processing).to be true
       expect(config.force_ocr).to be false
       expect(config.ocr).to be_nil
       expect(config.chunking).to be_nil

data/spec/unit/config/extraction_config_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Kreuzberg::Config::Extraction do
       config = described_class.new
 
       expect(config.use_cache).to be true
-      expect(config.enable_quality_processing).to be false
+      expect(config.enable_quality_processing).to be true
       expect(config.force_ocr).to be false
       expect(config.ocr).to be_nil
       expect(config.chunking).to be_nil
@@ -103,7 +103,7 @@ RSpec.describe Kreuzberg::Config::Extraction do
       hash = config.to_h
 
       expect(hash[:use_cache]).to be true
-      expect(hash[:enable_quality_processing]).to be false
+      expect(hash[:enable_quality_processing]).to be true
       expect(hash[:force_ocr]).to be false
     end
   end

data/vendor/Cargo.toml

@@ -3,7 +3,7 @@ members = ["kreuzberg", "kreuzberg-tesseract", "kreuzberg-ffi"]
 resolver = "2"
 
 [workspace.package]
-version = "4.2.1"
+version = "4.2.2"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/vendor/kreuzberg/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kreuzberg"
-version = "4.2.1"
+version = "4.2.2"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
@@ -71,7 +71,7 @@ keywords-yake = ["dep:yake-rust", "stopwords"]
 keywords-rake = ["dep:rake", "stopwords"]
 keywords = ["keywords-yake", "keywords-rake"]
 
-api = ["dep:axum", "dep:tower", "dep:tower-http", "tokio-runtime"]
+api = ["dep:axum", "dep:tower", "dep:tower-http", "dep:utoipa", "tokio-runtime"]
 mcp = ["dep:rmcp", "tokio-runtime"]
 mcp-http = ["mcp", "api"]
 
@@ -198,6 +198,7 @@ rake = { version = "0.3.6", optional = true }
 axum = { version = "0.8", features = ["macros", "json", "multipart"], optional = true }
 tower = { version = "0.5", optional = true }
 tower-http = { version = "0.6", features = ["cors", "trace", "limit"], optional = true }
+utoipa = { version = "5.3", features = ["axum_extras"], optional = true }
 rmcp = { version = "0.14.0", features = [
     "server",
     "macros",

data/vendor/kreuzberg/README.md

@@ -17,7 +17,7 @@ High-performance document intelligence library for Rust. Extract text, metadata,
 
 This is the core Rust library that powers the Python, TypeScript, and Ruby bindings.
 
-> **🚀 Version 4.2.1 Release**
+> **🚀 Version 4.2.2 Release**
 > This is a pre-release version. We invite you to test the library and [report any issues](https://github.com/kreuzberg-dev/kreuzberg/issues) you encounter.
 >
 > **Note**: The Rust crate is not currently published to crates.io for this RC. Use git dependencies or language bindings (Python, TypeScript, Ruby) instead.

data/vendor/kreuzberg/src/api/error.rs

@@ -2,14 +2,38 @@
 
 use axum::{
     Json,
+    extract::{FromRequest, Request, rejection::JsonRejection},
     http::StatusCode,
     response::{IntoResponse, Response},
 };
+use serde::de::DeserializeOwned;
 
 use crate::error::KreuzbergError;
 
 use super::types::ErrorResponse;
 
+/// Custom JSON extractor that returns JSON error responses instead of plain text.
+///
+/// This wraps axum's `Json` extractor but uses `ApiError` as the rejection type,
+/// ensuring that all JSON parsing errors are returned as JSON with proper content type.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct JsonApi<T>(pub T);
+
+impl<T, S> FromRequest<S> for JsonApi<T>
+where
+    T: DeserializeOwned,
+    S: Send + Sync,
+{
+    type Rejection = ApiError;
+
+    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
+        match Json::<T>::from_request(req, state).await {
+            Ok(Json(value)) => Ok(JsonApi(value)),
+            Err(rejection) => Err(ApiError::from(rejection)),
+        }
+    }
+}
+
 /// API-specific error wrapper.
 #[derive(Debug)]
 pub struct ApiError {
@@ -79,3 +103,39 @@ impl From<KreuzbergError> for ApiError {
         }
     }
 }
+
+impl From<JsonRejection> for ApiError {
+    fn from(rejection: JsonRejection) -> Self {
+        let (status, message) = match rejection {
+            JsonRejection::JsonDataError(err) => (
+                StatusCode::UNPROCESSABLE_ENTITY,
+                format!(
+                    "Failed to deserialize the JSON body into the target type: {}",
+                    err.body_text()
+                ),
+            ),
+            JsonRejection::JsonSyntaxError(err) => (
+                StatusCode::BAD_REQUEST,
+                format!("Failed to parse the request body as JSON: {}", err.body_text()),
+            ),
+            JsonRejection::MissingJsonContentType(_) => (
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "Expected request with `Content-Type: application/json`".to_string(),
+            ),
+            JsonRejection::BytesRejection(err) => {
+                (StatusCode::BAD_REQUEST, format!("Failed to read request body: {}", err))
+            }
+            _ => (StatusCode::BAD_REQUEST, "Unknown JSON parsing error".to_string()),
+        };
+
+        Self {
+            status,
+            body: ErrorResponse {
+                error_type: "JsonParsingError".to_string(),
+                message,
+                traceback: None,
+                status_code: status.as_u16(),
+            },
+        }
+    }
+}

data/vendor/kreuzberg/src/api/handlers.rs

@@ -8,13 +8,60 @@ use axum::{
 use crate::{batch_extract_bytes, cache, extract_bytes};
 
 use super::{
-    error::ApiError,
+    error::{ApiError, JsonApi},
     types::{
         ApiState, CacheClearResponse, CacheStatsResponse, ChunkRequest, ChunkResponse, EmbedRequest, EmbedResponse,
         ExtractResponse, HealthResponse, InfoResponse,
     },
 };
 
+/// Health check endpoint handler.
+///
+/// GET /health
+#[utoipa::path(
+    get,
+    path = "/health",
+    tag = "health",
+    responses(
+        (status = 200, description = "Service is healthy", body = HealthResponse),
+    )
+)]
+#[cfg_attr(feature = "otel", tracing::instrument(name = "api.health"))]
+pub async fn health_handler() -> Json<HealthResponse> {
+    // Get plugin status
+    let plugin_status = crate::plugins::startup_validation::PluginHealthStatus::check();
+
+    Json(HealthResponse {
+        status: "healthy".to_string(),
+        version: env!("CARGO_PKG_VERSION").to_string(),
+        plugins: Some(super::types::PluginStatus {
+            ocr_backends_count: plugin_status.ocr_backends_count,
+            ocr_backends: plugin_status.ocr_backends,
+            extractors_count: plugin_status.extractors_count,
+            post_processors_count: plugin_status.post_processors_count,
+        }),
+    })
+}
+
+/// Server info endpoint handler.
+///
+/// GET /info
+#[utoipa::path(
+    get,
+    path = "/info",
+    tag = "health",
+    responses(
+        (status = 200, description = "Server information", body = InfoResponse),
+    )
+)]
+#[cfg_attr(feature = "otel", tracing::instrument(name = "api.info"))]
+pub async fn info_handler() -> Json<InfoResponse> {
+    Json(InfoResponse {
+        version: env!("CARGO_PKG_VERSION").to_string(),
+        rust_backend: true,
+    })
+}
+
 /// Extract endpoint handler.
 ///
 /// POST /extract
@@ -37,6 +84,19 @@ use super::{
 ///
 /// The server's default config (loaded from kreuzberg.toml/yaml/json via discovery)
 /// is used as the base, and any per-request config overrides those defaults.
+// TODO: Add utoipa::path annotation once ExtractionResult implements ToSchema
+// #[utoipa::path(
+//     post,
+//     path = "/extract",
+//     tag = "extraction",
+//     request_body(content_type = "multipart/form-data"),
+//     responses(
+//         (status = 200, description = "Extraction successful", body = ExtractResponse),
+//         (status = 400, description = "Bad request", body = crate::api::types::ErrorResponse),
+//         (status = 413, description = "Payload too large", body = crate::api::types::ErrorResponse),
+//         (status = 500, description = "Internal server error", body = crate::api::types::ErrorResponse),
+//     )
+// )]
 #[cfg_attr(
     feature = "otel",
     tracing::instrument(
@@ -132,28 +192,6 @@ pub async fn extract_handler(
     Ok(Json(results))
 }
 
-/// Health check endpoint handler.
-///
-/// GET /health
-#[cfg_attr(feature = "otel", tracing::instrument(name = "api.health"))]
-pub async fn health_handler() -> Json<HealthResponse> {
-    Json(HealthResponse {
-        status: "healthy".to_string(),
-        version: env!("CARGO_PKG_VERSION").to_string(),
-    })
-}
-
-/// Server info endpoint handler.
-///
-/// GET /info
-#[cfg_attr(feature = "otel", tracing::instrument(name = "api.info"))]
-pub async fn info_handler() -> Json<InfoResponse> {
-    Json(InfoResponse {
-        version: env!("CARGO_PKG_VERSION").to_string(),
-        rust_backend: true,
-    })
-}
-
 /// Cache stats endpoint handler.
 ///
 /// GET /cache/stats
@@ -164,6 +202,15 @@ pub async fn info_handler() -> Json<InfoResponse> {
 /// - Current directory cannot be determined
 /// - Cache directory path contains non-UTF8 characters
 /// - Cache metadata retrieval fails
+#[utoipa::path(
+    get,
+    path = "/cache/stats",
+    tag = "cache",
+    responses(
+        (status = 200, description = "Cache statistics", body = CacheStatsResponse),
+        (status = 500, description = "Internal server error", body = crate::api::types::ErrorResponse),
+    )
+)]
 #[cfg_attr(feature = "otel", tracing::instrument(name = "api.cache_stats"))]
 pub async fn cache_stats_handler() -> Result<Json<CacheStatsResponse>, ApiError> {
     let cache_dir = std::env::current_dir()
@@ -204,6 +251,15 @@ pub async fn cache_stats_handler() -> Result<Json<CacheStatsResponse>, ApiError>
 /// - Current directory cannot be determined
 /// - Cache directory path contains non-UTF8 characters
 /// - Cache clearing operation fails
+#[utoipa::path(
+    delete,
+    path = "/cache/clear",
+    tag = "cache",
+    responses(
+        (status = 200, description = "Cache cleared", body = CacheClearResponse),
+        (status = 500, description = "Internal server error", body = crate::api::types::ErrorResponse),
+    )
+)]
 #[cfg_attr(feature = "otel", tracing::instrument(name = "api.cache_clear"))]
 pub async fn cache_clear_handler() -> Result<Json<CacheClearResponse>, ApiError> {
     let cache_dir = std::env::current_dir()
@@ -248,6 +304,18 @@ pub async fn cache_clear_handler() -> Result<Json<CacheClearResponse>, ApiError>
 /// - ONNX Runtime is not available
 /// - Model initialization fails
 /// - Embedding generation fails
+#[utoipa::path(
+    post,
+    path = "/embed",
+    tag = "embeddings",
+    request_body = EmbedRequest,
+    responses(
+        (status = 200, description = "Embeddings generated", body = EmbedResponse),
+        (status = 400, description = "Bad request - validation failed (e.g., empty texts array)", body = crate::api::types::ErrorResponse),
+        (status = 422, description = "Unprocessable entity - invalid JSON body", body = crate::api::types::ErrorResponse),
+        (status = 500, description = "Internal server error", body = crate::api::types::ErrorResponse),
+    )
+)]
 #[cfg(feature = "embeddings")]
 #[cfg_attr(
     feature = "otel",
@@ -260,7 +328,7 @@ pub async fn cache_clear_handler() -> Result<Json<CacheClearResponse>, ApiError>
         )
     )
 )]
-pub async fn embed_handler(Json(request): Json<EmbedRequest>) -> Result<Json<EmbedResponse>, ApiError> {
+pub async fn embed_handler(JsonApi(request): JsonApi<EmbedRequest>) -> Result<Json<EmbedResponse>, ApiError> {
     use crate::types::{Chunk, ChunkMetadata};
 
     if request.texts.is_empty() {
@@ -269,6 +337,13 @@ pub async fn embed_handler(Json(request): Json<EmbedRequest>) -> Result<Json<Emb
         )));
     }
 
+    // Validate that no texts are empty
+    if request.texts.iter().any(|t| t.is_empty()) {
+        return Err(ApiError::validation(crate::error::KreuzbergError::validation(
+            "All text entries must be non-empty strings",
+        )));
+    }
+
     // Use default config if none provided
     let config = request.config.unwrap_or_default();
 
@@ -331,8 +406,20 @@ pub async fn embed_handler(Json(request): Json<EmbedRequest>) -> Result<Json<Emb
 /// Embedding endpoint handler (when embeddings feature is disabled).
 ///
 /// Returns an error indicating embeddings feature is not enabled.
+#[utoipa::path(
+    post,
+    path = "/embed",
+    tag = "embeddings",
+    request_body = EmbedRequest,
+    responses(
+        (status = 200, description = "Embeddings generated", body = EmbedResponse),
+        (status = 400, description = "Bad request - validation failed (e.g., empty texts array)", body = crate::api::types::ErrorResponse),
+        (status = 422, description = "Unprocessable entity - invalid JSON body", body = crate::api::types::ErrorResponse),
+        (status = 500, description = "Internal server error", body = crate::api::types::ErrorResponse),
+    )
+)]
 #[cfg(not(feature = "embeddings"))]
-pub async fn embed_handler(Json(_request): Json<EmbedRequest>) -> Result<Json<EmbedResponse>, ApiError> {
+pub async fn embed_handler(JsonApi(_request): JsonApi<EmbedRequest>) -> Result<Json<EmbedResponse>, ApiError> {
     Err(ApiError::internal(crate::error::KreuzbergError::MissingDependency(
         "Embeddings feature is not enabled. Rebuild with --features embeddings".to_string(),
     )))
@@ -344,6 +431,18 @@ pub async fn embed_handler(Json(_request): Json<EmbedRequest>) -> Result<Json<Em
 ///
 /// Accepts JSON body with text and optional configuration.
 /// Returns chunks with metadata.
+#[utoipa::path(
+    post,
+    path = "/chunk",
+    tag = "chunking",
+    request_body = ChunkRequest,
+    responses(
+        (status = 200, description = "Text chunked successfully", body = ChunkResponse),
+        (status = 400, description = "Bad request - validation failed (e.g., empty text)", body = crate::api::types::ErrorResponse),
+        (status = 422, description = "Unprocessable entity - invalid JSON body", body = crate::api::types::ErrorResponse),
+        (status = 500, description = "Internal server error", body = crate::api::types::ErrorResponse),
+    )
+)]
 #[cfg_attr(
     feature = "otel",
     tracing::instrument(
@@ -352,7 +451,7 @@ pub async fn embed_handler(Json(_request): Json<EmbedRequest>) -> Result<Json<Em
         fields(text_length = request.text.len(), chunker_type = request.chunker_type.as_str())
     )
 )]
-pub async fn chunk_handler(Json(request): Json<ChunkRequest>) -> Result<Json<ChunkResponse>, ApiError> {
+pub async fn chunk_handler(JsonApi(request): JsonApi<ChunkRequest>) -> Result<Json<ChunkResponse>, ApiError> {
     use super::types::{ChunkItem, ChunkingConfigResponse};
     use crate::chunking::{ChunkerType, ChunkingConfig, chunk_text};
 
@@ -363,9 +462,9 @@ pub async fn chunk_handler(Json(request): Json<ChunkRequest>) -> Result<Json<Chu
         )));
     }
 
-    // Parse chunker_type
+    // Parse chunker_type (empty string is invalid, use default by omitting the field)
     let chunker_type = match request.chunker_type.to_lowercase().as_str() {
-        "text" | "" => ChunkerType::Text,
+        "text" => ChunkerType::Text,
         "markdown" => ChunkerType::Markdown,
         other => {
             return Err(ApiError::validation(crate::error::KreuzbergError::validation(format!(
@@ -377,15 +476,37 @@ pub async fn chunk_handler(Json(request): Json<ChunkRequest>) -> Result<Json<Chu
 
     // Build config with defaults
     let cfg = request.config.unwrap_or_default();
+    let max_characters = cfg.max_characters.unwrap_or(2000);
+    let overlap = cfg.overlap.unwrap_or(100);
+
+    // Validate chunking configuration
+    if overlap >= max_characters {
+        return Err(ApiError::validation(crate::error::KreuzbergError::validation(format!(
+            "Invalid chunking configuration: overlap ({}) must be less than max_characters ({})",
+            overlap, max_characters
+        ))));
+    }
+
     let config = ChunkingConfig {
-        max_characters: cfg.max_characters.unwrap_or(2000),
-        overlap: cfg.overlap.unwrap_or(100),
+        max_characters,
+        overlap,
         trim: cfg.trim.unwrap_or(true),
         chunker_type,
     };
 
-    // Perform chunking
-    let result = chunk_text(&request.text, &config, None).map_err(ApiError::internal)?;
+    // Perform chunking - convert any remaining errors to validation errors since they're likely config issues
+    let result = chunk_text(&request.text, &config, None).map_err(|e| {
+        // Check if error message indicates a configuration issue
+        let msg = e.to_string();
+        if msg.contains("configuration") || msg.contains("overlap") || msg.contains("capacity") {
+            ApiError::validation(crate::error::KreuzbergError::validation(format!(
+                "Invalid chunking configuration: {}",
+                msg
+            )))
+        } else {
+            ApiError::internal(e)
+        }
+    })?;
 
     // Transform to response
     let chunks = result

data/vendor/kreuzberg/src/api/mod.rs

@@ -87,6 +87,8 @@
 mod config;
 mod error;
 mod handlers;
+#[cfg(feature = "api")]
+pub mod openapi;
 mod router;
 mod startup;
 mod types;