Architectural and Linguistic Synthesis of the JustAnIota Bidirectional Semantic Converter

Full report

On this page

The Protocol5 Experimental Paradigm and Semantic Approximation

The modern computational processing of natural language has largely relied upon statistical tokenization algorithms, such as Byte-Pair Encoding (BPE) and unigram language modeling, which partition text based on the frequency of arbitrary byte sequences rather than underlying semantic meaning.1 This prevailing methodology introduces a fundamental representational disconnect: the models process fragments that possess no intrinsic meaning, overburdening the embedding layers of Transformer architectures with the dual task of deciphering structural syntax and abstract semantics simultaneously.1 The JustAnIota Converter, operating as an experimental framework deployed alongside mathematical demonstrations on Protocol5.com, represents a radical departure from this paradigm. It synthesizes AI-native computational models with deterministic linguistic theories to establish a language-agnostic, bidirectional translation bridge between standard English and the universal symbols embedded within the ISO/IEC 10646 standard.1

The conceptual foundation of the JustAnIota Converter is rooted in the premise that exact, word-for-word translation is an inherently flawed objective due to the highly variable grammatical and cultural nuances present across different human languages.1 Instead, the architecture focuses on mapping approximate conceptual weights. This approach utilizes a mathematical metaphor directly tied to the experimental nature of Protocol5.com: the objective is not to prove an exact equivalency, such as [Figure omitted from source export], but rather to operate under the assumption that combining semantic vectors will yield an approximate, highly proximal result in a high-dimensional space, akin to the conceptual equation [Figure omitted from source export]. While mathematically inexact, this equation correctly identifies the "gist" or the approximate order of magnitude.1 By extracting this "gist" or the approximate ideas hidden beneath the surface of the symbols, the system allows for cross-lingual comparisons that neutralize the structural biases of the origin language.1

This methodology ensures that semantic meaning is derived from the proximity of continuous vector embeddings rather than rigid dictionary lookups.2 Words and concepts that share underlying semantic intent will gravitationally cluster near each other within the multi-dimensional vector space, even if their surface-level vocabularies or original character sets share zero commonality.3 This report exhaustively details the architectural blueprint, the linguistic frameworks, the enterprise-grade C\# infrastructure, the local AI vector generation schemas, and the advanced SQL Server 2025 database mechanics required to implement this semantic paradigm on Protocol5.com.

Rejection of the Private-Use Profile and the "Secret Dictionary" Fallacy

In the initial theoretical planning of universal semantic encoding systems, proposals often suggest utilizing the ISO/IEC 10646 Supplementary Private Use Areas (PUA-A in Plane 15 and PUA-B in Plane 16\) as a cryptographic medium.1 The allure of the PUA is its vast capacity—yielding 131,068 unassigned code points—which guarantees zero conflict with standard, normative Unicode character updates.1 Such proposals advocate for encoding nodes, relations, and modifiers directly into the bit-level integer space of these unassigned characters to create a proprietary semantic hypergraph.1

However, the Protocol5.com experimental architecture explicitly and fundamentally rejects the use of a "versioned private-use profile." The core philosophy of the JustAnIota Converter is to extract and compare the latent, approximate ideas existing beneath natural language and universally recognized symbols, not to invent a synthetic, hidden language. Utilizing a private-use profile equates to establishing a "secret dictionary," which entirely defeats the purpose of the exercise. The objective is to demonstrate that language neutrality can be achieved by leveraging the semantic weight already carried by standard, globally adopted symbols.

Instead of hiding data in unassigned blocks, the JustAnIota Converter operates by iterating through the standard ISO/IEC 10646 assignments—specifically targeting the thousands of established Chinese characters (Han ideographs) and emojis that inherently carry complex, self-contained ideas. By assigning computational embeddings to these universally recognized characters and simultaneously assigning embeddings to English words, the system can compare the dimensional weights to uncover the "gist" behind the symbols without relying on a proprietary, secret mapping. This enforces absolute transparency and ensures that the system remains genuinely language-neutral, deriving meaning from the historical and cultural weight already embedded in the standard Unicode specification.

