MiniMe: Your AI's Memory System

Scenario 1: "Remember This Implementation"

See also: Search Guide | Performance Data

You just finished coding. Tell your AI:

You: "Remember this JWT implementation. I added refresh token rotation 
with Redis storage. Access tokens expire in 15 minutes, refresh tokens 
in 7 days. We're storing refresh tokens in HTTP-only cookies."

AI Response:

✓ Got it! I've stored the JWT implementation details with:

   - Type: code-snippet
   - Files: src/auth/jwt.ts, src/middleware/authMiddleware.ts
   - Tags: authentication, jwt, security, redis

This will help me understand our auth system in future sessions.

store_memory({
  content: `# JWT Refresh Token Implementation

## Architecture

- Access tokens: 15min expiry, in-memory only
- Refresh tokens: 7 days, HTTP-only cookies
- Storage: Redis for refresh token registry
- Security: Token rotation on each refresh

## Implementation Details

- RefreshTokenService handles rotation logic
- Axios interceptor triggers silent refresh at 2min before expiry
- Detects token reuse (security) → revokes all sessions
- Rate limiting: 10 refreshes/hour per user

## Files Modified

- src/auth/jwt.ts - Token generation and validation
- src/middleware/authMiddleware.ts - Request authentication
- src/services/refreshTokenService.ts - Rotation logic`,

  project_name: "payment-service",
  memory_type: "code-snippet",
  related_files: [
    "src/auth/jwt.ts",
    "src/middleware/authMiddleware.ts",
    "src/services/refreshTokenService.ts"
  ],
  tags: ["authentication", "jwt", "security", "redis"],
  importance_score: 0.9
})

// Returns: Memory #1234

Scenario 2: "What Did We Decide About X?"

You need to recall a past decision:

You: "What did we decide about database choice for user preferences?"

AI Response:

✓ We chose MongoDB over PostgreSQL for the user preferences service.

Key reasons:
- Schema flexibility for custom user fields
- Nested documents map naturally to preference hierarchies  
- No migrations needed for schema changes
- Team has more MongoDB experience

This was decided after a 2-hour team debate. The vote was 4-1 in favor.

Want me to expand on the technical trade-offs we discussed?

// AI searched with:

search_memories({
  query: "database choice user preferences decision",
  memory_type: "decision",
  project_name: "payment-service",
  search_mode: "semantic"
})

// Found memory #2456, AI read the summary, then used:

expand_memories({
  memory_ids: [2456]
})

// Got full content including rationale, alternatives considered, team vote

Scenario 3: "Before I Edit This File..."

See also: Memory Types | Search Performance

CRITICAL WORKFLOW - Always do this before modifying code:

You: "I'm about to edit src/auth/jwt.ts. What context do I need?"

AI Response:

Found 3 relevant memories for src/auth/jwt.ts:

1. **JWT Refresh Implementation** (2 weeks ago)
   - Implemented token rotation with Redis
   - Access tokens: 15min, Refresh: 7 days
   
2. **Bug Fix: Race Condition** (1 week ago)  
   - Fixed concurrent refresh requests causing token invalidation
   - Added request queuing in axios interceptor
   
3. **Security Enhancement** (3 days ago)
   - Added token reuse detection
   - Auto-revokes all sessions if replay attack detected

⚠️ Important: The token reuse detection logic is sensitive. If you modify 
refresh flow, make sure it still detects and handles reuse attempts.

// AI searched by file path pattern:

search_memories({
  query: "context implementation decisions",
  file_path: "src/auth/jwt.ts",  // Exact file match
  project_name: "payment-service"
})

// Alternative patterns:
// file_path: "src/auth/%"           // All files in auth directory
// file_path: "%jwt%"                // Any file with 'jwt' in path
// file_path: "src/%.ts"             // All TypeScript files in src

// Then expanded relevant memories:
expand_memories({ memory_ids: [1234, 1245, 1289] })

Scenario 4: "Find All My Work On X"

You need to review everything related to a feature:

You: "Show me everything we've done on authentication"

AI Response:

Found 8 memories related to authentication:

**Implementations (3)**
- JWT refresh token system with rotation
- OAuth2 integration with Google/GitHub
- Two-factor authentication with TOTP

**Decisions (2)**  
- Chose JWT over session-based auth
- Decided on 15min access token expiry

**Bugs Fixed (2)**
- Race condition in token refresh
- CORS issues with cookie-based auth

**Performance (1)**
- Reduced auth middleware latency from 45ms to 8ms

Want me to expand on any of these?

search_memories({
  query: "authentication implementations decisions bugs",
  project_name: "payment-service",
  search_mode: "semantic"  // Finds related concepts
  // memory_type: "any" (default - searches all types)
})

// Semantic search uses:
// - 60% vector embeddings (conceptual similarity)
// - 25% keywords (exact matches)
// - 15% tags (topic matching)

Scenario 5: "What Patterns Have Emerged?"

See also: Search Guide | Benchmark Results | Blog Articles

You want insights across all your work:

You: "What patterns have emerged in our API error handling?"

AI Response:

Analyzing 23 memories across 4 projects...

**Common Patterns Discovered:**

1. **Centralized Error Middleware** (Used in 3 projects)
   - Express middleware catches all errors
   - Transforms exceptions into consistent JSON format
   - Logs with correlation IDs for tracing

2. **Domain-Specific Exceptions** (Strong pattern)
   - Custom error classes: ValidationError, AuthError, NotFoundError
   - Each includes HTTP status code + error code
   - Makes error handling more semantic

3. **Circuit Breaker for External APIs** (Emerging)
   - Using Hystrix/resilience4j
   - Prevents cascade failures
   - Used in 2 recent services

