dreaming-memory 0.2.0__tar.gz

dreaming_memory-0.2.0/.env.example

@@ -0,0 +1,19 @@
+# Agent memory — development defaults (copy to .env, never commit secrets)
+
+# Postgres SSOT (required)
+AGENT_MEMORY_DATABASE_URL=postgresql://postgres:postgres@localhost:5432/agent_memory
+
+# Linear (same keys as utrecht-data-os)
+# LINEAR_API_KEY=lin_api_...
+# LINEAR_TEAM_ID=
+# LINEAR_TEAM_KEY=GROEP
+
+# Notion
+# NOTION_API_KEY=secret_...
+# NOTION_TOKEN=secret_...
+
+# Slack (incoming webhook for eval reports)
+SLACK_WEBHOOK_URL=
+
+# Optional LanceDB (local path or s3:// for R2)
+# LANCE_DB_URI=./data/lancedb

dreaming_memory-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+__pycache__/
+*.pyc
+.env
+.env.*
+!.env.example
+data/lancedb/
+.pytest_cache/
+dist/
+build/
+*.egg-info/
+uv.lock

dreaming_memory-0.2.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: dreaming-memory
+Version: 0.2.0
+Summary: Agent-agnostic memory extension — Postgres-backed agent memory with Linear, Notion, and Cloudflare integrations
+Project-URL: Homepage, https://github.com/OnlineChefGroep/cursor-dreaming-sdk
+Project-URL: Documentation, https://github.com/OnlineChefGroep/cursor-dreaming-sdk/tree/main/docs
+Project-URL: Repository, https://github.com/OnlineChefGroep/cursor-dreaming-sdk
+Project-URL: Issues, https://github.com/OnlineChefGroep/cursor-dreaming-sdk/issues
+Author: OnlineChefGroep
+License: MIT
+Keywords: agent-memory,dream-eval,linear,notion,postgres,postgrest
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: <3.15,>=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: psycopg-pool>=3.1
+Requires-Dist: psycopg[binary]>=3.2
+Requires-Dist: pydantic>=2.13
+Provides-Extra: all
+Requires-Dist: boto3>=1.35; extra == 'all'
+Requires-Dist: fastapi>=0.115; extra == 'all'
+Requires-Dist: lancedb>=0.22; extra == 'all'
+Requires-Dist: pyarrow>=18.0; extra == 'all'
+Requires-Dist: sentry-sdk>=2.19; extra == 'all'
+Requires-Dist: upstash-redis>=1.2; extra == 'all'
+Requires-Dist: uvicorn[standard]>=0.30; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.100; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: pyyaml>=6.0; extra == 'dev'
+Requires-Dist: ruff>=0.15; extra == 'dev'
+Provides-Extra: prefect
+Requires-Dist: prefect>=3.0; extra == 'prefect'
+Provides-Extra: r2
+Requires-Dist: boto3>=1.35; extra == 'r2'
+Provides-Extra: redis
+Requires-Dist: upstash-redis>=1.2; extra == 'redis'
+Provides-Extra: semantic
+Requires-Dist: lancedb>=0.22; extra == 'semantic'
+Requires-Dist: pyarrow>=18.0; extra == 'semantic'
+Provides-Extra: sentry
+Requires-Dist: sentry-sdk>=2.19; extra == 'sentry'
+Provides-Extra: web
+Requires-Dist: fastapi>=0.115; extra == 'web'
+Requires-Dist: uvicorn[standard]>=0.30; extra == 'web'
+Description-Content-Type: text/markdown
+
+# cursor-dreaming-memory
+
+Lightweight agent memory extension for **cursor-dreaming-sdk** (Utrecht Data OS / CHEF-308).
+
+## Install
+
+```bash
+cd python
+uv sync --extra dev
+uv run dream-memory init   # requires Postgres
+```
+
+Optional semantic layer:
+
+```bash
+uv sync --extra semantic
+```
+
+## Quick start
+
+```python
+from cursor_dreaming_memory import AgentMemory, SessionContext
+from cursor_dreaming_memory.types import MemoryType, MemorySource
+
+memory = AgentMemory()
+memory.ensure_schema()
+
+ctx = SessionContext.for_dream_eval("2026-06-15T09-00-00Z")
+memory.remember(ctx, MemoryType.OBSERVATION, {"faithfulness": 0.63}, source=MemorySource.SDK)
+```
+
+## CLI
+
+```bash
+dream-memory init
+dream-memory remember --session-id run-1 --content '{"note":"hello"}'
+dream-memory recall --session-id run-1
+dream-memory linear-ingest CHEF-308
+dream-memory notion-ingest <page_id>
+dream-memory export --session-id run-1 --output run-1.md
+dream-memory slack-report --run-id run-1 --metrics-json metrics.json
+dream-memory doctor
+```
+
+- `export` writes a session's memory records as Markdown (`--output` to a file, or stdout).
+- `slack-report` posts an eval report to Slack via `SLACK_WEBHOOK_URL` (no-op if unset).
+- `doctor` reports config presence plus Postgres, Linear, and Notion connectivity.
+
+## Example flow
+
+```bash
+uv run python examples/linear_memory_flow.py --issue CHEF-308 --comment
+```
+
+See [docs/agent-memory.md](../docs/agent-memory.md) for architecture and OCI deployment.

