Skip to content
EN FR

Embeddings and Conceptual Search

Documentation status: architecture — see Maturity and evidence.

logiCells uses embeddings as a numerical projection of conceptual memory. The current engine does more than store vectors: it keeps an explicit association between a conceptual value and its vector representation, can index those vectors with HNSW, and can map numerical search results back to symbolic identities.

The important boundary is:

conceptual value
    <-> embedding registry <-> vector
                               |
                               v
                            HNSW index
                               |
                               v
                     numerical candidates
                               |
                 symbolic filters / reranking
                               |
                               v
                     conceptual candidates

A vector is therefore not a replacement for a concept. It is a searchable numerical representation whose relationship to the conceptual value remains explicit.

What the current engine supports

  • bidirectional conceptual-value ↔ embedding-vector registration;
  • named embedding registries isolated from one another;
  • persistent HNSW indexes stored with the hypergraph;
  • scored K-nearest-neighbor retrieval;
  • conversion of HNSW hits back to conceptual values;
  • hard filtering by conceptual Kind / instance compatibility;
  • composite queries built from several weighted embedding terms;
  • candidate generation either from one composed query vector or by fusing per-term neighborhoods;
  • pluggable numerical reranking while symbolic filters retain authority over admissibility.

These capabilities are verified in the current engine source and tests. The pages in this section describe their architecture and semantics; they do not expose private implementation classes as a public SDK contract.

Semantic rule

Vector distance can rank candidates. It does not prove a fact, establish a type, or override symbolic constraints. When a query requires a conceptual kind, that kind can be enforced as a hard symbolic filter after numerical candidate generation.