# AgentMemory

Source: https://opvs.ai/docs/api/agentmemory

## `GET` /api/v1/memory/my/agents/{agent_id}/delivered

**Get My Agent Delivered Memory**

Return the exact last-delivered MEMORY.md when it is wholly brand-owned.

**Parameters**

- `agent_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/my/agents/{agent_id}/delivered' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/my/agents/{agent_id}/delivered",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/agents/{agent_id}/delivered", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/my/agents/{agent_id}/delivered", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/memory-deliveries

**List Memory Deliveries**

Return delivery metadata to an authenticated dashboard operator.

**Parameters**

- `agent_id` (query, any, optional)
- `limit` (query, integer, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/memory-deliveries' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/memory-deliveries",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memory-deliveries", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/memory-deliveries", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/sources

**List Sources**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/sources' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/sources",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sources", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/sources", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `POST` /api/v1/memory/sources

**Create Source**

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/sources' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/sources",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sources", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/sources", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `201` — Successful Response

## `GET` /api/v1/memory/sources/{source_id}

**Get Source**

**Parameters**

- `source_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/sources/{source_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/sources/{source_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sources/{source_id}", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/sources/{source_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `PATCH` /api/v1/memory/sources/{source_id}

**Update Source**

**Parameters**

- `source_id` (path, string, required)

```bash
curl -X PATCH 'https://app.opvs.ai/api/v1/memory/sources/{source_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.patch(
    "https://app.opvs.ai/api/v1/memory/sources/{source_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sources/{source_id}", {
  method: "PATCH",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("PATCH", "https://app.opvs.ai/api/v1/memory/sources/{source_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `DELETE` /api/v1/memory/sources/{source_id}

**Delete Source**

**Parameters**

- `source_id` (path, string, required)

```bash
curl -X DELETE 'https://app.opvs.ai/api/v1/memory/sources/{source_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.delete(
    "https://app.opvs.ai/api/v1/memory/sources/{source_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sources/{source_id}", {
  method: "DELETE",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://app.opvs.ai/api/v1/memory/sources/{source_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/sources/{source_id}/sync

**Sync Source**

**Parameters**

- `source_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/sources/{source_id}/sync' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/sources/{source_id}/sync",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sources/{source_id}/sync", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/sources/{source_id}/sync", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/ingest

**Ingest Session Events**

Submit pre-redacted local session events for extraction.

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/ingest' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/ingest",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/ingest", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/ingest", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `202` — Successful Response

## `POST` /api/v1/memory/knowledge:sync

**Sync Knowledge**

Pin one repository knowledge snapshot to the caller's own code project.

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/knowledge:sync' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/knowledge:sync",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/knowledge:sync", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/knowledge:sync", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/sessions

**List Sessions**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/sessions' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/sessions",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sessions", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/sessions", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/sessions/{session_id}

**Get Session**

**Parameters**

- `session_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/sessions/{session_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/sessions/{session_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/sessions/{session_id}", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/sessions/{session_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/entries:near

**Entries Near**

Return live lessons, their guards, and paths near selected code nodes.

**Request body**

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/entries:near' \
  -H 'Authorization: Bearer <token>' \
  -H 'Content-Type: application/json' \
  -d '{
  "project_id": "00000000-0000-0000-0000-000000000000",
  "node_ids": [
    "00000000-0000-0000-0000-000000000000"
  ],
  "paths": [
    "string"
  ],
  "depth": 2,
  "kinds": [
    "import"
  ],
  "direction": "both",
  "hub_cap": 25,
  "limit": 20
}'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/entries:near",
    headers={"Authorization": "Bearer <token>", "Content-Type": "application/json"},
    json={"project_id": "00000000-0000-0000-0000-000000000000", "node_ids": ["00000000-0000-0000-0000-000000000000"], "paths": ["string"], "depth": 2, "kinds": ["import"], "direction": "both", "hub_cap": 25, "limit": 20},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries:near", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>", "Content-Type": "application/json" },
  body: JSON.stringify({"project_id": "00000000-0000-0000-0000-000000000000", "node_ids": ["00000000-0000-0000-0000-000000000000"], "paths": ["string"], "depth": 2, "kinds": ["import"], "direction": "both", "hub_cap": 25, "limit": 20})
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"project_id": "00000000-0000-0000-0000-000000000000", "node_ids": ["00000000-0000-0000-0000-000000000000"], "paths": ["string"], "depth": 2, "kinds": ["import"], "direction": "both", "hub_cap": 25, "limit": 20}`)
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/entries:near", body)
	req.Header.Set("Authorization", "Bearer <token>")
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/anchors:lookup

**Lookup Anchors**

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/anchors:lookup' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/anchors:lookup",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/anchors:lookup", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/anchors:lookup", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `POST` /api/v1/memory/entries:similar

**Similar Entries**

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/entries:similar' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/entries:similar",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries:similar", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/entries:similar", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/entries/search

**Search Entries**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/search' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/search",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/search", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/search", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/my/export

**Export My Memories**

Download memories learned from this brand's own conversations.

**Parameters**

- `format` (query, string, optional)
- `agent_id` (query, any, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/my/export' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/my/export",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/export", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/my/export", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/my/memories/review/pending

**Pending My Memory Reviews**

**Parameters**

- `since` (query, string, required)
- `limit` (query, integer, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/my/memories/review/pending' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/my/memories/review/pending",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/review/pending", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/my/memories/review/pending", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/my/memories/verdicts

**List My Memory Verdicts**

**Parameters**

- `since` (query, string, required)
- `limit` (query, integer, optional)
- `cursor` (query, any, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/my/memories/verdicts' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/my/memories/verdicts",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/verdicts", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/my/memories/verdicts", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/my/memories/verdicts/{verdict_id}/approve

**Approve My Memory Verdict**

**Parameters**

- `verdict_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/approve' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/approve",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/approve", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/approve", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/my/memories/verdicts/{verdict_id}/override

**Override My Memory Verdict**

**Parameters**

- `verdict_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/override' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/override",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/override", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/override", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/my/memories/{memory_id}/verdicts

**Create My Memory Verdict**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/verdicts' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/verdicts",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/verdicts", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/verdicts", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `201` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/desks/{desk_ref}/memories

**Query Desk Memories**

List memory under a brand-owned dev desk's stable environment identity.

**Parameters**

- `desk_ref` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/desks/{desk_ref}/memories' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/desks/{desk_ref}/memories",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/desks/{desk_ref}/memories", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/desks/{desk_ref}/memories", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/my/memories

**Query My Memories**

List memories learned in the selected brand's conversations.

**Parameters**

- `agent_id` (query, any, optional)
- `forgotten` (query, boolean, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/my/memories' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/my/memories",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/my/memories", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/my/memories/{memory_id}/pin

**Pin My Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `DELETE` /api/v1/memory/my/memories/{memory_id}/pin

**Unpin My Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X DELETE 'https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.delete(
    "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin", {
  method: "DELETE",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/my/memories/{memory_id}/pins

**My Memory Pin History**

The pin history of one memory, for a dashboard user.

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pins' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pins",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pins", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pins", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/my/memories/{memory_id}/forget

**Forget My Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/forget' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/forget",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/forget", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/forget", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/my/memories/{memory_id}/restore

**Restore My Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/restore' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/restore",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/restore", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/restore", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/my/memories/{memory_id}/correct

**Correct My Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/correct' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/correct",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/correct", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/correct", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/memories

**Query Memories**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/memories' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/memories",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/memories", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `POST` /api/v1/memory/memories

**Create Memory**

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/memories' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/memories",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/memories", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `201` — Successful Response

## `GET` /api/v1/memory/platform/memories

**Query Platform Memories**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/platform/memories' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/platform/memories",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/platform/memories", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/platform/memories", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/memories/stats

**Memory Stats**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/memories/stats' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/memories/stats",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories/stats", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/memories/stats", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/pins

**Pin History**

Return tenant-wide pin history to a super-admin dashboard session.

**Parameters**

- `limit` (query, integer, optional)
- `since` (query, any, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/pins' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/pins",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/pins", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/pins", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/memories/{memory_id}/pins

**Memory Pin History**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pins' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pins",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pins", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pins", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/memories/{memory_id}

**Get Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/memories/{memory_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/memories/{memory_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories/{memory_id}", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/memories/{memory_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `PATCH` /api/v1/memory/memories/{memory_id}

**Update Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X PATCH 'https://app.opvs.ai/api/v1/memory/memories/{memory_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.patch(
    "https://app.opvs.ai/api/v1/memory/memories/{memory_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories/{memory_id}", {
  method: "PATCH",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("PATCH", "https://app.opvs.ai/api/v1/memory/memories/{memory_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `DELETE` /api/v1/memory/memories/{memory_id}

**Delete Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X DELETE 'https://app.opvs.ai/api/v1/memory/memories/{memory_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.delete(
    "https://app.opvs.ai/api/v1/memory/memories/{memory_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories/{memory_id}", {
  method: "DELETE",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://app.opvs.ai/api/v1/memory/memories/{memory_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/entries/pending

**Pending Entries**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/pending' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/pending",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/pending", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/pending", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/entries/verdicts

**List Entry Verdicts**

**Parameters**

- `since` (query, string, required)
- `limit` (query, integer, optional)
- `cursor` (query, any, optional)
- `reviewer` (query, any, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/verdicts' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/verdicts",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/verdicts", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/verdicts", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/entries/verdicts/stats

**Entry Verdict Stats**

**Parameters**

- `days` (query, any, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/verdicts/stats' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/verdicts/stats",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/verdicts/stats", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/verdicts/stats", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/entries/checks

**List Entry Checks**

**Parameters**

- `since` (query, any, optional)
- `result` (query, any, optional)
- `entry_id` (query, any, optional)
- `limit` (query, integer, optional)
- `cursor` (query, any, optional)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/checks' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/checks",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/checks", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/checks", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/entries/checks/summary

**Summarize Entry Checks**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/checks/summary' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/checks/summary",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/checks/summary", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/checks/summary", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `POST` /api/v1/memory/entries/verdicts/{verdict_id}/override

**Override Entry Verdict**

**Parameters**

- `verdict_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/override' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/override",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/override", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/override", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/entries/verdicts/{verdict_id}/approve

**Approve Entry Verdict**

**Parameters**

- `verdict_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/approve' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/approve",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/approve", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/approve", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/entries/{entry_id}/verdicts

**Create Entry Verdict**

**Parameters**

- `entry_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/entries/{entry_id}/verdicts' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/verdicts",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/{entry_id}/verdicts", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/verdicts", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `201` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/memories/{memory_id}/pin

**Pin Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `DELETE` /api/v1/memory/memories/{memory_id}/pin

**Unpin Memory**

**Parameters**

- `memory_id` (path, string, required)

```bash
curl -X DELETE 'https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.delete(
    "https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin", {
  method: "DELETE",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/entries/{entry_id}/pin

**Pin Entry**

**Parameters**

- `entry_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `DELETE` /api/v1/memory/entries/{entry_id}/pin

**Unpin Entry**

**Parameters**

- `entry_id` (path, string, required)

```bash
curl -X DELETE 'https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.delete(
    "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin", {
  method: "DELETE",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/entries/{entry_id}/pins

**Entry Pin History**

**Parameters**

- `entry_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pins' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pins",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pins", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pins", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/entries/stats

**Entry Stats**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/stats' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/stats",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/stats", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/stats", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/entries/{entry_id}

**Get Entry**

**Parameters**

- `entry_id` (path, string, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/entries/{entry_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/entries/{entry_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/entries/{entry_id}", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/entries/{entry_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/agents/{agent_id}/context

**Get Agent Context**

**Parameters**

- `agent_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/agents/{agent_id}/context/relevant

**Get Relevant Context**

**Parameters**

- `agent_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context/relevant' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context/relevant",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context/relevant", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context/relevant", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/agents/{agent_id}/extract-on-disconnect

**Extract On Disconnect**

**Parameters**

- `agent_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/agents/{agent_id}/extract-on-disconnect' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/agents/{agent_id}/extract-on-disconnect",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/agents/{agent_id}/extract-on-disconnect", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/agents/{agent_id}/extract-on-disconnect", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `POST` /api/v1/memory/pipeline/extract/{source_id}

**Trigger Extraction**

**Parameters**

- `source_id` (path, string, required)

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/pipeline/extract/{source_id}' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/pipeline/extract/{source_id}",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/pipeline/extract/{source_id}", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/pipeline/extract/{source_id}", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `GET` /api/v1/memory/pipeline/runs

**List Runs**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/pipeline/runs' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/pipeline/runs",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/pipeline/runs", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/pipeline/runs", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `POST` /api/v1/memory/pipeline/maintain

**Trigger Maintenance**

```bash
curl -X POST 'https://app.opvs.ai/api/v1/memory/pipeline/maintain' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.post(
    "https://app.opvs.ai/api/v1/memory/pipeline/maintain",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/pipeline/maintain", {
  method: "POST",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://app.opvs.ai/api/v1/memory/pipeline/maintain", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/memory/pipeline/maintenance-runs

**List Maintenance Runs**

```bash
curl -X GET 'https://app.opvs.ai/api/v1/memory/pipeline/maintenance-runs' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/memory/pipeline/maintenance-runs",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/memory/pipeline/maintenance-runs", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/memory/pipeline/maintenance-runs", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response

## `GET` /api/v1/brands/{brand_id}/memory-sharing

**Get Memory Sharing**

Read this brand's sharing choice; any active member may call it.

**Parameters**

- `brand_id` (path, integer, required)

```bash
curl -X GET 'https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing' \
  -H 'Authorization: Bearer <token>'
```

```python
import httpx

resp = httpx.get(
    "https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing",
    headers={"Authorization": "Bearer <token>"},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing", {
  method: "GET",
  headers: { "Authorization": "Bearer <token>" }
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing", nil)
	req.Header.Set("Authorization", "Bearer <token>")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## `PUT` /api/v1/brands/{brand_id}/memory-sharing

**Put Memory Sharing**

Create or update this brand's sharing choice; brand admins only.

**Parameters**

- `brand_id` (path, integer, required)

**Request body**

```bash
curl -X PUT 'https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing' \
  -H 'Authorization: Bearer <token>' \
  -H 'Content-Type: application/json' \
  -d '{
  "opted_out": true
}'
```

```python
import httpx

resp = httpx.put(
    "https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing",
    headers={"Authorization": "Bearer <token>", "Content-Type": "application/json"},
    json={"opted_out": true},
)
resp.raise_for_status()
print(resp.json())
```

```javascript
const resp = await fetch("https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing", {
  method: "PUT",
  headers: { "Authorization": "Bearer <token>", "Content-Type": "application/json" },
  body: JSON.stringify({"opted_out": true})
});
const data = await resp.json();
console.log(data);
```

```go
package main

import (
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"opted_out": true}`)
	req, _ := http.NewRequest("PUT", "https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing", body)
	req.Header.Set("Authorization", "Bearer <token>")
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
}
```

**Responses**

- `200` — Successful Response
- `422` — Validation Error

## Get My Agent Delivered Memory

`GET https://app.opvs.ai/api/v1/memory/my/agents/{agent_id}/delivered`

Return the exact last-delivered MEMORY.md when it is wholly brand-owned.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## List Memory Deliveries

`GET https://app.opvs.ai/api/v1/memory/memory-deliveries`

Return delivery metadata to an authenticated dashboard operator.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## List Sources

`GET https://app.opvs.ai/api/v1/memory/sources`

## Create Source

`POST https://app.opvs.ai/api/v1/memory/sources`

## Get Source

`GET https://app.opvs.ai/api/v1/memory/sources/{source_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Update Source

`PATCH https://app.opvs.ai/api/v1/memory/sources/{source_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Delete Source

`DELETE https://app.opvs.ai/api/v1/memory/sources/{source_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Sync Source

`POST https://app.opvs.ai/api/v1/memory/sources/{source_id}/sync`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Ingest Session Events

`POST https://app.opvs.ai/api/v1/memory/ingest`

Submit pre-redacted local session events for extraction.

## Sync Knowledge

`POST https://app.opvs.ai/api/v1/memory/knowledge:sync`

Pin one repository knowledge snapshot to the caller's own code project.

## List Sessions

`GET https://app.opvs.ai/api/v1/memory/sessions`

## Get Session

`GET https://app.opvs.ai/api/v1/memory/sessions/{session_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Entries Near

`POST https://app.opvs.ai/api/v1/memory/entries:near`

Return live lessons, their guards, and paths near selected code nodes.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Lookup Anchors

`POST https://app.opvs.ai/api/v1/memory/anchors:lookup`

## Similar Entries

`POST https://app.opvs.ai/api/v1/memory/entries:similar`

## Search Entries

`GET https://app.opvs.ai/api/v1/memory/entries/search`

## Export My Memories

`GET https://app.opvs.ai/api/v1/memory/my/export`

Download memories learned from this brand's own conversations.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Pending My Memory Reviews

`GET https://app.opvs.ai/api/v1/memory/my/memories/review/pending`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## List My Memory Verdicts

`GET https://app.opvs.ai/api/v1/memory/my/memories/verdicts`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Approve My Memory Verdict

`POST https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/approve`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Override My Memory Verdict

`POST https://app.opvs.ai/api/v1/memory/my/memories/verdicts/{verdict_id}/override`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Create My Memory Verdict

`POST https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/verdicts`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Query Desk Memories

`GET https://app.opvs.ai/api/v1/memory/desks/{desk_ref}/memories`

List memory under a brand-owned dev desk's stable environment identity.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Query My Memories

`GET https://app.opvs.ai/api/v1/memory/my/memories`

List memories learned in the selected brand's conversations.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Pin My Memory

`POST https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Unpin My Memory

`DELETE https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pin`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## My Memory Pin History

`GET https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/pins`

The pin history of one memory, for a dashboard user.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Forget My Memory

`POST https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/forget`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Restore My Memory

`POST https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/restore`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Correct My Memory

`POST https://app.opvs.ai/api/v1/memory/my/memories/{memory_id}/correct`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Query Memories

`GET https://app.opvs.ai/api/v1/memory/memories`

## Create Memory

`POST https://app.opvs.ai/api/v1/memory/memories`

## Query Platform Memories

`GET https://app.opvs.ai/api/v1/memory/platform/memories`

## Memory Stats

`GET https://app.opvs.ai/api/v1/memory/memories/stats`

## Pin History

`GET https://app.opvs.ai/api/v1/memory/pins`

Return tenant-wide pin history to a super-admin dashboard session.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Memory Pin History

`GET https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pins`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Get Memory

`GET https://app.opvs.ai/api/v1/memory/memories/{memory_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Update Memory

`PATCH https://app.opvs.ai/api/v1/memory/memories/{memory_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Delete Memory

`DELETE https://app.opvs.ai/api/v1/memory/memories/{memory_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Pending Entries

`GET https://app.opvs.ai/api/v1/memory/entries/pending`

## List Entry Verdicts

`GET https://app.opvs.ai/api/v1/memory/entries/verdicts`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Entry Verdict Stats

`GET https://app.opvs.ai/api/v1/memory/entries/verdicts/stats`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## List Entry Checks

`GET https://app.opvs.ai/api/v1/memory/entries/checks`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Summarize Entry Checks

`GET https://app.opvs.ai/api/v1/memory/entries/checks/summary`

## Override Entry Verdict

`POST https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/override`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Approve Entry Verdict

`POST https://app.opvs.ai/api/v1/memory/entries/verdicts/{verdict_id}/approve`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Create Entry Verdict

`POST https://app.opvs.ai/api/v1/memory/entries/{entry_id}/verdicts`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Pin Memory

`POST https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Unpin Memory

`DELETE https://app.opvs.ai/api/v1/memory/memories/{memory_id}/pin`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Pin Entry

`POST https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Unpin Entry

`DELETE https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pin`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Entry Pin History

`GET https://app.opvs.ai/api/v1/memory/entries/{entry_id}/pins`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Entry Stats

`GET https://app.opvs.ai/api/v1/memory/entries/stats`

## Get Entry

`GET https://app.opvs.ai/api/v1/memory/entries/{entry_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Get Agent Context

`POST https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Get Relevant Context

`POST https://app.opvs.ai/api/v1/memory/agents/{agent_id}/context/relevant`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Extract On Disconnect

`POST https://app.opvs.ai/api/v1/memory/agents/{agent_id}/extract-on-disconnect`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Trigger Extraction

`POST https://app.opvs.ai/api/v1/memory/pipeline/extract/{source_id}`

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## List Runs

`GET https://app.opvs.ai/api/v1/memory/pipeline/runs`

## Trigger Maintenance

`POST https://app.opvs.ai/api/v1/memory/pipeline/maintain`

## List Maintenance Runs

`GET https://app.opvs.ai/api/v1/memory/pipeline/maintenance-runs`

## Get Memory Sharing

`GET https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing`

Read this brand's sharing choice; any active member may call it.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |

## Put Memory Sharing

`PUT https://app.opvs.ai/api/v1/brands/{brand_id}/memory-sharing`

Create or update this brand's sharing choice; brand admins only.

| Code | When | What to do |
| --- | --- | --- |
| 422 | Validation Error |  |