# Resource Memory

Every registered resource memory instance operation, with source-derived inputs, outputs, access policy, and errors.

Source: https://docs.minds.sh/docs/api/instance/resource-memory



This reference covers **10 HTTP operations** registered by the Akasha daemon. Call these paths on your instance base URL. See [authentication](/docs/api/instance/authentication), [errors](/docs/api/instance/errors), and [coverage](/docs/api/instance/coverage) before integrating.

| Method | Path                               | Operation                                                     |
| ------ | ---------------------------------- | ------------------------------------------------------------- |
| `POST` | `/v1/memory/resources`             | [Memory resource store](#post-v1-memory-resources)            |
| `GET`  | `/v1/memory/resources/list`        | [Resource list](#get-v1-memory-resources-list)                |
| `POST` | `/v1/memory/resources/get`         | [Resource get](#post-v1-memory-resources-get)                 |
| `POST` | `/v1/memory/resources/data`        | [Resource data](#post-v1-memory-resources-data)               |
| `POST` | `/v1/memory/resources/data/exists` | [Resource data exists](#post-v1-memory-resources-data-exists) |
| `POST` | `/v1/memory/resources/data/size`   | [Resource data size](#post-v1-memory-resources-data-size)     |
| `POST` | `/v1/memory/resources/type`        | [Resource by type](#post-v1-memory-resources-type)            |
| `POST` | `/v1/memory/resources/access`      | [Resource record access](#post-v1-memory-resources-access)    |
| `POST` | `/v1/memory/resources/usage`       | [Resource usage](#post-v1-memory-resources-usage)             |
| `POST` | `/v1/memory/resources/chunks`      | [Resource chunks](#post-v1-memory-resources-chunks)           |

<a id="post-v1-memory-resources" />

## POST `/v1/memory/resources` [#post-v1memoryresources]

Memory resource store

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request]

**Json** — `ResourceStoreRequest`

| Field      | Rust type      | Required on input | Notes |
| ---------- | -------------- | ----------------- | ----- |
| `resource` | `ResourceItem` | Yes               |       |
| `data_b64` | `String`       | Yes               |       |

```rust
struct ResourceStoreRequest {
    resource: ResourceItem,
    data_b64: String,
}
```

### Response [#response]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"ok": true})
```

### Errors and validation [#errors-and-validation]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn memory_resource_store(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceStoreRequest>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        state.usage_emitter.emit_cognitive_op("memory");
        let data = base64::engine::general_purpose::STANDARD
            .decode(req.data_b64.as_bytes())
            .map_err(|e| DaemonError::InvalidRequest(format!("bad base64: {e}")))?;
        db.resource_store(req.resource, &data)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:7552`. Registration: `akasha-daemon/src/main.rs:4648`.

<a id="get-v1-memory-resources-list" />

## GET `/v1/memory/resources/list` [#get-v1memoryresourceslist]

Resource list

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-1]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-1]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(list).unwrap_or(serde_json::json!([])),
```

### Errors and validation [#errors-and-validation-1]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_list(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let list = db
            .resource_list()
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(
            serde_json::to_value(list).unwrap_or(serde_json::json!([])),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3617`. Registration: `akasha-daemon/src/main.rs:4649`.

<a id="post-v1-memory-resources-get" />

## POST `/v1/memory/resources/get` [#post-v1memoryresourcesget]

Resource get

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-2]

**Json** — `ResourceIdReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct ResourceIdReq {
    id: String,
}
```

### Response [#response-2]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"item": item})
```

### Errors and validation [#errors-and-validation-2]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_get(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceIdReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let item = db
            .resource_get(&id)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"item": item})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3631`. Registration: `akasha-daemon/src/main.rs:4650`.

<a id="post-v1-memory-resources-data" />

## POST `/v1/memory/resources/data` [#post-v1memoryresourcesdata]

Resource data

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-3]

**Json** — `ResourceIdReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct ResourceIdReq {
    id: String,
}
```

### Response [#response-3]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"data_b64": data.map(|d| base64::engine::general_purpose::STANDARD.encode(d))}),
```

### Errors and validation [#errors-and-validation-3]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_data(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceIdReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let data = db
            .resource_data(&id)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(
            serde_json::json!({"data_b64": data.map(|d| base64::engine::general_purpose::STANDARD.encode(d))}),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3646`. Registration: `akasha-daemon/src/main.rs:4651`.

<a id="post-v1-memory-resources-data-exists" />

## POST `/v1/memory/resources/data/exists` [#post-v1memoryresourcesdataexists]

Resource data exists

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-4]

**Json** — `ResourceIdReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct ResourceIdReq {
    id: String,
}
```

### Response [#response-4]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"exists": exists})
```

### Errors and validation [#errors-and-validation-4]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_data_exists(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceIdReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let exists = db
            .resource_data_exists(&id)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"exists": exists})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3663`. Registration: `akasha-daemon/src/main.rs:4652`.

<a id="post-v1-memory-resources-data-size" />

## POST `/v1/memory/resources/data/size` [#post-v1memoryresourcesdatasize]

Resource data size

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-5]

**Json** — `ResourceIdReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct ResourceIdReq {
    id: String,
}
```

### Response [#response-5]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"size": sz})
```

### Errors and validation [#errors-and-validation-5]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_data_size(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceIdReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let sz = db
            .resource_data_size(&id)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"size": sz})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3678`. Registration: `akasha-daemon/src/main.rs:4656`.

<a id="post-v1-memory-resources-type" />

## POST `/v1/memory/resources/type` [#post-v1memoryresourcestype]

Resource by type

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-6]

**Json** — `ResourceTypeReq`

| Field  | Rust type | Required on input | Notes |
| ------ | --------- | ----------------- | ----- |
| `kind` | `String`  | Yes               |       |

```rust
struct ResourceTypeReq {
    kind: String,
}
```

### Response [#response-6]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(list).unwrap_or(serde_json::json!([])),
```

### Errors and validation [#errors-and-validation-6]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_by_type(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceTypeReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let kind = match req.kind.as_str() {
            "Document" | "document" => ResourceType::Document,
            "Image" | "image" => ResourceType::Image,
            "Video" | "video" => ResourceType::Video,
            "Audio" | "audio" => ResourceType::Audio,
            "Archive" | "archive" => ResourceType::Archive,
            "Code" | "code" => ResourceType::Code,
            "Data" | "data" => ResourceType::Data,
            "Model" | "model" => ResourceType::Model,
            other => ResourceType::Other(other.to_string()),
        };
        let list = db
            .resource_by_type(&kind)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(
            serde_json::to_value(list).unwrap_or(serde_json::json!([])),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3698`. Registration: `akasha-daemon/src/main.rs:4657`.

<a id="post-v1-memory-resources-access" />

## POST `/v1/memory/resources/access` [#post-v1memoryresourcesaccess]

Resource record access

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-7]

**Json** — `ResourceAccessReq`

| Field    | Rust type | Required on input | Notes |
| -------- | --------- | ----------------- | ----- |
| `id`     | `String`  | Yes               |       |
| `access` | `String`  | Yes               |       |

```rust
struct ResourceAccessReq {
    id: String,
    access: String,
}
```

### Response [#response-7]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"ok": true})
```

### Errors and validation [#errors-and-validation-7]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_record_access(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceAccessReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let access = match req.access.as_str() {
            "read" => ResourceAccessType::Read,
            "download" => ResourceAccessType::Download,
            "preview" => ResourceAccessType::Preview,
            "search" => ResourceAccessType::Search,
            "metadata" => ResourceAccessType::Metadata,
            _ => ResourceAccessType::Read,
        };
        db.resource_record_access(&id, access)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3730`. Registration: `akasha-daemon/src/main.rs:4658`.

<a id="post-v1-memory-resources-usage" />

## POST `/v1/memory/resources/usage` [#post-v1memoryresourcesusage]

Resource usage

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-8]

