feat: Enhance server configuration with HTTP gateway and tiered memory settings

- Added HTTP gateway module to the server for improved request handling.
- Updated tiered memory configuration with new parameters: lower_watermark and promotion_cooldown_ms.
- Adjusted physical memory limit in logs and tests to reflect new settings.
- Enhanced schema serialization for MorpheusSchema to support new features.

Author: shisoft

.gitignore

@@ -128,4 +128,8 @@ perf.data*
 *.onnx_data
 
 
-nohup.out
+# Heaptrack profiling dumps
+heaptrack.*.zst
+
+
+nohup.out

HTTP_API.md

@@ -0,0 +1,196 @@
+# Morpheus HTTP API
+
+Base URL: `http://127.0.0.1:8080` (default)
+
+Environment:
+- `MORPHEUS_HTTP_ADDR`: bind address (default `127.0.0.1:8080`)
+- `MORPHEUS_HTTP_ADMIN_TOKEN`: when set, admin endpoints require `Authorization: Bearer <token>`
+- `MORPHEUS_HTTP_CORS=permissive`: enable permissive CORS
+
+## Response and Errors
+
+Success response:
+```json
+{ "data": { ... } }
+```
+
+Error response:
+```json
+{ "code": "...", "message": "..." }
+```
+
+## ID Format
+
+Cell, vertex, edge IDs are base58-encoded 16-byte IDs. The server returns base58 strings for IDs.
+
+## Data Encoding
+
+Graph vertex data and edge body use JSON objects (maps). Cell data accepts a generic `HttpValue`.
+
+### Map
+```json
+{ "k": "v" }
+```
+
+### Array
+```json
+[1, 2, 3]
+```
+
+### Typed Values
+Use `{"$type": "...", "value": ...}` for non-JSON or specific types.
+
+Examples:
+```json
+{"$type":"u64","value":123}
+{"$type":"id","value":"5QqkMJFr5s7J9wB8Q2kN1J"}
+{"$type":"bytes","value":[1,2,3]}
+{"$type":"u32[]","value":[1,2,3]}
+```
+
+Supported `$type` values:
+- `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`, `f32`, `f64`
+- `char`, `string`, `bool`, `na`
+- `id` (base58 string value)
+- `bytes`, `small_bytes` (array of byte numbers)
+- `map`, `array`
+- `bool[]`, `char[]`, `i8[]`, `i16[]`, `i32[]`, `i64[]`, `u8[]`, `u16[]`, `u32[]`, `u64[]`,
+  `f32[]`, `f64[]`, `pos2d32[]`, `pos2d64[]`, `pos3d32[]`, `pos3d64[]`, `id[]`, `string[]`,
+  `bytes[]`, `small_bytes[]`
+
+Notes:
+- Untagged numbers are interpreted as `i64`, `u64`, or `f64` depending on JSON parsing.
+- `id` decoding also accepts `{ "higher": <u64>, "lower": <u64> }` for backward compatibility, but responses return base58 strings.
+
+## Health
+
+`GET /v1/health`
+
+Response:
+```json
+{ "data": {} }
+```
+
+## Graph Schemas (Morpheus)
+
+`GET /v1/graph/schemas`
+
+`GET /v1/graph/schemas/:name`
+
+`POST /v1/graph/schemas` (admin)
+
+Request:
+```json
+{
+  "id": 0,
+  "name": "my_vertex",
+  "schema_type": "Vertex",
+  "key_field": null,
+  "fields": [],
+  "is_dynamic": true
+}
+```
+
+Edge schema example:
+```json
+{
+  "name": "my_edge",
+  "schema_type": {
+    "Edge": {
+      "edge_type": "Directed",
+      "has_body": true
+    }
+  },
+  "fields": [],
+  "is_dynamic": true
+}
+```
+
+`DELETE /v1/graph/schemas/:name` (admin)
+
+## Cell Schemas (Neb)
+
+`GET /v1/cell/schemas`
+
+`GET /v1/cell/schemas/:name`
+
+`POST /v1/cell/schemas` (admin)
+
+Request:
+```json
+{
+  "id": 0,
+  "name": "my_cell",
+  "key_field": null,
+  "fields": [],
+  "is_dynamic": true,
+  "is_scannable": false
+}
+```
+
+`DELETE /v1/cell/schemas/:name` (admin)
+
+## Graph Operations
+
+`POST /v1/graph/vertices` (admin)
+
+Request by schema name:
+```json
+{
+  "schema_name": "my_vertex",
+  "data": {}
+}
+```
+
+Request by schema id:
+```json
+{
+  "schema_id": 42,
+  "data": {},
+  "id": "5QqkMJFr5s7J9wB8Q2kN1J"
+}
+```
+
+`GET /v1/graph/vertices/:id`
+
+`DELETE /v1/graph/vertices/:id` (admin)
+
+`POST /v1/graph/edges` (admin)
+
+Request:
+```json
+{
+  "from_id": "5QqkMJFr5s7J9wB8Q2kN1J",
+  "to_id": "3Yv8v4Cw1W5Hk9p2LxQw9Q",
+  "schema_name": "my_edge",
+  "body": {}
+}
+```
+
+`GET /v1/graph/vertices/:id/edges?schema=<name-or-id>&direction=outbound|inbound|undirected`
+
+## Cell CRUD
+
+All cell CRUD endpoints require admin token when `MORPHEUS_HTTP_ADMIN_TOKEN` is set.
+
+`GET /v1/cells/:id`
+
+`POST /v1/cells/:id`
+
+`PUT /v1/cells/:id`
+
+`DELETE /v1/cells/:id`
+
+Request (POST/PUT):
+```json
+{
+  "schema_id": 123,
+  "data": {}
+}
+```
+
+## Legacy Schema Endpoints
+
+These map to graph schema reads:
+- `GET /v1/schemas`
+- `GET /v1/schemas/:name`

