{"content":[{"text":"total 16\ndrwxr-xr-x 3 root root 4096 Sep 18 08:00 .\ndrwxr-xr-x 7 root root 4096 Sep 19 05:58 ..\ndrwxr-xr-x 8 root root 4096 Sep 18 08:00 .git\n-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore\n","type":"text"}]}

{"content":[{"text":"{\"info\":{\"author\":null,\"author_email\":\"Forrest Bao <forrest@pairsys.ai>\",\"bugtrack_url\":null,\"classifiers\":[\"Development Status :: 4 - Beta\",\"Intended Audience :: Developers\",\"Programming Language :: Python :: 3\",\"Programming Language :: Python :: 3.10\",\"Programming Language :: Python :: 3.11\",\"Programming Language :: Python :: 3.12\",\"Programming Language :: Python :: 3.13\",\"Typing :: Typed\"],\"description\":\"# GoodMem Python SDK\\n\\nAn OpenAI-style API for Goodmem with auto-inference of model para\n200\n{\"error\":\"Not found\"}","type":"text"}]}

curl -s -m 10 https://pypi.org/pypi/goodmem/json > /tmp/gm.json; python3 -c "
import json
d=json.load(open('/tmp/gm.json'))
info=d['info']
print('version:', info['version'])
print('home:', info.get('home_page'), info.get('project_urls'))
print('summary:', info['summary'])
print('---DESC---')
print(info['description'][:8000])
"

{"content":[{"text":"version: 0.1.34\nhome: None {'Documentation': 'https://docs.goodmem.ai', 'Homepage': 'https://github.com/PAIR-Systems-Inc/goodmem', 'Repository': 'https://github.com/PAIR-Systems-Inc/goodmem'}\nsummary: GoodMem's Convenient SDK for Python\n---DESC---\n# GoodMem Python SDK\n\nAn OpenAI-style API for Goodmem with auto-inference of model parameters, streaming retrieval, async support, and auto-pagination. The SDK stays in sync with the server's OpenAPI spec — except for hand-written convenience methods (model registry auto-inference, flat post-processor kwargs, etc.) that wrap the generated layer. Please see [../notes/clients_gen.md](../notes/clients_gen.md) for the SDK generation details and [../notes/docs_gen.md](../notes/docs_gen.md) for the doc generation details.\n\n## Installation\n\n```bash\npip install goodmem\n```\n\n## Usage\n\n### The programmatic way\n\n```python\nfrom goodmem import Goodmem\n\nclient = Goodmem(\n    base_url=\"http://localhost:8080\",\n    api_key=\"gm_...\"\n)\n\nembedder = client.embedders.create(\n    display_name=\"OpenAI Embedder\",\n    model_identifier=\"text-embedding-3-large\",\n    api_key=\"sk-your-openai-key\",\n)\n\nprint(f\"Created: {embedder.embedder_id}\")\n```\n### The Skill way \n\n```bash\n# One-time setup — copy the skill into your Claude Code skills directory\ncp -r $(python -c \"import goodmem; print(goodmem.__path__[0])\")/skills ~/.claude/skills/goodmem\n```\n\nOnce installed, Claude Code automatically loads the GoodMem SDK reference when you ask it to create embedders, store memories, run retrieval, etc.\n\n## Project structure\n\n```\nclients/\n├── python/              # Python SDK (this directory, published to PyPI as \"goodmem\")\n├── _clients_gen/         # Code generation (spec → SDK + MCP)\n├── _docs_gen/            # Doc generation (ref pages, skills, sdk2rest)\n├── mcp/                 # MCP server (published to npm as @pairsystems/goodmem-mcp)\n├── claude/              # Claude Code plugin (git subtree → public repo)\n├── vibe/                # Cross-SDK vibe auditing (audit_docs.sh, audit_ref_doc.sh, ...)\n├── registries/          # Shared model registries (copied into each SDK)\n├── ci/                  # CI infrastructure\n├── notes/               # Internal dev notes (clients_gen.md, docs_gen.md)\n├── clients_gen.sh        # Full SDK generation pipeline\n└── docs_gen.sh           # Full doc generation pipeline\n```\n\n## Development commands\n\n```bash\n# Generation (run from clients/, not python/)\ncd ..\n./clients_gen.sh                # compile server → IR → Python SDK → MCP → test\n./clients_gen.sh -y             # same, but skip server-reset confirmation (unattended/CI)\n./docs_gen.sh                   # ref pages + skills + snippets\n./docs_gen.sh --sdk2rest        # translate SDK test snippets → REST equivalents\n\n# Publishing (run from python/)\ncd python\n./publish.sh                   # Publish to PyPI\n./publish.sh --test            # Publish to TestPyPI\n\n# Vibe auditing (Claude Code non-interactive)\n../vibe/audit_docs.sh          # run all doc audits (ref docs + skill docs)\n../vibe/audit_ref_doc.sh       # audit generated MDX ref docs against SDK source\n../vibe/audit_skill_doc.sh     # audit generated skill reference (SDK, REST, patterns)\n```\nIn `clients_gen.sh`, integration test is only activated when environment variables `GOODMEM_BASE_URL` and `GOODMEM_API_KEY` are set.\n\n> **Warning:** Before the integration tests, `clients_gen.sh` runs `goodmem-reset.sh` to **delete ALL resources** on the target server. Never point `GOODMEM_BASE_URL` at a production server — use a throwaway local instance. (CI no longer resets anything: it composes a fresh server per suite and tears it down. See [ci/README.md](../ci/README.md).)\n\nSee [notes/clients_gen.md](../notes/clients_gen.md) for the full regeneration workflow and [notes/docs_gen.md](../notes/docs_gen.md) for the doc and auditing pipelines.\n\n\n\n## Documentation\n\n* [Code generation guide](../notes/clients_gen.md) — architecture, regeneration, testing, tier details\n* [Doc generation guide](../notes/docs_gen.md) — how ref docs are generated, docstring authoring\n* [CI pipeline](../ci/README.md) — GitHub Actions workflow, secrets, Fly.io test server setup\n* [API reference](https://docs.goodmem.ai/docs/reference/sdk/python) — published SDK docs\n\n## TODO\n\n1. Add `gemini-embedding-001` to embedder registry once backend adds `OPENAI_COMPATIBLE` to `ProviderType`.\n2. Add Anthropic, Google, Cohere, and Mistral LLMs to registry once backend adds matching `LLMProviderType` values.\n3. Automate model registry updates to add new models as they are released.\n4. Generate SDK to an intermediate representation, then map that to cURL, HTTPie, HTTPX, Go, JavaScript, etc. \n\n\n","type":"text"}]}

curl -s -m 15 https://docs.goodmem.ai/ -o /tmp/docs.html -w "%{http_code}\n"; curl -s -m 15 https://goodmem.com -o /tmp/home.html -w "%{http_code}\n"; curl -s -m 15 https://goodmem.com/pricing -o /tmp/pricing.html -w "%{http_code}\n"

python3 -c "
import re,html
t=open('/tmp/pricing.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S)
t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t)
t=html.unescape(re.sub(r'\s+',' ',t))
print(t[:4000])
"

{"content":[{"text":"  114 /tmp/pricing.html\n  114 /tmp/home.html\n26930 /tmp/docs.html\n27158 total\n<!DOCTYPE html><html><head><script>window.onload=function(){window.location.href=\"/lander\"}</script></head></html>","type":"text"}]}

