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

56
docs/snippets/c/metadata/language_detection.md Normal file
View File

@@ -0,0 +1,56 @@
```c title="C"
#include "kreuzberg.h"
#include <stdio.h>
#include <string.h>
int main(void) {
const char *config_json =
"{"
"\"language_detection\": {"
"\"enabled\": true,"
"\"min_confidence\": 0.9,"
"\"detect_multiple\": false"
"}"
"}";
KREUZBERGExtractionConfig *config = kreuzberg_extraction_config_from_json(config_json);
if (!config) {
fprintf(stderr, "config parse failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
return 1;
}
KREUZBERGExtractionResult *result =
kreuzberg_extract_file_sync("document.pdf", NULL, config);
if (!result) {
fprintf(stderr, "extraction failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
kreuzberg_extraction_config_free(config);
return 1;
}
KREUZBERGMetadata *metadata = kreuzberg_extraction_result_metadata(result);
if (metadata) {
char *language = kreuzberg_metadata_language(metadata);
if (language) {
printf("Metadata language: %s\n", language);
kreuzberg_free_string(language);
}
kreuzberg_metadata_free(metadata);
}
char *detected_languages_json = kreuzberg_extraction_result_detected_languages(result);
if (detected_languages_json) {
printf("Detected languages: %s\n", detected_languages_json);
kreuzberg_free_string(detected_languages_json);
} else {
printf("No languages detected\n");
}
kreuzberg_extraction_result_free(result);
kreuzberg_extraction_config_free(config);
return 0;
}
```

46
docs/snippets/c/metadata/language_detection_multilingual.md Normal file
View File

@@ -0,0 +1,46 @@
```c title="C"
#include "kreuzberg.h"
#include <stdio.h>
#include <string.h>
int main(void) {
const char *config_json =
"{"
"\"language_detection\": {"
"\"enabled\": true,"
"\"min_confidence\": 0.8,"
"\"detect_multiple\": true"
"}"
"}";
KREUZBERGExtractionConfig *config = kreuzberg_extraction_config_from_json(config_json);
if (!config) {
fprintf(stderr, "config parse failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
return 1;
}
KREUZBERGExtractionResult *result =
kreuzberg_extract_file_sync("multilingual_document.pdf", NULL, config);
if (!result) {
fprintf(stderr, "extraction failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
kreuzberg_extraction_config_free(config);
return 1;
}
char *detected_languages_json = kreuzberg_extraction_result_detected_languages(result);
if (detected_languages_json) {
printf("Detected languages (JSON array): %s\n", detected_languages_json);
kreuzberg_free_string(detected_languages_json);
} else {
printf("No languages detected\n");
}
kreuzberg_extraction_result_free(result);
kreuzberg_extraction_config_free(config);
return 0;
}
```

27
docs/snippets/c/metadata/metadata.md Normal file
View File

@@ -0,0 +1,27 @@
```c title="C"
#include "kreuzberg.h"
#include <stdio.h>
int main(void) {
struct CExtractionResult *result = kreuzberg_extract_file_sync("document.pdf");
if (!result || !result->success) {
fprintf(stderr, "Error: %s\n", kreuzberg_get_error_details().message);
return 1;
}
printf("Content: %s\n", result->content);
printf("MIME: %s\n", result->mime_type);
if (result->language)
printf("Language: %s\n", result->language);
if (result->date)
printf("Date: %s\n", result->date);
if (result->subject)
printf("Subject: %s\n", result->subject);
if (result->metadata_json)
printf("Metadata: %s\n", result->metadata_json);
kreuzberg_free_result(result);
return 0;
}
```

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

@@ -0,0 +1,62 @@
```c title="C"
#include "kreuzberg.h"
#include <stdio.h>
#include <string.h>
int main(void) {
const char *config_json =
"{"
"\"pages\": {"
"\"extract_pages\": true"
"}"
"}";
KREUZBERGExtractionConfig *config = kreuzberg_extraction_config_from_json(config_json);
if (!config) {
fprintf(stderr, "config parse failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
return 1;
}
KREUZBERGExtractionResult *result =
kreuzberg_extract_file_sync("document.pdf", NULL, config);
if (!result) {
fprintf(stderr, "extraction failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
kreuzberg_extraction_config_free(config);
return 1;
}
char *content = kreuzberg_extraction_result_content(result);
if (content) {
printf("Total content length: %zu bytes\n", strlen(content));
kreuzberg_free_string(content);
}
KREUZBERGMetadata *metadata = kreuzberg_extraction_result_metadata(result);
if (metadata) {
KREUZBERGPageStructure *pages = kreuzberg_metadata_pages(metadata);
if (pages) {
printf("Total pages: %zu\n", kreuzberg_page_structure_total_count(pages));
char *boundaries_json = kreuzberg_page_structure_boundaries(pages);
if (boundaries_json) {
printf("Page boundaries (JSON): %s\n", boundaries_json);
kreuzberg_free_string(boundaries_json);
} else {
printf("No page boundaries available\n");
}
kreuzberg_page_structure_free(pages);
} else {
printf("No page structure available\n");
}
kreuzberg_metadata_free(metadata);
}
kreuzberg_extraction_result_free(result);
kreuzberg_extraction_config_free(config);
return 0;
}
```

