Implemented 5-minute short-term caching for relationship inference:
**store.rs**:
- Added relationship_cache SQLite table
- save_relationship_cache(), get_cached_relationship()
- save_all_relationships_cache(), get_cached_all_relationships()
- clear_relationship_cache() - called on memory create/update/delete
- Cache duration: 5 minutes (configurable constant)
**relationship.rs**:
- Modified infer_all_relationships() to use cache
- Added get_relationship() function with caching support
- Cache hit: return immediately
- Cache miss: compute, save to cache, return
**base.rs**:
- Updated tool_get_relationship() to use cached version
- Reduced load from O(n) scan to O(1) cache lookup
**Benefits**:
- Reduces AI load when frequently querying relationships
- Automatic cache invalidation on data changes
- Scales better with growing memory count
- No user-facing changes
**Documentation**:
- Updated ARCHITECTURE.md with caching strategy details
This addresses scalability concerns for Layer 4 as memory data grows.
Layer 5 focuses on sharing AI interactions as "information + personality":
- SharedInteraction: Problem, approach, result with author profile
- ShareableProfile: User essence from Layer 3.5 + Layer 4
- Privacy-first: Share patterns, not raw data
- Use cases: AI-era GitHub Gist, knowledge SNS, persona showcase
Philosophy: People seek both useful information and authentic personality.
Like SNS/streaming, the combination creates value. Information alone is
sterile; personality alone is hollow.
Updated:
- docs/ARCHITECTURE.md: Comprehensive Layer 5 design with data models
- README.md: Added Layer 5 feature overview
- Layer overview diagram updated
- Update README.md with Layer 4 relationship inference features
- Add comprehensive Layer 4 section to ARCHITECTURE.md
- Update implementation strategy to show Phase 4 complete
- Add CLI control flag documentation (--enable-layer4)
- Update version to 0.3.0
- Document personality-aware bond strength calculation
- Add relationship type classification details
Implemented optional Layer 4 activation via CLI argument,
allowing users to enable relationship features only when needed.
Changes to main.rs:
- Added --enable-layer4 flag to Server command
- Pass flag to BaseMCPServer::new()
Changes to base.rs:
- Added enable_layer4 field to BaseMCPServer
- Updated new() to accept enable_layer4 parameter
- Conditional tool exposure in get_available_tools():
* Layer 1-3.5 tools: always available
* Layer 4 tools: only when flag is true
- Added safety check in execute_tool():
* Returns error if Layer 4 tools called without flag
* Clear error message guides user to enable flag
Usage:
# Normal mode (Layer 1-3.5 only)
aigpt server
# Game/Companion mode (Layer 1-4)
aigpt server --enable-layer4
Design rationale:
- Layer 4 is optional feature for specific use cases
- Explicit opt-in prevents accidental exposure
- Tools list reflects actual capabilities
- Clear separation between core and optional features
Layer 4 provides relationship inference by analyzing memory patterns
and user personality. This is an optional layer used when game or
companion features are active.
Core Philosophy:
- Independent from Layers 1-3.5 (optional feature)
- Inference-based, not stored (computed on-demand)
- Simple calculation using existing data
- Foundation for external applications (games, companions, etc.)
Implementation (src/core/relationship.rs):
- RelationshipInference struct with key metrics:
* interaction_count: number of memories with entity
* avg_priority: average priority of those memories
* days_since_last: recency of interaction
* bond_strength: inferred strength (0.0-1.0)
* relationship_type: close_friend, friend, acquaintance, etc.
* confidence: data quality indicator (0.0-1.0)
Inference Logic:
- Personality-aware: introverts favor count, extroverts favor quality
- Simple rules: bond_strength from interaction patterns
- Automatic type classification based on metrics
- Confidence increases with more data
MCP Tools (src/mcp/base.rs):
- get_relationship(entity_id): Get specific relationship
- list_relationships(limit): List all relationships sorted by strength
Design Decisions:
- No caching: compute on-demand for simplicity
- No persistence: relationships are derived, not stored
- Leverages Layer 1 (related_entities) and Layer 3.5 (profile)
- Can be extended later with caching if needed
Usage Pattern:
- Normal use: Layers 1-3.5 only
- Game/Companion mode: Enable Layer 4 tools
- Frontend calls get_relationship() for character interactions
- aigpt backend provides inference, frontend handles presentation
Extended Memory struct and database schema to support entity
tracking, which is foundation for Layer 4 relationship system.
Changes to Memory struct (src/core/memory.rs):
- Added related_entities: Option<Vec<String>> field
- Added new_with_entities() constructor for Layer 4
- Added set_related_entities() setter method
- Added has_entity() helper method to check entity membership
- All fields are optional for backward compatibility
Changes to database (src/core/store.rs):
- Added related_entities column to memories table
- Automatic migration for existing databases
- Store as JSON array in TEXT column
- Updated all CRUD operations (create, get, update, list, search)
- Parse JSON to Vec<String> when reading from database
Design rationale:
- "Who with" is fundamental attribute of memory
- Enables efficient querying by entity
- Foundation for Layer 4 relationship inference
- Optional field maintains backward compatibility
- Simple JSON serialization for flexibility
Usage:
Memory::new_with_entities(
content,
ai_interpretation,
priority_score,
Some(vec!["alice".to_string(), "bob".to_string()])
)
Layer 3.5 provides a unified, essential summary of the user by integrating
data from Layers 1-3. This addresses the product design gap where individual
layers work correctly but lack a cohesive, simple output.
Design Philosophy:
- "Internal complexity, external simplicity"
- AI references get_profile() as primary tool (efficient)
- Detailed data still accessible when needed (flexible)
- Auto-caching with smart update triggers (performant)
Implementation:
- UserProfile struct: dominant traits, core interests, core values
- Automatic data aggregation from Layer 1-3
- Frequency analysis for topics/values extraction
- SQLite caching (user_profiles table, single row)
- Update triggers: 10+ new memories, new analysis, or 7+ days old
- MCP tool: get_profile (primary), others available for details
Data Structure:
- dominant_traits: Top 3 Big Five traits
- core_interests: Top 5 frequent topics from memories
- core_values: Top 5 values from high-priority memories
- key_memory_ids: Top 10 priority memories as evidence
- data_quality: 0.0-1.0 confidence score
Usage Pattern:
- Normal: AI calls get_profile() only when needed
- Deep dive: AI calls list_memories(), get_memory(id) for details
- Efficient: Profile cached, regenerates only when necessary
Updated README.md and ARCHITECTURE.md to reflect current implementation
status. All three layers are now complete and functional.
Changes:
- README.md: Added Layer 2 (AI Memory) and Layer 3 (Big Five) features
- README.md: Added MCP tools list and usage examples
- README.md: Added Big Five personality traits explanation
- ARCHITECTURE.md: Updated Layer 2 and 3 status to Complete
- ARCHITECTURE.md: Updated implementation strategy phases
- Archived old documentation in docs/archive/old-versions/
Current status:
- Layer 1 ✅ Complete: Pure memory storage
- Layer 2 ✅ Complete: AI interpretation + priority scoring
- Layer 3 ✅ Complete: Big Five personality analysis
- Layer 4 🔵 Planned: Game systems and companion features
- Layer 5 🔵 Future: Distribution and sharing
Layer 3 evaluates the user based on their Layer 2 memories using the
Big Five personality model (OCEAN), which is the most reliable
psychological model for personality assessment.
Changes:
- Add UserAnalysis struct with Big Five traits (Openness,
Conscientiousness, Extraversion, Agreeableness, Neuroticism)
- Create user_analyses table in SQLite for storing analyses
- Add storage methods: save_analysis, get_latest_analysis, list_analyses
- Add MCP tools: save_user_analysis and get_user_analysis
- Include helper methods: dominant_trait(), is_high()
- All scores are f32 clamped to 0.0-1.0 range
Architecture:
- Layer 3 analyzes patterns from Layer 2 memories (AI interpretations
and priority scores) to build psychological profile
- AI judges personality, tool records the analysis
- Independent from memory storage but references Layer 2 data
Add AI interpretation and priority scoring capabilities to the memory system.
Simple, efficient implementation following the principle: "AI judges, tool records."
## Core Changes
### Memory struct (src/core/memory.rs)
- Added `ai_interpretation: Option<String>` - AI's creative interpretation
- Added `priority_score: Option<f32>` - Priority from 0.0 to 1.0
- New constructor: `Memory::new_ai()` for Layer 2
- Helper methods: `set_ai_interpretation()`, `set_priority_score()`
- Comprehensive tests for all new functionality
### SQLite storage (src/core/store.rs)
- Extended schema with `ai_interpretation` and `priority_score` columns
- Automatic migration for existing databases
- Added index on `priority_score` for future sorting
- Updated all queries to include new fields
- Search now includes `ai_interpretation` in results
### MCP Server (src/mcp/base.rs)
- New tool: `create_ai_memory` with optional interpretation and score
- Updated all existing tools to return Layer 2 fields
- Backward compatible: `create_memory` still works (Layer 1)
## Design Philosophy
**"AI judges, tool records"**
- Tool provides simple storage, no complex logic
- AI (Claude) decides interpretation and importance
- Both fields are optional for flexibility
- Natural integration: interpretation + evaluation happen together
## Usage Example
```javascript
// Layer 1: Simple storage (still works)
create_memory({ content: "Tokyo weather is sunny" })
// Layer 2: AI-enhanced storage
create_ai_memory({
content: "Tokyo weather is sunny",
ai_interpretation: "User planning outdoor activities in Tokyo. Weather info important for travel decisions.",
priority_score: 0.75
})
```
## Backward Compatibility
- Layer 1 functionality unchanged
- Existing databases auto-migrate
- All Layer 2 fields are Optional<T>
- Old tools continue to work
## Testing
- All unit tests passing
- Schema migration tested
- Score clamping (0.0-1.0) tested
- Optional fields tested
Version: 0.2.0 (Layer 2)
Status: Implementation complete, ready for local testing
- Add default values for interpreted_content (empty string)
- Add default values for priority_score (0.5)
- This allows loading old memory.json files without these fields
Existing data is now compatible with new code structure.
Binary targets must import from the library using the crate name (aigpt::),
not as local modules (pub mod memory).
This fixes the 'unresolved import' errors.
- Remove duplicate module declarations in lib.rs
- Replace full-width spaces with normal spaces in companion.rs
- Add #[allow(dead_code)] for min_priority_score (future feature)
Now compiles cleanly with minimal warnings!
- Fix get_memories_by_priority f32 comparison
- Add Datelike import to game_formatter.rs
- Add Datelike import to companion.rs
All compilation errors should now be resolved.
- Fix f32 comparison: use partial_cmp instead of cmp
- Add Datelike import for ordinal() method
- Remove unused imports (Arc, Mutex)
- Fix unused variable warning (user_type -> _user_type)
All errors and most warnings are now resolved.
- Added version number to about text: 'Simple memory storage for Claude with MCP (v0.2.0)'
- Added version to long_about as well
- Now --help shows version clearly
Users can verify version from both:
aigpt --version
aigpt --help
- Added --version/-V option to show version
- Bumped version from 0.1.0 to 0.2.0
- Updated description to mention game mode
Users can now verify which version is running with:
aigpt --version
This helps debug whether the latest build is being used.
- create_memory now shows game-style results by default
- game_mode parameter added (default: true)
- Both create_memory and create_memory_with_ai now show game results
- Users can disable game mode with game_mode: false if needed
This ensures game-style display appears regardless of which tool Claude Code chooses.
- Mark create_memory as DEPRECATED
- Enhance create_memory_with_ai description with detailed instructions and example
- Add emoji indicators (⚠️ DEPRECATED, ✨ RECOMMENDED)
- Provide step-by-step scoring guide (4 criteria, each 0.0-0.25)
- Include concrete example showing expected behavior
This should help Claude Code choose the right tool and understand how to use it.
- Remove external AI API dependency (no more OpenAI/Claude API calls)
- Claude Code now does all interpretation and scoring locally
- Zero cost: No API fees
- Complete privacy: No data sent to external servers
- Simplified dependencies: Removed openai crate and ai-analysis feature
Changes:
- ai_interpreter.rs: Simplified to lightweight wrapper
- Cargo.toml: Removed ai-analysis feature and openai dependency
- mcp/base.rs: Updated create_memory_with_ai to accept interpreted_content and priority_score from Claude Code
- memory.rs: Added create_memory_with_interpretation() method
- Documentation: Updated README, QUICKSTART, USAGE to reflect local-only operation
- Added CHANGELOG.md to track changes
How it works now:
User → Claude Code (interprets & scores) → aigpt (stores) → game result
Benefits:
✅ 完全ローカル (Fully local)
✅ ゼロコスト (Zero cost)
✅ プライバシー保護 (Privacy protected)
✅ 高速 (Faster - no network latency)
✅ シンプル (Simpler - fewer dependencies)
User insight: "This works as a romance companion!"
Absolutely brilliant! Memory scoring + AI reactions = Perfect romance game
## New Features
### 💕 AI Companion System
Create your personal AI companion with 5 personality types:
- ⚡ Energetic (adventurous) - Matches with Innovators
- 📚 Intellectual (thoughtful) - Matches with Philosophers
- 🎯 Practical (reliable) - Matches with Pragmatists
- 🌙 Dreamy (romantic) - Matches with Visionaries
- ⚖️ Balanced - Matches with Analysts
### 🎮 How It Works
1. Create memory with AI → Get priority score
2. Show memory to companion → She reacts!
3. High score memory → Better reaction
4. Affection ↑ XP ↑ Trust ↑ Level ↑
### 💕 Relationship Mechanics
- **Affection Score**: 0.0-1.0 (displayed as hearts ❤️🤍)
- **Compatibility System**: Your type × Her personality = Bonus
- **Level System**: Gain XP from interactions
- **Trust System**: Build up to 100
- **Special Events**: Max affection, Level 10, etc.
### 🎊 Special Events
- Max Affection Event: Confession!
- Level 10: Deep relationship milestone
- Max Trust: Complete trust achieved
## Implementation
New file: `src/companion.rs`
- Companion struct with personality
- CompanionPersonality enum (5 types)
- React to memory based on score & type
- Compatibility calculation
- Special event triggers
- Daily message generation
MCP Tools:
- create_companion: Create your companion
- companion_react: Show memory & get reaction
- companion_profile: View stats
Game Display:
```
╔══════════════════════════════════════╗
║ 💕 エミリー の反応 ║
╚══════════════════════════════════════╝
⚡ エミリー:
「すごい！あなたのアイデア、本当に好き！」
💕 好感度: ❤️❤️🤍🤍🤍🤍🤍🤍🤍🤍 15%
💎 XP獲得: +850 XP
🎊 レベルアップ！
```
## Why This Is Perfect
Memory Score = Romance Game Mechanics:
- LEGENDARY memory → "Amazing! I love you!"
- EPIC memory → "That's so cool about you!"
- High compatibility → Faster relationship growth
- Your actual thoughts → Personal reactions
It's like a dating sim where the relationship grows based on your REAL thoughts and ideas, not scripted choices!
Next: Persistence, more events, character customization
Vision: "Make AI conversations into new content"
This roadmap outlines the evolution from current memory backend to
a full AI OS game experience:
## Phases
**Phase 1** (✅ Done): Memory Backend
- AI interpretation with priority scoring (0.0-1.0)
- Automatic capacity management
- MCP tool integration
**Phase 2** (Next - 1 month): Content Platform
- Auto-record Claude Code sessions
- Generate Markdown/HTML/ATProto content
- Personality profiling (MBTI, Big5)
- One-click publishing to Bluesky/blog
**Phase 3** (3 months): Share Service
- Public sharing at ai.syui.gpt
- Discovery by psychology score
- Personality-based matching
**Phase 4** (6 months): Gamification
- XP/Level/Achievement system
- Memory rarity (Common→Legendary)
- Daily quests and ranking
**Phase 5** (1 year): AI Companion
- Character with personality
- Unique messages based on player memories
- Daily activity generation
- Relationship/trust system
**Phase 6** (1.5 years): AI OS Integration
- Docker container with Claude Code base
- Skill marketplace
- Cloud sync
**Phase 7** (2 years): Full Game Experience
- Story mode
- Multiplayer
- Creator economy
## Key Insights
Based on user's analysis:
1. SNS achieved its goal (broadcast + connection)
2. Next era: AI OS integration
3. AI conversations become content
4. Everything gamifies eventually
5. AI companion = daily life + unique messages
## Tech Stack Recommendations
- Phase 2: comrak, atrium-api, rust-bert
- Phase 4-5: bevy, egui
- Business: Freemium model
See docs/ROADMAP.md for full details.
Critical improvements based on technical review:
## Fixed Issues (Priority: High)
1. AI features now properly integrated with MCP server
- Added create_memory_with_ai tool (was implemented but unused!)
- Added list_memories_by_priority tool
- All memory outputs now include new fields: interpreted_content, priority_score, user_context
2. Added getter methods to MemoryManager
- get_memory(id) for single memory retrieval
- get_all_memories() for bulk access
3. Complete memory information in MCP responses
- search_memories now returns all fields
- Priority-based filtering and sorting functional
## New Files
- docs/TECHNICAL_REVIEW.md: Comprehensive technical evaluation
- Scores: 65/100 overall, identified key improvements
- Actionable recommendations for Phase 1-3
- Architecture proposals and code examples
## Updated Documentation
- README.md: Added usage examples for new AI tools
- Clear distinction between basic and AI-powered tools
## Technical Debt Identified
- openai crate version needs update (see review doc)
- Config externalization needed
- Test suite missing
- LLM provider abstraction recommended
This brings the implementation in line with the "psychological priority memory"
concept. The AI interpretation and scoring features are now actually usable!
Next: Phase 2 improvements (config externalization, error handling)
Core changes:
- Add AI interpreter module for content interpretation and priority scoring
- Extend Memory struct with interpreted_content, priority_score (f32: 0.0-1.0), and user_context
- Implement automatic memory pruning based on priority scores
- Add capacity management (default: 100 memories max)
- Create comprehensive design documentation
Technical details:
- Changed priority_score from u8 (1-100) to f32 (0.0-1.0) for better AI compatibility
- Add create_memory_with_ai() method for AI-enhanced memory creation
- Implement get_memories_by_priority() for priority-based sorting
- Score evaluation criteria: emotional impact, user relevance, novelty, utility
Philosophy:
This implements a "psychological priority memory system" where AI interprets
and evaluates memories rather than storing raw content. Inspired by how human
memory works - interpreting and prioritizing rather than perfect recording.
## Compilation Fixes
- Resolve borrow checker error in docs.rs by using proper reference (`&home_content`)
- Remove unused imports across all modules to eliminate import warnings
- Fix unused variables in memory.rs and relationship.rs
- Add `#\![allow(dead_code)]` to suppress intentional API method warnings
- Update test variables to use underscore prefix for unused parameters
## MCP Server Enhancements
- Add `handle_direct_tool_call` method for HTTP endpoint compatibility
- Fix MCP tool routing to support direct HTTP calls to `/mcp/call/{tool_name}`
- Ensure all 17 MCP tools are accessible via both standard and HTTP protocols
- Improve error handling for unknown methods and tool calls
## Memory System Verification
- Confirm memory persistence and retrieval functionality
- Verify contextual memory search with query filtering
- Test relationship tracking across multiple users
- Validate ai.shell integration with OpenAI GPT-4o-mini
## Build Quality
- Achieve zero compilation errors and zero critical warnings
- Pass all 5 unit tests successfully
- Maintain clean build with suppressed intentional API warnings
- Update dependencies via `cargo update`
## Performance Results
✅ Memory system: Functional (remembers "Rust移行について話していましたね")
✅ MCP server: 17 tools operational on port 8080
✅ Relationship tracking: Active for 6 users with interaction history
✅ ai.shell: Seamless integration with persistent memory
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
