Memory Operations

Store, retrieve, and maintain high-quality memories in Memanto.

Memory Fundamentals

What is a Memory?

A memory in Memanto includes:

Content: The core information.
Type: Semantic category (fact, preference, decision, etc.).
Title (optional): Short label for readability.
Confidence (optional): Reliability score from 0 to 1.
Metadata (optional): Extra structured context.

Memory Lifecycle

Store -> Index (instant) -> Recall -> Conflict detection -> Resolve

Core Operations

Use these commands for most workflows:

Store a memory: memanto remember "..." --type fact
Batch store: memanto remember --batch memories.json
Recall semantically: memanto recall "..."
Answer from context: memanto answer "..."
Delete a memory: memanto forget MEMORY_ID
Detect contradictions: memanto conflicts
Export memory history: memanto memory export

Uploading Files into Memory

When information already exists in documents, upload files instead of manually adding many individual memories.

Supported Formats

.pdf, .docx, .xlsx, .json, .txt, .csv, .md (up to 5 GB per file).

CLI

Activate an agent session, then upload:

memanto agent activate customer-support
memanto upload ./customer-profile.pdf

Recall uploaded knowledge with normal search:

memanto recall "What is the customer's annual revenue?"

REST API

import httpx

with open("customer-profile.pdf", "rb") as f:
    response = httpx.post(
        "http://localhost:8000/api/v2/agents/customer-support/upload-file",
        files={"file": ("customer-profile.pdf", f, "application/pdf")},
        headers={"X-Session-Token": session_token},
    )

result = response.json()
print(f"Status: {result['status']}, File: {result['file_name']}")

Upload vs Remember

Use `upload` when…	Use `remember` when…
You have existing documents	You are storing short atomic facts
Content spans many pages	You want explicit memory typing per item
You ingest structured data files	You want precise confidence per memory

Extracting from Conversations

If you have raw chat logs, Memanto can automatically parse the conversation and use the underlying LLM to extract durable, structured memories (like facts and preferences) while discarding the noise.

Using the Web UI

The Memanto Web Dashboard features an Extract tab in the Playground:

Paste a JSON array of conversation turns ([{"role": "user", "content": "..."}, ...]).
Click Preview Extraction to review the memory cards Memanto generated. You can modify types, content, and confidence.
Click Save to Database to persist the selected facts.
(Optional) Use Extract & Save to skip the preview and directly persist the memories.

Using the CLI

You can extract and store memories from a local JSON file containing your chat history:

# Preview what would be extracted
memanto remember --from-conversation chat.json --dry-run

# Extract and persist directly
memanto remember --from-conversation chat.json

Using the REST API

Send your conversation payload to the extract endpoint:

curl -X POST "http://localhost:8000/api/v2/agents/my-agent/remember/extract" \
  -H "X-Session-Token: <your-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "I prefer 4 spaces for indentation."},
      {"role": "assistant", "content": "Got it."}
    ],
    "dry_run": true
  }'

Recall Patterns

Semantic Recall

memanto recall "What do I know about user preferences?"

Filter by Type

memanto recall "How should I contact this user?" --type preference

Limit Result Volume

memanto recall "customer details" --limit 10

Temporal Recall

Use the temporal recall variants (--as-of, --changed-since, and --recent) to query memory across time. See Temporal Memory Details for complete patterns and examples.

Answering and Conflict Management

Grounded Answers

memanto answer "Based on memory, how should we communicate with this customer?"

Conflict Detection

memanto conflicts

When contradictions are found, resolve them by keeping the new memory, the old one, both, removing both, or replacing them with a manual entry. See List Conflicts and Resolve Conflict for the API contract.

Deleting a Memory

Remove a single memory from the active agent by its ID. Find the ID in the output of memanto recall, then:

memanto forget b7c3cf31-e537-49f1-abc4-c50ac6adeac5

This prompts for confirmation. Add --force to skip it. See the forget command and Delete Memory API for details.

For contradictions, prefer resolving conflicts (keep new/old/both, remove both, or replace) over deleting history. Use forget for one-off removals such as a memory stored by mistake.

Migrating from Other Providers

Already have memories in Mem0, Letta, or Supermemory? Import them into a Memanto agent with memanto migrate:

# Preview the mapping and savings report without writing
memanto migrate mem0 --dry-run

# Import into the active agent
memanto migrate mem0

See the migrate command for providers, options, and output details.

Export and Sync

Export to Markdown

memanto memory export

Export to Custom Path

memanto memory export --output /path/to/memory.md

Sync to MEMORY.md

memanto memory sync

Performance Tips

Use specific memory types instead of defaulting everything to fact.
Batch ingest when importing many items.
Keep recall limits tight for faster, cleaner responses.
Use confidence scoring when information quality varies.

Best Practices

DO

Keep memories concise and atomic.
Record source context in metadata when useful.
Resolve conflicts explicitly when contradictions arise rather than deleting history.

DON’T

Store the same fact repeatedly.
Mix multiple unrelated facts in one memory.
Over-fetch with very high recall limits by default.

Next Steps

CLI: Remember, Recall
API: Remember, Recall
Temporal Guide: Temporal Memory Details

Memory operations are the core of Memanto. Keep this flow lean, typed, and conflict-aware for best results.

Getting Started

Guides

Reference

Memory Operations

Memory Operations

Memory Fundamentals

What is a Memory?

Memory Lifecycle

Core Operations

Uploading Files into Memory

Supported Formats

CLI

REST API

Upload vs Remember

Extracting from Conversations

Using the Web UI

Using the CLI

Using the REST API

Recall Patterns

Semantic Recall

Filter by Type

Limit Result Volume

Temporal Recall

Answering and Conflict Management

Grounded Answers

Conflict Detection

Deleting a Memory

Migrating from Other Providers

Export and Sync

Export to Markdown

Export to Custom Path

Sync to MEMORY.md

Performance Tips

Best Practices

DO

DON’T

Next Steps

​Memory Operations

​Memory Fundamentals

​What is a Memory?

​Memory Lifecycle

​Core Operations

​Uploading Files into Memory

​Supported Formats

​CLI

​REST API

​Upload vs Remember

​Extracting from Conversations

​Using the Web UI

​Using the CLI

​Using the REST API

​Recall Patterns

​Semantic Recall

​Filter by Type

​Limit Result Volume

​Temporal Recall

​Answering and Conflict Management

​Grounded Answers

​Conflict Detection

​Deleting a Memory

​Migrating from Other Providers

​Export and Sync

​Export to Markdown

​Export to Custom Path

​Sync to MEMORY.md

​Performance Tips

​Best Practices

​ DO

​ DON’T

​Next Steps

Memory Operations

Memory Fundamentals

What is a Memory?

Memory Lifecycle

Core Operations

Uploading Files into Memory

Supported Formats

CLI

REST API

Upload vs Remember

Extracting from Conversations

Using the Web UI

Using the CLI

Using the REST API

Recall Patterns

Semantic Recall

Filter by Type

Limit Result Volume

Temporal Recall

Answering and Conflict Management

Grounded Answers

Conflict Detection

Deleting a Memory

Migrating from Other Providers

Export and Sync

Export to Markdown

Export to Custom Path

Sync to MEMORY.md

Performance Tips

Best Practices

DO

DON’T

Next Steps