JustAnIota IOTA-1 Bidirectional Semantic Converter: Architecture of an Approximate Unicode-to-Meaning Embedding System

Full report

On this page

The translation of human language into structured machine data has historically been constrained by the pursuit of deterministic precision. The JustAnIota IOTA-1 Bidirectional Semantic Converter, positioned centrally within the Protocol5.com experimental paradigm, intentionally discards this constraint in favor of a nuanced, mathematically driven approximate equality.1 By architecting a comprehensive system that maps the entirety of the ISO/IEC 10646 standard (Unicode) against a highly curated English lexicon—specifically the Electronic Frontier Foundation (EFF) 7,776-word list—the architecture prioritizes semantic proximity over syntactic exactitude. The foundational, unalterable rule of this architecture dictates that linguistic mapping within continuous vector spaces is not an exercise in rigid arithmetic equivalence. A mapping of complex semantic weights is conceptually analogous to the equation 999 \+ 999 ≈ 1700\. The result is mathematically inexact, yet the directional, thematic "gist" of the meaning is captured, preserved, and made queryable.

Any theoretical objections, prevailing research, or established paradigms demanding precise, one-to-one linguistic equivalence are structurally incompatible with this system's ultimate goals and are consequently discarded in the architectural design. The prevailing literature frequently asserts that cross-lingual exactitude is impossible, and within the context of rigid translation, this is correct; however, the IOTA-1 system does not attempt exact translation. Therefore, suggestions against this approximate methodology are actively ignored. This exhaustive research report details the enterprise-grade C\#.NET architecture utilized for the Protocol5.com deployment, the SQL Server 2025/2026 AI Database integration, the local Large Language Model (LLM) implementation via LM Studio, and the highly optimized, non-relational PHP flat-file architecture designed for the JustAnIota.com WordPress deployment.

The Epistemology of Approximate Semantic Conversion

The core objective of the IOTA-1 architecture is to generate, store, and compare mathematical weights—known as embeddings—associated with public ISO/IEC 10646 characters and English anchor words from the EFF wordlist.1 By analyzing the cosine similarity between these high-dimensional continuous vectors, the system effectively isolates the underlying conceptual ideas embedded beneath the language itself. The system strictly and intentionally avoids any reliance on "versioned private-use profiles" or secret, proprietary dictionaries, as doing so would circumvent the purpose of utilizing a universally recognized, publicly available standard.1 The power of the system lies in the fact that it is completely language-neutral, leveraging symbols that represent ideas rather than strictly phonetic constructs.

In traditional natural language processing (NLP), character-level embedding is often deemed insufficient due to the presumed lack of context inherent in single characters. However, this architectural framework actively leverages the immense semantic density inherent in specific Unicode blocks, most notably the CJK (Chinese, Japanese, and Korean) Unified Ideographs and modern symbol blocks such as emojis.2 A single CJK ideograph, of which there are tens of thousands, often carries the semantic weight and complex meaning of an entire English phrase.3 By systematically iterating through the Unicode Character Database (UCD) and assigning dense vector embeddings to each character, the system creates a language-neutral semantic atlas.1

When an English word from the 7,776-word EFF list is vectorized, it serves as a fixed semantic anchor within this dimensional space. The conversion process from an idea to a symbol, or from a symbol back to an idea, relies entirely on calculating the vector distance between the English anchor and the Unicode character. The closest mathematical match provides an approximate translation of the underlying idea. This methodology recognizes that representations of meaning are inherently fluid. High-level semantics are treated as an emergent property of structural primitives rather than fixed definitions stored in a traditional relational dictionary.5 Consequently, the "gist" of the translation is extracted purely by comparing vector weights, establishing a paradigm where the approximate idea under the symbols can be compared to any language because the mathematical representation is inherently neutral.

The Universal Semantic Atlas: ISO/IEC 10646 and the EFF Wordlist