**Recommendation:** Standardize on pattern #1 + #2 across all services.
We've proven this works well and it's familiar to the team.

get_insights({
  analysis_type: "patterns",  // Other types: quality, technical_debt, comprehensive
  topic: "error handling API",  // Semantic filter on clusters
  time_range: "90d",
  project_name: "payment-service"  // Or omit to search ALL projects
})

// Returns:
// - Pre-computed cluster summaries
// - Pattern detection across memories
// - Frequency analysis
// - Recommendations from LLM analysis
// - Memory IDs for each pattern (for drilling down)

Scenario 6: "Why Do We Keep Having This Bug?"

You notice recurring issues:

You: "Analyze our authentication bugs. Why do they keep happening?"

AI Response:

Quality Analysis: Authentication Bugs

**Recurring Root Causes:**

1. **Race Conditions (3 occurrences)** ⚠️
   - Concurrent token refresh requests
   - Multiple tabs triggering simultaneous auth
   - Fix: Request queuing pattern works consistently

2. **Token Expiry Edge Cases (2 occurrences)**
   - Clock skew between servers
   - Tokens expiring mid-request
   - Fix: Add 2-minute buffer for refresh trigger

3. **CORS Misconfigurations (2 occurrences)**
   - Cookie domain settings incorrect
   - SameSite attribute issues
   - Fix: Environment-specific CORS config checklist created

**Recommendation:** Add integration tests specifically for concurrent auth
scenarios. This is our weakest testing area and accounts for 40% of auth bugs.

get_insights({
  analysis_type: "quality",  // Focuses on bugs and issues
  topic: "authentication bugs",
  time_range: "180d",
  project_name: "payment-service"
})

// Returns:
// - Root cause analysis (why bugs happen)
// - Fix approaches (what worked)
// - Recurrence patterns (similar bugs)
// - Confidence scores
// - Related memory IDs

Scenario 7: "Help Me Think Through This Problem"

You have a complex design decision:

You: "Help me think through migrating from REST to GraphQL. 
We have 50+ REST endpoints and 3 mobile apps using them."

AI Response:

🤔 Starting structured thinking sequence...

**Initial Assessment:**
- 50+ REST endpoints is significant (migration effort: large)
- 3 mobile apps = breaking changes could impact users
- Need to consider: backwards compatibility, team learning curve, tooling

Let me work through different approaches...

**Branch 1: Big Bang Migration**
- Pros: Clean break, no hybrid maintenance
- Cons: High risk, requires coordinated deployment
- Timeline: 3-4 months
- Risk: HIGH ⚠️

**Branch 2: Gradual Migration (Facade Pattern)**
- Start with GraphQL gateway
- Gateway proxies to existing REST endpoints  
- Migrate endpoints one-by-one
- Mobile apps gradually adopt GraphQL
- Pros: Lower risk, incremental value
- Cons: Temporary complexity, longer timeline
- Timeline: 6-8 months
- Risk: MEDIUM

**Branch 3: New Features Only**
- Keep all existing REST endpoints
- Build only NEW features in GraphQL
- Mobile apps support both (versioned APIs)
- Pros: Minimal disruption, lowest risk
- Cons: Permanent hybrid system, technical debt
- Timeline: Ongoing
- Risk: LOW

**My Recommendation:**
Branch 2 (Gradual Migration) because:
1. Manages risk with incremental rollout
2. Proves value before full commitment
3. Team learns GraphQL while still productive
4. Can pause/pivot if issues arise

Ready to dive deeper into Branch 2 implementation plan?

// Start thinking sequence:

start_thinking({
  goal: "Evaluate GraphQL migration strategy for 50+ REST endpoints with 3 mobile apps",
  project_name: "payment-service"
})

// Returns: sequence_id: "seq_abc123"

// Add thoughts (AI does this automatically):

add_thought({
  sequence_id: "seq_abc123",
  thought_type: "observation",
  thought: "50+ REST endpoints is significant migration effort..."
})

// Create alternative branches:

add_thought({
  sequence_id: "seq_abc123",
  thought_type: "branch",  // Creates new thinking branch
  branch_name: "Big Bang Migration",
  thought: "Replace all REST at once..."
})

add_thought({
  sequence_id: "seq_abc123",
  thought_type: "branch",
  branch_name: "Gradual Migration",
  thought: "GraphQL gateway facade pattern..."
})

// Final recommendation:

add_thought({
  sequence_id: "seq_abc123",
  thought_type: "conclusion",  // Saves as decision memory
  thought: "Recommend Branch 2 because..."
})

Scenario 8: "Track This Task"

You need to remember to do something:

You: "Remind me to add rate limiting to the login endpoint. 
This is related to the authentication work we just finished."

AI Response:

Task created: "Add rate limiting to login endpoint"

I've linked this to:
- Memory #1234: JWT implementation
- Memory #1245: Auth bug fix
- Memory #1289: Security enhancements

When you come back to this, you'll have full context!

(View all tasks with: "Show me my pending tasks")

// Create task:

tasks({
  action: "create",
  task_description: "Add rate limiting to login endpoint",
  project_name: "payment-service"
})

// Returns: task_id: "task_xyz789"

// Link related memories:

tasks({
  action: "link_memories",
  task_id: "task_xyz789",
  memory_ids: [1234, 1245, 1289],
  project_name: "payment-service"
})

// Later, view tasks:

tasks({
  action: "get",
  project_name: "payment-service",
  include_completed: false  // Show only pending
})

// Complete task:

tasks({
  action: "complete",
  task_id: "task_xyz789",
  project_name: "payment-service"
})