hjess/fil
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Nomad changes
All checks were successful
Deploy fil (kreuzberg) / deploy (push) Successful in 49s
Details

Browse Source
This commit is contained in:
Henrik Jess Nielsen
2026-06-01 23:40:55 +02:00
parent 72b1a0a6ed
commit b4c07d3693
5723 changed files with 1130655 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
docs/snippets/zig/metadata/language_detection.md Normal file
View File

@@ -0,0 +1,47 @@
```zig title="Zig"
const std = @import("std");
const kreuzberg = @import("kreuzberg");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const config_json =
\\{
\\ "language_detection": {
\\ "enabled": true,
\\ "min_confidence": 0.9,
\\ "detect_multiple": true
\\ }
\\}
;
const result_json = try kreuzberg.extract_file_sync("document.pdf", null, config_json);
defer std.heap.c_allocator.free(result_json);
var parsed = try std.json.parseFromSlice(std.json.Value, allocator, result_json, .{});
defer parsed.deinit();
const root = parsed.value;
if (root != .object) return;
const stdout = std.io.getStdOut().writer();
if (root.object.get("content")) |content_val| {
if (content_val == .string) {
try stdout.print("content length: {d}\n", .{content_val.string.len});
}
}
if (root.object.get("detected_languages")) |languages_val| {
if (languages_val == .array) {
for (languages_val.array.items) |lang_val| {
if (lang_val == .string) {
try stdout.print("Detected: {s}\n", .{lang_val.string});
}
}
}
}
}
```

43
docs/snippets/zig/metadata/language_detection_multilingual.md Normal file
View File

@@ -0,0 +1,43 @@
```zig title="Zig"
const std = @import("std");
const kreuzberg = @import("kreuzberg");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const config_json =
\\{
\\ "language_detection": {
\\ "enabled": true,
\\ "min_confidence": 0.8,
\\ "detect_multiple": true
\\ }
\\}
;
const result_json = try kreuzberg.extract_file_sync("multilingual_document.pdf", null, config_json);
defer std.heap.c_allocator.free(result_json);
var parsed = try std.json.parseFromSlice(std.json.Value, allocator, result_json, .{});
defer parsed.deinit();
const root = parsed.value;
if (root != .object) return;
const stdout = std.io.getStdOut().writer();
try stdout.print("Detected languages:", .{});
if (root.object.get("detected_languages")) |languages_val| {
if (languages_val == .array) {
for (languages_val.array.items) |lang_val| {
if (lang_val == .string) {
try stdout.print(" {s}", .{lang_val.string});
}
}
}
}
try stdout.print("\n", .{});
}
```

65
docs/snippets/zig/metadata/metadata.md Normal file
View File

@@ -0,0 +1,65 @@
```zig title="Zig"
const std = @import("std");
const kreuzberg = @import("kreuzberg");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const config_json = "{}";
const result_json = try kreuzberg.extract_file_sync("document.pdf", null, config_json);
defer std.heap.c_allocator.free(result_json);
var parsed = try std.json.parseFromSlice(std.json.Value, allocator, result_json, .{});
defer parsed.deinit();
const root = parsed.value;
if (root != .object) return;
const stdout = std.io.getStdOut().writer();
if (root.object.get("metadata")) |metadata_val| {
if (metadata_val != .object) return;
const metadata = metadata_val.object;
if (metadata.get("title")) |title_val| {
if (title_val == .string) {
try stdout.print("Title: {s}\n", .{title_val.string});
}
}
if (metadata.get("authors")) |authors_val| {
if (authors_val == .array) {
for (authors_val.array.items) |author| {
if (author == .string) {
try stdout.print("Author: {s}\n", .{author.string});
}
}
}
}
if (metadata.get("language")) |language_val| {
if (language_val == .string) {
try stdout.print("Language: {s}\n", .{language_val.string});
}
}
if (metadata.get("created_at")) |created_val| {
if (created_val == .string) {
try stdout.print("Created: {s}\n", .{created_val.string});
}
}
if (metadata.get("pages")) |pages_val| {
if (pages_val == .object) {
if (pages_val.object.get("total_count")) |total_val| {
if (total_val == .integer) {
try stdout.print("Pages: {d}\n", .{total_val.integer});
}
}
}
}
}
}
```

62
docs/snippets/zig/metadata/page_boundaries.md Normal file
View File