The theoretical underpinnings of the IOTA-1 converter depend intrinsically on mapping the vast structure of Unicode directly against the highly constrained EFF wordlist. This approach limits the English search space to 7,776 discrete concepts while opening the symbolic search space to the entirety of human written communication defined by the ISO standard.

Leveraging High-Density Unicode Blocks

The Unicode standard is meticulously organized into contiguous ranges of code points known as blocks, which share common linguistic properties, historical roots, or visual themes.6 The IOTA-1 system isolates blocks with exceptionally high semantic value, intentionally bypassing purely phonetic, control, or formatting characters that carry no independent conceptual weight.6 The CJK Unified Ideographs block is of primary, paramount importance to this architectural strategy, as it contains over 101,996 logograms that represent incredibly complex words, actions, or abstract concepts.2 Similarly, the Miscellaneous Symbols and Pictographs block contains modern visual semantics, commonly known as emojis, which carry widely understood, culturally transcendent meanings across linguistic borders.8 By generating vectors for these specific blocks, the system builds a repository of pure conceptual representations.

Constructing and Averaging the Mathematical Weights

The architecture operates under the strict directive that exact translation is an incorrect pursuit; the true objective is identifying directional meaning.1 When the database is initially populated, each targeted ISO character is passed to the local LLM to generate a dense floating-point vector.1 Simultaneously, the 7,776 words of the EFF wordlist are embedded into their own respective vectors.1

To extract meaning from multi-character input, or to aggregate concepts into a single representative symbol, the Logic Layer computes the weighted average of the word embeddings.11 In the mathematics of continuous vector spaces, adding or averaging dense vectors combines their underlying concepts.13 If the system is attempting to approximate a complex English sentence into a single ISO character, it averages the embeddings of the sentence's constituent EFF words, applies term frequency-inverse document frequency (TF-IDF) weighting if deemed necessary by the specific operational context, and projects that newly calculated vector into the dimensional space.11

The system then calculates the cosine similarity against the vast table of ISO character vectors.1 The closest resulting vectors represent the individual characters that best encapsulate the approximate, blended idea of the English text. The mathematical imprecision—the deliberate reality that 999 \+ 999 does not equal exactly 2000 in this continuous vector space, but rather approximates to 1700—is not a flaw to be corrected. It is the fundamental, driving mechanism that allows language-neutral ideas to bridge the immense gap between abstract graphical symbols and rigid, rule-based lexicons.

Enterprise C#.NET Architecture: The Protocol5.com Deployment

The primary computational engine driving the IOTA-1 Semantic Converter for the mathematical experiment site, Protocol5.com, is a robust, enterprise-level C\#.NET ecosystem. This backend infrastructure is carefully designed to isolate the profound complexities of AI inferences, string memory management, and advanced database operations from the front-end consumer applications.1

The Facade Pattern Implementation

At the extreme outer boundary of the C\# system sits the IJustAnIotaConverterFacade interface, which rigorously implements the Facade design pattern.1 In highly complex architectural systems involving volatile external dependencies—such as shifting local AI inference endpoints and rapidly evolving SQL Server topologies—the Facade pattern provides a critical Anti-Corruption Layer.16

The Facade entirely encapsulates the deeply complex internal workflows of string parsing, multi-threaded memory allocation, and external REST API invocation.1 Front-end applications hosted on Protocol5.com interact exclusively with this simplified, high-level API. If the underlying AI subsystem migrates from LM Studio to an entirely different local provider, or if the database schema evolves to leverage newer SQL Server 2026 AI features, the Facade meticulously shields the consuming web clients from these breaking structural changes.1 Furthermore, the interface abstraction is highly conducive to automated Continuous Integration and Continuous Deployment (CI/CD) pipelines, allowing software engineers to mock the IJustAnIotaConverterFacade and execute rapid unit tests on the core business logic without ever requiring a live instance of the resource-heavy AI infrastructure or the database.1

The Logic Layer and Cyclic Pathways

