Memory Store lets your agents keep information they can retrieve later—within a single session (or run), across all sessions of the same agent, an entire conversation (a group of runs), or even every agent in a project.

Think of Memory Store as:

• A built-in KV-store for quick, light data

• Faster than an external database for small-to-medium payloads

• Visible only to your agents (not exposed to end users)

• Can use as temporary storage (to save results and retrieve them) or a persistent storage of agent run data

Data Types Stored in Memory Store:
You can save either plain text or JSON as individual keys, lists, or dictionaries.

How Memory Store Scopes Work

Tip: Keep the data as long as you need it and remember to delete it with Remove once you’re done.

Core Actions

Action	What it does	Screenshot
Put	Save a value (text or JSON) under a key in the chosen scope.
Get	Retrieve the stored value. Choose Return As → Text or JSON.
Append	Add text to an existing string key, separated by the Separator you enter.
Remove	Delete the key (and all its data) from the scope. (No screenshot – it’s just a single-field dialog.)
Add To List / Remove From List	Treat the value as an ordered list; push or pop items (text or JSON).
Add To Dictionary	Treat the value as a dictionary; upsert item_key : item_value.

Need a refresher on all actions? The action picker shows them in one place:

Canonical Use-Case Patterns

1. Surface Data Upwards in a Flow
   Problem: A value created inside an inner route is needed by a later, higher-level step.
   Solution: Put it (scope Run) inside the route ➜ Get outside.

2. Remember Thread-Level State (Group Scope)
   Problem: You classified the first message’s intent and want to reuse that classification for follow-ups in the same email thread, chat or Slack thread.
   Solution: Put the classification (scope Group, key thread_intent) with group_id = thread_ts. Every subsequent agent run for that thread can Get it instantly.

3. Build a List of Extraction Results for Processed Attachments inside a Loop (Run Scope)
   Problem: Need to avoid re-processing the same file URLs across multiple runs of an import-bot.
   Solution: Add To List (scope Flow) each file ID and its extraction results inside a Loop. Get the results after the Loop.

Best-Practice Reminders

• Serialize complex structures as JSON. That keeps things type-safe when you switch between text and structured data, use 'Convert Text to JSON' to convert the text and process it as a JSON object.

• Watch payload size. Memory Store is optimized for small size values (max kilobytes, not megabytes). Do not store large value as it will slow down or limits your agent execusion.

• Remove what you create. Especially any PII or sensitive data—use the Remove action in a finally/cleanup branch.

UpBrains AI Agent Builder – Memory Store Guide

(Expanded introduction with deeper context, common patterns, and key caveats)

0. Why Memory Store Exists

Every step inside an agent run has its own scratch-pad variables, but those variables disappear the moment the step (or run) ends. Memory Store is your agent’s “long-term memory.” It lets you persist information so that:

Think of Memory Store as:

• A built-in KV-store for quick, light data

• Faster than an external database for small-to-medium payloads

• Visible only to your UpBrains agents (never exposed to end users)

1. Choosing the Right Scope (with real-world scenarios)

Important notes
• Least-persistence principle: default to Run scope unless you truly need wider sharing.
• Namespace your keys. E.g., invoice_extractor.last_total to avoid clobbering another team’s key.
• Clean up aggressively. Anything no longer needed—especially in Group/Flow/Project—should be removed with the Remove action to avoid stale data and privacy leaks.

2. Core Actions (unchanged, screenshots included for quick recall)

(Action picker for reference)

3. Canonical Use-Case Patterns

1. Surface Data Upwards in a Flow
   Problem: A value created inside an inner route is needed by a later, higher-level step.
   Solution: Put it (scope Run) inside the route ➜ Get outside.

2. Remember Thread-Level State
   Problem: You classified the first message’s intent and want to reuse that classification for follow-ups in the same Slack thread.
   Solution: Put the classification (scope Group, key thread_intent) with group_id = thread_ts. Every subsequent agent run for that thread can Get it instantly.

3. Build a Rolling List of Processed Attachments
   Problem: Need to avoid re-processing the same file URLs across multiple runs of an import-bot.
   Solution: Add To List (scope Flow) each file ID. Before processing, Get the list and skip duplicates.

4. Project-Wide Feature Flags
   Problem: Turn on “enhanced logging” for all agents in QA but not in production.
   Solution: Put (scope Project) key enhanced_logging = true. Each agent checks it with Get at startup.

4. Best-Practice Reminders

• Serialize complex structures as JSON. That keeps things type-safe when you switch between text and structured data.

• Watch payload size. Memory Store is optimised for kilobytes, not megabytes. For large blobs, use blob storage or an external DB.

• Plan for key collisions. If multiple teams share the same Project scope, prefix keys with team or agent names.

• Remove what you create. Especially any PII or sensitive data—use the Remove action in a finally/cleanup branch.

5. Quick Reference Cheat-Sheet

With these expanded explanations, you now have not only the how, but the when and why to leverage Memory Store—unlocking richer, conversation-aware automations while keeping your data tidy and secure.

When Memory Store isn’t enough — use Collections
Collections are UpBrains AI’s fully structured, relational data stores. Treat them like an embedded database you can create, search, and manipulate through the Open Search tool in your agent logic. Because Collections support AI-powered semantic search and filtering, choose them whenever you need complex queries, large datasets, or rich relations that go beyond Memory Store’s lightweight key-value model.