python3 -c "
import re,html
t=open('/tmp/docs.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S)
t=re.sub(r'<style.*?</style>','',t,flags=re.S)
# collect links
links=re.findall(r'href=\"([^\"]+)\"',t)
print(links[:60])
t2=re.sub(r'<[^>]+>',' ',t)
t2=html.unescape(re.sub(r'\s+',' ',t2))
print(t2[:3000])
"

{"content":[{"text":"['/_next/static/media/e4af272ccee01ff0-s.p.woff2', '/goodmem-g-blue.png', '/_next/static/css/5c4fe2c5dade8579.css', '/_next/static/chunks/webpack-7d293a16a38cab91.js', 'https://docs.goodmem.ai/', '/favicon.ico', '/favicon.ico', '/favicon-192.png', '/favicon-192.png', '/', '/docs/', '/docs/reference/api-reference/']\n GoodMem Documentation GoodMem Search ⌘ K GoodMem Agentic AI Memory Infrastructure The memory layer between your agents and their data. GoodMem turns documents, knowledge, and history into persistent, governed memory and serves the right context to any model at retrieval time. Memory & Retrieval Multi-modal memories — text, image, audio, video — with hybrid semantic search, reranking, and streaming summaries Governed Access Principals, roles, grants, and scoped API keys control who can retrieve what, with auditable retrieval logging Open Model Stack First-class providers — OpenAI, TEI, vLLM, llama.cpp, Cohere, Jina, Voyage — over gRPC, REST, and SDKs in five languages Documentation API Reference \n","type":"text"}]}

for p in /docs/ /docs/quickstart /docs/quickstart/ /pricing /docs/pricing /docs/pricing/ /docs/getting-started/ /docs/reference/api-reference/; do code=$(curl -s -m 10 -o /tmp/page.html -w "%{http_code}" https://docs.goodmem.ai$p); echo "== $p $code $(wc -c </tmp/page.html)"; done

{"content":[{"text":"== /docs/ 200 254664\n== /docs/quickstart 404 15240\n== /docs/quickstart/ 404 15240\n== /pricing 404 15240\n== /docs/pricing 404 15240\n== /docs/pricing/ 404 15240\n== /docs/getting-started/ 404 15240\n== /docs/reference/api-reference/ 200 244452\n","type":"text"}]}

curl -s -m 15 https://docs.goodmem.ai/docs/ -o /tmp/d.html; python3 -c "
import re,html
t=open('/tmp/d.html').read()
links=sorted(set(re.findall(r'href=\"(/docs/[^\"]+)\"',t)))
for l in links: print(l)
" | head -80

{"content":[{"text":"/docs/concepts/security-model/\n/docs/get-started/nextsteps/\n/docs/reference/cli/\n/docs/reference/console/\n/docs/reference/sdk/\n/docs/reference/server-runtime/\n","type":"text"}]}

{"content":[{"text":"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n<url>\n<loc>https://docs.goodmem.ai/</loc>\n<lastmod>2026-09-10T22:50:39-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/</loc>\n<lastmod>2026-08-25T13:54:29-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/concepts/api-keys-and-ceilings/</loc>\n<lastmod>2026-09-02T17:12:05-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/concepts/roles-grants-and-selectors/</loc>\n<lastmod>2026-08-17T11:37:13-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/concepts/security-model/</loc>\n<lastmod>2026-08-25T22:22:35-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/concepts/users-and-service-identities/</loc>\n<lastmod>2026-08-26T11:40:38-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/get-started/nextsteps/</loc>\n<lastmod>2026-08-26T12:14:33-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/access-control/isolate-agents/</loc>\n<lastmod>2026-08-25T22:22:35-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/access-control/onboard-a-user/</loc>\n<lastmod>2026-08-25T22:22:35-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/access-control/redeem-an-enrollment/</loc>\n<lastmod>2026-08-25T22:22:35-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/access-control/scoped-api-keys/</loc>\n<lastmod>2026-08-25T22:22:35-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/access-control/service-identities/</loc>\n<lastmod>2026-08-25T22:22:35-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/access-control/share-a-space/</loc>\n<lastmod>2026-08-25T22:22:35-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/access-control/upgrade-authorization/</loc>\n<lastmod>2026-08-17T12:20:53-05:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/basic-rag/</loc>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/endpoint-registration/</loc>\n<lastmod>2026-09-01T22:09:32-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/hybrid-search/</loc>\n<lastmod>2026-01-19T16:54:57-08:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/install/</loc>\n<lastmod>2026-09-10T22:50:39-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/metadata-filters/</loc>\n<lastmod>2026-02-19T15:42:15-08:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/ocr-quickstart/</loc>\n<lastmod>2026-03-10T11:51:36-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/optimize-document-ingestion/</loc>\n<lastmod>2026-09-03T20:08:40-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/how-to/work-with-page-images/</loc>\n<lastmod>2026-09-03T20:08:40-07:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/integrations/</loc>\n<lastmod>2026-07-20T23:09:04+03:00</lastmod>\n</url>\n<url>\n<loc>https://docs.goodmem.ai/docs/i\n     29 API key\n     10 Cloud\n     10 API Key\n      2 hosted\n","type":"text"}]}

curl -s -m 10 https://docs.goodmem.ai/sitemap.xml | grep -o '<loc>[^<]*</loc>' | sed 's/<[^>]*>//g' > /tmp/urls.txt; wc -l /tmp/urls.txt; grep -iE "pric|install|start|cloud|server|deploy|sign" /tmp/urls.txt

{"content":[{"text":"402 /tmp/urls.txt\nhttps://docs.goodmem.ai/docs/get-started/nextsteps/\nhttps://docs.goodmem.ai/docs/how-to/install/\nhttps://docs.goodmem.ai/docs/how-to/ocr-quickstart/\nhttps://docs.goodmem.ai/docs/reference/api-reference/rest/access-policy/assignRole/\nhttps://docs.goodmem.ai/docs/reference/api-reference/rest/access-policy/getRoleAssignment/\nhttps://docs.goodmem.ai/docs/reference/api-reference/rest/access-policy/listRoleAssignments/\nhttps://docs.goodmem.ai/docs/reference/api-reference/rest/access-policy/revokeRoleAssignment/\nhttps://docs.goodmem.ai/docs/reference/api-reference/rest/admin/drainServer/\nhttps://docs.goodmem.ai/docs/reference/cli/access-policy/goodmem_access-policy_role-assignment/\nhttps://docs.goodmem.ai/docs/reference/cli/access-policy/goodmem_access-policy_role-assignment_assign/\nhttps://docs.goodmem.ai/docs/reference/cli/access-policy/goodmem_access-policy_role-assignment_get/\nhttps://docs.goodmem.ai/docs/reference/cli/access-policy/goodmem_access-policy_role-assignment_list/\nhttps://docs.goodmem.ai/docs/reference/cli/access-policy/goodmem_access-policy_role-assignment_revoke/\nhttps://docs.goodmem.ai/docs/reference/cli/space/goodmem_space_access_role_assign/\nhttps://docs.goodmem.ai/docs/reference/cli/system/goodmem_system_install/\nhttps://docs.goodmem.ai/docs/reference/cli/system/goodmem_system_start/\nhttps://docs.goodmem.ai/docs/reference/cli/system/goodmem_system_uninstall/\nhttps://docs.goodmem.ai/docs/reference/server-runtime/\n","type":"text"}]}

fetch(){ curl -s -m 15 "$1" | python3 -c "
import re,html,sys
t=sys.stdin.read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S)
t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t)
t=html.unescape(re.sub(r'\s+',' ',t))
print(t[:3500])
"; }
echo "=== INSTALL ==="; fetch https://docs.goodmem.ai/docs/how-to/install/
echo; echo "=== NEXTSTEPS ==="; fetch https://docs.goodmem.ai/docs/get-started/nextsteps/

{"content":[{"text":"=== INSTALL ===\n Install and Upgrade GoodMem | GoodMem Docs GoodMem GoodMem Search ⌘ K Getting Started How-To Guides Installation and Upgrade of GoodMem Building a Basic RAG Agent using GoodMem Endpoint registration guide Optimize Document Ingestion for Better Search OCR Quickstart Work with Document Page Images Hybrid Search Pipeline Guidelines Work Through Metadata Filters Users and Access Concepts Integrations Reference Installation and Upgrade of GoodMem How-To Guides Installation and Upgrade of GoodMem Install and upgrade GoodMem in restricted networks or offline environments using local CLI packages, container images, and registry mirrors. Installing in a network-restricted environment The default installer fetches from these upstream hosts: get.goodmem.ai — the GoodMem CLI tarball get.docker.com — the Docker engine installer (only when Docker is not yet installed) ghcr.io — the GoodMem server image docker.io — the PostgreSQL+pgvector image sigstore.dev — signature material for cosign verification When any of these is unreachable — typically inside a corporate firewall or in mainland China — the installer accepts a small set of flags that let you complete an install using a pre-staged CLI tarball plus a reachable registry mirror. This page walks through the canonical setup using Nanjing University's public mirrors ( ghcr.nju.edu.cn and docker.nju.edu.cn ) as the example. Substitute your own internal mirror hosts if you have them. That mirror-based flow is described first. If the target machine has no reachable registry at all — a true air-gap — see Fully offline install (air-gapped) below, which pre-stages the container images as well as the CLI tarball. Prerequisites Docker engine is already installed and reachable. The installer's auto-install path calls get.docker.com , which may also be blocked. On Debian/Ubuntu inside China, configure a Docker Hub mirror in /etc/docker/daemon.json once (e.g. https://docker.nju.edu.cn ) and sudo systemctl restart docker . Two files delivered out of band (email, scp, internal object storage): install.sh — the bash entry point (the same file served at https://get.goodmem.ai ). goodmem-<os>-<arch>.tar.gz — the CLI tarball matching the target platform (e.g. goodmem-linux-amd64.tar.gz ). A reachable mirror of ghcr.io that proxies pair-systems-inc/goodmem/server , such as ghcr.nju.edu.cn . A reachable mirror of docker.io that proxies pgvector/pgvector , such as mirror.gcr.io (Google's public Docker Hub proxy — globally reachable and proxies the full Docker Hub namespace). Not every Docker Hub mirror proxies every namespace — at the time of writing docker.nju.edu.cn returns 403 for pgvector/pgvector while serving other images fine. Before installing, verify with: docker pull < your-mirro r > /pgvector/pgvector:pg17 If that fails, pick a different mirror or rely on a daemon-level registry-mirrors config in /etc/docker/daemon.json instead. Install command bash install.sh \\ --local-cli-tarball ./goodmem-linux-amd64.tar.gz \\ --goodmem-image ghcr.nju.edu.cn/pair-systems-inc/goodmem/server:latest \\ --pgvector-image mirror.gcr.io/pgvector/pgvector:pg17 \\ --skip-verify \\ --handsfree --db-password \"your-secure-password-min-14-chars\" \\ --tls-disabled What each flag does: Flag Effect --local-cli-tarball <path> Use this tarball instead of downloading from get.goodmem.ai . --goodmem-image <ref> Override the GoodMem server image — point at a mirrored registry (e.g. ghcr.nju.edu.cn/... ). --pgvector-image <ref> Override the pgvect\n\n=== NEXTSTEPS ===\n Getting Started GoodMem GoodMem Search ⌘ K Getting Started How-To Guides Concepts Integrations Reference Getting Started Getting Started Getting started with GoodMem configuration and testing By now you should have installed GoodMem, either manually or through the devcontainer. If you have not completed this step, please begin with the installation . Prefer a visual interface? The GoodMem server includes a built-in web console at /console/ . It walks you through the same setup steps below — creating an embedder, space, and LLM — without needing the command line. See the Console documentation for details. Note: OCR (Optical Character Recognition) is provided by the GoodMem OCR add-on service/image and is not included in the base install. If you plan to use OCR, enable the add-on and configure GOODMEM_OCR_BASE_URL . Devcontainer Setup (Skip if you installed GoodMem manually) Click below to open a Codespace using the GoodMem template repository: Open Codespace To view your GoodMem API Key, use this command: grep api_key ~/.goodmem/config.toml Configuration Steps When installation completes, you should see output similar to the following: ✓ Installation completed successfully! ℹ GoodMem is ready to use. ℹ Web console: https://localhost:8080/console ℹ Active profile: default ℹ Server URL: https://localhost:9090 ℹ API Key: gm_xxxxxxxxxxxxxxxxxxxxxxxx ℹ Install type: local-docker The default install uses a self-signed certificate. TLS is enabled out of the box, but clients (browsers, SDKs, curl ) cannot verify the ephemeral certificate. For local development we recommend mkcert — it creates locally-trusted certificates in minutes and eliminates TLS errors in every language. If you already installed with the default self-signed setup, the same guide includes a step-by-step migration for switching that install to mkcert later. See TLS Configuration for the full set of options. The installer saves your root API key to the active CLI profile automatically, so CLI commands work immediately. If you plan to use the SDKs or REST API directly, note the key from the output above — it is only shown once. You can also use the command below to grab the GoodMem api key: grep api_key ~/.goodmem/config.toml The Security Model page explains how API keys and permissions work. Obtain your OpenAI API Key from the OpenAI dashboard and keep it ready for the next step. To keep the key out of your shell history, export it as GOODMEM_CRED_API_KEY and omit --cred-api-key in the next step; the CLI reads the environment variable when the flag is absent. Create an embedder (must be created before a space): goodmem embedder create \\ --display-name \"OpenAI Small Embedder\" \\ --provider-type OPENAI \\ --endpoint-url \"https://api.openai.com/v1\" \\ --model-identifier \"text-embedding-3-small\" \\ --dimensionality 1536 \\ --cred-api-key YOUR_OPENAI_API_KEY_FROM_STEP_3 The command should output: Embedder created successfully! ID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx Display Name: OpenAI Small Embedder Owner: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx Provider Type: OPENAI Distribution: DENSE Endpoint URL: https://api.openai.com/v1 API Path: /embeddings Model: text-embedding-3-small Dimensionality: 1536 Modalities: TEXT Created by: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx Created at: 2026-08-20T21:09:00Z SAVE THE ID Need help choosing endpoint_url or api_path for a provider? See the Endpoint registration guide . Create a space linked to that embedder: goodmem space create \\ --name \"My OpenAI Sma\n","type":"text"}]}

grep -iE "pric|billing|plan|tier|subscription|cost|\\$" /tmp/urls.txt; echo "---"; curl -s -m 10 https://get.goodmem.ai | head -c 800; echo; echo "---"; curl -s -m 10 -o /dev/null -w "%{http_code}\n" https://app.goodmem.ai https://cloud.goodmem.ai https://api.goodmem.ai

{"content":[{"text":"---\n#!/usr/bin/env bash\n#\n# GoodMem Installer\n#\n# Downloads the GoodMem CLI binary and runs 'goodmem system install' with optional arguments.\n# All arguments are forwarded directly to the CLI installer.\n#\n# Usage: curl -s https://get.goodmem.ai | bash [-s -- [destination_dir] [installer_flags...]]\n#\n# Examples:\n#   # Interactive installation (default)\n#   curl -s https://get.goodmem.ai | bash\n#\n#   # Non-interactive with required flags\n#   curl -s https://get.goodmem.ai | bash -s -- --handsfree --db-password \"my-secure-password\"\n#\n#   # Custom installation directory\n#   curl -s https://get.goodmem.ai | bash -s -- /usr/local/bin\n#\n#   # Remote database configuration\n#   curl -s https://get.goodmem.ai | bash -s -- --handsfree --remote-db \\\n#     --db-url \"postgresql://user:pass@host:5432/goodmem\n---\n302\n302\n000\n\n\nCommand exited with code 6","type":"text"}],"details":{}}

curl -s -m 10 -o /dev/null -w "app: %{http_code} -> %{redirect_url}\n" https://app.goodmem.ai; curl -s -m 10 -o /dev/null -w "cloud: %{http_code} -> %{redirect_url}\n" https://cloud.goodmem.ai; curl -s -m 15 https://goodmem.ai -o /tmp/gai.html -w "goodmem.ai: %{http_code}\n"; python3 -c "
import re,html
t=open('/tmp/gai.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=html.unescape(re.sub(r'\s+',' ',re.sub(r'<[^>]+>',' ',t)))
print(t[:2500])" 2>/dev/null

{"content":[{"text":"app: 302 -> https://app.goodmem.ai/login\ncloud: 302 -> https://cloud.goodmem.ai/login\ngoodmem.ai: 200\n Goodmem - Agentic AI Memory Infrastructure Available in Anthropic's Claude Code marketplace | 3.6k+ installs Available in Google ADK's Tools & Integrations for Agents | 36.5k+ Docker pulls Now available on Google Cloud Marketplace Available in Activepieces npm package | 5.5k+ downloads GoodMem Features Cloud Pricing Quick Start Resources Sign in Start free System status Memory that survives context windows. GoodMem is memory infrastructure for AI agents. It connects your documents, knowledge bases, and history to any model's context window — the right context, at the right time. In a controlled benchmark on a production agent, that cut token burn by 28%. see the study → Start free Self-host terminal # Install goodmem user@goodmem :~$ curl -s \"https://get.goodmem.ai\" | bash SDKs in five languages Python TypeScript Java .NET Go Smarter agents, lower token bills Adding a memory layer makes your agents sharper, more grounded, and far cheaper to run. Proven on your workload The Retrieval Optimizer in GoodMem Cloud compares embedding models and rerankers — open-weight or API — on your real queries and validates the winner on held-out data. Evidence, not vibes. Lower token spend Retrieve only the context that matters instead of stuffing full history into every prompt. In our benchmark, agents also finished with 23% fewer reasoning steps — and no measurable drop in answer quality. Read the study Governed & grounded Memory with authorization built in: owners, roles, scoped API keys, and every retrieval logged. Answers stay grounded in your own sources; security teams keep control. See the security comparison From document Q&A to multi-agent systems Start with one agent and a folder of documents — the same memory layer scales to orchestrated agent teams. RAG Systems From simple document Q&A to enterprise knowledge systems with semantic search and persistent context. AI Assistants & Agents From basic conversational responses to agents with persistent memory and personalization. Agent Workflows From simple task automation to orchestrated multi-agent systems with shared memory and coordination. One pipeline, any provider “ The ability to swap providers, mix local and cloud infrastructure, and keep the retrieval pipeline consistent across all of them is genuinely impressive. B. — migrated a RAG pipeline from OpenAI to AWS Bedrock to a Mac Mini running Ollama OpenAI AWS Bedrock Ollama First-class support for the open model stack — vLLM, TEI, Ollama, OpenRouter — alongsi\n","type":"text"}]}

for u in https://goodmem.ai/pricing https://goodmem.ai/cloud https://goodmem.ai/quick-start https://goodmem.ai/quickstart; do echo "== $u"; curl -s -m 15 -L "$u" -o /tmp/p.html -w "%{http_code} %{size_download}\n"; python3 -c "
import re,html
t=open('/tmp/p.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=html.unescape(re.sub(r'\s+',' ',re.sub(r'<[^>]+>',' ',t)))
print(t[:2500])"; echo; done

{"content":[{"text":"== https://goodmem.ai/pricing\n200 37845\n Pricing | Goodmem Available in Anthropic's Claude Code marketplace | 3.6k+ installs Available in Google ADK's Tools & Integrations for Agents | 36.5k+ Docker pulls Now available on Google Cloud Marketplace Available in Activepieces npm package | 5.5k+ downloads GoodMem Features Cloud Pricing Quick Start Resources Sign in Start free Simple, transparent pricing Always free to self-host. Or start a free 14-day trial of fully managed GoodMem Cloud — no credit card required. Self-hosted Production-ready self-hosting, free for commercial use. Free Self-host GoodMem What's included: Free for commercial SaaS – build and monetize your app; 100% free for internal ops and commercial use. Embed & ship anywhere – royalty-free distribution for Docker, VMs, and on-prem installers. Perpetual version rights included. Unlimited memories per node – your hardware, your limits; we impose zero artificial caps. High-performance gRPC API – tap directly into gRPC for maximum throughput and low latency. Multi-language SDKs – first-class support for Python, Java, Go, JS, and .NET. Read the GoodMem Free Binary License Fully managed GoodMem Cloud Continuously optimized for your data — ready in seconds. From $15 /mo Start free What's included: Free 14-day trial – full-featured, no credit card required. Auto-Optimizer – continuous fine-tuning on your data to automatically maximize recall and relevance. Fully managed hosting – we run, monitor, scale, and update your instance while you focus on product. Instant provisioning – a ready-to-use GoodMem instance in seconds; sign in with Google or GitHub. Fair, usage-based pricing – starts at $15/mo and scales with what you use, no surprise overages. Pricing estimator coming soon Enterprise For OEMs, regulated industries, and managed service providers. Custom Contact Us What's included: MSP & Reseller License – Permission to sell GoodMem as a managed service or multi-tenant platform to your customers. Commercial IP indemnification – available under negotiated enterprise terms. OEM & White-Label Rights – Remove all GoodMem branding for a seamless embedded customer experience. Source Code Access – Full security auditing rights and source code availability for compliance. Managed High-Availability – 99.99% uptime SLA with 24/7 dedicated incident response, under a signed enterprise agreement. GPU-Accelerated OCR – Extract text from scanned PDFs and images with built-in vision model processing. How usage-based pricing works on GoodMem Cloud This ap\n\n== https://goodmem.ai/cloud\n200 48673\n GoodMem Cloud | Goodmem Available in Anthropic's Claude Code marketplace | 3.6k+ installs Available in Google ADK's Tools & Integrations for Agents | 36.5k+ Docker pulls Now available on Google Cloud Marketplace Available in Activepieces npm package | 5.5k+ downloads GoodMem Features Cloud Pricing Quick Start Resources Sign in Start free GoodMem Cloud Managed memory that optimizes itself. GoodMem Cloud runs the whole stack for you — instant provisioning, a built-in auto-optimizer that continuously fine-tunes your instance, and usage-based pricing. Same GoodMem, zero ops. Start free Prefer to self-host? Free 14-day trial · no credit card · sign in with Google or GitHub Why GoodMem Cloud Everything you love about GoodMem, fully managed — plus an optimizer that keeps your memory tuned to your data over time. Auto-Optimizer Continuous fine-tuning on your own data automatically maximizes recall and relevance — the managed advantage you can't get self-hosting. See the fine-tuning benchmark Instant provisioning A ready-to-use GoodMem instance in seconds. Sign in with Google or GitHub and start storing memories immediately — no infrastructure to set up. Start free Fully managed We run, monitor, scale, and upgrade your instance. No servers, databases, or version upgrades to babysit. Secure & isolated Every workspace is provisioned with a separate GoodMem application instance and database, with encrypted credentials. Read the security model Usage-based pricing Pay only for the compute and storage you actually use. No seats, no surprise overages — see exact rates in the console. See pricing Same GoodMem, zero ops The full GoodMem API, SDKs, and web console you already know — without the overhead of running it yourself. Explore the full feature set Your first memory in under a minute No infrastructure and nothing to configure: sign in, get your instance, point your agent at the API. 1 Sign in Google, GitHub, or an emailed magic link. No credit card and nothing to install. Start free 2 Get your instance A managed GoodMem instance is provisioned for you in seconds. Teams, instances, usage, and billing live in one dashboard. See how usage-based pricing works 3 Connect your data Store and retrieve memories from any language over the REST API, or use the Python, JavaScript, Java, .NET, and Go SDKs. Build your first RAG flow import requests BASE = \"https://<your-instance>\" # shown in your console HEADERS = {\"x-api-key\": \"your-api-key\"} # Store a memory requests.post(f\"{BAS\n\n== https://goodmem.ai/quick-start\n200 92150\n Quick Start Guide | Goodmem Available in Anthropic's Claude Code marketplace | 3.6k+ installs Available in Google ADK's Tools & Integrations for Agents | 36.5k+ Docker pulls Now available on Google Cloud Marketplace Available in Activepieces npm package | 5.5k+ downloads GoodMem Features Cloud Pricing Quick Start Resources Sign in Start free Get Started Now Choose how you want to deploy GoodMem Already installed? Skip to what's next Start without installing Use a managed instance or launch a ready-to-code browser environment GoodMem Cloud Managed service Choose your region and instance size. We provision and operate GoodMem for you. Choose your deployment region Flexible instance sizing Automatic backups Start free 14-day free trial No credit card required GitHub Codespaces Browser playground Launch GoodMem in a fully configured cloud development environment with no local setup. VS Code in browser Pre-installed dependencies Live examples & tutorials Launch Install Locally Full control, runs on your server terminal curl -s \"https://get.goodmem.ai\" | bash Installs server, web console , CLI , and all dependencies Windows? Install via WSL · Advanced: Server flags · TLS setup · CLI only: --cli-only Self-host in your cloud Production-ready deploys on infrastructure you own Self-serve deploys · from ~$20/mo curl -s https://get.goodmem.ai/railway | bash Two services: GoodMem server + PostgreSQL/pgvector container with persistent volume Instant public URL with HTTPS — gRPC requires manual TCP proxy 3 min curl -s https://get.goodmem.ai/flyio | bash Two apps: GoodMem server + PostgreSQL/pgvector container with persistent volume Instant public URL with HTTPS — REST and gRPC endpoints ready 3 min Amazon Lightsail curl -s https://get.goodmem.ai/lightsail | bash Lightsail Ubuntu VM + AWS managed PostgreSQL Static IP with instance-level TLS — bring your own domain 15 min Hetzner curl -s https://get.goodmem.ai/hetzner | bash Single server: GoodMem + PostgreSQL/pgvector containers with persistent volume Instant public URL via sslip.io with HTTPS + gRPC — lowest cost per GB 2 min Enterprise marketplace Google Cloud Marketplace GoodMem Enterprise Production deployment in your own GCP project, with an enterprise support policy included Billed through your Google Cloud account — counts toward committed-use spend View on Google Cloud Marketplace Talk to sales What to do next You're installed — now put GoodMem to work. Configure & Test Create an embedder, set up a space, ingest \n\n== https://goodmem.ai/quickstart\n404 20632\n Page Not Found Available in Anthropic's Claude Code marketplace | 3.6k+ installs Available in Google ADK's Tools & Integrations for Agents | 36.5k+ Docker pulls Now available on Google Cloud Marketplace Available in Activepieces npm package | 5.5k+ downloads GoodMem Features Cloud Pricing Quick Start Resources Sign in Start free 404 Page not found The page you're looking for doesn't exist or has been moved. Don't worry, even AI agents lose their way sometimes. Go Back Go Home Looking for something specific? Popular Pages → Home → Features → Pricing → Quick Start Resources → Documentation → Demos → Support Can't find what you're looking for? Try searching our documentation GoodMem The memory layer for agentic AI. Build intelligent agents with persistent, searchable memory infrastructure. Product Features Pricing Demo About Cloud Overview Console Terms of Service Privacy Policy Data Processing Addendum Enterprise Enterprise Security GoodMem vs Vector DB Security Trust Center License Documentation Whitepapers FAQ Quick Start Documentation API Reference Community Blog Forums Twitter Contact © 2026 PAIR Systems, Inc. All rights reserved. System status Cookie preferences Built for developers who build the future. \n\n","type":"text"}]}

curl -s -m 15 https://goodmem.ai/pricing -o /tmp/pr.html; python3 -c "
import re,html
t=open('/tmp/pr.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=html.unescape(re.sub(r'\s+',' ',re.sub(r'<[^>]+>',' ',t)))
i=t.find('How usage-based pricing works')
print(t[i:i+3000])"

{"content":[{"text":"How usage-based pricing works on GoodMem Cloud This applies to the GoodMem Cloud plan only. Self-hosting has no usage fees, and Enterprise pricing is quoted per deployment. Metered by the second Every GoodMem instance bills by the second, and only while it is running. Month-to-date costs appear on your dashboard as they accrue. Pause when idle Pausing an instance stops its compute charges. You keep paying only for the data it stores, which costs far less than compute. The rate is the instance size Each instance size has a fixed hourly rate. Every size's exact rate is on the rate sheet in your console. One invoice per team Once a month your team receives a single invoice with a line for each instance. Small balances roll into the next month instead of triggering a charge. Spend caps on tuning Auto-Optimizer fine-tuning runs are metered the same way against a spend cap you set. A run that reaches its cap halts instead of overspending. Need something bespoke? We work with enterprise customers to build custom solutions that fit your specific requirements, including on-premise deployments, custom SLAs, and specialized integrations. Contact Us Our team will respond within one business day Frequently asked questions Everything you need to know about using and distributing GoodMem. Who is GoodMem for? GoodMem is designed for developers building AI agents that need persistent memory. Whether you're creating customer support bots, coding assistants, or analytics agents, GoodMem helps your AI remember context across conversations and sessions. Where does GoodMem fit into my agent stack? GoodMem acts as the memory layer between your AI agent and its data sources. It integrates with popular frameworks like LangChain and LlamaIndex, and works alongside any LLM provider (OpenAI, Anthropic, etc.) to give your agents persistent, searchable memory. What is a \"memory\" in GoodMem? A memory is a document, not an extracted fact. When you create one you submit the original content along with its content type and an optional metadata object. GoodMem stores that original content, extracts text from it, splits it into chunks according to the space's chunking configuration, and embeds each chunk. Retrieval returns chunks, each of which cites the memory and the position it came from. One memory therefore produces many indexed chunks, and chunk count — not memory count — is what drives storage. Is GoodMem open source? No. GoodMem is not open source. The server is proprietary software distributed as a binary under the GoodMem Free Binary License, which grants continuing rights to use versions you validly obtain, subject to the license's terms, but does not grant rights in the source code. The client SDKs are published under Apache-2.0 and are open source; the server is not. \"Free\" in the license name refers to price for the covered uses, not to software freedom. What if you change the license later? Our license includes perpetual version rights (Section 5), so if we release a\n","type":"text"}]}

python3 -c "
import re,html
t=open('/tmp/p.html').read()
" ; curl -s -m 15 https://goodmem.ai/cloud -o /tmp/cl.html; python3 -c "
import re,html
t=open('/tmp/cl.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=html.unescape(re.sub(r'\s+',' ',re.sub(r'<[^>]+>',' ',t)))
i=t.find('Your first memory')
print(t[i:i+2500])"

{"content":[{"text":"Your first memory in under a minute No infrastructure and nothing to configure: sign in, get your instance, point your agent at the API. 1 Sign in Google, GitHub, or an emailed magic link. No credit card and nothing to install. Start free 2 Get your instance A managed GoodMem instance is provisioned for you in seconds. Teams, instances, usage, and billing live in one dashboard. See how usage-based pricing works 3 Connect your data Store and retrieve memories from any language over the REST API, or use the Python, JavaScript, Java, .NET, and Go SDKs. Build your first RAG flow import requests BASE = \"https://<your-instance>\" # shown in your console HEADERS = {\"x-api-key\": \"your-api-key\"} # Store a memory requests.post(f\"{BASE}/v1/memories\", headers=HEADERS, json={ \"spaceId\": \"your-space-id\", \"contentType\": \"text/plain\", \"originalContent\": \"User prefers dark mode and Python\", }) Cloud or self-host — your call Same GoodMem either way. Choose managed convenience or full control. GoodMem Cloud Fully managed and self-optimizing. Fully managed and auto-scaled Auto-Optimizer included Instant setup — sign in with Google or GitHub Usage-based pricing, pay for what you use Free 14-day trial, no credit card Start free Self-host Run it yourself, anywhere. Free for commercial use Run on your own infrastructure Full control over your data No usage fees — your hardware, your limits Ships in Docker, VMs, and on-prem installers Read the Quick Start Start building on GoodMem Cloud Spin up a managed, self-optimizing memory layer in seconds. Free for 14 days, no credit card required. Start free GoodMem The memory layer for agentic AI. Build intelligent agents with persistent, searchable memory infrastructure. Product Features Pricing Demo About Cloud Overview Console Terms of Service Privacy Policy Data Processing Addendum Enterprise Enterprise Security GoodMem vs Vector DB Security Trust Center License Documentation Whitepapers FAQ Quick Start Documentation API Reference Community Blog Forums Twitter Contact © 2026 PAIR Systems, Inc. All rights reserved. System status Cookie preferences Built for developers who build the future. \n","type":"text"}]}

curl -s -m 15 https://docs.goodmem.ai/docs/how-to/basic-rag/ -o /tmp/rag.html; python3 -c "
import re,html
t=open('/tmp/rag.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=html.unescape(re.sub(r'\s+',' ',re.sub(r'<[^>]+>',' ',t)))
i=t.find('Building a Basic RAG')
print(t[i:i+4000])"

{"content":[{"text":"Building a Basic RAG Agent using GoodMem Endpoint registration guide Optimize Document Ingestion for Better Search OCR Quickstart Work with Document Page Images Hybrid Search Pipeline Guidelines Work Through Metadata Filters Users and Access Concepts Integrations Reference Building a Basic RAG Agent using GoodMem How-To Guides Building a Basic RAG Agent using GoodMem Build a RAG agent with GoodMem: register an embedder and LLM, ingest text and PDFs into a space, retrieve context, and optionally add a reranker. What you’ll build Retrieval-augmented generation (RAG) injects knowledge from external sources (for example, documents) into an LLM—no retraining required—so it can answer questions or make decisions it otherwise couldn't. That knowledge is hot-swappable: add, remove, or replace sources to update what the LLM should know. GoodMem is the memory layer between your agent and its data, providing persistent, searchable context. It manages embedders, LLMs, and rerankers as first-class resources you wire together at query time, and it can be extended with advanced optimization via GoodMem Cloud Tuner (private beta). In this tutorial, you'll see how quickly you can build a RAG agent in GoodMem. Prerequisites Get an OpenAI API key. Then set the environment variable: export OPENAI_API_KEY = \"your_openai_api_key\" Install GoodMem: curl -s https://get.goodmem.ai | bash -s -- --handsfree \\ --db-password \"your-secure-password-min-14-chars\" \\ --tls-disabled The installation script prints a Web console URL and a GoodMem API key. The REST base URL is the web-console URL without the trailing /console (for the command above, normally http://localhost:8080 ). The separately printed Server URL is the gRPC endpoint used by the CLI, not the REST endpoint. Export the REST base URL and API key for this tutorial: export GOODMEM_BASE_URL = \"your_goodmem_base_url\" export GOODMEM_API_KEY = \"your_goodmem_api_key\" Note that GOODMEM_BASE_URL should not contain the /v1 suffix. Install the SDK based on how you'll interface with GoodMem. CLI cURL Python Go Java TypeScript .NET Nothing to do; the GoodMem CLI is installed as part of the GoodMem installation. Skip this section. If your server isn't running on the default gRPC endpoint ( https://localhost:9090 ; installs created with --tls-disabled , like the one above, use http://localhost:9090 , which the installer-written CLI profile already points at), add --server to the CLI commands (the CLI does not use GOODMEM_BASE_URL ). Nothing to do; cURL is standard on most Linux distributions. Skip this section. pip install goodmem Then set up your Python environment: import json import os import time from goodmem import Goodmem GOODMEM_BASE_URL = os.environ[ \"GOODMEM_BASE_URL\" ] GOODMEM_API_KEY = os.environ[ \"GOODMEM_API_KEY\" ] OPENAI_API_KEY = os.environ[ \"OPENAI_API_KEY\" ] client = Goodmem( base_url = GOODMEM_BASE_URL , api_key = GOODMEM_API_KEY , # The streaming retrieve (Step 3 below) drives an LLM end-to-end and can # take 30–90 seconds on a cold server before the first event arrives — # well past the SDK's default 30s read timeout. The example should run # reliably against cold deployments (e.g. Fly machines that auto-stop), # not just warm dev boxes, so we use a generous 180s timeout here. timeout = 180.0 , ) go mod init basicrag go env -w GOPROXY=\"https://go-proxy.fury.io/pairsys/,https://proxy.golang.org,direct\" go env -w GONOSUMDB=\"fury.io/pairsys/*\" go get fury.io/pairsys/goodmem@latest The SDK requires Go 1.23 or newer. Create a main.go file with the required imports and client configuration: package main import ( \" context \" \" encoding/json \" \" fmt \" \" log \" \" os \" \" time \" goodmem \" fury.io/pairsys/goodmem \" \" fury.io/pairsys/goodmem/models \" ) func main () { // Set up variables goodmemBaseURL := os. Getenv ( \"GOODMEM_BASE_URL\" ) goodmemAPIKey := os. Getenv ( \"GOODMEM_API_KEY\" ) openAIAPIKey := os. Getenv ( \"OPENAI_API_KEY\" ) client, err := goodmem. New (goodmemBaseURL, goodmemAPIKey) if err != nil \n","type":"text"}]}

curl -s -m 10 -L https://app.goodmem.ai/login -o /tmp/login.html -w "%{http_code} %{url_effective}\n"; python3 -c "
import re,html
t=open('/tmp/login.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=html.unescape(re.sub(r'\s+',' ',re.sub(r'<[^>]+>',' ',t)))
print(t[:1200])"

{"content":[{"text":"200 https://app.goodmem.ai/login\n GoodMem Cloud Console made text metrics depend on a third-party CDN: with it blocked, the same string measures 12% wider in the fallback face, which turned the layout audit red on an unmodified tree. Do not reintroduce the CDN link. --> \n","type":"text"}]}

python3 - <<'EOF'
from goodmem import Goodmem
import inspect
print([a for a in dir(Goodmem) if not a.startswith('_')][:40])
sig = inspect.signature(Goodmem.__init__)
print(sig)
EOF

{"content":[{"text":"['close']\n(self, base_url: 'str | None' = None, api_key: 'str | None' = None, *, timeout: 'float | httpx.Timeout | None' = <object object at 0x7f1aa8f7ba70>, verify: 'bool | str' = <object object at 0x7f1aa8f7ba70>, http_client: 'httpx.Client | None' = None, stream_max_line_bytes: 'int | None' = None) -> 'None'\n","type":"text"}]}

python3 - <<'EOF'
from goodmem import Goodmem
c = Goodmem(base_url="http://x", api_key="gm_x")
attrs = [a for a in dir(c) if not a.startswith('_')]
print(attrs)
for a in attrs:
    o = getattr(c, a)
    print(a, [m for m in dir(o) if not m.startswith('_')][:15])
EOF

{"content":[{"text":"['access_policy', 'admin', 'apikeys', 'close', 'embedders', 'instance', 'llms', 'memories', 'ocr', 'ping', 'rerankers', 'service_identities', 'spaces', 'system', 'user_enrollments', 'users']\naccess_policy ['check', 'grants', 'role_assignments']\nadmin ['background_jobs', 'drain', 'license', 'retrieve_memory_log_policies', 'transfer_instance_ownership']\napikeys ['create', 'delete', 'get', 'list', 'update']\nclose []\nembedders ['create', 'delete', 'get', 'list', 'update']\ninstance ['get']\nllms ['create', 'delete', 'get', 'list', 'update']\nmemories ['batch_create', 'batch_delete', 'batch_get', 'content', 'create', 'delete', 'get', 'list', 'pages', 'pages_image', 'retrieve']\nocr ['document']\nping ['once', 'stream']\nrerankers ['create', 'delete', 'get', 'list', 'update']\nservice_identities ['create', 'delete', 'get', 'list', 'transfer_ownership', 'update']\nspaces ['create', 'delete', 'get', 'list', 'transfer_ownership', 'update']\nsystem ['info', 'init']\nuser_enrollments ['complete']\nusers ['create', 'create_enrollment', 'delete', 'get', 'get_by_username', 'get_enrollment', 'list', 'list_enrollments', 'me', 'revoke_enrollment', 'update']\n","type":"text"}]}

python3 - <<'EOF'
from goodmem import Goodmem
import inspect
c = Goodmem(base_url="http://x", api_key="gm_x")
for name in ["embedders.create","spaces.create","memories.create","memories.retrieve","llms.create"]:
    obj = c
    for part in name.split('.'):
        obj = getattr(obj, part)
    try:
        print(name, str(inspect.signature(obj))[:600], "\n")
    except Exception as e:
        print(name, "ERR", e)
EOF

{"content":[{"text":"embedders.create (*, display_name: 'str', model_identifier: 'str', api_key: 'str | None' = None, api_path: 'str | None' = None, credentials: 'EndpointAuthentication | None' = None, dashscope_api_dialect: 'DashScopeApiDialect | None' = None, description: 'str | None' = None, dimensionality: 'int | None' = None, distribution_type: 'DistributionType' = 'DENSE', embedder_id: 'str | None' = None, endpoint_url: 'str | None' = None, gemini_endpoint_config: 'GeminiEndpointConfig | None' = None, labels: 'dict[str, str] | None' = None, max_sequence_length: 'int | None' = None, monitoring_endpoint: 'str | None' = None, o \n\nspaces.create (*, name: 'str', space_embedders: 'list[SpaceEmbedderConfig]', default_chunking_config: 'ChunkingConfiguration' = {'recursive': {'chunkSize': 512, 'chunkOverlap': 64, 'keepStrategy': 'KEEP_END', 'lengthMeasurement': 'CHARACTER_COUNT'}}, labels: 'dict[str, str] | None' = None, owner_id: 'str | None' = None, space_id: 'str | None' = None) -> 'Space' \n\nmemories.create (*, space_id: 'str', chunking_config: 'ChunkingConfiguration | None' = None, content_type: 'str | None' = None, extract_page_images: 'bool | None' = None, memory_id: 'str | None' = None, metadata: 'dict[str, Any] | None' = None, original_content: 'str | None' = None, original_content_b64: 'str | None' = None, original_content_ref: 'str | None' = None, file_path: 'str | None' = None) -> 'Memory' \n\nmemories.retrieve (*, message: 'str', chronological_resort: 'bool | None' = None, context: 'list[ContextItem] | None' = None, fetch_memory: 'bool | None' = None, fetch_memory_content: 'bool | None' = None, gen_token_budget: 'int | None' = None, hnsw: 'HnswOptions | None' = None, llm_id: 'str | None' = None, llm_temp: 'float | None' = None, logging: 'LoggingOptions | None' = None, max_results: 'int | None' = None, output_budget: 'TokenBudget | None' = None, post_processor: 'PostProcessor | None' = None, prompt: 'str | None' = None, relevance_threshold: 'float | None' = None, requested_size: 'int | None' = None,  \n\nllms.create (*, display_name: 'str', model_identifier: 'str', api_key: 'str | None' = None, api_path: 'str | None' = None, capabilities: 'LLMCapabilities | None' = None, client_config: 'dict[str, Any] | None' = None, credentials: 'EndpointAuthentication | None' = None, dashscope_api_dialect: 'DashScopeApiDialect | None' = None, default_sampling_params: 'LLMSamplingParams | None' = None, description: 'str | None' = None, endpoint_url: 'str | None' = None, labels: 'dict[str, str] | None' = None, llm_id: 'str | None' = None, max_context_length: 'int | None' = None, monitoring_endpoint: 'str | None' = None, o \n\n","type":"text"}]}

python3 - <<'EOF'
from goodmem import Goodmem
import inspect
c = Goodmem(base_url="http://x", api_key="gm_x")
sig = inspect.signature(c.memories.retrieve)
print(list(sig.parameters))
print(sig.return_annotation)
EOF
python3 -c "
from goodmem.models import SpaceEmbedderConfig, MemoryRetrievalResponse
import inspect
print(SpaceEmbedderConfig.model_fields.keys() if hasattr(SpaceEmbedderConfig,'model_fields') else inspect.signature(SpaceEmbedderConfig.__init__))
" 2>&1 | tail -3

{"content":[{"text":"['message', 'chronological_resort', 'context', 'fetch_memory', 'fetch_memory_content', 'gen_token_budget', 'hnsw', 'llm_id', 'llm_temp', 'logging', 'max_results', 'output_budget', 'post_processor', 'prompt', 'relevance_threshold', 'requested_size', 'reranker_id', 'space_ids', 'space_keys', 'sys_prompt', 'stream']\nRetrieveMemoryStream | list[RetrieveMemoryEvent]\nTraceback (most recent call last):\n  File \"<string>\", line 2, in <module>\nImportError: cannot import name 'MemoryRetrievalResponse' from 'goodmem.models' (/opt/freestyle/python/lib/python3.12/site-packages/goodmem/models/__init__.py)\n","type":"text"}]}

python3 - <<'EOF'
from goodmem.models import SpaceEmbedderConfig, RetrieveMemoryEvent
print("SpaceEmbedderConfig:", list(SpaceEmbedderConfig.model_fields))
print("RetrieveMemoryEvent:", list(RetrieveMemoryEvent.model_fields))
EOF

{"content":[{"text":"SpaceEmbedderConfig: ['embedder_id', 'default_retrieval_weight']\nRetrieveMemoryEvent: ['result_set_boundary', 'abstract_reply', 'retrieved_item', 'memory_definition', 'status']\n","type":"text"}]}

python3 - <<'EOF'
from goodmem.models import RetrievedItem
print(list(RetrievedItem.model_fields))
EOF

python3 - <<'EOF'
from goodmem.models import RetrievedItem
f = RetrievedItem.model_fields
print(f['chunk'].annotation, f['memory'].annotation)
from goodmem import models
import inspect
# find chunk-like model
names = [n for n in dir(models) if 'Chunk' in n or 'Citation' in n]
print(names)
EOF
grep -rn "retrieved_item" /opt/freestyle/python/lib/python3.12/site-packages/goodmem --include=*.py -l | head -5

{"content":[{"text":"goodmem.models.chunk_reference.ChunkReference | None goodmem.models.memory.Memory | None\n['ChunkReference', 'ChunkingConfiguration', 'MemoryChunkResponse', 'NoChunkingConfiguration', 'RecursiveChunkingConfiguration', 'SentenceChunkingConfiguration']\n/opt/freestyle/python/lib/python3.12/site-packages/goodmem/models/__init__.py\n/opt/freestyle/python/lib/python3.12/site-packages/goodmem/models/retrieve_memory_event.py\n/opt/freestyle/python/lib/python3.12/site-packages/goodmem/streaming.py\n","type":"text"}]}

python3 - <<'EOF'
from goodmem.models import ChunkReference
print(list(ChunkReference.model_fields))
EOF

{"content":[{"text":"Successfully replaced 1 block(s) in /sandbox/repo/goodmem_example.py.","type":"text"}],"details":{"diff":"    ...\n 52     )\n 53     print(f\"Stored memory: {mem.memory_id}\")\n 54 \n 55 # 4. Retrieve relevant chunks for a query (semantic search, no LLM needed).\n-56 result = client.memories.retrieve(\n+56 events = client.memories.retrieve(\n 57     message=\"When do database migrations happen?\",\n 58     space_ids=[space.space_id],\n 59     requested_size=3,\n 60 )\n-61 for hit in result.chunks:\n-62     print(f\"[score={hit.distance:.3f}] {hit.text}\")\n+61 # Non-streaming retrieve returns a list of RetrieveMemoryEvent objects;\n+62 # each event with a retrieved_item carries one chunk reference.\n+63 for event in events:\n+64     item = event.retrieved_item\n+65     if item and item.chunk:\n+66         print(f\"[score={item.relevance_score:.3f}] {item.chunk}\")\n 63 \n 64 client.close()","patch":"--- /sandbox/repo/goodmem_example.py\n+++ /sandbox/repo/goodmem_example.py\n@@ -52,13 +52,17 @@\n     )\n     print(f\"Stored memory: {mem.memory_id}\")\n \n # 4. Retrieve relevant chunks for a query (semantic search, no LLM needed).\n-result = client.memories.retrieve(\n+events = client.memories.retrieve(\n     message=\"When do database migrations happen?\",\n     space_ids=[space.space_id],\n     requested_size=3,\n )\n-for hit in result.chunks:\n-    print(f\"[score={hit.distance:.3f}] {hit.text}\")\n+# Non-streaming retrieve returns a list of RetrieveMemoryEvent objects;\n+# each event with a retrieved_item carries one chunk reference.\n+for event in events:\n+    item = event.retrieved_item\n+    if item and item.chunk:\n+        print(f\"[score={item.relevance_score:.3f}] {item.chunk}\")\n \n client.close()\n","firstChangedLine":56}}

python3 - <<'EOF'
from goodmem.models import ChunkReference
f = ChunkReference.model_fields
for k,v in f.items(): print(k, v.annotation)
EOF
python3 -m py_compile /sandbox/repo/goodmem_example.py && echo "compiles OK"

{"content":[{"text":"result_set_id <class 'str'>\nchunk <class 'goodmem.models.memory_chunk_response.MemoryChunkResponse'>\nmemory_index <class 'int'>\nrelevance_score <class 'float'>\ncompiles OK\n","type":"text"}]}

python3 - <<'EOF'
from goodmem.models import MemoryChunkResponse
for k,v in MemoryChunkResponse.model_fields.items(): print(k, v.annotation)
EOF

{"content":[{"text":"chunk_id <class 'str'>\nmemory_id <class 'str'>\nchunk_sequence_number <class 'int'>\nchunk_text <class 'str'>\nvector_status typing.Optional[typing.Literal['UNSPECIFIED', 'PENDING', 'PROCESSING', 'COMPLETED', 'FAILED']]\nstart_offset int | None\nend_offset int | None\nmetadata dict[str, typing.Any] | None\ncreated_at <class 'int'>\nupdated_at <class 'int'>\ncreated_by_id <class 'str'>\nupdated_by_id <class 'str'>\n","type":"text"}]}

{"content":[{"text":"Successfully replaced 1 block(s) in /sandbox/repo/goodmem_example.py.","type":"text"}],"details":{"diff":"    ...\n 62 # each event with a retrieved_item carries one chunk reference.\n 63 for event in events:\n 64     item = event.retrieved_item\n 65     if item and item.chunk:\n-66         print(f\"[score={item.relevance_score:.3f}] {item.chunk}\")\n+66         print(f\"[score={item.relevance_score:.3f}] {item.chunk.chunk_text}\")\n 67 \n 68 client.close()","patch":"--- /sandbox/repo/goodmem_example.py\n+++ /sandbox/repo/goodmem_example.py\n@@ -62,7 +62,7 @@\n # each event with a retrieved_item carries one chunk reference.\n for event in events:\n     item = event.retrieved_item\n     if item and item.chunk:\n-        print(f\"[score={item.relevance_score:.3f}] {item.chunk}\")\n+        print(f\"[score={item.relevance_score:.3f}] {item.chunk.chunk_text}\")\n \n client.close()\n","firstChangedLine":66}}