**Json** — `ResourceUsageReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct ResourceUsageReq {
    id: String,
}
```

### Response [#response-8]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(stats).unwrap_or(serde_json::json!({})),
```

### Errors and validation [#errors-and-validation-8]

Directly referenced error variants: `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_usage(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ResourceUsageReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let id = uuid::Uuid::parse_str(&req.id)
            .map_err(|_| DaemonError::InvalidRequest("invalid id".into()))?;
        let stats: ResourceUsageStats = db
            .resource_usage(&id)
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;
        Ok(Json(
            serde_json::to_value(stats).unwrap_or(serde_json::json!({})),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:7608`. Registration: `akasha-daemon/src/main.rs:4659`.

<a id="post-v1-memory-resources-chunks" />

## POST `/v1/memory/resources/chunks` [#post-v1memoryresourceschunks]

Resource chunks

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_memory`                     |
| Runtime service      | `memory`                                   |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-9]

**Implementation limit:** Placeholder implementation: returns an empty JSON array; backend data retrieval is not implemented here.

**Json** — `ResourceChunksReq`

| Field         | Rust type | Required on input | Notes |
| ------------- | --------- | ----------------- | ----- |
| `resource_id` | `String`  | Yes               |       |

```rust
struct ResourceChunksReq {
    #[allow(dead_code)]
    resource_id: String,
}
```

### Response [#response-9]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!([])
```

### Errors and validation [#errors-and-validation-9]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn resource_chunks(
        State(state): State<AppState>,
        Json(_req): Json<ResourceChunksReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        // text_chunks_for_resource is not yet available on AkashaDB; return empty array
        Ok(Json(serde_json::json!([])))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10542`. Registration: `akasha-daemon/src/main.rs:4702`.