> ## Documentation Index
> Fetch the complete documentation index at: https://engramdb.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# MemoryNode API Reference

> Detailed reference for the MemoryNode API

# MemoryNode API Reference

The `MemoryNode` is the fundamental unit of storage in EngramDB. This document provides a detailed reference for the `MemoryNode` API.

## Creating a Memory Node

### `MemoryNode::new(embeddings)`

Creates a new memory node with the given embeddings.

**Parameters:**

* `embeddings`: `Vec<f32>` - Vector representation of the memory content

**Returns:**

* A new `MemoryNode` with a generated UUID and initialized fields

**Example:**

```rust theme={null}
let embeddings = vec![0.1, 0.2, 0.3, 0.4];
let memory = MemoryNode::new(embeddings);
```

## Basic Properties

### `id()`

Returns the unique identifier of this memory node.

**Returns:**

* `Uuid` - The unique identifier

**Example:**

```rust theme={null}
let id = memory.id();
println!("Memory ID: {}", id);
```

### `embeddings()`

Returns a reference to the vector embeddings.

**Returns:**

* `&[f32]` - Reference to the embeddings vector

**Example:**

```rust theme={null}
let embeddings = memory.embeddings();
println!("Embeddings: {:?}", embeddings);
```

### `set_embeddings(embeddings)`

Sets the embeddings to a new value.

**Parameters:**

* `embeddings`: `Vec<f32>` - New vector embeddings

**Example:**

```rust theme={null}
let new_embeddings = vec![0.2, 0.3, 0.4, 0.5];
memory.set_embeddings(new_embeddings);
```

### `creation_timestamp()`

Returns the creation timestamp.

**Returns:**

* `u64` - Unix timestamp when the memory was created

**Example:**

```rust theme={null}
let timestamp = memory.creation_timestamp();
println!("Created at: {}", timestamp);
```

## Working with Attributes

### `attributes()`

Returns a reference to all attributes.

**Returns:**

* `&HashMap<String, AttributeValue>` - Reference to the attributes map

**Example:**

```rust theme={null}
let attributes = memory.attributes();
println!("All attributes: {:?}", attributes);
```

### `get_attribute(key)`

Gets the value of a specific attribute.

**Parameters:**

* `key`: `&str` - The attribute key to retrieve

**Returns:**

* `Option<&AttributeValue>` - The attribute value, or None if not found

**Example:**

```rust theme={null}
if let Some(value) = memory.get_attribute("importance") {
    println!("Importance: {:?}", value);
}
```

### `set_attribute(key, value)`

Sets an attribute.

**Parameters:**

* `key`: `String` - The attribute key
* `value`: `AttributeValue` - The attribute value

**Example:**

```rust theme={null}
memory.set_attribute(
    "title".to_string(),
    AttributeValue::String("Important memory".to_string())
);

memory.set_attribute(
    "importance".to_string(),
    AttributeValue::Float(0.8)
);
```

## Working with Connections

### `connections()`

Returns a reference to all connections.

**Returns:**

* `&Vec<Connection>` - Reference to the connections vector

**Example:**

```rust theme={null}
let connections = memory.connections();
println!("Number of connections: {}", connections.len());
```

### `add_connection(connection)`

Adds a connection to another memory node.

**Parameters:**

* `connection`: `Connection` - The connection to add

**Example:**

```rust theme={null}
let target_id = Uuid::new_v4();
let connection = Connection::new(
    target_id,
    RelationshipType::Association,
    0.75
);
memory.add_connection(connection);
```

### `remove_connection(target_id)`

Removes a connection to the specified target.

**Parameters:**

* `target_id`: `Uuid` - The ID of the target memory node

**Returns:**

* `bool` - True if a connection was removed, false otherwise

**Example:**

```rust theme={null}
let removed = memory.remove_connection(target_id);
if removed {
    println!("Connection removed");
}
```

## Working with Temporal Layers

### `temporal_layers()`

Returns a reference to all temporal layers.

**Returns:**

* `&Vec<TemporalLayer>` - Reference to the temporal layers vector

**Example:**

```rust theme={null}
let layers = memory.temporal_layers();
println!("Number of temporal layers: {}", layers.len());
```

### `add_temporal_layer(layer)`

Adds a temporal layer to track changes to this memory.

**Parameters:**

* `layer`: `TemporalLayer` - The temporal layer to add

**Example:**

```rust theme={null}
let layer = TemporalLayer::new(
    Some(old_embeddings),
    Some(old_attributes),
    "Updated with new information".to_string()
);
memory.add_temporal_layer(layer);
```

## Access Patterns

### `access_patterns()`

Returns a reference to the access patterns.

**Returns:**

* `&AccessHistory` - Reference to the access history

**Example:**

```rust theme={null}
let access_history = memory.access_patterns();
println!("Access count: {}", access_history.access_count());
```

### `record_access()`

Records an access to this memory node.

**Example:**

```rust theme={null}
memory.record_access();
```

## AttributeValue Types

The `AttributeValue` enum represents different types of values that can be stored as attributes:

```rust theme={null}
pub enum AttributeValue {
    String(String),
    Integer(i64),
    Float(f64),
    Boolean(bool),
    List(Vec<AttributeValue>),
    Map(std::collections::HashMap<String, AttributeValue>),
}
```

**Example:**

```rust theme={null}
// String attribute
memory.set_attribute(
    "title".to_string(),
    AttributeValue::String("Meeting notes".to_string())
);

// Integer attribute
memory.set_attribute(
    "priority".to_string(),
    AttributeValue::Integer(1)
);

// Float attribute
memory.set_attribute(
    "confidence".to_string(),
    AttributeValue::Float(0.95)
);

// Boolean attribute
memory.set_attribute(
    "is_important".to_string(),
    AttributeValue::Boolean(true)
);

// List attribute
memory.set_attribute(
    "tags".to_string(),
    AttributeValue::List(vec![
        AttributeValue::String("work".to_string()),
        AttributeValue::String("project".to_string())
    ])
);

// Map attribute
let mut map = std::collections::HashMap::new();
map.insert("name".to_string(), AttributeValue::String("John".to_string()));
map.insert("age".to_string(), AttributeValue::Integer(30));

memory.set_attribute(
    "person".to_string(),
    AttributeValue::Map(map)
);
```