ELIPS domain types define the data structures and exception types used throughout the native C++ engine.

Overview

Domain types live in the elips:: namespace and are declared under headers in elips/domain/.

RecordID

cpp

using RecordID = std::uint64_t;

Records in ELIPS are uniquely identified by a 64-bit unsigned integer RecordID. If an explicit ID is omitted during insertion, the engine assigns an auto-incrementing 64-bit key.

Vector

cpp

using Vector = std::vector<float>;

Dense vector embeddings are represented as 32-bit floating point vectors (std::vector<float>).

Payload

cpp

using PayloadValue = std::variant<
    std::int64_t,
    double,
    std::string,
    bool,
    std::vector<std::string>
>;

using Payload = std::map<std::string, PayloadValue>;

Metadata attributes associated with a vector record are stored in a key-value map supporting primitive scalar types and string arrays.

Record

cpp

struct Record {
    RecordID id{0};
    Vector vector;
    Payload payload;
    std::optional<DocumentAttachment> document;
    std::optional<ChunkInfo> chunk;
    std::optional<EmbeddingLineage> lineage;
};

SearchResult

cpp

struct SearchResult {
    RecordID id{0};
    float distance{0.0f};
    float score{0.0f};
    Record record;
};

Vector similarity search returns SearchResult instances containing distance metrics, similarity scores, and hydrated Record payloads.

Domain Attachments

cpp

struct DocumentAttachment {
    std::string text;
    std::string mime_type{"text/plain"};
};

struct ChunkInfo {
    std::size_t index{0};
    std::size_t start_char{0};
    std::size_t end_char{0};
};

struct EmbeddingLineage {
    std::string model_name;
    std::uint32_t dimension{0};
};

C++ Exception Hierarchy

cpp

namespace elips {
    class ElipsException : public std::runtime_error;
    class ValidationException : public ElipsException;
    class LockConflictException : public ElipsException;
    class TransactionException : public ElipsException;
    class DiskException : public ElipsException;
    class GpuException : public ElipsException;
}

All C++ exceptions derive from elips::ElipsException. Catching ElipsException guarantees catching all engine-thrown runtime errors.