Situated immediately behind the Facade lies the Logic Layer, serving as the central nervous system of the IOTA-1 Converter. This vital layer orchestrates the cyclic, bidirectional pathways required to translate English text into ISO/IEC 10646 embeddings, and to seamlessly reverse the process from Unicode back to English.1

A highly specific and deeply technical architectural challenge addressed within the Logic Layer is the memory management of UTF-16 surrogate pairs within the.NET runtime environment.1 Standard iteration through strings using the default 16-bit char data type risks inadvertently severing surrogate pairs, effectively corrupting the semantic integrity of CJK ideographs, historic scripts, and complex emojis before they ever reach the embedding model.1 To completely circumvent this risk, the Logic Layer entirely abandons standard character arrays in favor of utilizing the System.Text.Rune struct.1

By implementing iterative logic powered specifically by the Rune.TryGetRuneAt() method, the system safely and deterministically advances its memory pointers by the correct Utf16SequenceLength.1 This structural guarantee ensures that multi-byte Unicode characters are passed into the local embedding pipeline fully intact, preserving the precise visual and semantic data required by the LLM to generate an accurate dimensional vector.1

Semantic Cache Optimization

Because non-deterministic AI inferences are computationally expensive and introduce unwanted, unpredictable latency, the Logic Layer implements a rigorous Semantic Cache Optimization routine.1 Before dispatching any embedding request to the local LLM or querying the database for a heavy vector calculation, the Logic Layer generates a normalized cryptographic fingerprint of the request.1

The system then evaluates cached historical matches based on strict mathematical thresholds. If the cache returns a historical match possessing a cosine similarity score exceeding 0.95, the system completely bypasses the generative AI processing phase.1 The cached result is returned instantly, drastically optimizing response times and significantly reducing the thermal and electrical load on the local hosting hardware.1 This mechanism explicitly supports the project's stated goal of enabling basic "gist of it" translation purely from the database once the metadata is sufficiently populated, entirely eliminating the need for real-time AI generation in repetitive querying scenarios.1

ADO.NET and the Repository Pattern

Data persistence within the.NET ecosystem is managed exclusively through the Repository Pattern, adhering strictly to the foundational tenets of Domain-Driven Design (DDD).1 The repository acts as an in-memory collection of domain objects, intentionally abstracting the raw data access code from the pure Logic Layer.1 This architectural separation ensures the core conversion logic remains completely agnostic to the underlying SQL syntax.

The data access layer utilizes the updated Microsoft.Data.SqlClient provider to interface directly with SQL Server 2025 and 2026 environments.22 Utilizing a dedicated repository ensures that complex vector queries, mapping routines, and transaction scopes are contained securely within the infrastructure layer, preventing database dependencies from leaking into the pristine domain logic.21

Persistence Layer: SQL Server 2025 and 2026 AI Features

The persistence architecture for the Protocol5.com implementation leverages the advanced AI database features introduced in the SQL Server 2025 preview and the SQL Server 2026 roadmap, specifically the native VECTOR data type and the highly optimized DiskANN indexing capabilities.19 The mandate to utilize two distinct tables—one for all ISO characters with their respective embeddings, and another for the EFF 7,776-wordlist with its embeddings—is executed seamlessly within this environment.

The Native Vector Data Type and Binary Transport

Historically, storing high-dimensional embeddings in relational SQL databases required converting floating-point arrays into bulky, inefficient JSON strings, which incurred severe parsing penalties during both read and write operations.23 SQL Server 2025 resolves this fundamental limitation by introducing an optimized binary format for fixed-dimension numeric embeddings, while still safely exposing them as JSON arrays for backward compatibility with legacy clients.23

