Memory System

How Astronox remembers context across conversations.

What is Memory?

Astronox's memory system allows it to remember facts, preferences, and context across different conversations. Unlike conversation history (which is per-chat), memory is persistent and global.

Example:

Day 1: "Remember that I prefer Python over JavaScript"
       AI: ✓ Stored in memory

Day 5: "Write a script to process CSV files"
       AI: I'll use Python since that's your preference...
       [Generates Python script]

How Memory Works

What Gets Stored

Explicitly asked:

"Remember my project deadline is December 31"
"Store this: I work on the Phoenix project"
"Save that I use VS Code as my editor"

Implicitly learned:

You: "I always use TypeScript for new projects"
AI: I'll remember your TypeScript preference

You: "My work folder is /Users/me/Work"
AI: Noted - I'll use this path when relevant

What Does NOT Get Stored

Never automatically stored:

• Passwords or API keys
• Credit card numbers
• Social security numbers
• Full conversation transcripts
• Temporary file contents

Privacy-first: Sensitive data excluded by default.

Memory Categories

Personal

What: Your preferences and work style

Examples:

• Preferred programming languages
• Favorite tools and editors
• Working hours / timezone
• Communication style preferences

Sample facts:

• Prefers Python for scripting
• Uses VS Code as primary editor
• Works on macOS
• Prefers detailed explanations

Projects

What: Active work and codebases

Examples:

• Project names and locations
• Tech stacks
• Deadlines and milestones
• Team members

Sample facts:

• Working on "Phoenix" project in ~/Work/phoenix/
• Using React + Node.js stack
• Deadline: December 31, 2025
• Frontend deployed to Vercel

Technical

What: Technologies, frameworks, tools

Examples:

• Languages you know
• Frameworks you use
• Package managers
• Build tools

Sample facts:

• Experienced with React, Vue, Next.js
• Uses npm (not yarn)
• Runs tests with Jest
• Deploys via GitHub Actions

Custom

What: User-defined categories

Create your own:

"Create a memory category called 'Clients'"
"Remember in category 'Hobbies': I enjoy photography"

Use cases:

• Client information
• Personal hobbies
• Learning goals
• Anything you want tracked separately

Using Memory

Storing Information

Explicit Storage

Direct commands:

"Remember that I prefer tabs over spaces"
"Store this: my backup folder is on external drive D:"
"Save this fact: I deploy to AWS not Azure"
"Note: I work EST timezone"

Implicit Learning

Natural conversation:

You: "I always test with pytest before committing"
AI: I'll remember you use pytest for testing

You: "My photos are in /Users/me/Pictures/Photos"
AI: Noted. I'll use this path for photo tasks

Confirmation

AI confirms when storing:

✓ Stored in memory (Personal): Prefers pytest for testing
✓ Saved to Projects: Photos location

Retrieving Information

Automatic Recall

Memory used automatically when relevant:

You: "Help me set up a new project"
AI: I'll create a React + Node.js setup (your usual stack)
    Using npm for dependencies (your preference)
    Setting up Jest for testing

Explicit Queries

Ask what's remembered:

"What do you remember about me?"
"Show me all stored facts"
"What do you know about my projects?"
"List everything in the Technical category"

Response:

Here's what I remember:

Personal:
• Prefers Python for scripting
• Uses VS Code
• Works on macOS

Projects:
• Phoenix project (~/Work/phoenix/)
• Deadline: Dec 31, 2025
• Stack: React + Node.js

Technical:
• Testing with pytest
• Package manager: npm
• Deploys via GitHub Actions

Updating Memory

Change stored facts:

"Update my preferred language to TypeScript"
"Change the Phoenix deadline to January 15"
"Actually, I use vim not VS Code"

AI updates:

✓ Updated Personal: Editor changed to vim
✓ Updated Projects: Phoenix deadline → Jan 15, 2026

Deleting Memory

Delete Specific Fact

"Forget that I work on the Phoenix project"
"Remove my timezone preference"
"Delete everything about Client X"

Delete Category

"Clear all facts in the Projects category"
"Forget everything you know about my work"

Clear All Memory

"Clear all your memory"
"Forget everything you've stored"

⚠️ Warning: Permanent deletion!

Confirmation required:

⚠️ This will delete ALL stored memory
   Including 47 facts across all categories
   This cannot be undone

[✓ Confirm deletion] [✗ Cancel]

Memory Best Practices

✅ Store Stable Preferences

Good to store:

"Remember I prefer functional programming style"
"Store my usual project folder: ~/Dev"
"Save that I use dark theme everywhere"

These don't change often → useful for AI to remember

✅ Update When Things Change

"Update: I switched from VS Code to Cursor"
"Change my preferred stack to Next.js instead of React"

Keep memory current for best results

✅ Be Specific

Vague:

"Remember I like Python"  ← For what? All tasks?

Specific:

"Remember: I prefer Python for data processing, JavaScript for web apps"

✅ Organize by Category

