Smara Memory

Persistent memory for AI agents — store, search, and recall user context via the Smara Memory API

Security Scan

The skill's requirements and runtime instructions align with its stated purpose (persistent memory via Smara) and request only a single API key; no unrelated permissions or installers are present.

Purpose & Capability

Name/description, examples, and requested env var (SMARA_API_KEY) all match a memory/storage service. No unrelated credentials, binaries, or config paths are requested.

Instruction Scope

SKILL.md only instructs the agent to call Smara API endpoints (store, search, get context, delete) and to extract facts from conversations. This is within scope, but the instructions imply storing user facts which can include sensitive personal data—understand privacy/retention implications before enabling automatic storage.

Install Mechanism

Instruction-only skill with no install spec or code files; nothing will be written to disk by an installer. This is the lowest-risk install model.

Credentials

Only a single API key (SMARA_API_KEY) is required and is the declared primary credential. This is proportionate to a remote memory service.

Persistence & Privilege

always is false and the skill is user-invocable; model invocation is allowed (default). Autonomous use plus persistent memory is expected for this skill but increases the impact if the external service or key is compromised—consider limiting scope and monitoring usage.

Assessment

This skill is coherent for storing and recalling conversation memory, but before installing: (1) Verify Smara (https://smara.io) and read their privacy/retention/security docs; (2) Use a scoped API key and rotate/revoke it if needed; (3) Avoid automatically storing highly sensitive PII (SSNs, full credit card numbers, medical records); (4) Decide whether the agent may auto-store facts or should require user consent for persistent storage; (5) Monitor API usage and logs for unexpected activity. If you need stronger guarantees, ask the provider about encryption-at-rest, data deletion policies, and whether you can redact or hash identifiers before sending.

Smara Memory Skill

Gives your agent persistent memory across conversations. Store facts about users, search by meaning, and retrieve full context — powered by Smara's Ebbinghaus decay scoring.

When to use

• When the agent learns something about a user that should persist (preferences, facts, context)
• When the agent needs to recall what it knows about a user
• When the agent should check if it already knows something before asking again
• After meaningful conversations to extract and store key facts

Setup

1. Get a free API key at https://smara.io
2. Set SMARA_API_KEY in your environment

Actions

Store a memory

curl -X POST https://api.smara.io/v1/memories \
  -H "Authorization: Bearer $SMARA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user_id": "user_id_here",
    "fact": "User prefers dark mode and uses vim keybindings",
    "importance": 0.7
  }'

Search memories

curl "https://api.smara.io/v1/memories/search?user_id=user_id_here&query=editor+preferences&limit=5" \
  -H "Authorization: Bearer $SMARA_API_KEY"

Get full user context

curl "https://api.smara.io/v1/users/user_id_here/context" \
  -H "Authorization: Bearer $SMARA_API_KEY"

Delete a memory

curl -X DELETE "https://api.smara.io/v1/memories/MEMORY_ID" \
  -H "Authorization: Bearer $SMARA_API_KEY"

Instructions for the agent

1. After conversations: Extract key facts (preferences, decisions, context) and store them as memories with relevant tags
2. Before responding: Search for relevant memories to personalize responses
3. Contradiction handling: Smara automatically handles contradictions — if a user changes a preference, just store the new one and the old one is soft-deleted
4. Duplicate handling: Smara skips duplicates automatically — safe to store the same fact multiple times
5. Decay scoring: Memories naturally lose weight over time. Recent, frequently-accessed memories rank higher. This is automatic.

Example workflow

User: "I switched to Neovim last week"

Agent thinks:
1. Search memories for "editor preferences" → finds "Uses vim keybindings"
2. Store new memory: "Switched to Neovim (from vim)" with tags ["preferences", "editor"]
3. Smara auto-detects contradiction with old vim memory → soft-deletes it
4. Respond acknowledging the switch

API Reference

Full docs: https://api.smara.io/docs/