The new VECTOR data type supports highly complex representations, ranging from 1 to 1998 dimensions, with each element stored efficiently as a single-precision (float32) or half-precision (float16) floating-point value.23 In the IOTA-1 system, the vectors representing the ISO/IEC 10646 characters and the EFF wordlist are stored in dedicated columns defined by this native syntax: column\_name VECTOR( { dimensions } ).23 Half-precision float16 vectors are specifically utilized where applicable to drastically reduce the storage footprint across the massive ISO database without materially sacrificing the accuracy of the approximate semantic match.23

The communication between the C\# Repository Layer and the SQL Server environment relies on the SqlVector\<T\> class introduced in Microsoft.Data.SqlClient version 6.1.22 This critical driver update modifies the Tabular Data Stream (TDS) protocol to support the direct transmission of vector data in a custom binary format.22 By utilizing binary transport rather than JSON string transmission, the system experiences radical performance enhancements. Empirical observations indicate an extraordinary 50x improvement in read speeds, a 3.3x improvement in write speeds, and a 19x improvement in bulk copy operations.22 For an architecture tasked with database-level semantic correlation across tens of thousands of ISO characters and 7,776 English anchors, this massive reduction in CPU processing load and memory allocation is an absolute mission-critical necessity.1

Vector Search Mechanisms: Exact vs. Approximate

The IOTA-1 converter requires the programmatic ability to compare the semantic weights of an input vector against the entire stored database to find the closest conceptual meaning. SQL Server 2025 and 2026 provide two distinct mechanisms for this, both of which are utilized dynamically by the Logic Layer depending on the specific operational context and the size of the queried dataset.

Exact Nearest Neighbors (ENN): The VECTOR\_DISTANCE function calculates the precise, absolute mathematical distance between two vectors without relying on an index.27 The IOTA-1 system primarily utilizes the cosine distance metric, which evaluates the angular distance between vectors on a scale of 0 to 2, where 0 indicates utterly identical vectors.27 Because exact searches require a full table scan and must calculate the distance against every single row, they are highly CPU-intensive and slow at scale.28 The architecture strictly restricts the use of VECTOR\_DISTANCE to filtered, constrained queries where the dataset size is pre-reduced via standard SQL predicates to under 50,000 vectors.28

Approximate Nearest Neighbors (ANN): For web-scale searches spanning the entire, un-filtered Unicode embedding database across hundreds of thousands of entries, the system utilizes the VECTOR\_SEARCH function, which is powered by the DiskANN algorithmic index.27 DiskANN is a sophisticated, graph-based indexing algorithm integrated deeply into the SQL Server engine that allows for ultra-fast vector retrieval while maintaining exceptionally high accuracy (achieving a recall rate of approximately 0.95).29 The algorithm is specifically designed to leverage fast SSD hardware, drastically reducing the traditional need to keep massive graph indexes entirely loaded in system RAM.29 The architectural roadmap for SQL Server 2026 indicates continued, aggressive enhancements to vector search performance, including tighter query optimizer integration, iterative filtering, and full insert/update/delete support without locking the table to read-only, ensuring the underlying database remains highly responsive to real-time AI experiences.19

Local AI Inferencing: The LM Studio Integration

A strict, uncompromising requirement of the IOTA-1 architecture is the ability to generate vectors entirely locally, permanently avoiding any operational dependence on external, cloud-based, proprietary AI APIs.1 To achieve this localized autonomy, the system seamlessly integrates a local LLM environment using LM Studio.1

Embedding Pipeline and Server Configuration

LM Studio operates internally as a local inference server, exposing an OpenAI-compatible REST API through the standard /v1/embeddings endpoint.32 By simply rerouting the base URL of the standard C\# AI SDKs within the.NET Facade—changing it from https://api.openai.com to http://localhost:1234/v1—the system effortlessly directs all text inputs to the local embedding model.32

The architecture strictly mandates the use of embedding-optimized models (such as nomic-embed-text or bge variants) rather than standard conversational or instruction-tuned models, which are poorly suited for dense vector generation.32 To aggressively minimize VRAM and system RAM consumption, the system prefers GGUF-quantized model variants. These variants compress the neural model weights mathematically without significantly degrading the dimensional quality of the resulting output embeddings.32