"Store in Projects category: client-portal uses Django"
"Remember in Technical: I use PostgreSQL for databases"

Benefits:

• Easier to find
• Easier to delete category-specific info
• Better organization

❌ Don't Store Sensitive Data

Never:

❌ "Remember my password is hunter2"
❌ "Store my credit card: 1234-5678..."
❌ "Save my API key: sk-12345..."

Use password managers for credentials, not AI memory.

❌ Don't Over-Store

Avoid:

❌ "Remember every file on my computer"
❌ "Store all my emails"
❌ "Save this entire codebase"

Memory is for preferences and context, not data dumps.

Memory in Action

Scenario 1: New Project Setup

With memory:

You: "Set up a new project called 'dashboard'"

AI: Creating project with your preferences:
    • Language: TypeScript (your preference)
    • Framework: Next.js (your usual choice)
    • Testing: Jest (as you prefer)
    • Location: ~/Dev/dashboard (your dev folder)

    Proceed?

Without memory:

You: "Set up a new project called 'dashboard'"

AI: What tech stack would you like?
    TypeScript or JavaScript?
    Which framework?
    Where should I create the folder?

Memory saves time and context!

Scenario 2: File Organization

With memory:

You: "Organize these photos"

AI: Moving photos to your Pictures folder
    (~/Users/me/Pictures/Photos)
    Grouping by year/month as you prefer

Without memory:

You: "Organize these photos"

AI: Where should I move them?
    How would you like them organized?

Scenario 3: Code Generation

With memory:

You: "Write a function to validate email"

AI: [Generates Python function with type hints]

    # Using Python as you prefer
    # With type hints (your style)
    def validate_email(email: str) -> bool:
        ...

Without memory:

You: "Write a function to validate email"

AI: Which language would you like?
    [Generates generic code]

Advanced Memory Features

Context Weighting

More recent facts take precedence:

Day 1: "I use React"
Day 30: "Update: I switched to Vue"

Current: AI uses Vue (newer fact)

Relevance Scoring

AI determines when to use memory:

Relevant context:

You: "Set up a web project"
AI: [Uses React preference - relevant]

Irrelevant context:

You: "Find my vacation photos"
AI: [Doesn't mention React - irrelevant]

Memory Conflicts

If conflicting facts exist:

Stored:
• "Prefers TypeScript"
• "Uses JavaScript for quick scripts"

You: "Write a quick script"

AI: I see you prefer TypeScript generally,
    but use JavaScript for quick scripts.
    Which would you like for this?

Privacy & Security

What's Stored Locally

Location:

• macOS: ~/Library/Application Support/Astronox/memory.json
• Windows: %APPDATA%\Astronox\memory.json

Format: JSON (human-readable)

Security:

• Encrypted at rest (optional)
• Local only (not cloud-synced)
• You can view/edit manually (advanced)

What's Sent to AI

Only when relevant:

• AI retrieves relevant memory facts for context
• Included in conversation prompt
• Only facts applicable to current task

Example:

Your task: "Help me write Python code"

Sent to AI:
• Prefers Python
• Uses pytest for testing
• Likes functional programming

NOT sent:
• Vacation photo location
• Client names
• Unrelated preferences

Manual Memory File Editing

Advanced users can edit directly:

{
  "categories": {
    "personal": {
      "facts": [
        {
          "fact": "Prefers Python for scripting",
          "timestamp": "2025-12-20T10:30:00Z",
          "confidence": 0.95
        }
      ]
    }
  }
}

⚠️ Caution: Invalid JSON will break memory system. Backup first!

Memory Limits

Current limits:

• Total facts: 1,000 facts (generous for most users)
• Fact size: 500 characters per fact
• File size: ~500KB max

When limit reached:

• Oldest facts auto-pruned
• Low-confidence facts removed first
• Notification shown

Increase limits (future):

• Settings → Memory → Increase limits
• Or manually clean old facts

Troubleshooting Memory

AI Doesn't Remember

Possible causes:

1. Memory disabled in settings
2. Fact not actually stored (check with "What do you remember?")
3. Irrelevant to current task (AI didn't retrieve)
4. Fact too old (pruned)

Solutions:

"Check your memory - did you store X?"
"Re-remember: I prefer Python"

AI Remembers Incorrectly

Fix:

"That's wrong - update your memory"
"Correct: I use npm not yarn"
"Delete that fact and store this instead: ..."

Memory File Corrupted

Symptoms:

• Memory doesn't work
• App errors on launch
• Facts disappeared

Fix:

1. Backup current memory.json
2. Delete memory.json
3. Restart Astronox
4. Re-add important facts

Too Many Irrelevant Facts

Clean up:

"Show me all memory facts"
[Review list]
"Delete facts 5, 7, 12, and 18"
"Clear the entire Personal category"

Future Enhancements

Coming soon:

• Cloud sync (optional, encrypted)
• Import/export memory
• Memory analytics (most-used facts)
• Auto-categorization
• Memory search
• Collaborative memory (team workspaces)

Next: Learn about Automations for reusable scripts.