dreaming_memory-0.2.0/README.md

@@ -0,0 +1,55 @@
+# cursor-dreaming-memory
+
+Lightweight agent memory extension for **cursor-dreaming-sdk** (Utrecht Data OS / CHEF-308).
+
+## Install
+
+```bash
+cd python
+uv sync --extra dev
+uv run dream-memory init   # requires Postgres
+```
+
+Optional semantic layer:
+
+```bash
+uv sync --extra semantic
+```
+
+## Quick start
+
+```python
+from cursor_dreaming_memory import AgentMemory, SessionContext
+from cursor_dreaming_memory.types import MemoryType, MemorySource
+
+memory = AgentMemory()
+memory.ensure_schema()
+
+ctx = SessionContext.for_dream_eval("2026-06-15T09-00-00Z")
+memory.remember(ctx, MemoryType.OBSERVATION, {"faithfulness": 0.63}, source=MemorySource.SDK)
+```
+
+## CLI
+
+```bash
+dream-memory init
+dream-memory remember --session-id run-1 --content '{"note":"hello"}'
+dream-memory recall --session-id run-1
+dream-memory linear-ingest CHEF-308
+dream-memory notion-ingest <page_id>
+dream-memory export --session-id run-1 --output run-1.md
+dream-memory slack-report --run-id run-1 --metrics-json metrics.json
+dream-memory doctor
+```
+
+- `export` writes a session's memory records as Markdown (`--output` to a file, or stdout).
+- `slack-report` posts an eval report to Slack via `SLACK_WEBHOOK_URL` (no-op if unset).
+- `doctor` reports config presence plus Postgres, Linear, and Notion connectivity.
+
+## Example flow
+
+```bash
+uv run python examples/linear_memory_flow.py --issue CHEF-308 --comment
+```
+
+See [docs/agent-memory.md](../docs/agent-memory.md) for architecture and OCI deployment.

dreaming_memory-0.2.0/deploy/cloudflare/utrecht-dataos-api.worker.js

@@ -0,0 +1,53 @@
+// utrecht-dataos-control-plane-api  (Cloudflare Worker, custom domain api.chefgroep.online)
+// Placeholder control-plane API surface + reverse proxy for the agent-memory dashboard.
+// Bindings (kept on deploy via keep_bindings): UPSTASH_REDIS_REST_URL, UPSTASH_REDIS_REST_TOKEN
+
+const DASHBOARD_ORIGIN = 'https://memory.chefgroep.online';
+
+addEventListener('fetch', (event) => {
+  event.respondWith(handle(event.request));
+});
+
+async function handle(request) {
+  const url = new URL(request.url);
+  const path = url.pathname;
+
+  // Dashboard, served under the online API at /dashboard
+  if (path === '/dashboard' || path === '/dashboard/' || path.startsWith('/dashboard/')) {
+    const sub = path.length > '/dashboard'.length ? path.slice('/dashboard'.length) : '/';
+    return proxy(DASHBOARD_ORIGIN + sub + url.search, request);
+  }
+  // Footer links / refresh targets used by the dashboard HTML
+  if (path === '/api/metrics' || path === '/healthz') {
+    return proxy(DASHBOARD_ORIGIN + path + url.search, request);
+  }
+
+  const hasUpstash =
+    typeof UPSTASH_REDIS_REST_URL !== 'undefined' && !!UPSTASH_REDIS_REST_URL;
+  const body = {
+    service: 'utrecht-dataos-control-plane-api',
+    status: 'ok',
+    hostname: url.hostname,
+    path,
+    upstash_bound: hasUpstash,
+    dashboard: 'https://api.chefgroep.online/dashboard',
+    dashboard_origin: DASHBOARD_ORIGIN,
+    note: 'placeholder API surface for Utrecht Data OS control plane',
+    ts: new Date().toISOString(),
+  };
+  return new Response(JSON.stringify(body, null, 2), {
+    status: 200,
+    headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },
+  });
+}
+
+async function proxy(target, request) {
+  const upstream = await fetch(target, {
+    method: 'GET',
+    headers: { accept: request.headers.get('accept') || '*/*' },
+    redirect: 'follow',
+  });
+  const ct = upstream.headers.get('content-type') || 'text/html; charset=utf-8';
+  const headers = new Headers({ 'content-type': ct, 'cache-control': 'no-store' });
+  return new Response(upstream.body, { status: upstream.status, headers });
+}