Tokenization Complexities and Non-Deterministic Extrapolation

When an arbitrary English string or an unmapped ISO/IEC 10646 character is processed by the system, the data is passed to the local LLM for tokenization.9 The Byte-Pair-Encoder (BPE) algorithm breaks down the text into manageable tokens. However, in the specific context of CJK Unified Ideographs, significant complexities arise. The standard cl100k\_base encoding frequently lacks the space to represent all 100,000+ CJK characters as single tokens. Consequently, a single character may be fragmented into two or three separate tokens.9 The LLM must process these fragmented tokens through its transformer architecture to generate a cohesive, high-dimensional continuous vector.9

This resulting vector captures the deep semantic properties of the input, transcending the visual symbol to grasp the underlying idea.10 If an English word from the EFF list is submitted, the generated vector is compared via cosine similarity against the pre-populated database table of ISO character embeddings. The result is a seamless bidirectional bridging of fundamentally distinct languages using continuous vector mathematics as the ultimate intermediary.

The Database-less Alternative: WordPress and PHP Flat-File Architecture

While the Protocol5.com deployment relies heavily on SQL Server 2025 and C\# for deterministic, enterprise-grade orchestration, the architecture dictates a highly divergent path for the JustAnIota.com deployment. To ensure the solution remains "cheap and easy" and fully compatible with standard, low-cost shared WordPress hosting environments that lack advanced vector databases, the architecture outlines a PHP-driven, completely database-less fallback model utilizing flat files and system RAM.1

WordPress Interactivity and SSRF Mitigation

The WordPress integration intentionally avoids housing the complex semantic engine directly within the CMS core.1 Instead, the user interface is constructed dynamically using server-registered custom blocks and the highly efficient Interactivity API introduced in WordPress 6.5.1 This modern approach avoids the immense processing overhead of thick Single Page Application (SPA) frameworks while maintaining an exceptionally responsive front-end user experience.1

When a user initiates a semantic query, the WordPress routing system captures the request via custom REST endpoints. These endpoints are protected by strict permission\_callback functions and utilize secure, cookie-based nonce authentication.1 The custom PHP layer then forwards this request to the backend processing logic. Because handling URL forwarding in PHP introduces severe Server-Side Request Forgery (SSRF) vulnerabilities, the system strictly implements wp\_safe\_remote\_post() rather than standard curl execution or the generic wp\_remote\_post().1 This specific function aggressively validates IP addresses, rejects local loopbacks, and sanitizes dangerous redirects before safely dispatching the payload.

High-Performance Binary Storage and RAM Optimization in PHP

To achieve vector similarity searches entirely within native PHP without a database, the system must overcome severe memory constraints inherent to the language. Loading tens of thousands of floating-point arrays representing Unicode characters into a standard PHP array quickly results in fatal memory exhaustion.15 A standard PHP array representation of just 10,000 high-dimensional vectors can easily consume over 715 MB of RAM, crashing standard hosting environments.15

To brilliantly solve this limitation, the architecture abandons standard arrays and relies on strict binary file layouts. Vector data is written directly to disk using PHP's native pack() function, which cleanly compresses floating-point data into a dense, machine-readable binary format.37

In the flat-file implementation, the 7,776 EFF English anchor words and the selected ISO character blocks are pre-embedded locally and saved directly into dense .bin files.1 When a semantic query is executed on the WordPress site, custom PHP utilizes fopen() and fread() to stream the binary data, and unpack() to decode the specific vector coordinates into temporary memory.37

For optimal cosine similarity computation, the system adamantly avoids loading the entire matrix into memory simultaneously.41 Instead, it uses a lazy-loading strategy, reading vectors in small chunks, rapidly computing the Euclidean distance or dot product against the query vector, maintaining a running tally of the top nearest neighbors, and immediately discarding the rest from memory to keep the RAM footprint minuscule.36

