Give your agents
institutional memory.

# 1. Configure once — every provider key is optional.
cp .env.example .env

# 2. Start everything: ArcadeDB, API, workspace, MCP server.
make memoryworks

# API       http://localhost:8000   (docs at /docs, health at /api/health)
# Workspace http://localhost:3000
# MCP       http://localhost:8001   (streamable HTTP)

# No Docker? Run the two surfaces natively and use the in-process graph.
export GRAPH_BACKEND=memory

make backend    # uvicorn app.main:app --reload --port 8000
make frontend   # next dev on port 3000

# Optional: seed a sample organization to explore:
curl -X POST http://localhost:8000/api/org/scenario/seed \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"reset": false}'

# Load or reset a realistic demo organization inside Docker:
make demo     # load demo data
make reset    # wipe back to a clean workspace

# One repo, two services (vercel.json at the root):
#   frontend → Next.js app (root: frontend/)
#   backend  → FastAPI container (Dockerfile.vercel)

vercel link
vercel env add JWT_SECRET production          # required — signs sessions
vercel env add OPENROUTER_API_KEY production  # model for live agent sessions

# Canonical origin — every OAuth callback is derived from it:
vercel env add PUBLIC_BASE_URL production     # https://memoryworks.app
vercel env add FRONTEND_URL production        # https://memoryworks.app
vercel env add GRAPH_BACKEND production       # memory

# Vercel containers are stateless: SQLite and the in-memory graph reset when a
# new container starts. For durable data, use the single-VM deploy (deploy/server).
# PUBLIC_DEMO_MODE=true is a stricter profile for a shared, disposable demo.

# Real sign-in providers (values from GitHub / Google consoles):
vercel env add GITHUB_CLIENT_ID production
vercel env add GITHUB_CLIENT_SECRET production
vercel env add GOOGLE_CLIENT_ID production
vercel env add GOOGLE_CLIENT_SECRET production

vercel --prod

# GitHub OAuth app → Authorization callback URL (one per app)
https://memoryworks.app/api/auth/github/callback

# Google Cloud → Credentials → OAuth client → Authorized redirect URIs
https://memoryworks.app/api/auth/google/callback

# Locally the host is derived from the request, so the defaults just work:
#   http://localhost:8000/api/auth/github/callback
#   http://localhost:8000/api/auth/google/callback

GITHUB_CLIENT_ID=...
GITHUB_CLIENT_SECRET=...
GITHUB_REDIRECT_URI=http://localhost:8000/api/auth/github/callback

GOOGLE_CLIENT_ID=...
GOOGLE_CLIENT_SECRET=...
GOOGLE_REDIRECT_URI=http://localhost:8000/api/auth/google/callback

# Passwordless email codes (people sign in without an OAuth provider)
EMAIL_AUTH_ENABLED=true
EMAIL_FROM=memory@company.com
SMTP_HOST=smtp.company.com
SMTP_PORT=587
SMTP_USER=...
SMTP_PASSWORD=...

# Create a workspace-scoped key in the UI (Sources → API keys),
# or with the endpoint:
curl -X POST "$ORGMEMORY_API_URL/api/keys" \
  -H "Authorization: Bearer $SESSION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "ci-agent"}'

# Agents then authenticate as a bearer token:
export ORGMEMORY_API_URL=https://your-host
export ORGMEMORY_API_KEY=om_live_...

OPENROUTER_API_KEY=...          # GLM (default)
GLM_MODEL=z-ai/glm-5.3-flash
GLM_BASE_URL=https://openrouter.ai/api/v1

OPENAI_API_KEY=...              # GPT
ANTHROPIC_API_KEY=...           # Claude
GOOGLE_API_KEY=...              # Gemini
XAI_API_KEY=...                 # Grok
KIMI_API_KEY=...                # Kimi

ORG_MEMORY_DEFAULT_MODEL_PROVIDER=glm

# With no model key at all, every agent run falls back to a deterministic
# policy that still calls the real tools — the product never hard-fails.

# Agent mode in the chat streams one real, model-driven session. Every step
# is a tool call against the workspace; changes stop at a plan for a person.

curl -N -X POST "https://your-host/api/org/ask/stream" \
  -H "Content-Type: application/json" -b "session cookie" \
  -d '{"question": "Are we ready to launch?", "space_ids": []}'

# One NDJSON event per line:
{"type":"start","id":"agtsess_…","model":"glm"}
{"type":"step","step":{"tool":"get_orgmemory_readiness","thought":"…","summary":"NOT READY — 1 blocker."}}
{"type":"done","session":{…,"answer":"…","proposal":{"status":"pending_approval"}}}

curl -X POST "https://your-host/api/ask" \
  -H "Authorization: Bearer $ORGMEMORY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "project_id": "prj_platform",
    "query": "What changed in checkout, and why?",
    "token_budget": 8000
  }'

python -m pip install -e ./python_sdk
# or via the Makefile: make sdk-install

from orgmemory import MemoryWorks

memory = MemoryWorks(
    base_url="http://localhost:8000",
    api_key="om_live_...",
)

context = memory.ask(
    project_id="prj_platform",
    query="What changed in checkout, and why?",
)

print(context.answer)
print(context.compiled_context)

# Pass the source-backed context to any model or agent.
agent.run(context.compiled_context)

export ORGMEMORY_API_URL=http://localhost:8000
export ORGMEMORY_API_KEY=om_live_...

orgmemory health
orgmemory projects
orgmemory project-create --name "Checkout platform"
orgmemory ask prj_platform "What changed in checkout, and why?"
orgmemory memories prj_platform
orgmemory graph prj_platform
orgmemory swarm swarm_01J...

orgmemory ingest prj_platform \
  --file ./incident-review.md \
  --source-type doc \
  --title "Checkout incident review"

# Or send inline content
orgmemory ingest prj_platform \
  --content "Release 48 moved checkout to the new ledger." \
  --source-type other

make mcp        # stdio transport
make mcp-http   # streamable HTTP on :8001

# Claude Desktop / any MCP client (stdio):
{
  "mcpServers": {
    "memoryworks": {
      "command": "mcp_server/.venv/bin/python",
      "args": ["mcp_server/server.py", "--transport", "stdio"],
      "env": { "MEMORYWORKS_API_URL": "http://localhost:8000",
               "MEMORYWORKS_API_KEY": "om_live_..." }
    }
  }
}

make test    # backend pytest + frontend tests + SDK tests
make lint    # ruff + black + tsc --noEmit
make ci      # test + lint + production build
make reset   # reset local data to a clean slate