Iterative Parsing of ISO/IEC 10646 and the Unihan Database

To achieve this language-neutral approximation, the JustAnIota Converter must programmatically iterate through the vast expanse of the ISO/IEC 10646 standard, parsing the characters and extracting their foundational definitions to feed into the embedding model. This process requires a highly robust understanding of the Unicode Character Database (UCD).5

The Unicode Character Database (UCD)

The UCD is an exhaustive collection of data files that define the normative properties, names, and behaviors of every single character in the standard.5 Central to this extraction process is the programmatic parsing of UnicodeData.txt, which serves as the primary data file defining a massive array of properties, including character names, general categories, canonical combining classes, and bidirectional behavior (Bidi\_Class).5

By iterating through this database, the C\# logic layer can extract the formal semantic descriptions of characters. For example, emojis, which transcend spoken language barriers, possess rich descriptive names in the UCD that can be embedded into vector space to capture their conceptual weight.5

The Unihan Database

To extract meaning from the thousands of Chinese characters required by the Protocol5.com experiment, the architecture heavily relies on the Unihan database (documented in UAX \#38).5 The Unihan database provides vital property data for Han ideographs, which are utilized across Chinese, Japanese, and Korean (CJK) scripts.10

Formally, ideographs within the Unicode standard are not defined by rigid, singular dictionary definitions; rather, they are defined via their relational mappings and historical usage across multiple cultures.9 The Unihan database catalogs these mappings, providing access to legacy encoding standard conversions, historical dictionary references, semantic meaning, and reading information compiled by various linguistic authorities.10

The C\# environment utilizes specialized parsing libraries—often based on parser combinators like Sprache or custom implementations—to systematically extract these Unihan properties.10 By digesting the radical-stroke indices and the multi-layered definitions provided by Unihan, the JustAnIota Converter aggregates a comprehensive text description of the ideograph.10 This aggregated description is then passed to the local LLM to generate an embedding. Because the ideograph represents an idea rather than a phonetic sound, its resulting vector embedding serves as a language-neutral anchor point in the multidimensional space, allowing English words to be compared against the pure concept represented by the character.

C# Memory Architecture and System.Text.Rune Implementation

Iterating through the entirety of the ISO/IEC 10646 standard within a C\# enterprise environment presents a profound technical and architectural challenge due to historical design decisions regarding memory allocation and string representation.14

Within the.NET ecosystem, strings are stored in contiguous memory as a sequence of 16-bit integers, where the char data type represents a single 16-bit UTF-16 code unit.15 Because standard UTF-16 can only represent code points up to 0xFFFF (the Basic Multilingual Plane), a single char is fundamentally incapable of natively holding characters from the supplementary planes (Plane 1 and beyond), which house modern emojis, historical scripts, and extended CJK ideographs.14

To represent these higher code points, UTF-16 utilizes a mechanism known as "surrogate pairs"—a combination of two distinct 16-bit char instances (a high surrogate and a low surrogate) that together represent a single visual character or Unicode scalar value.14 If a developer attempts to iterate through a Unicode string simply by incrementing an integer index (i++) and evaluating a single char at a time, the logic will abruptly slice a surrogate pair in half.14 This naive iteration destroys the data, yields invalid bytes, and causes the semantic extraction algorithm to fail catastrophically.14

To resolve this critical flaw and ensure perfect fidelity when parsing the ISO/IEC 10646 standard, the JustAnIota Converter's C\# Logic Layer relies exclusively on the System.Text.Rune struct.16 Introduced in modern.NET versions, a Rune explicitly represents a fully validated Unicode scalar value, abstracting away the surrogate pair mechanics entirely.15 A Rune instance encapsulates a 32-bit integer that guarantees the data falls within valid Unicode ranges and is never an orphaned high or low surrogate.15

During the iteration of the character database, the Logic Layer uses the Rune.TryGetRuneAt() method to traverse the character array.18 This method safely consumes either one char (if it detects a base plane character) or two chars (if it detects a surrogate pair), and subsequently advances the iterator precisely by the Utf16SequenceLength of the decoded Rune.18

By strictly enforcing Rune-based iteration, the system guarantees that complex emojis and rare CJK ideographs are fed into the embedding generation pipeline perfectly intact, preserving the semantic integrity required for accurate vector weighting.18

Deterministic Linguistic Foundations: NSM and UNL

While the embeddings provide the high-dimensional spatial coordinates for approximate ideas, the architecture requires a deterministic linguistic framework to bridge the gap between abstract vectors and readable data, particularly during offline degradation modes. To avoid the circularity of standard dictionaries, the JustAnIota Converter utilizes a synthesized framework merging the Natural Semantic Metalanguage (NSM) and the Universal Networking Language (UNL).1

Natural Semantic Metalanguage (NSM)

The NSM theory, developed through decades of cross-linguistic empirical research, asserts that all complex human thoughts can be reduced to a highly constrained, irreducible set of "semantic primes".1 These primes are conceptual atoms that have exact equivalents in every human language, eliminating the risk of cultural or grammatical ambiguity.1 By utilizing these primes, highly specific concepts can be paraphrased into universal sequences.1 For instance, a complex concept is distilled into its universal paraphrase, breaking down the linguistic barriers that normally impede direct translation.1

Within the JustAnIota Converter, the 65 identified NSM semantic primes are categorized and heavily weighted within the system's vector space, allowing for the discrete mapping of conceptual nodes.1

Universal Networking Language (UNL)

While NSM supplies the isolated semantic nodes, the Universal Networking Language (UNL) provides the rigorous syntactical architecture needed to connect them.1 UNL structures information as a mathematical hypergraph, where NSM primes function as the nodes, and a strictly defined set of 46 semantic relations function as the directed, labeled edges connecting these nodes.1

These explicit binary relations—such as agt (agent) to denote the initiator of an action, or obj (object) to denote the entity acted upon—create an unambiguous, mathematically traversable map of intent and action.1 By representing language as a relational graph rather than a linear sequence of tokens, the system forces the AI embedding layer to evaluate the structural logic of the idea, drastically improving the accuracy of the resulting vector weight comparisons.1

C# Enterprise Architecture: The Facade Pattern and Logic Layer

The JustAnIota Converter is engineered upon a highly structured, enterprise-grade C\#.NET architecture. Because the system must orchestrate complex interactions between string memory management, local AI REST APIs, and advanced SQL Server vector mathematics, it requires a design pattern that strictly enforces the separation of concerns.1 The cornerstone of this enterprise architecture is the implementation of the Facade Pattern, specifically manifested through an IJustAnIotaConverterFacade interface.1

The Facade Pattern and System Decoupling

In enterprise application development, the Facade pattern serves as a critical intermediary layer that shields front-end client applications and external microservices from the intricate, tightly coupled subsystems residing beneath it.1 Front-end interfaces on the Protocol5.com experiment site submit simple, human-readable requests to the Facade without requiring any knowledge of the underlying vector mathematics, the System.Text.Rune iteration logic, or the ADO.NET connection parameters.1

The primary software engineering advantages of this architectural choice include:

1. Complexity Encapsulation: The immense difficulty of marshaling data between deterministic C\# algorithms and non-deterministic LLM outputs is hidden entirely from the consumer.1
2. Testability and CI/CD Integration: External development teams can mock the IJustAnIotaConverterFacade interface to execute automated unit testing. This allows the pipeline to validate business logic without the need to spin up resource-heavy local AI infrastructure or instantiate a massive SQL Server database, drastically reducing build times.1
3. Subsystem Decoupling: The ecosystem of Large Language Models and vector databases is highly volatile. If the engineering team decides to swap LM Studio for a different local provider, or if the SQL Server 2025 schema requires an update, these changes are localized behind the Facade, leaving the client application entirely unaffected.1

The Logic Layer and Cyclic Pathways

Situated immediately behind the Facade, the Logic Layer serves as the central nervous system of the JustAnIota Converter. It manages the execution of both deterministic data processing (parsing Unicode) and non-deterministic semantic extrapolation (generating embeddings).1 The logic dictates two primary, cyclic pathways required by the user query: English to ISO/IEC 10646 embeddings, and back.1

During the English to Embeddings pathway, the Logic Layer intercepts the raw English text and marshals it to the local AI endpoint to generate a high-dimensional continuous vector.1 It subsequently queries the SQL Server 2025 AI database using this embedding to search for the closest conceptual match among the thousands of pre-processed Chinese characters and emojis.1

At this juncture, the system leverages a crucial "semantic cache" optimization.1 The Logic Layer evaluates the proximity of the returned matches based on a strict mathematical threshold. If the similarity search identifies a pre-existing vector match with an exceptionally high degree of proximity (e.g., a cosine similarity score exceeding 0.95), the system circumvents further generative AI processing entirely, immediately returning the cached result.1 If the threshold is not met, the request is routed back to the local LLM for further semantic extrapolation to generate a novel approximation.1

Data Persistence: ADO.NET and the Repository Pattern

To manage data access and abstract the complexities of the SQL Server 2025 AI database, the enterprise architecture strictly enforces the Repository Pattern, deeply integrated with ADO.NET and newly introduced vector data types.1 The Repository Pattern is a fundamental tenet of Domain-Driven Design (DDD) intended to keep persistence concerns entirely segregated from the system's core domain model.20

The repository acts as an in-memory intermediary, providing a consistent, strongly-typed interface for the C\# Logic Layer to interact with data while abstracting away complex SQL syntax, query shapes, and connection management.20 By decoupling the data access logic, the Repository Pattern provides immense operational flexibility.24 It allows the system to interact seamlessly with the native vector data types introduced in SQL Server 2025 without polluting the business logic with SQL-specific implementation details.22

In the context of the Protocol5.com experiment, the repository is responsible for managing the bulk insertion of the thousands of ISO/IEC 10646 embeddings generated during the initialization phase, as well as executing the rapid, high-frequency read operations required during the similarity search phase.1

Local AI Integration: LM Studio and Generative Inference

The JustAnIota Converter relies on local, quantized language models to generate the multidimensional vectors necessary for semantic comparison.1 To ensure absolute data sovereignty, eliminate external API latency, and avoid the prohibitive ongoing inference costs associated with cloud providers, the architecture mandates the use of LM Studio.1 LM Studio operates as a local hosting environment capable of running highly optimized, quantized models, such as the qwen2.5-7b-instruct model specifically identified for this architecture.1

OpenAI-Compatible REST Endpoints

The integration between the deterministic C\# Logic Layer and the generative AI model hosted in LM Studio is achieved through an OpenAI-compatible REST API.1 Rather than forcing developers to write custom API wrappers for every local model, LM Studio exposes endpoints that flawlessly mimic the established OpenAI specifications, including the highly critical /v1/chat/completions and /v1/embeddings routes.28

This compatibility is a massive architectural advantage. Developers working within the C\# environment can utilize standard, enterprise-supported Microsoft or community-built OpenAI SDKs (such as the Semantic Kernel or the standard OpenAI C\# client) by simply overriding the BaseUrl property to point to the local host address designated by LM Studio (e.g., http://localhost:1234/v1).1

Generating Local Embeddings

During operation, the Logic Layer continuously invokes the /v1/embeddings endpoint exposed by LM Studio.1 Input text—whether it is a raw English sentence, a parsed Unihan definition of a Chinese character, or a descriptive UCD string of an emoji—is transmitted via HTTP POST to the local model.29 The model processes the semantic weight of the input and returns a massive array of floating-point numbers representing the precise mathematical location of that concept within its high-dimensional understanding of language.29

This continuous stream of locally generated embeddings forms the raw fuel for the SQL Server database. Because the process is entirely local, the system can iterate through the entirety of the ISO/IEC 10646 standard, generating millions of data points without incurring API rate limits or financial costs, fulfilling the experimental requirements of the Protocol5.com deployment.

SQL Server 2025 AI Integration and Vector Storage

The persistence, management, and querying of these semantic vectors rely entirely on the advanced AI features introduced natively in SQL Server 2025\.2 Previously, enterprise architectures requiring vector search were forced to bolt on dedicated, standalone vector databases, which severely complicated data governance, backup strategies, and transactional consistency.33 SQL Server 2025 resolves this by integrating vector capabilities directly into the SQL Database Engine, allowing developers to handle vector searches using standard Transact-SQL (T-SQL) while maintaining enterprise-grade compliance.33

The Native VECTOR Data Type

SQL Server 2025 introduces a native VECTOR data type specifically engineered to store the ordered arrays of numbers generated by the embedding models.33 These vectors are stored on disk in a highly optimized binary format for rapid retrieval and minimal footprint, yet they are conveniently exposed to developers and client applications as standard JSON arrays for ease of use.32

By default, the VECTOR data type utilizes float32 (single-precision floating-point values), but SQL Server 2025 also supports float16 (half-precision) vectors.36 For experimental datasets with massive volume, utilizing half-precision significantly optimizes storage overhead and memory consumption without causing a fatal degradation in semantic accuracy.36 The definition of a column specifies the exact required dimensionality, ensuring that the database strictly enforces vector shapes (e.g., VECTOR(1024) or VECTOR(1536)), preventing dimensional mismatch errors during query execution.36

ADO.NET Binary Transport via SqlVector

To transport these high-dimensional vectors efficiently between the C\# ADO.NET Repository layer and the SQL Server database, the Microsoft.Data.SqlClient provider introduces native vector handling via the SqlVector\<T\> class (e.g., SqlVector\<float\>).25

Historically, passing arrays to a database required serializing them into bulky JSON strings, transmitting the strings over the network, and forcing the database engine to deserialize and parse the text back into numbers—a massive computational bottleneck.25 The SqlVector\<T\> class bypasses this entirely by utilizing an optimized binary transport directly over the Tabular Data Stream (TDS) protocol.25 Within the Repository Pattern layer, C\# leverages SqlVector\<float\> to execute rapid parameter binding during bulk copy operations and stored procedure invocations, ensuring that the database is populated with maximum throughput.25

Vector Similarity Search: Exact Calculation vs. DiskANN Indexing

Once the English words and the parsed ISO/IEC 10646 character definitions have been converted into embeddings and stored in the database, the JustAnIota Converter must evaluate their semantic proximity to find the "gist" or approximate overlap.2 This closeness, or distance, is measured mathematically to determine how similar two disparate concepts are.33 SQL Server 2025 provides sophisticated mechanisms for executing these comparisons.

Distance Metrics and Exact kNN Search

SQL Server provides built-in support for distance metrics via the VECTOR\_DISTANCE T-SQL function.37 This function calculates the exact mathematical distance between a query vector (e.g., the English word) and a target vector (e.g., the Chinese character).37

The database supports three primary distance metrics, each serving different geometric evaluations:

When a query vector is passed to the database, VECTOR\_DISTANCE can be used in conjunction with an ORDER BY clause to execute an exact K-Nearest Neighbors (kNN) search.33 Because VECTOR\_DISTANCE guarantees perfect mathematical accuracy, it does not use an index; it must calculate the distance between the query vector and every single row in the target dataset (a full table scan).33 This operation is immensely CPU-intensive.33 Microsoft strictly recommends limiting exact searches using VECTOR\_DISTANCE to datasets containing fewer than 50,000 vectors, making it unsuitable for scanning the entirety of the Unicode standard on every query.33

Approximate Nearest Neighbors (ANN) and DiskANN Indexing

Because the Protocol5.com experiment requires processing massive amounts of lexical variations across multiple languages rapidly, exact kNN search is prohibitively slow. To achieve the necessary scalability, the architecture utilizes Approximate Nearest Neighbors (ANN) searching.39 ANN embraces the core philosophy of the experiment—that approximation is sufficient—by trading a negligible fraction of accuracy (recall) for exponential gains in processing speed and reduced resource consumption.39

In SQL Server 2025, ANN capabilities are unlocked through the creation of vector indexes utilizing the DiskANN algorithm.39 Developed by Microsoft Research, DiskANN is an advanced graph-based indexing algorithm uniquely optimized for Solid State Drive (SSD) storage.40 Unlike traditional, memory-bound algorithms such as HNSW—which require the entire index graph to reside in expensive RAM—DiskANN creates a highly efficient navigational graph where each vector is connected to its closest semantic neighbors.40 The algorithm keeps only a small, compressed portion of the graph in memory, rapidly streaming the bulk of the navigational data from the SSD.40 This architecture maintains incredibly high queries per second (QPS) and low latency while utilizing a fraction of the memory footprint of competing vector databases.42

The deployment of this index is executed via the CREATE VECTOR INDEX T-SQL statement.41 The syntax demands the specification of the vector column, the desired distance metric (e.g., METRIC \= 'cosine'), and the algorithm type (TYPE \= DiskANN).40 To prevent the engine from attempting to index trivial amounts of data, SQL Server strictly enforces a minimum data requirement: a vector index cannot be generated on a table containing fewer than 100 non-null vectors; attempting to do so triggers Error Msg 42266\.41 Furthermore, database administrators can utilize the MAXDOP parameter to explicitly limit the number of parallel processors consumed during the computationally heavy index build process.41

Once the DiskANN index is successfully deployed, the C\# Repository layer queries the dataset using the VECTOR\_SEARCH function instead of VECTOR\_DISTANCE.37 Rather than scanning every row, VECTOR\_SEARCH navigates the DiskANN graph, returning approximate, highly relevant results with extreme rapidity.41 The latest version 3 implementations of this engine support full Data Manipulation Language (DML) operations, ensuring that new embeddings inserted via INSERT or modified via UPDATE commands dynamically update the vector index in the background without causing read locking or requiring complete index rebuilds.41

Hybrid Search and Reciprocal Rank Fusion (RRF)

While vector embeddings are unparalleled at capturing the broad "gist" of a concept, relying entirely on probabilistic vector similarity can occasionally produce results that lack specific keyword exactitude.45 The JustAnIota Logic Layer resolves this ambiguity by implementing a Hybrid Search paradigm.1 Hybrid search executes both a traditional, deterministic lexical query (such as BM25 ranking or SQL Server's native FREETEXTTABLE) and a probabilistic vector search (VECTOR\_SEARCH) simultaneously.1

The distinct result sets from these two radically different algorithms are then normalized and merged using a mathematical technique known as Reciprocal Rank Fusion (RRF).1 RRF computes a unified score by evaluating the inverse of each document's rank across the disparate search methods. This synthesis ensures that the system honors specific entity names and technical terms via lexical matching while capturing the overarching conceptual meaning via semantic vector embeddings.1

The Offline "Gist" Mode and Graceful Degradation

A fundamental requirement of the JustAnIota Converter for the Protocol5.com deployment is the ability to operate, albeit in a diminished capacity, without active access to the local Generative AI.1 Once the SQL Server database has been populated with the baseline vector embeddings for English words and the parsed ISO/IEC 10646 characters, the system implements a principle of graceful degradation.1

If the LM Studio instance is offline, computationally saturated, or disabled for demonstration purposes, the C\# Logic Layer falls back to an offline "gist" mode.1 In this degraded state, the system bypasses the /v1/embeddings generation endpoint entirely. Instead, it relies strictly on deterministic relational joins and pre-calculated vector comparisons residing within the SQL Server database. Because the database already holds the mathematical coordinates for thousands of universal symbols and basic English primitives, the system can still retrieve and return the closest approximate matches based on the static data.1

While the system loses the ability to dynamically "smooth" these concepts into perfectly fluid, conversational English phrasing without the active LLM, it successfully returns the raw, literal semantic components and the heavily weighted standard symbols.1 This ensures that a baseline approximation of meaning—the very core of the [Figure omitted from source export] experimental analogy—is always available, demonstrating that language-neutral semantic comparison can function purely on vector mathematics and established international character standards without reliance on secret dictionaries or active neural generation.

Works cited

1. AI Multilingual Text Encoding Specification.md
2. Vectors in SQL Server 2025 \- SQLServerCentral, accessed May 3, 2026, https://www.sqlservercentral.com/articles/vectors-in-sql-server-2025
3. Generating and Comparing Sentence Embeddings | CodeSignal Learn, accessed May 3, 2026, https://codesignal.com/learn/courses/text-representation-techniques-for-rag-systems/lessons/generating-and-comparing-sentence-embeddings
4. Semantic similarity with sentence embeddings \- Fast Data Science, accessed May 3, 2026, https://fastdatascience.com/natural-language-processing/semantic-similarity-with-sentence-embeddings/
5. UAX \#44: Unicode Character Database, accessed May 3, 2026, https://www.unicode.org/reports/tr44/
6. Where are the fields documented for the unicode.org file "UnicodeData.txt"? \- Stack Overflow, accessed May 3, 2026, https://stackoverflow.com/questions/755035/where-are-the-fields-documented-for-the-unicode-org-file-unicodedata-txt
7. UAX \#44: Unicode Character Database, accessed May 3, 2026, http://www.unicode.org/reports/tr44/tr44-3.html
8. Unicode and Text Retrieval \- IBM, accessed May 3, 2026, https://www.ibm.com/docs/en/tamino/10.7.0?topic=unicode-text-retrieval
9. UAX \#38: Unicode Han Database (Unihan), accessed May 3, 2026, https://www.unicode.org/reports/tr38/
10. Unihan Database Lookup \- Unicode, accessed May 3, 2026, https://www.unicode.org/charts/unihan.html
11. UAX \#38: Unicode Han Database (Unihan) \- UC Berkeley Linguistics, accessed May 3, 2026, http://linguistics.berkeley.edu/\~rscook/UTC/tr38-6d5.html
12. GitHub \- sprache/Sprache: A tiny, friendly, C\# parser construction library, accessed May 3, 2026, https://github.com/sprache/Sprache
13. Parsing in C\#: all the tools and libraries you can use \- Federico Tomassetti, accessed May 3, 2026, https://tomassetti.me/parsing-in-csharp/
14. Something about iterating through UTF-16 Unicode strings (.NET, C\#) \- aleprojects.com, accessed May 3, 2026, https://aleprojects.com/en/doc/iterate-utf16
15. What is the difference between Rune and char in C\# when handling Unicode characters?, accessed May 3, 2026, https://stackoverflow.com/questions/76484814/what-is-the-difference-between-rune-and-char-in-c-sharp-when-handling-unicode-ch
16. Introduction to character encoding in .NET \- Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/dotnet/standard/base-types/character-encoding-introduction
17. How to use character encoding classes in .NET \- Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/dotnet/standard/base-types/character-encoding
18. System.Text.Rune class \- .NET \- Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/dotnet/fundamentals/runtime-libraries/system-text-rune
19. Rune struct \- DEV Community, accessed May 3, 2026, https://dev.to/entomy/rune-struct-b58
20. Designing the infrastructure persistence layer \- .NET | Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/infrastructure-persistence-layer-design
21. Facade with repository pattern. Handle simple requests \- Stack Overflow, accessed May 3, 2026, https://stackoverflow.com/questions/53169716/facade-with-repository-pattern-handle-simple-requests
22. Repository Pattern in the Context of Enterprise Architecture \- DEV Community, accessed May 3, 2026, https://dev.to/dylantv/repository-pattern-in-the-context-of-enterprise-architecture-4eb8
23. Enterprise Patterns for ASP.NET Core Minimal API: Repository Pattern \- Chris Woody Woodruff | Fractional Architect, accessed May 3, 2026, https://www.woodruff.dev/enterprise-patterns-for-asp-net-core-minimal-api-repository-pattern/
24. Understanding the Repository Pattern in C\# .NET with Examples | by Chandrashekhar Singh | Medium, accessed May 3, 2026, https://medium.com/@chandrashekharsingh25/understanding-the-repository-pattern-in-c-net-with-examples-51f02c4074ba
25. Vector datatype support in SqlClient \- ADO.NET Provider for SQL Server | Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/sql/connect/ado-net/sql/vector-data-sql-server?view=sql-server-ver17
26. LM Studio as a Local LLM API Server, accessed May 3, 2026, https://lmstudio.ai/docs/developer/core/server
27. Tutorial: Accessing a server compatible with OpenAI in LMStudio with C\# : r/devsarg \- Reddit, accessed May 3, 2026, https://www.reddit.com/r/devsarg/comments/1irarsq/tutorial\_accediendo\_a\_un\_servidor\_compatible\_con/?tl=en
28. OpenAI Compatibility Endpoints \- LM Studio, accessed May 3, 2026, https://lmstudio.ai/docs/developer/openai-compat
29. Embeddings | LM Studio, accessed May 3, 2026, https://lmstudio.ai/docs/developer/openai-compat/embeddings
30. OpenAI Compatible Providers: LM Studio \- AI SDK, accessed May 3, 2026, https://ai-sdk.dev/v4/providers/openai-compatible-providers/lmstudio
31. What is Similarity Between Sentences? \- Cohere, accessed May 3, 2026, https://cohere.com/llmu/what-is-similarity-between-sentences
32. What's New in SQL Server 2025 \- Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/sql/sql-server/what-s-new-in-sql-server-2025?view=sql-server-ver17
33. Vector Search & Vector Index \- SQL Server | Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/sql/sql-server/ai/vectors?view=sql-server-ver17
34. Embedding AI Models and Machine Learning Inside SQL Server 2025 – TrustedTech, accessed May 3, 2026, https://www.trustedtechteam.com/blogs/sql-server/ai-models-and-machine-learning-inside-sql-server-2025
35. From SQL Server 2008 R2 to SQL Server 2025: The Rise of SQL Server as a Vector Database | by Karunakar Kotha | Medium, accessed May 3, 2026, https://medium.com/@KarunaDataArchitect/from-sql-server-2008-r2-to-sql-server-2025-the-rise-of-sql-server-as-a-vector-database-b0d61817fc06
36. Vector Data Type \- SQL Server | Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/sql/t-sql/data-types/vector-data-type?view=sql-server-ver17
37. SQL Server Vector Data Type, Search, and Indexing \- DbVisualizer, accessed May 3, 2026, https://www.dbvis.com/thetable/sql-server-vector-data-type-search-and-indexing/
38. VECTOR\_DISTANCE (Transact-SQL) \- SQL Server | Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/sql/t-sql/functions/vector-distance-transact-sql?view=sql-server-ver17
39. Announcing Public Preview of DiskANN in SQL Server 2025 | Microsoft Community Hub, accessed May 3, 2026, https://techcommunity.microsoft.com/blog/sqlserver/announcing-public-preview-of-diskann-in-sql-server-2025/4414683
40. SQL-Server 2025: Vector Indexes & Semantic Search Performance \- dbi services, accessed May 3, 2026, https://www.dbi-services.com/blog/sql-server-2025-vector-indexes-semantic-search-performance/
41. CREATE VECTOR INDEX (Transact-SQL) \- SQL Server | Microsoft ..., accessed May 3, 2026, https://learn.microsoft.com/en-us/sql/t-sql/statements/create-vector-index-transact-sql?view=sql-server-ver17
42. Vector Search in SQL Server 2025: VECTOR data type and DiskANN \- Aleson ITC, accessed May 3, 2026, https://aleson-itc.com/en/vector-search-in-sql-server-2025-vector-data-type-and-diskann/
43. Comparing DiskANN in SQL Server & HNSW in RavenDB, accessed May 3, 2026, https://ravendb.net/articles/comparing-diskann-in-sql-server-hnsw-in-ravendb
44. SQL Server 2025 Benchmarking with Vector Database \- Microsoft Q\&A, accessed May 3, 2026, https://learn.microsoft.com/en-nz/answers/questions/5858575/sql-server-2025-benchmarking-with-vector-database
45. Microsoft SQL Server Database Provider \- Vector Search \- EF Core, accessed May 3, 2026, https://learn.microsoft.com/en-us/ef/core/providers/sql-server/vector-search