Pure PHP Vector Database Paradigms

This architectural approach aligns conceptually with pure-PHP embedded vector database concepts (such as the Vektor or MemVector libraries) which achieve zero-RAM overhead by utilizing the Hierarchical Navigable Small World (HNSW) algorithm directly on disk.39 By mapping graph connections and metadata directly into binary files, the PHP script can perform hyper-optimized disk-seeking strategies to traverse the graph and find approximate nearest neighbors without any external dependencies, networking latency, or C-extensions.39 This completely fulfills the project's requirement to operate seamlessly within a basic, cheap WordPress/PHP stack without relying on SQL Server 2026 or costly cloud infrastructure.

Vector Mathematics and the Bidirectional Workflow

The practical application of the IOTA-1 converter on the Protocol5.com mathematical experiment site relies on executing the English-to-ISO-to-English workflow using pure continuous vector mathematics. The system evaluates the proximity of ideas by calculating distances between vectors representing characters and words.

Averaging Embeddings and Semantic Proximity

When a user submits a phrase containing multiple words, the system isolates each word, verifies it against the EFF 7,776 wordlist, and retrieves the corresponding pre-calculated vectors from the SQL Server database. To derive the overarching meaning of the phrase, the Logic Layer calculates a weighted average of these word embeddings.11 This mathematical aggregation effectively blends the distinct concepts into a single, unified vector that represents the holistic idea of the phrase.13

This aggregated vector is then compared against the ISO/IEC 10646 table. By executing a cosine similarity search, the system measures the angle between the aggregated phrase vector and every Unicode character vector.27 The characters with the smallest angular distance (closest to 0\) are identified as the most semantically proximate. This results in the identification of a CJK ideograph or emoji that most accurately encapsulates the broad idea of the original English phrase.

Bypassing AI for Database-Driven Meaning

The architectural directive requires the ability to query meanings without the use of active AI once the database is populated. Because the embeddings for both the ISO characters and the EFF wordlist are persistently stored in their respective tables (or binary flat files in the PHP version), the system can function purely as a massive mathematical lookup table.1

If a user inputs a known Unicode character, the system retrieves its vector from the database and performs a VECTOR\_SEARCH against the EFF wordlist table. The nearest English words are returned instantly. This provides a "gist of it" translation that completely bypasses the local LLM.1 While live AI generation provides superior contextual nuance for entirely novel inputs, the pre-populated database allows for instantaneous, highly accurate approximate translations based entirely on historical vector weights. This guarantees that the system can scale infinitely without being bottlenecked by the inference speed of the local LM Studio instance.

Systemic Implications and Conclusions

The JustAnIota IOTA-1 Bidirectional Semantic Converter radically redefines the parameters of linguistic mapping by fully embracing the ambiguity inherent in language and modeling it mathematically through high-dimensional continuous vectors. By strictly enforcing the rule that exact translation is an impossible and unnecessary pursuit, the architecture succeeds in proving that the directional "gist" of a meaning can be quantified, stored, and navigated across any language barrier.

The enterprise architecture deployed on Protocol5.com leverages a rigorous C\#.NET environment, expertly utilizing the Facade and Repository patterns to manage the highly complex orchestration of deterministic data handling and non-deterministic AI inferences. By exploiting the very latest innovations slated for SQL Server 2025 and 2026—including the native VECTOR data type, hyper-efficient binary transport via the updated TDS protocol, and DiskANN indexing—the system achieves unparalleled vector persistence and retrieval capabilities. This robust ecosystem allows the system to cross-reference over 100,000 Unicode characters against 7,776 English semantic anchors in milliseconds.

