Struct Embedding 

pub struct Embedding {
    pub data_point_id: Uuid,
    pub data_type: String,
    pub field_name: String,
    pub vector: Vec<f32>,
}

Embedding vector for a data point field.

Each embedding represents a specific field (e.g., “text”, “name”) of a data point (e.g., DocumentChunk, Entity) as a dense vector.

Examples

use cognee_models::Embedding;
use uuid::Uuid;

let chunk_id = Uuid::new_v4();
let embedding = Embedding::new(
    chunk_id,
    "DocumentChunk",
    "text",
    vec![0.1, 0.2, 0.3], // Dense vector
);

assert_eq!(embedding.dimensions(), 3);
assert_eq!(embedding.field_name, "text");

Fields

data_point_id: Uuid

UUID of the data point this embedding belongs to

data_type: String

Type of the data point (e.g., “DocumentChunk”, “Entity”, “TextSummary”)

field_name: String

Name of the field that was embedded (e.g., “text”, “name”, “content”)

vector: Vec<f32>

Dense embedding vector (f32 for compatibility with most vector DBs)

Implementations

impl Embedding

pub fn new( data_point_id: Uuid, data_type: impl Into<String>, field_name: impl Into<String>, vector: Vec<f32>, ) -> Self

Create a new embedding.

Arguments

• data_point_id - UUID of the source data point
• data_type - Type discriminator (e.g., “DocumentChunk”)
• field_name - Field that was embedded (e.g., “text”)
• vector - Dense embedding vector (usually 384, 768, or 1536 dimensions)

pub fn dimensions(&self) -> usize

Get the dimensionality of the embedding vector.

pub fn norm(&self) -> f32

Calculate L2 norm of the embedding (should be ~1.0 if normalized).

pub fn cosine_similarity(&self, other: &Embedding) -> Option<f32>

Calculate cosine similarity with another embedding.

Both embeddings must be normalized (L2 norm = 1.0). Returns dot product in range [-1.0, 1.0].

Trait Implementations

impl Clone for Embedding

fn clone(&self) -> Embedding

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Embedding

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Embedding

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Embedding

fn eq(&self, other: &Embedding) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Embedding

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Embedding