Memory SDK

# Store any value — string, dict, list
memory.set("user_prefs", {
    "theme": "dark",
    "lang": "python"
})

# Retrieve by key
prefs = memory.get("user_prefs")
print(prefs["theme"])  # dark

# Namespaced memory
memory.set("agent_state", data,
           namespace="project-x")

// Store any value — string, object, array
await memory.set('user_prefs', {
  theme: 'dark',
  lang: 'node'
})

// Retrieve by key
const prefs = await memory.get('user_prefs')
console.log(prefs.theme)  // dark

// Namespaced memory
await memory.set('agent_state', data,
  { namespace: 'project-x' })

# Start a dream session
session = memory.dream.start(
    namespace="project-x",
    strategy="synthesize"
    # strategies: synthesize, pattern_extract,
    # insight_generate, compress, associate
)
print(session["dream_id"])

# Poll for completion
status = memory.dream.status(session["dream_id"])
print(status["phase"])  # running | done

// Start a dream session
const session = await memory.dream.start(
  'project-x',
  'synthesize'
  // strategies: synthesize, pattern_extract,
  // insight_generate, compress, associate
)
console.log(session.dream_id)

// Poll for completion
const status = await memory.dream.status(
  session.dream_id
)
console.log(status.phase)  // running | done

# Create a shared memory space
space = memory.share.create(
    name="team-brain"
)
share_id = space["share_id"]

# Invite a collaborator
memory.collaborator.invite(
    share_id=share_id,
    email="teammate@company.com"
)

# Write to shared space
memory.share.write(share_id, "standup_notes",
                   "Shipped auth today")

// Create a shared memory space
const space = await memory.share.create(
  'team-brain'
)
const { share_id } = space

// Invite a collaborator
await memory.collaborator.invite({
  share_id,
  email: 'teammate@company.com'
})

// Write to shared space
await memory.share.write(
  share_id, 'standup_notes', 'Shipped auth today'
)

# Take a snapshot before risky work
snap = memory.snapshot(namespace="project-x")
snapshot_id = snap["snapshot_id"]

# ... do risky operations ...
memory.set("config", experimental_data)

# Restore if something went wrong
memory.restore(snapshot_id)

# List all snapshots
snaps = memory.snapshot.list(
    namespace="project-x"
)

// Take a snapshot before risky work
const snap = await memory.snapshot('project-x')
const { snapshot_id } = snap

// ... do risky operations ...
await memory.set('config', experimentalData)

// Restore if something went wrong
await memory.restore(snapshot_id)

// List all snapshots
const snaps = await memory.snapshot.list(
  'project-x'
)

# Initialize a belief with a prior
memory.bayesian.update(
    key="user_prefers_dark_mode",
    prior=0.5,
    likelihood=0.85
)

# Query current belief
belief = memory.bayesian.get(
    "user_prefers_dark_mode"
)
print(belief["posterior"])  # 0.739...

# Update again with new evidence
memory.bayesian.update(
    key="user_prefers_dark_mode",
    likelihood=0.92
)

// Initialize a belief with a prior
await memory.bayesian.update({
  key: 'user_prefers_dark_mode',
  prior: 0.5,
  likelihood: 0.85
})

// Query current belief
const belief = await memory.bayesian.get(
  'user_prefers_dark_mode'
)
console.log(belief.posterior)  // 0.739...

// Update with new evidence
await memory.bayesian.update({
  key: 'user_prefers_dark_mode',
  likelihood: 0.92
})

# Add an episode to the chain
ep = memory.episode.add(
    content="Fetched user profile from API",
    metadata={"tool": "http-get", "ms": 142}
)

# Add the next episode (auto-linked)
memory.episode.add(
    content="Summarized user data with Claude",
    prev_id=ep["episode_id"]
)

# Retrieve the full chain
chain = memory.episode.chain(ep["episode_id"])
for node in chain:
    print(node["content"])

// Add an episode to the chain
const ep = await memory.episode.add({
  content: 'Fetched user profile from API',
  metadata: { tool: 'http-get', ms: 142 }
})

// Add the next episode (auto-linked)
await memory.episode.add({
  content: 'Summarized user data with Claude',
  prev_id: ep.episode_id
})

// Retrieve the full chain
const chain = await memory.episode.chain(
  ep.episode_id
)
chain.forEach(node => console.log(node.content))

# Fire an action when a key is written
memory.trigger.create(
    condition={
        "key": "task_status",
        "equals": "complete"
    },
    action={
        "type": "webhook",
        "url": "https://myapp.com/done"
    }
)

# List active triggers
triggers = memory.trigger.list()

# Remove a trigger
memory.trigger.delete(trigger_id)

// Fire an action when a key is written
await memory.trigger.create({
  condition: {
    key: 'task_status',
    equals: 'complete'
  },
  action: {
    type: 'webhook',
    url: 'https://myapp.com/done'
  }
})

// List active triggers
const triggers = await memory.trigger.list()

// Remove a trigger
await memory.trigger.delete(triggerId)

# Teach a named procedure
memory.procedure.learn(
    name="daily_standup",
    tool_chain=[
        {"tool": "memory-search",
         "query": "yesterday's progress"},
        {"tool": "llm-summarize"},
        {"tool": "memory-set",
         "key": "standup_summary"}
    ]
)

# Execute by name later
result = memory.procedure.run("daily_standup")

// Teach a named procedure
await memory.procedure.learn({
  name: 'daily_standup',
  tool_chain: [
    { tool: 'memory-search',
      query: "yesterday's progress" },
    { tool: 'llm-summarize' },
    { tool: 'memory-set',
      key: 'standup_summary' }
  ]
})

// Execute by name later
const result = await memory.procedure.run(
  'daily_standup'
)

# Orchestrate a swarm of agents
swarm = memory.swarm.orchestrate(
    task="Analyze Q1 user feedback and"
         " extract top 5 pain points",
    agents=[
        {"id": "researcher",  "model": "claude"},
        {"id": "analyst",    "model": "grok"},
        {"id": "synthesizer", "model": "claude"}
    ]
)
print(swarm["result"])

// Orchestrate a swarm of agents
const swarm = await memory.swarm.orchestrate({
  task: 'Analyze Q1 user feedback and'
      + ' extract top 5 pain points',
  agents: [
    { id: 'researcher',  model: 'claude' },
    { id: 'analyst',    model: 'grok'   },
    { id: 'synthesizer', model: 'claude' }
  ]
})
console.log(swarm.result)