crates/morpheus-http-client/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "morpheus-http-client"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.85"
+
+[lints.rust]
+unsafe_code = "warn"
+
+[lints.clippy]
+all = "warn"
+pedantic = "warn"
+
+[dependencies]
+reqwest = { version = "0.12", features = ["json"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+url = "2"
+bs58 = "0.5"
+
+[dev-dependencies]
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

crates/morpheus-http-client/src/error.rs

@@ -0,0 +1,79 @@
+use std::fmt;
+
+use reqwest::header::InvalidHeaderValue;
+use url::ParseError;
+
+use crate::types::ApiErrorBody;
+
+#[derive(Debug, Clone)]
+pub struct ApiError {
+    pub status: u16,
+    pub body: ApiErrorBody,
+}
+
+impl fmt::Display for ApiError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "api error {}: {}: {}",
+            self.status, self.body.code, self.body.message
+        )
+    }
+}
+
+impl std::error::Error for ApiError {}
+
+#[derive(Debug)]
+pub enum ClientError {
+    InvalidUrl(ParseError),
+    InvalidHeaderValue(InvalidHeaderValue),
+    Http(reqwest::Error),
+    Api(ApiError),
+    InvalidArgument(String),
+}
+
+impl ClientError {
+    pub fn invalid_url(e: ParseError) -> Self {
+        Self::InvalidUrl(e)
+    }
+
+    pub fn invalid_header_value(e: InvalidHeaderValue) -> Self {
+        Self::InvalidHeaderValue(e)
+    }
+
+    pub fn http(e: reqwest::Error) -> Self {
+        Self::Http(e)
+    }
+
+    pub fn api(err: ApiError) -> Self {
+        Self::Api(err)
+    }
+
+    pub fn invalid_argument(msg: impl Into<String>) -> Self {
+        Self::InvalidArgument(msg.into())
+    }
+}
+
+impl fmt::Display for ClientError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ClientError::InvalidUrl(e) => write!(f, "invalid base url: {e}"),
+            ClientError::InvalidHeaderValue(e) => write!(f, "invalid header value: {e}"),
+            ClientError::Http(e) => write!(f, "http error: {e}"),
+            ClientError::Api(e) => write!(f, "{e}"),
+            ClientError::InvalidArgument(msg) => write!(f, "invalid argument: {msg}"),
+        }
+    }
+}
+
+impl std::error::Error for ClientError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            ClientError::InvalidUrl(e) => Some(e),
+            ClientError::InvalidHeaderValue(e) => Some(e),
+            ClientError::Http(e) => Some(e),
+            ClientError::Api(e) => Some(e),
+            ClientError::InvalidArgument(_) => None,
+        }
+    }
+}