Remember

# remember - Knowledge Storage

## Purpose
Store valuable knowledge, experiences, solutions, and insights in the hAIveMind collective memory for future reference by all agents.

## When to Use
- **Problem Solutions**: Save successful fixes and workarounds
- **Configuration Changes**: Document important system modifications
- **Lessons Learned**: Record insights from incidents or projects
- **Best Practices**: Share effective procedures and approaches
- **Important Discoveries**: Save research findings or optimization techniques
- **Team Knowledge**: Preserve expertise that others can benefit from

## Syntax
```
remember "content to store" [category] [options]
```

## Parameters
- **content** (required): The knowledge, solution, or information to store
- **category** (optional): Memory classification for better organization
  - `infrastructure`: System configs, hardware, network setup
  - `incidents`: Problem reports, root causes, resolutions
  - `security`: Vulnerabilities, patches, security procedures
  - `deployments`: Release processes, rollback procedures
  - `monitoring`: Alert configs, dashboard setups, metrics
  - `runbooks`: Step-by-step procedures, automation scripts
  - `project`: Project-specific knowledge and context
- **options** (optional):
  - `--tags="tag1,tag2"`: Manual tags for better searchability
  - `--private`: Store only for this machine (not shared)
  - `--important`: Mark as high-priority memory
  - `--expires=days`: Auto-delete after N days (default: never)

## Memory Processing Intelligence

### Automatic Content Analysis
- **Smart Categorization**: AI determines most appropriate category
- **Tag Generation**: Automatically extracts relevant keywords
- **Sentiment Analysis**: Identifies success/failure patterns
- **Technical Extraction**: Parses commands, configs, error codes
- **Relationship Mapping**: Links to related existing memories

### Content Enhancement
- **Context Addition**: Adds timestamp, machine, agent info
- **Search Optimization**: Processes content for better discoverability
- **Version Tracking**: Links to previous versions if updated
- **Cross-References**: Identifies connections to other memories

## Real-World Examples

### Solution Documentation
```
remember "Fixed elasticsearch high CPU by adding query timeout of 30s in elasticsearch.yml: search.default_search_timeout: 30s. CPU dropped from 95% to 45% within 10 minutes" infrastructure --tags="elasticsearch,performance,timeout"
```
**Result**: Solution stored with infrastructure category and searchable tags

### Incident Resolution
```
remember "Database deadlock resolved by optimizing transaction order in user registration flow. Changed to: 1) create user record 2) update profile 3) send email. Eliminated 90% of deadlock errors" incidents --important
```
**Result**: Critical incident solution marked as high-priority

### Configuration Change
```
remember "Updated nginx worker_processes to auto and worker_connections to 2048 for better performance on 8-core servers. Load time improved by 40%" infrastructure
```
**Result**: Performance optimization documented for future reference

### Security Finding
```
remember "JWT tokens should expire in 15 minutes for API access, 7 days for refresh tokens. Implemented sliding window refresh to maintain UX while improving security" security --tags="jwt,authentication,tokens"
```
**Result**: Security best practice stored with appropriate classification

### Troubleshooting Discovery
```
remember "502 bad gateway errors from nginx always indicate upstream server issues. Check: 1) backend service status 2) port connectivity 3) firewall rules 4) backend health endpoints" runbooks
```
**Result**: Troubleshooting procedure stored as operational runbook

## Expected Output

### Successful Storage
```
📦 Storing Memory in hAIveMind Collective...

🧠 Content Analysis:
   ↳ Length: 847 characters
   ↳ Technical terms detected: elasticsearch, CPU, query timeout, elasticsearch.yml
   ↳ Suggested category: infrastructure (confidence: 94%)
   ↳ Auto-generated tags: elasticsearch, performance, optimization, CPU, timeout

🏷️  Memory Classification:
   ↳ Category: infrastructure
   ↳ Priority: normal  
   ↳ Sharing: collective (all agents)
   ↳ Retention: permanent

💾 Storage Complete:
   ↳ Memory ID: mem-20250124-1530-789
   ↳ Stored on: lance-dev
   ↳ Synced to: 11 other agents
   ↳ Search ready: ~30 seconds

🔗 Related Memories Found:
   ↳ elasticsearch performance tuning (3 similar memories)
   ↳ query optimization techniques (5 related memories)
   ↳ CPU usage troubleshooting (8 connected memories)

✅ Memory successfully added to collective knowledge!
   Use: recall "elasticsearch CPU performance" to find this memory
```