@@ -0,0 +1,62 @@
```zig title="Zig"
const std = @import("std");
const kreuzberg = @import("kreuzberg");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const config_json = "{}";
const result_json = try kreuzberg.extract_file_sync("document.pdf", null, config_json);
defer std.heap.c_allocator.free(result_json);
var parsed = try std.json.parseFromSlice(std.json.Value, allocator, result_json, .{});
defer parsed.deinit();
const root = parsed.value;
if (root != .object) return;
const stdout = std.io.getStdOut().writer();
const content_val = root.object.get("content") orelse return;
if (content_val != .string) return;
const content = content_val.string;
const metadata_val = root.object.get("metadata") orelse return;
if (metadata_val != .object) return;
const pages_val = metadata_val.object.get("pages") orelse return;
if (pages_val != .object) return;
const boundaries_val = pages_val.object.get("boundaries") orelse return;
if (boundaries_val != .array) return;
var index: usize = 0;
for (boundaries_val.array.items) |boundary| {
if (index >= 3) break;
if (boundary != .object) continue;
const byte_start_val = boundary.object.get("byte_start") orelse continue;
const byte_end_val = boundary.object.get("byte_end") orelse continue;
const page_number_val = boundary.object.get("page_number") orelse continue;
if (byte_start_val != .integer or byte_end_val != .integer or page_number_val != .integer) {
continue;
}
const byte_start: usize = @intCast(byte_start_val.integer);
const byte_end: usize = @intCast(byte_end_val.integer);
const page_number = page_number_val.integer;
const page_text = content[byte_start..byte_end];
const preview_end = @min(@as(usize, 100), page_text.len);
try stdout.print("Page {d}:\n", .{page_number});
try stdout.print(" Byte range: {d}-{d}\n", .{ byte_start, byte_end });
try stdout.print(" Preview: {s}...\n", .{page_text[0..preview_end]});
index += 1;
}
}
```

59
docs/snippets/zig/metadata/page_tracking_basic.md Normal file
View File

@@ -0,0 +1,59 @@
```zig title="Zig"
const std = @import("std");
const kreuzberg = @import("kreuzberg");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const config_json =
\\{
\\ "pages": {
\\ "extract_pages": true
\\ }
\\}
;
const result_json = try kreuzberg.extract_file_sync("document.pdf", null, config_json);
defer std.heap.c_allocator.free(result_json);
var parsed = try std.json.parseFromSlice(std.json.Value, allocator, result_json, .{});
defer parsed.deinit();
const root = parsed.value;
if (root != .object) return;
const stdout = std.io.getStdOut().writer();
const pages_val = root.object.get("pages") orelse return;
if (pages_val != .array) return;
for (pages_val.array.items) |page| {
if (page != .object) continue;
const page_number_val = page.object.get("page_number") orelse continue;
if (page_number_val != .integer) continue;
try stdout.print("Page {d}:\n", .{page_number_val.integer});
if (page.object.get("content")) |content_val| {
if (content_val == .string) {
try stdout.print(" Content: {d} chars\n", .{content_val.string.len});
}
}
if (page.object.get("tables")) |tables_val| {
if (tables_val == .array) {
try stdout.print(" Tables: {d}\n", .{tables_val.array.items.len});
}
}
if (page.object.get("images")) |images_val| {
if (images_val == .array) {
try stdout.print(" Images: {d}\n", .{images_val.array.items.len});
}
}
}
}
```

58
docs/snippets/zig/metadata/tables.md Normal file
View File

@@ -0,0 +1,58 @@
```zig title="Zig"
const std = @import("std");
const kreuzberg = @import("kreuzberg");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const config_json = "{}";
const result_json = try kreuzberg.extract_file_sync("document.pdf", null, config_json);
defer std.heap.c_allocator.free(result_json);
var parsed = try std.json.parseFromSlice(std.json.Value, allocator, result_json, .{});
defer parsed.deinit();
const root = parsed.value;
if (root != .object) return;
const stdout = std.io.getStdOut().writer();
const tables_val = root.object.get("tables") orelse return;
if (tables_val != .array) return;
for (tables_val.array.items) |table| {
if (table != .object) continue;
if (table.object.get("cells")) |cells_val| {
if (cells_val == .array) {
try stdout.print("Table with {d} rows\n", .{cells_val.array.items.len});
for (cells_val.array.items) |row_val| {
if (row_val != .array) continue;
try stdout.print(" Row:", .{});
for (row_val.array.items) |cell_val| {
if (cell_val == .string) {
try stdout.print(" [{s}]", .{cell_val.string});
}
}
try stdout.print("\n", .{});
}
}
}
if (table.object.get("markdown")) |markdown_val| {
if (markdown_val == .string) {
try stdout.print("{s}\n", .{markdown_val.string});
}
}
if (table.object.get("page_number")) |page_val| {
if (page_val == .integer) {
try stdout.print("Page: {d}\n", .{page_val.integer});
}
}
}
}
```

47
docs/snippets/zig/metadata/vector_database_integration.md Normal file
View File

@@ -0,0 +1,47 @@
```zig title="Zig"
const std = @import("std");
const kreuzberg = @import("kreuzberg");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const config_json =
\\{
\\ "chunking": {
\\ "max_characters": 512,
\\ "overlap": 50,
\\ "embedding": {
\\ "model": "balanced",
\\ "normalize": true
\\ }
\\ }
\\}
;
const result_json = try kreuzberg.extract_file_sync("document.pdf", null, config_json);
defer std.heap.c_allocator.free(result_json);
var parsed = try std.json.parseFromSlice(std.json.Value, allocator, result_json, .{});
defer parsed.deinit();
const root = parsed.value;
if (root != .object) return;
const stdout = std.io.getStdOut().writer();
const chunks_val = root.object.get("chunks") orelse return;
if (chunks_val != .array) return;
for (chunks_val.array.items, 0..) |chunk, index| {
if (chunk != .object) continue;
const embedding_val = chunk.object.get("embedding") orelse continue;
if (embedding_val != .array) continue;
try stdout.print("Chunk {d}: {d} dimensions\n", .{ index, embedding_val.array.items.len });
// Store embedding_val.array.items in vector database
}
}
```