54
docs/snippets/c/metadata/page_tracking_basic.md Normal file
View File

@@ -0,0 +1,54 @@
```c title="C"
#include "kreuzberg.h"
#include <stdio.h>
#include <string.h>
int main(void) {
const char *config_json =
"{"
"\"pages\": {"
"\"extract_pages\": true"
"}"
"}";
KREUZBERGExtractionConfig *config = kreuzberg_extraction_config_from_json(config_json);
if (!config) {
fprintf(stderr, "config parse failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
return 1;
}
KREUZBERGExtractionResult *result =
kreuzberg_extract_file_sync("document.pdf", NULL, config);
if (!result) {
fprintf(stderr, "extraction failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
kreuzberg_extraction_config_free(config);
return 1;
}
char *pages_json = kreuzberg_extraction_result_pages(result);
if (pages_json) {
printf("Pages (JSON array): %s\n", pages_json);
kreuzberg_free_string(pages_json);
} else {
printf("No pages available\n");
}
KREUZBERGMetadata *metadata = kreuzberg_extraction_result_metadata(result);
if (metadata) {
KREUZBERGPageStructure *pages = kreuzberg_metadata_pages(metadata);
if (pages) {
printf("Total page count: %zu\n", kreuzberg_page_structure_total_count(pages));
kreuzberg_page_structure_free(pages);
}
kreuzberg_metadata_free(metadata);
}
kreuzberg_extraction_result_free(result);
kreuzberg_extraction_config_free(config);
return 0;
}
```

21
docs/snippets/c/metadata/tables.md Normal file
View File

@@ -0,0 +1,21 @@
```c title="C"
#include "kreuzberg.h"
#include <stdio.h>
int main(void) {
struct CExtractionResult *result = kreuzberg_extract_file_sync("spreadsheet.xlsx");
if (!result || !result->success) {
fprintf(stderr, "Error: %s\n", kreuzberg_get_error_details().message);
return 1;
}
if (result->tables_json) {
printf("Tables (JSON): %s\n", result->tables_json);
} else {
printf("No tables found\n");
}
kreuzberg_free_result(result);
return 0;
}
```

60
docs/snippets/c/metadata/vector_database_integration.md Normal file
View File

@@ -0,0 +1,60 @@
```c title="C"
#include "kreuzberg.h"
#include <stdio.h>
#include <string.h>
int main(void) {
const char *config_json =
"{"
"\"chunking\": {"
"\"chunker_type\": \"character\","
"\"max_characters\": 512,"
"\"overlap\": 50,"
"\"embedding\": {"
"\"model\": {\"preset\": {\"name\": \"balanced\"}},"
"\"normalize\": true"
"}"
"}"
"}";
KREUZBERGExtractionConfig *config = kreuzberg_extraction_config_from_json(config_json);
if (!config) {
fprintf(stderr, "config parse failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
return 1;
}
KREUZBERGExtractionResult *result =
kreuzberg_extract_file_sync("document.pdf", NULL, config);
if (!result) {
fprintf(stderr, "extraction failed (code %d): %s\n",
kreuzberg_last_error_code(),
kreuzberg_last_error_context());
kreuzberg_extraction_config_free(config);
return 1;
}
char *chunks_json = kreuzberg_extraction_result_chunks(result);
if (chunks_json) {
printf("Chunks with embeddings (JSON): %s\n", chunks_json);
kreuzberg_free_string(chunks_json);
} else {
printf("No chunks produced\n");
}
KREUZBERGMetadata *metadata = kreuzberg_extraction_result_metadata(result);
if (metadata) {
char *title = kreuzberg_metadata_title(metadata);
if (title) {
printf("Document title: %s\n", title);
kreuzberg_free_string(title);
}
kreuzberg_metadata_free(metadata);
}
kreuzberg_extraction_result_free(result);
kreuzberg_extraction_config_free(config);
return 0;
}
```