### Memory with Manual Tags
```
📦 Storing Tagged Memory...

🏷️  Manual Tags Applied: jwt, authentication, tokens
🧠 AI-Generated Tags: security, expiration, refresh-token, sliding-window
📊 Combined Tags: jwt, authentication, tokens, security, expiration, refresh-token, sliding-window

💾 Storage Details:
   ↳ Memory ID: mem-20250124-1535-234
   ↳ Category: security (auto-detected)
   ↳ Priority: normal
   ↳ Searchability: Enhanced with 7 tags

✅ Memory stored and ready for collective access!
```

### Private Memory Storage
```
🔒 Storing Private Memory (local only)...

⚠️  Note: This memory will only be accessible from this machine
💾 Storage: Local ChromaDB only (not shared with collective)

✅ Private memory stored locally
   Use: recall "query" --machine=lance-dev to find this memory
```

## Memory Categories and Use Cases

### Infrastructure Category
- Server configurations and optimizations
- Network setup and troubleshooting
- Performance tuning discoveries
- Hardware-related solutions
- Service deployment configurations

### Incidents Category  
- Problem descriptions and root causes
- Resolution steps and outcomes
- Post-mortem findings
- Recurring issue patterns
- Emergency response procedures

### Security Category
- Vulnerability findings and patches
- Security configuration best practices
- Compliance requirements and audits
- Authentication and authorization setups
- Security incident responses

### Runbooks Category
- Step-by-step operational procedures
- Automation scripts and their usage
- Maintenance schedules and checklists
- Recovery procedures
- Standard operating procedures

## Memory Quality Guidelines

### Effective Memory Content
- **Be Specific**: Include exact commands, file paths, error messages
- **Provide Context**: Explain when/why solution was needed
- **Include Outcomes**: Describe results and impact
- **Add Details**: Version numbers, system specs, timing info
- **Use Clear Language**: Write for future readers who lack context

### Examples of Good vs Poor Memories

**Good Memory:**
```
remember "Fixed Redis memory leak by upgrading from 6.0.9 to 6.2.6 and adding 'maxmemory-policy allkeys-lru' to redis.conf. Memory usage dropped from 8GB to 2GB constant. Applied to redis-primary and redis-replica on 2025-01-24." infrastructure
```

**Poor Memory:**  
```
remember "Fixed Redis issue" infrastructure
```

## Performance Considerations
- **Storage Time**: ~2-5 seconds for typical memories
- **Sync Time**: ~10-30 seconds to propagate to all agents
- **Search Availability**: ~30 seconds after storage
- **Storage Size**: ~1-5KB per memory (text compressed)
- **Network Impact**: Minimal, uses efficient delta sync

## Error Scenarios and Solutions

### Storage Failures
```
❌ Error: Failed to store memory (network timeout)
💡 Solutions:
   1. Check collective connectivity: hv-status
   2. Retry with simpler content
   3. Try private storage: remember "content" --private
   4. Check disk space and permissions
```

### Content Too Large
```
⚠️  Warning: Memory content exceeds recommended size (5000 chars)
💡 Recommendations:
   1. Summarize key points instead of full logs
   2. Store detailed info in external docs, reference in memory
   3. Split into multiple focused memories
   4. Use --expires option for temporary large content
```

### Categorization Issues
```
🤔 AI uncertain about category (45% confidence)
💡 Suggestions:
   1. Manually specify category: remember "content" infrastructure
   2. Add more context to help AI classification
   3. Use specific technical terms in content
   4. Review and correct after storage if needed
```

## Best Practices for Memory Storage
- **Document Solutions**: Always remember successful fixes
- **Include Commands**: Store exact commands that worked
- **Add Context**: Explain the situation and environment
- **Use Good Tags**: Help future searches find your memory
- **Be Detailed**: Future you will thank present you
- **Share Knowledge**: Don't use --private unless truly sensitive
- **Update When Needed**: Remember improvements to existing solutions

## Related Commands
- **Before storing**: Use `recall` to check if similar memory exists
- **After storing**: Use `hv-broadcast` to announce important discoveries
- **For verification**: Use `recall` to confirm memory was stored correctly
- **For sharing**: Use `hv-query` to help others find your stored knowledge

---

**Memory to Store**: $ARGUMENTS

This will process, categorize, and store your memory in the hAIveMind collective knowledge base where it will be available for instant recall by all connected agents.