Cookbook — 8 recipes, one afternoon.

import openai
from remlabs import REM

openai.api_key = "sk-..."
client = REM(api_key="rem_...")

def chat(user_id, msg):
    # recall — retrieve relevant context for this user
    ctx = client.recall(namespace=user_id, query=msg, k=5)
    resp = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"Context: {ctx}"},
            {"role": "user", "content": msg}
        ]).choices[0].message.content
    # store — persist this turn for next time
    client.store(namespace=user_id, key=f"turn-{hash(msg)}", value=f"{msg} → {resp}")
    return resp

import Anthropic from "@anthropic-ai/sdk";
import { REM } from "@remlabs/sdk";

const claude = new Anthropic({ apiKey: process.env.ANTHROPIC_KEY });
const rem = new REM({ apiKey: process.env.REM_KEY });

async function research(topic: string) {
  const prior = await rem.recall({ query: topic, namespace: "research" });
  const msg = await claude.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    messages: [{ role: "user",
      content: `Prior findings: ${prior.answer ?? prior.results}\n\nDeeper dive on: ${topic}` }]
  });
  const finding = msg.content[0].type === "text" ? msg.content[0].text : "";
  await rem.store({
    key: `research-${Date.now()}`,
    value: finding,
    namespace: "research",
    metadata: { topic }
  });
  return finding;
}

# Write
curl -X POST https://remlabs.ai/v1/memory-set \
  -H "Authorization: Bearer rem_..." \
  -H "Content-Type: application/json" \
  -d '{"key":"note-'"$(date +%s)"'","value":"Your note body","namespace":"user-42"}'

# Search
curl -X POST https://remlabs.ai/v1/memory-search \
  -H "Authorization: Bearer rem_..." \
  -H "Content-Type: application/json" \
  -d '{"query":"what did I write about Q2 OKRs","namespace":"user-42","limit":5}'

from flask import Flask, request
app = Flask(__name__)

@app.post("/rem-webhook")
def on_event():
    ev = request.json
    if ev["event"] == "memory.contradiction":
        notify_slack(f"Contradiction: {ev['memory_a']} vs {ev['memory_b']}")
    elif ev["event"] == "dream.complete":
        email_briefing(ev["summary"])
    return {"ok": True}

curl -X POST https://remlabs.ai/v1/webhooks \
  -H "Authorization: Bearer rem_..." \
  -d '{"url":"https://yourapp.com/rem-webhook","events":["memory.set","dream.complete","memory.contradiction"]}'

from remlabs import REM
client = REM(api_key="rem_...")

def agent_write(agent_id, key, value):
    client.store(
        namespace="team-alpha",
        key=key,
        value=value,
        metadata={"agent": agent_id})

agent_write("researcher", "f-1", "Found: Q3 churn up 8%.")
agent_write("analyst",   "a-1", "Cause: onboarding dropoff at step 3.")
agent_write("writer",    "w-1", "Draft post: 'Why step 3 broke.'")

# Any agent recalls the shared namespace:
hits = client.recall(namespace="team-alpha", query="Q3 churn story", k=10)

curl -X POST https://remlabs.ai/v1/memory/graph-query \
  -H "Authorization: Bearer rem_..." \
  -H "Content-Type: application/json" \
  -d '{"seed":"Q3 churn","depth":2,"namespace":"team-alpha"}'

const job = await rem.dream({
  namespace: "team-alpha",
  strategies: ["contradict", "synthesize", "forecast"],
  task: "Why is our Q3 churn up?"
});
// Poll
let status = job;
while (status.status !== "complete") {
  await new Promise(r => setTimeout(r, 2000));
  status = await rem.dream.status(job.id);
}
console.log(`${status.insights} insights emitted.`);

from remlabs import REM
client = REM(api_key="rem_...")

# dream — kick off consolidation, returns a job
job = client.dream(
    namespace="team-alpha",
    strategy="reflect",
    task="Why is our Q3 churn up?")
# poll until complete
while job["status"] != "complete":
    job = client.dream_status(job["id"])
print(f"{len(job['insights'])} insights emitted.")

import os, glob, requests
notes = []
for path in glob.glob("./vault/**/*.md", recursive=True):
    with open(path) as f:
        notes.append({
            "value": f.read(),
            "namespace": "obsidian",
            "metadata": {"source": "obsidian", "path": path}
        })

# Batch-send
for chunk in [notes[i:i+100] for i in range(0, len(notes), 100)]:
    r = requests.post("https://remlabs.ai/v1/memory/store-batch",
        headers={"Authorization": f"Bearer {REM_KEY}"},
        json={"items": chunk}).json()
    print(f"stored: {r.get('count', 0)}")