dreaming_memory-0.2.0/deploy/fleet/README.md

@@ -0,0 +1,53 @@
+# Fleet deployment — agent memory
+
+Connect every code-agent CLI on the fleet (Cursor, Codex, Claude, OpenCode, Grok)
+to the shared Postgres memory layer.
+
+## Topology
+
+| Node | Shape | Role |
+|------|-------|------|
+| `bc-scan-arm` | A1.Flex (ARM, 23GB) | **Memory SSOT** — Postgres + vector (qdrant/weaviate) + llama.cpp |
+| `bc-scan-2` | A1.Flex (ARM) | Inference / inventory worker |
+| `bc-scan-1` | E2.1.Micro (x86) | Scanner |
+| `bc-monitor` | E2.1.Micro (x86) | Monitoring |
+| `sofie` (this host) | local | Dev + orchestration |
+
+Postgres SSOT: `postgresql://agentmem:***@100.68.121.19:5432/agent_memory` (Tailscale).
+
+## 1. Sync env to all nodes
+
+```bash
+cd python/deploy/fleet
+./sync-env.sh                 # all nodes
+./sync-env.sh bc-scan-arm     # single node
+```
+
+This ships only the memory-related keys to `~/.agent-memory.env` on each node and
+sources it from `~/.bashrc`.
+
+## 2. Install the package on a node
+
+```bash
+./install-agent-memory.sh bc-scan-2
+```
+
+## 3. Wire code-agent CLIs
+
+Each agent CLI inherits the DSN + keys because its shell sources `~/.agent-memory.env`.
+Agents call memory three ways:
+
+| Surface | How |
+|---------|-----|
+| Python | `from cursor_dreaming_memory import AgentMemory` |
+| CLI | `dream-memory remember/recall/linear-ingest/notion-ingest` |
+| Skill | `skills-bundle/shared/agent-memory.md` (drop into any agent skills dir) |
+
+`session_type` is auto-detected per agent (cursor / codex / claude / opencode / grok)
+via `SessionContext.from_sdk_payload()`.
+
+## 4. Verify
+
+```bash
+ssh bc-scan-arm 'cd ~/Orgchefgroep/cursor-dreaming-sdk/python && uv run dream-memory recall --limit 5'
+```

dreaming_memory-0.2.0/deploy/fleet/agent-memory-dashboard.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=Agent Memory metrics dashboard (always-on)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=%h/cursor-dreaming-memory
+ExecStart=/bin/bash -lc 'set -a; [ -f %h/.agent-memory.env ] && . %h/.agent-memory.env; set +a; exec %h/.local/bin/uv run dream-memory serve --host 0.0.0.0 --port 8787'
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target

dreaming_memory-0.2.0/deploy/fleet/agent-memory-eval.service

@@ -0,0 +1,10 @@
+[Unit]
+Description=Dream eval + Linear memory sync (oneshot)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+WorkingDirectory=%h/cursor-dreaming-memory
+# Source the shell-style env file (export KEY="val") then run the sync flow.
+ExecStart=/bin/bash -lc 'set -a; [ -f %h/.agent-memory.env ] && . %h/.agent-memory.env; set +a; exec %h/.local/bin/uv run python deploy/oci/prefect_flow.py'

dreaming_memory-0.2.0/deploy/fleet/agent-memory-eval.timer

@@ -0,0 +1,11 @@
+[Unit]
+Description=Schedule dream eval + Linear memory sync
+
+[Timer]
+# Daily 02:00 + Monday 09:00 (mirrors dream_eval_weekly automation)
+OnCalendar=*-*-* 02:00:00
+OnCalendar=Mon *-*-* 09:00:00
+Persistent=true
+
+[Install]
+WantedBy=timers.target

