> ## Documentation Index
> Fetch the complete documentation index at: https://docs.memanto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Memory Types

> Complete reference for all 13 semantic memory types in Memanto.

# Memory Types Reference

Complete reference for all 13 semantic memory types in Memanto.

## Why Memory Types?

Memory types serve two purposes:

1. **Organization** - Group related memories instead of throwing everything into a generic "notes" bucket.
2. **Filtering** - Query specific types (e.g., retrieving only "commitments" or "preferences").

## Quick Reference

| Type             | Use Case              | Example                   |
| ---------------- | --------------------- | ------------------------- |
| **fact**         | Objective information | "User is in Finance dept" |
| **preference**   | Likes/dislikes        | "Prefers email contact"   |
| **decision**     | Choices made          | "Chose PostgreSQL"        |
| **commitment**   | Promises/obligations  | "Will deliver Friday"     |
| **goal**         | Objectives            | "Reach 10K users"         |
| **event**        | Things that happened  | "Meeting at 2pm"          |
| **instruction**  | Rules/procedures      | "Validate input always"   |
| **relationship** | Connections           | "Alice manages Bob"       |
| **context**      | Situational info      | "In Q1 planning"          |
| **learning**     | Lessons learned       | "Users need help"         |
| **observation**  | Patterns noticed      | "Traffic peaks Fridays"   |
| **error**        | Mistakes to avoid     | "Skip validation=bug"     |
| **artifact**     | Documents/files       | "Q3 budget.xlsx"          |

## Detailed Definitions

### fact

**Objective, verifiable information about the world or domain.**

* Static information
* Not opinions or preferences
* Verifiable claims
* Core knowledge

Examples:

* "Paris is the capital of France"
* "Database uses PostgreSQL"
* "Team has 5 engineers"

CLI:

```bash theme={null}
memanto remember "Paris is the capital of France" --type fact
```

### preference

**User or system likes, dislikes, or preferences.**

* Opinions about preferences
* User/system choices
* Style choices
* Communication preferences

Examples:

* "Prefers dark mode"
* "Email over phone"
* "Concise responses"

CLI:

```bash theme={null}
memanto remember "Prefers email contact" --type preference
```

### decision

**Important choices made that affect future behavior.**

* Technology choices
* Process decisions
* Strategic choices
* Why decisions

Examples:

* "Chose TypeScript for codebase"
* "Decided to use AWS"
* "Selected Agile methodology"

CLI:

```bash theme={null}
memanto remember "Chose PostgreSQL for database" --type decision
```

### commitment

**Promises or obligations made.**

* Deliverables
* Promises to keep
* Obligations
* Accountability

Examples:

* "Will deliver report by Friday"
* "Committed to 10% growth"
* "Promised 24/7 support"

CLI:

```bash theme={null}
memanto remember "Will deliver API docs by Friday" --type commitment
```

### goal

**Objectives to achieve.**

* Future targets
* KPIs
* Milestones
* Aspirations

Examples:

* "Reach 1M users"
* "Improve performance by 50%"
* "Launch MVP by Q2"

CLI:

```bash theme={null}
memanto remember "Launch MVP by March 31" --type goal
```

### event

**Something that happened or will happen.**

* Historical events
* Meetings
* Incidents
* Milestones

Examples:

* "Had meeting with CEO"
* "System outage on March 20"
* "Project launched successfully"

CLI:

```bash theme={null}
memanto remember "Team meeting at 2pm" --type event
```

### instruction

**Rules, guidelines, or procedures to follow.**

* Policies
* Best practices
* Procedures
* Constraints

Examples:

* "Always validate input"
* "Follow REST conventions"
* "Require code review"

CLI:

```bash theme={null}
memanto remember "Always validate user input" --type instruction
```

### relationship

**Connections or relationships between entities.**

* People relationships
* System dependencies
* Business relationships
* Hierarchies

Examples:

* "Alice manages Bob"
* "Project X depends on API Y"
* "Customer referred by John"

CLI:

```bash theme={null}
memanto remember "Alice manages Bob" --type relationship
```

### context

**Contextual information about the current situation.**

* Seasonal context
* Business phases
* System states
* Environmental factors

Examples:

* "In Q1 planning phase"
* "Budget season is active"
* "System in maintenance"

CLI:

```bash theme={null}
memanto remember "We're in Q1 planning" --type context
```

### learning

**Lessons learned from experience.**

* Insights
* Lessons
* Patterns recognized
* Knowledge gained

Examples:

* "Users need better onboarding"
* "Mobile-first is essential"
* "Documentation must be clear"

CLI:

```bash theme={null}
memanto remember "Users need simpler onboarding" --type learning
```

### observation

**Something noticed or perceived.**

* Patterns observed
* Trends noticed
* Data observations
* Field observations

Examples:

* "Traffic peaks on Fridays"
* "Users skip step 2"
* "Support tickets spike after releases"

CLI:

```bash theme={null}
memanto remember "Traffic peaks on Fridays" --type observation
```

### error

**Mistakes to avoid in the future.**

* Warnings
* Lessons from failures
* Anti-patterns
* Known issues

Examples:

* "Avoid deprecated API"
* "Skip validation=bug"
* "Don't hardcode secrets"

CLI:

```bash theme={null}
memanto remember "Never skip input validation" --type error
```

### artifact

**Important documents, files, or references.**

* Documents
* Code files
* Resources
* References

Examples:

* "Q3 budget spreadsheet"
* "API documentation file"
* "Customer contract"

CLI:

```bash theme={null}
memanto remember "Q3 budget spreadsheet" --type artifact
```

## Selection Guide

```
Does it describe something that happened?
  → event

Is it a choice or decision?
  → decision

Is it a promise or obligation?
  → commitment

Is it a rule or guideline?
  → instruction

Is it someone's preference?
  → preference

Is it an objective fact?
  → fact

Is it a future goal?
  → goal

Is it a lesson learned?
  → learning

Is it a pattern observed?
  → observation

Is it a warning or mistake?
  → error

Is it a connection between things?
  → relationship

Is it situational info?
  → context

Otherwise, ask: "Is it a document/file?"
  → artifact
```

## Best Practices

### <Icon icon="check" /> DO

* Use specific types for better organization
* Choose the most specific type available
* Be consistent in your selections
* Filter queries by type when appropriate

### <Icon icon="xmark" /> DON'T

* Overuse generic "fact" type
* Store everything as one type
* Mix unrelated information in one memory
* Ignore type distinctions
* Use wrong type for convenience
* Skip commitment type for promises
* Forget about error type for lessons

***

## Filtering by Type

### CLI

```bash theme={null}
# 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

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