Skip to main content

​
Memory Types

MEMANTO supports 13 semantic memory types to categorize and organize information.

​
Why Memory Types?

Memory types serve two purposes:
  1. Organization - Group related memories
  2. Filtering - Query specific types
Instead of storing everything as generic “notes,” use types to make memories more useful and queryable.

​
All Memory Types

​
fact

Objective, verifiable information. Examples:
  • “Alice works in Finance”
  • “Project deadline is April 15”
  • “Database is PostgreSQL”
When to use: Static information about the world or domain

​
preference

User or system likes/dislikes. Examples:
  • “Prefers email over phone”
  • “Likes concise responses”
  • “Dark mode preferred”
When to use: Information about choices and preferences

​
decision

Choices made that affect future behavior. Examples:
  • “Chose PostgreSQL for database”
  • “Decided to prioritize mobile support”
  • “Selected Vue.js for frontend”
When to use: Important choices to remember and reference

​
commitment

Promises or obligations made. Examples:
  • “Will deliver report by Friday”
  • “Committed to 5% annual growth”
  • “Will attend quarterly meeting”
When to use: Promises to track and fulfill

​
goal

Objectives to achieve. Examples:
  • “Reach 10K users by Q4”
  • “Improve response time to under 100ms”
  • “Increase customer satisfaction to 95%”
When to use: Future-focused objectives

​
event

Something that happened. Examples:
  • “Had meeting with CEO at 2pm”
  • “Customer called with urgent issue”
  • “Team celebrated project launch”
When to use: Historical events and occurrences

​
instruction

Rules, guidelines, or procedures. Examples:
  • “Always validate user input”
  • “Respond within 2 hours”
  • “Follow company security policy”
When to use: Rules and guidelines to follow

​
relationship

Connections between entities. Examples:
  • “Alice manages Bob”
  • “Project X depends on Project Y”
  • “Customer is referred by John”
When to use: Relationships between people, systems, or objects

​
context

Contextual information about the current situation. Examples:
  • “We’re in Q1 planning phase”
  • “Budget season is active”
  • “System is in maintenance window”
When to use: Situational context that affects behavior

​
learning

Lessons learned from experience. Examples:
  • “Users need better onboarding”
  • “Mobile-first is essential”
  • “Documentation must be clear”
When to use: Insights and lessons to apply going forward

​
observation

Something noticed or perceived. Examples:
  • “Traffic peaks on Fridays”
  • “Users often skip step 2”
  • “Support requests increase after releases”
When to use: Patterns or observations from data

​
error

Mistakes to avoid. Examples:
  • “Avoid using deprecated API”
  • “Never skip input validation”
  • “Don’t commit sensitive data”
When to use: Warnings and mistakes to prevent

​
artifact

Important documents, files, or code. Examples:
  • “Q3 budget spreadsheet”
  • “API documentation”
  • “Customer contract”
When to use: References to important resources

​
Choosing the Right Type

​
Decision Tree

Is it a promise/obligation?
  → commitment

Is it a choice we made?
  → decision

Is it a lesson learned?
  → learning

Is it something that happened?
  → event

Is it a rule/guideline?
  → instruction

Is it something someone likes?
  → preference

Is it a relationship?
  → relationship

Is it a future objective?
  → goal

Is it something to avoid?
  → error

Is it contextual?
  → context

Is it a pattern observed?
  → observation

Is it a document/file?
  → artifact

Otherwise:
  → fact

​
Usage Examples

​
Customer Support Agent

# Facts about customer
memanto remember "Alice Johnson" --type fact
memanto remember "Works in Finance" --type fact

# Preferences
memanto remember "Prefers email contact" --type preference

# Support decisions
memanto remember "Support Plan B (Premium)" --type decision

# Commitments
memanto remember "Will deliver onboarding by Friday" --type commitment

# Issues encountered
memanto remember "Previous billing system was confusing" --type error

# Learned lessons
memanto remember "Customers need step-by-step guidance" --type learning

​
Project Management Agent

# Project facts
memanto remember "Project uses TypeScript and React" --type fact

# Goals
memanto remember "Launch MVP by March 31" --type goal

# Decisions
memanto remember "Chose AWS for hosting" --type decision

# Commitments
memanto remember "Team will complete reviews by EOD" --type commitment

# Dependencies (relationships)
memanto remember "Authentication blocks API implementation" --type relationship

# Lessons
memanto remember "Code reviews catch more bugs earlier" --type learning

​
Filtering by Type

​
CLI

# Get only commitments
memanto recall "what must we do" --type commitment

# Get only preferences
memanto recall "what does user like" --type preference

# Get only decisions
memanto recall "why did we choose this" --type decision

​
API

response = httpx.get(
    f"{base}/agents/{agent}/recall",
    params={
        "query": "What must we do?",
        "memory_type": "commitment"
    },
    headers=headers
)

​
Best Practices

​
DO

  • Use specific types (not generic “fact”)
  • Mix types to create richer context
  • Review types when organizing memories
  • Use filtering to get targeted results
  • Document why you chose a type

​
DON’T

  • Store everything as “fact”
  • Ignore type distinctions
  • Use wrong type for convenience
  • Skip commitment type for promises
  • Forget about error type for lessons

​
Next Steps