dreaming_memory-0.2.0/deploy/fleet/cloudflare_tunnel.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""Create/Update a Cloudflare Tunnel that exposes the metrics dashboard on a domain.
+
+Requires a Cloudflare API token with:
+  - Account → Cloudflare Tunnel: Edit
+  - Zone → DNS: Edit  (on the target zone)
+  - Zone → Zone: Read
+
+Env:
+  CLOUDFLARE_API_TOKEN   (scoped as above)
+  CLOUDFLARE_ACCOUNT_ID
+  TUNNEL_HOSTNAME        e.g. memory.chefgroep.nl
+  TUNNEL_NAME            default: agent-memory
+  LOCAL_SERVICE          default: http://localhost:8787
+
+Outputs the tunnel run token. Install the connector with:
+  sudo cloudflared service install <TOKEN>
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.request
+
+API = "https://api.cloudflare.com/client/v4"
+
+
+def _auth_headers() -> dict:
+    """Bearer token, or legacy global-key (X-Auth-Email/Key) if provided."""
+    email = os.environ.get("CLOUDFLARE_EMAIL")
+    gkey = os.environ.get("CLOUDFLARE_GLOBAL_API_KEY")
+    if email and gkey:
+        return {"X-Auth-Email": email, "X-Auth-Key": gkey}
+    return {"Authorization": f"Bearer {os.environ['CLOUDFLARE_API_TOKEN']}"}
+
+
+def _req(method: str, path: str, token: str, body: dict | None = None) -> dict:
+    data = json.dumps(body).encode() if body is not None else None
+    headers = {"Content-Type": "application/json", **_auth_headers()}
+    req = urllib.request.Request(
+        f"{API}{path}",
+        data=data,
+        method=method,
+        headers=headers,
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        out = json.loads(resp.read().decode())
+    if not out.get("success"):
+        raise SystemExit(f"CF API error {method} {path}: {out.get('errors')}")
+    return out
+
+
+def main() -> None:
+    token = os.environ.get("CLOUDFLARE_API_TOKEN", "")
+    acct = os.environ["CLOUDFLARE_ACCOUNT_ID"]
+    hostname = os.environ["TUNNEL_HOSTNAME"]
+    name = os.environ.get("TUNNEL_NAME", "agent-memory")
+    service = os.environ.get("LOCAL_SERVICE", "http://localhost:8787")
+    zone_name = ".".join(hostname.split(".")[-2:])
+
+    # 1. Resolve zone
+    zones = _req("GET", f"/zones?name={zone_name}", token)["result"]
+    if not zones:
+        raise SystemExit(f"Zone {zone_name} not found / not authorized")
+    zone_id = zones[0]["id"]
+
+    # 2. Create (or reuse) the tunnel — cloudflare-managed config
+    existing = _req("GET", f"/accounts/{acct}/cfd_tunnel?name={name}&is_deleted=false", token)
+    if existing["result"]:
+        tunnel = existing["result"][0]
+        tunnel_id = tunnel["id"]
+        tok = _req("GET", f"/accounts/{acct}/cfd_tunnel/{tunnel_id}/token", token)["result"]
+    else:
+        created = _req(
+            "POST",
+            f"/accounts/{acct}/cfd_tunnel",
+            token,
+            {"name": name, "config_src": "cloudflare"},
+        )["result"]
+        tunnel_id = created["id"]
+        tok = created["token"]
+
+    # 3. Configure ingress
+    _req(
+        "PUT",
+        f"/accounts/{acct}/cfd_tunnel/{tunnel_id}/configurations",
+        token,
+        {
+            "config": {
+                "ingress": [
+                    {"hostname": hostname, "service": service},
+                    {"service": "http_status:404"},
+                ]
+            }
+        },
+    )
+
+    # 4. DNS CNAME → tunnel
+    cname = f"{tunnel_id}.cfargotunnel.com"
+    recs = _req("GET", f"/zones/{zone_id}/dns_records?name={hostname}", token)["result"]
+    payload = {"type": "CNAME", "name": hostname, "content": cname, "proxied": True}
+    if recs:
+        _req("PUT", f"/zones/{zone_id}/dns_records/{recs[0]['id']}", token, payload)
+    else:
+        _req("POST", f"/zones/{zone_id}/dns_records", token, payload)
+
+    print(json.dumps({"tunnel_id": tunnel_id, "hostname": hostname, "url": f"https://{hostname}"}))
+    print("TUNNEL_TOKEN=" + tok, file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

dreaming_memory-0.2.0/deploy/fleet/install-agent-memory.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# Install the cursor-dreaming-memory package on a fleet node and verify the DB link.
+# Usage: ./install-agent-memory.sh <node>
+set -euo pipefail
+NODE="${1:?usage: install-agent-memory.sh <node>}"
+REPO_DIR="/home/ubuntu/Orgchefgroep/cursor-dreaming-sdk"
+
+ssh "$NODE" bash -s <<'REMOTE'
+set -euo pipefail
+[ -f ~/.agent-memory.env ] && . ~/.agent-memory.env
+command -v uv >/dev/null 2>&1 || curl -LsSf https://astral.sh/uv/install.sh | sh
+mkdir -p ~/Orgchefgroep
+if [ ! -d ~/Orgchefgroep/cursor-dreaming-sdk ]; then
+  gh repo clone OnlineChefGroep/cursor-dreaming-sdk ~/Orgchefgroep/cursor-dreaming-sdk 2>/dev/null \
+    || git clone https://github.com/OnlineChefGroep/cursor-dreaming-sdk ~/Orgchefgroep/cursor-dreaming-sdk
+fi
+cd ~/Orgchefgroep/cursor-dreaming-sdk/python
+git pull --ff-only 2>/dev/null || true
+uv sync
+echo "--- verifying DB link ---"
+uv run python -c "from cursor_dreaming_memory import AgentMemory; m=AgentMemory(enable_sentry=False); print(m.config.redacted()); m.ensure_schema(); print('schema OK')"
+REMOTE
+echo "Installed agent-memory on $NODE"

dreaming_memory-0.2.0/deploy/fleet/install-memory.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Idempotent installer: wire the agent memory layer into one fleet host.
+# Connects every code-agent CLI on the host to the shared OCI Postgres SSOT.
+#
+# Usage (from sofie control node):
+#   for h in bc-monitor bc-scan-arm bc-scan-2; do
+#     scp -r python "$h:~/cursor-dreaming-memory"
+#     ssh "$h" 'bash ~/cursor-dreaming-memory/deploy/fleet/install-memory.sh'
+#   done
+#
+# Secrets are read at runtime from ~/.config/agent-memory/.env on each host.
+set -euo pipefail
+
+REPO_DIR="${REPO_DIR:-$HOME/cursor-dreaming-memory}"
+ENV_DIR="$HOME/.config/agent-memory"
+ENV_FILE="$ENV_DIR/.env"
+
+echo "[*] Installing agent memory on $(hostname)"
+
+# 1. uv
+if ! command -v uv >/dev/null 2>&1; then
+  echo "[*] Installing uv"
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  export PATH="$HOME/.local/bin:$PATH"
+fi
+
+# 2. Python deps
+cd "$REPO_DIR"
+uv sync --extra all
+
+# 3. Secrets file (filled out-of-band; never committed)
+mkdir -p "$ENV_DIR"
+if [ ! -f "$ENV_FILE" ]; then
+  cat > "$ENV_FILE" <<'EOF'
+# Per-host agent memory secrets (chmod 600). Fill these in.
+AGENT_MEMORY_DATABASE_URL=
+LINEAR_API_KEY=
+NOTION_API_KEY=
+CLOUDFLARE_API_TOKEN=
+CLOUDFLARE_ACCOUNT_ID=
+SENTRY_DSN=
+SENTRY_ENVIRONMENT=fleet
+EOF
+  chmod 600 "$ENV_FILE"
+  echo "[!] Created $ENV_FILE — fill in secrets, then re-run doctor."
+fi
+
+# 4. Verify
+set +e
+FLEET_ENV_FILE="$ENV_FILE" uv run dream-memory doctor
+echo "[*] Done. Agents on this host can now: uv run --project $REPO_DIR dream-memory ..."

dreaming_memory-0.2.0/deploy/fleet/sync-env.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Sync agent-memory env (DSN + secrets) to all fleet nodes over Tailscale.
+# Usage: ./sync-env.sh [node ...]   (defaults to all known nodes)
+set -euo pipefail
+
+NODES=("${@:-bc-scan-arm bc-scan-2 bc-scan-1 bc-monitor}")
+SRC="${HOME}/.openclaude/.env"
+REMOTE_ENV="/home/ubuntu/.agent-memory.env"
+
+if [[ ! -f "$SRC" ]]; then
+  echo "ERROR: $SRC not found" >&2
+  exit 1
+fi
+
+# Only ship the keys the memory layer needs (never the full secrets file).
+KEYS=(AGENT_MEMORY_DATABASE_URL LINEAR_API_KEY LINEAR_TEAM_KEY NOTION_API_KEY NOTION_TOKEN \
+      CLOUDFLARE_API_TOKEN CLOUDFLARE_ACCOUNT_ID R2_BUCKET R2_ACCESS_KEY_ID R2_SECRET_ACCESS_KEY R2_ENDPOINT \
+      SENTRY_DSN SENTRY_ENVIRONMENT)
+
+TMP="$(mktemp)"
+# shellcheck disable=SC1090
+source "$SRC"
+for k in "${KEYS[@]}"; do
+  v="${!k:-}"
+  [[ -n "$v" ]] && echo "export $k=\"$v\"" >> "$TMP"
+done
+
+for node in ${NODES[@]}; do
+  echo "→ $node"
+  scp -q "$TMP" "$node:$REMOTE_ENV"
+  # Ensure interactive + non-interactive shells load it
+  ssh "$node" "grep -q 'agent-memory.env' ~/.bashrc 2>/dev/null || echo '[ -f ~/.agent-memory.env ] && . ~/.agent-memory.env' >> ~/.bashrc"
+done
+rm -f "$TMP"
+echo "Done. Memory env synced to: ${NODES[*]}"

dreaming_memory-0.2.0/deploy/oci/README.md

@@ -0,0 +1,98 @@
+# OCI deployment — agent memory on Ampere A1
+
+Deploy the cursor-dreaming-memory layer on Oracle Cloud Free Tier (ARM).
+
+## Prerequisites
+
+- OCI CLI configured (`~/.oci/config`)
+- Ampere A1 compute instance (Ubuntu 22.04+ ARM64)
+- SSH access to the instance
+
+## 1. Provision instance (optional)
+
+```bash
+# List available shapes in your compartment
+oci compute shape list --compartment-id <COMPARTMENT_OCID>
+
+# Create instance (example — adjust image OCID for your region)
+oci compute instance launch \
+  --availability-domain <AD> \
+  --compartment-id <COMPARTMENT_OCID> \
+  --shape VM.Standard.A1.Flex \
+  --shape-config '{"ocpus":1,"memoryInGBs":6}' \
+  --display-name agent-memory-a1 \
+  --image-id <UBUNTU_ARM_IMAGE_OCID> \
+  --subnet-id <SUBNET_OCID> \
+  --assign-public-ip true
+```
+
+## 2. Copy code to instance
+
+```bash
+rsync -avz python/ ubuntu@<INSTANCE_IP>:~/cursor-dreaming-memory/
+scp .env ubuntu@<INSTANCE_IP>:~/cursor-dreaming-memory/.env
+```
+
+## 3. Start Postgres
+
+On the instance:
+
+```bash
+cd ~/cursor-dreaming-memory/deploy/oci
+docker compose up -d
+```
+
+Postgres listens on `localhost:5432`, database `agent_memory`.
+
+## 4. Install Python package
+
+```bash
+cd ~/cursor-dreaming-memory
+curl -LsSf https://astral.sh/uv/install.sh | sh
+uv sync
+export AGENT_MEMORY_DATABASE_URL=postgresql://postgres:postgres@localhost:5432/agent_memory
+uv run dream-memory init
+```
+
+## 5. Environment variables
+
+```bash
+export LINEAR_API_KEY=lin_api_...
+export NOTION_API_KEY=secret_...
+export AGENT_MEMORY_DATABASE_URL=postgresql://postgres:postgres@localhost:5432/agent_memory
+```
+
+## 6. Optional: Prefect scheduled sync
+
+```bash
+uv sync --extra prefect
+uv run python deploy/oci/prefect_flow.py
+```
+
+Runs a daily Linear issue ingest for configured CHEF/GROEP tickets.
+
+## 7. systemd service (optional)
+
+```ini
+# /etc/systemd/system/agent-memory.service
+[Unit]
+Description=Agent Memory Prefect Worker
+After=docker.service
+
+[Service]
+Type=simple
+User=ubuntu
+WorkingDirectory=/home/ubuntu/cursor-dreaming-memory
+EnvironmentFile=/home/ubuntu/cursor-dreaming-memory/.env
+ExecStart=/home/ubuntu/.local/bin/uv run python deploy/oci/prefect_flow.py
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+```
+
+## ARM notes
+
+- Use `psycopg[binary]` wheels (included) — no x86-only deps
+- LanceDB optional extra works on aarch64 when installed via pip
+- Keep memory lightweight: 1 OCPU / 6 GB RAM is sufficient for dev