Concurrently, the project successfully theorizes, outlines, and implements a completely disparate, highly cost-effective architectural fallback for WordPress environments on JustAnIota.com. By entirely abandoning relational databases in favor of strict binary flat files manipulated via PHP's native pack() and unpack() operations, the system achieves an incredibly lightweight memory footprint. This innovative, memory-efficient architecture proves that advanced semantic searches, binary quantization, and AI-driven vector comparisons can be fully democratized and deployed on standard, low-cost shared hosting infrastructure without sacrificing the core functionality of the semantic converter.

Ultimately, by leveraging the public ISO/IEC 10646 standard as a universal, language-neutral anchor, and treating embeddings not as rigid meaning containers but as structural primitives of thought, the IOTA-1 architecture successfully demonstrates a scalable, highly resilient framework for approximate semantic translation.

Works cited

1. Protocol5.com\_ Language Embedding Architecture.md
2. CJK Unified Ideographs \- Wikipedia, accessed May 3, 2026, https://en.wikipedia.org/wiki/CJK\_Unified\_Ideographs
3. Chapter 18 – Unicode 17.0.0, accessed May 3, 2026, https://unicode.org/versions/Unicode17.0.0/core-spec/chapter-18/
4. UAX \#44: Unicode Character Database, accessed May 3, 2026, https://www.unicode.org/reports/tr44/
5. Emergent Semantics Beyond Token Embeddings: Transformer LMs with Frozen Visual Unicode Representations \- arXiv, accessed May 3, 2026, https://arxiv.org/html/2507.04886v4
6. Unicode character property \- Wikipedia, accessed May 3, 2026, https://en.wikipedia.org/wiki/Unicode\_character\_property
7. Unicode block \- Wikipedia, accessed May 3, 2026, https://en.wikipedia.org/wiki/Unicode\_block
8. Unicode Exploits Are Compromising Application Security \- Prompt Security, accessed May 3, 2026, https://prompt.security/blog/unicode-exploits-are-compromising-application-security
9. Working with Chinese, Japanese, and Korean text in Generative AI pipelines, accessed May 3, 2026, https://tonybaloney.github.io/posts/cjk-chinese-japanese-korean-llm-ai-best-practices.html
10. A Guide to LLM Embeddings \- The Couchbase Blog, accessed May 3, 2026, https://www.couchbase.com/blog/llm-embeddings/
11. What does a weighted word embedding mean? \- Stack Overflow, accessed May 3, 2026, https://stackoverflow.com/questions/47727078/what-does-a-weighted-word-embedding-mean
12. Task-Optimized Word Embeddings for Text Classification Representations \- Frontiers, accessed May 3, 2026, https://www.frontiersin.org/journals/applied-mathematics-and-statistics/articles/10.3389/fams.2019.00067/full
13. What Are Word and Sentence Embeddings? | Cohere Blog, accessed May 3, 2026, https://cohere.com/llmu/sentence-word-embeddings
14. Why is it Okay to Average Embeddings? \- Randorithms, accessed May 3, 2026, https://randorithms.com/2020/11/17/Adding-Embeddings.html
15. MemVector: Vector Search, Embeddings and RAG in a PHP Extension \- Open Swoole, accessed May 3, 2026, https://openswoole.com/article/ext-memvector-local-vector-ai-for-php
16. Anti-corruption Layer pattern \- Azure Architecture Center | Microsoft Learn, accessed May 3, 2026, https://learn.microsoft.com/en-us/azure/architecture/patterns/anti-corruption-layer
17. Facade Design Pattern in C\#: Complete Guide with Examples \- Dev Leader, accessed May 3, 2026, https://www.devleader.ca/2026/04/26/facade-design-pattern-in-c-complete-guide-with-examples
18. Facade Design Pattern In C\# \- C\# Corner, accessed May 3, 2026, https://www.c-sharpcorner.com/article/facade-design-pattern-using-c-sharp/
19. Advancing agentic AI with Microsoft databases across a unified data estate \- Microsoft SQL Server Blog, accessed May 3, 2026, https://www.microsoft.com/en-us/sql-server/blog/2026/03/18/advancing-agentic-ai-with-microsoft-databases-across-a-unified-data-estate/
20. How to implement facade patterns in .NET C\# \- YouTube, accessed May 3, 2026, https://www.youtube.com/watch?v=I\_dCLKESc6g
21. Repository Pattern C\# ultimate guide: Entity Framework Core, Clean Architecture, DTOs, Dependency Injection, CQRS \- Medium, accessed May 3, 2026, https://medium.com/@codebob75/repository-pattern-c-ultimate-guide-entity-framework-core-clean-architecture-dtos-dependency-6a8d8b444dcb
22. Introduction to Microsoft.Data.SqlClient Namespace \- ADO.NET Provider for SQL Server, accessed May 3, 2026, https://learn.microsoft.com/en-us/sql/connect/ado-net/introduction-microsoft-data-sqlclient-namespace?view=sql-server-ver17
23. 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
24. Is the Repository Pattern a must-have, or is it just extra code? \- Reddit, accessed May 3, 2026, https://www.reddit.com/r/dotnet/comments/1ifkt8t/is\_the\_repository\_pattern\_a\_musthave\_or\_is\_it/
25. SQL Server 2025 CTP 2.1: DiskANN Improvements \- Microsoft Dev Blogs, accessed May 3, 2026, https://devblogs.microsoft.com/azure-sql/sql-server-2025-ctp-2-1-diskann-improvements/
26. 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
27. 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
28. 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
29. 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/
30. 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
31. SQL Server 2025 vector index limitations question : r/SQLServer \- Reddit, accessed May 3, 2026, https://www.reddit.com/r/SQLServer/comments/1mf0j9n/sql\_server\_2025\_vector\_index\_limitations\_question/
32. LM Studio Text Embedding: Local Embeddings with Open-Source Models, accessed May 3, 2026, https://www.hakunamatatatech.com/our-resources/blog/lm-studio-text-embedding
33. LM Studio as a Local LLM API Server, accessed May 3, 2026, https://lmstudio.ai/docs/developer/core/server
34. OpenAI Compatibility Endpoints \- LM Studio, accessed May 3, 2026, https://lmstudio.ai/docs/developer/openai-compat
35. Embedding | LM Studio, accessed May 3, 2026, https://lmstudio.ai/docs/python/embedding
36. PHP Memory Optimization Tips \- Medium, accessed May 3, 2026, https://medium.com/@khouloud.haddad/php-memory-optimization-tips-f362144b9ce4
37. NodeJS & PHP pack() and unpack() Functions Explained | by Sergiu Gordienco \- Medium, accessed May 3, 2026, https://medium.com/@sergiu.gordienco/nodejs-php-pack-and-unpack-functions-explained-aa48e8db2155
38. Handling binary data in PHP with pack() and unpack() \- adayinthelifeof.nl, accessed May 3, 2026, https://adayinthelifeof.nl/2010/01/14/handling-binary-data-in-php-with-pack-and-unpack/
39. centamiv/vektor: A native PHP Vector Database implementation with strict binary storage and Zero-RAM overhead. \- GitHub, accessed May 3, 2026, https://github.com/centamiv/vektor
40. unpack \- Manual \- PHP, accessed May 3, 2026, https://www.php.net/manual/en/function.unpack.php
41. Cosine similarity for very large dataset \- python \- Stack Overflow, accessed May 3, 2026, https://stackoverflow.com/questions/53875473/cosine-similarity-for-very-large-dataset
42. Fast and Accurate Vector Similarity Search in Native MySQL | by Dj Luiting | Medium, accessed May 3, 2026, https://medium.com/@dj.luiting/fast-and-accurate-vector-similarity-search-in-native-mysql-there-are-many-existing-specialized-0646ded2a565
43. MemVector: Local Vector API, Storage & Embedding Engine for PHP \- GitHub, accessed May 3, 2026, https://github.com/memvector/ext-memvector