diff --git a/README.md b/README.md
index 0598e41..d21071e 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,31 @@
 # aigpt
 
-Simple memory storage for Claude with MCP support.
+AI memory system with psychological analysis for Claude via MCP.
 
-**Layer 1: Pure Memory Storage** - A clean, SQLite-based memory system with ULID identifiers.
+**Current: Layers 1-3 Complete** - Memory storage, AI interpretation, and personality analysis.
 
 ## Features
 
+### Layer 1: Pure Memory Storage
 - 🗄️ **SQLite Storage**: Reliable database with ACID guarantees
 - 🔖 **ULID IDs**: Time-sortable, 26-character unique identifiers
 - 🔍 **Search**: Fast content-based search
+- 📝 **CRUD Operations**: Complete memory management
+
+### Layer 2: AI Memory
+- 🧠 **AI Interpretation**: Claude interprets and evaluates memories
+- 📊 **Priority Scoring**: Importance ratings (0.0-1.0)
+- 🎯 **Smart Storage**: Memory + evaluation in one step
+
+### Layer 3: Personality Analysis
+- 🔬 **Big Five Model**: Scientifically validated personality assessment
+- 📈 **Pattern Recognition**: Analyzes memory patterns to build user profile
+- 💾 **Historical Tracking**: Save and compare analyses over time
+
+### General
 - 🛠️ **MCP Integration**: Works seamlessly with Claude Code
 - 🧪 **Well-tested**: Comprehensive test coverage
+- 🚀 **Simple & Fast**: Minimal dependencies, pure Rust
 
 ## Quick Start
 
@@ -47,30 +62,87 @@ aigpt stats
 claude mcp add aigpt /path/to/aigpt/target/release/aigpt server
 ```
 
-Then use in Claude Code:
-- "Remember that tomorrow will be sunny"
-- "Search for weather information"
-- "Show all my memories"
+## MCP Tools
+
+### Layer 1: Basic Memory (6 tools)
+- `create_memory` - Simple memory creation
+- `get_memory` - Retrieve by ID
+- `list_memories` - List all memories
+- `search_memories` - Content-based search
+- `update_memory` - Update existing memory
+- `delete_memory` - Remove memory
+
+### Layer 2: AI Memory (1 tool)
+- `create_ai_memory` - Create with AI interpretation and priority score
+
+### Layer 3: Personality Analysis (2 tools)
+- `save_user_analysis` - Save Big Five personality analysis
+- `get_user_analysis` - Retrieve latest personality profile
+
+## Usage Examples in Claude Code
+
+### Layer 1: Simple Memory
+```
+Remember that the project deadline is next Friday.
+```
+Claude will use `create_memory` automatically.
+
+### Layer 2: AI Memory with Evaluation
+```
+create_ai_memory({
+  content: "Designed a new microservices architecture",
+  ai_interpretation: "Shows technical creativity and strategic thinking",
+  priority_score: 0.85
+})
+```
+
+### Layer 3: Personality Analysis
+```
+# After accumulating memories, analyze personality
+save_user_analysis({
+  openness: 0.8,
+  conscientiousness: 0.7,
+  extraversion: 0.4,
+  agreeableness: 0.65,
+  neuroticism: 0.3,
+  summary: "High creativity and planning ability, introverted personality"
+})
+
+# Retrieve analysis
+get_user_analysis()
+```
+
+## Big Five Personality Traits
+
+- **Openness**: Creativity, curiosity, openness to new experiences
+- **Conscientiousness**: Organization, planning, reliability
+- **Extraversion**: Social energy, assertiveness, outgoingness
+- **Agreeableness**: Cooperation, empathy, kindness
+- **Neuroticism**: Emotional stability (low = stable, high = sensitive)
+
+Scores range from 0.0 to 1.0, where higher scores indicate stronger trait expression.
 
 ## Storage Location
 
-Memories are stored in: `~/.config/syui/ai/gpt/memory.db`
+All data stored in: `~/.config/syui/ai/gpt/memory.db`
 
 ## Architecture
 
-This is **Layer 1** of a planned multi-layer system:
+Multi-layer system design:
 
-- **Layer 1** (Current): Pure memory storage
-- **Layer 2** (Planned): AI interpretation with priority scoring
-- **Layer 3** (Planned): User evaluation and diagnosis
-- **Layer 4** (Planned): Game systems and companion features
+- **Layer 1** ✅ Complete: Pure memory storage
+- **Layer 2** ✅ Complete: AI interpretation with priority scoring
+- **Layer 3** ✅ Complete: Big Five personality analysis
+- **Layer 4** 🔵 Planned: Game systems and companion features
+- **Layer 5** 🔵 Future: Distribution and sharing
 
 See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for details.
 
 ## Documentation
 
-- [Layer 1 Details](docs/LAYER1.md) - Technical details of current implementation
 - [Architecture](docs/ARCHITECTURE.md) - Multi-layer system design
+- [Layer 1 Details](docs/LAYER1.md) - Technical details of memory storage
+- [Old Versions](docs/archive/old-versions/) - Previous documentation
 
 ## Development
 
@@ -85,6 +157,10 @@ cargo build --release
 RUST_LOG=debug aigpt server
 ```
 
+## Design Philosophy
+
+**"AI evolves, tools don't"** - This tool provides simple, reliable storage while AI (Claude) handles interpretation, evaluation, and analysis. The tool focuses on being maintainable and stable.
+
 ## License
 
 MIT
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 8875b0b..bd644e9 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -12,29 +12,29 @@ aigptは、独立したレイヤーを積み重ねる設計です。各レイヤ
 
 ```
 ┌─────────────────────────────────────────┐
-│  Layer 5: Distribution & Sharing       │  Future
+│  Layer 5: Distribution & Sharing       │  🔵 Future
 │  (Game streaming, public/private)      │
 ├─────────────────────────────────────────┤
-│  Layer 4b: AI Companion                │  Future
+│  Layer 4b: AI Companion                │  🔵 Planned
 │  (Romance system, personality growth)   │
 ├─────────────────────────────────────────┤
-│  Layer 4a: Game Systems                │  Future
+│  Layer 4a: Game Systems                │  🔵 Planned
 │  (Ranking, rarity, XP, visualization)   │
 ├─────────────────────────────────────────┤
-│  Layer 3: User Evaluation              │  Future
-│  (Personality diagnosis from patterns)  │
+│  Layer 3: User Evaluation              │  ✅ Complete
+│  (Big Five personality analysis)        │
 ├─────────────────────────────────────────┤
-│  Layer 2: AI Memory                    │  Future
+│  Layer 2: AI Memory                    │  ✅ Complete
 │  (Claude interpretation, priority_score)│
 ├─────────────────────────────────────────┤
-│  Layer 1: Pure Memory Storage          │  ✅ Current
+│  Layer 1: Pure Memory Storage          │  ✅ Complete
 │  (SQLite, ULID, CRUD operations)       │
 └─────────────────────────────────────────┘
 ```
 
-## Layer 1: Pure Memory Storage (Current)
+## Layer 1: Pure Memory Storage
 
-**Status**: ✅ **Implemented & Tested**
+**Status**: ✅ **Complete**
 
 ### Purpose
 正確なデータの保存と参照。シンプルで信頼できる基盤。
@@ -86,16 +86,16 @@ src/
 
 ---
 
-## Layer 2: AI Memory (Planned)
+## Layer 2: AI Memory
 
-**Status**: 🔵 **Planned**
+**Status**: ✅ **Complete**
 
 ### Purpose
-Claudeが記憶内容を解釈し、重要度を評価。
+Claudeが記憶内容を解釈し、重要度を評価。人間の記憶プロセス（記憶と同時に評価）を模倣。
 
 ### Extended Data Model
 ```rust
-pub struct AIMemory {
+pub struct Memory {
     // Layer 1 fields
     pub id: String,
     pub content: String,
@@ -103,63 +103,75 @@ pub struct AIMemory {
     pub updated_at: DateTime<Utc>,
 
     // Layer 2 additions
-    pub interpreted_content: String,  // Claude's interpretation
-    pub priority_score: f32,          // 0.0 - 1.0
-    pub psychological_factors: PsychologicalFactors,
-}
-
-pub struct PsychologicalFactors {
-    pub emotional_weight: f32,    // 0.0 - 1.0
-    pub personal_relevance: f32,  // 0.0 - 1.0
-    pub novelty: f32,             // 0.0 - 1.0
-    pub utility: f32,             // 0.0 - 1.0
+    pub ai_interpretation: Option<String>,  // Claude's interpretation
+    pub priority_score: Option<f32>,        // 0.0 - 1.0
 }
 ```
 
-### MCP Tools (Additional)
-- `create_memory_with_ai` - Create with Claude interpretation
-- `reinterpret_memory` - Re-evaluate existing memory
-- `get_high_priority` - Get memories above threshold
+### MCP Tools
+- `create_ai_memory` - Create memory with AI interpretation and priority score
+  - `content`: Memory content
+  - `ai_interpretation`: Optional AI interpretation
+  - `priority_score`: Optional priority (0.0-1.0)
 
-### Implementation Strategy
-- Feature flag: `--features ai-memory`
-- Backward compatible with Layer 1
+### Philosophy
+"AIは進化しますが、ツールは進化しません" - AIが判断し、ツールは記録のみ。
+
+### Implementation
+- Backward compatible with Layer 1 (Optional fields)
+- Automatic schema migration from Layer 1
 - Claude Code does interpretation (no external API)
 
 ---
 
-## Layer 3: User Evaluation (Planned)
+## Layer 3: User Evaluation
 
-**Status**: 🔵 **Planned**
+**Status**: ✅ **Complete**
 
 ### Purpose
-メモリパターンからユーザーの性格を診断。
+Layer 2のメモリパターンからユーザーの性格を分析。Big Five心理学モデルを使用。
 
-### Diagnosis Types
+### Data Model
 ```rust
-pub enum DiagnosisType {
-    Innovator,      // 革新者
-    Philosopher,    // 哲学者
-    Pragmatist,     // 実用主義者
-    Explorer,       // 探検家
-    Protector,      // 保護者
-    Visionary,      // 未来志向
+pub struct UserAnalysis {
+    pub id: String,
+    pub openness: f32,              // 0.0-1.0: 創造性、好奇心
+    pub conscientiousness: f32,      // 0.0-1.0: 計画性、信頼性
+    pub extraversion: f32,           // 0.0-1.0: 外向性、社交性
+    pub agreeableness: f32,          // 0.0-1.0: 協調性、共感性
+    pub neuroticism: f32,            // 0.0-1.0: 神経質さ（低い=安定）
+    pub summary: String,             // 分析サマリー
+    pub analyzed_at: DateTime<Utc>,
 }
 ```
 
-### Analysis
-- Memory content patterns
-- Priority score distribution
-- Creation frequency
-- Topic diversity
+### Big Five Model
+心理学で最も信頼性の高い性格モデル（OCEAN）：
+- **O**penness: 新しい経験への開かれさ
+- **C**onscientiousness: 誠実性、計画性
+- **E**xtraversion: 外向性
+- **A**greeableness: 協調性
+- **N**euroticism: 神経質さ
 
-### MCP Tools (Additional)
-- `diagnose_user` - Run personality diagnosis
-- `get_user_profile` - Get analysis summary
+### Analysis Process
+1. Layer 2メモリを蓄積
+2. AIがパターンを分析（活動の種類、優先度の傾向など）
+3. Big Fiveスコアを推測
+4. 分析結果を保存
+
+### MCP Tools
+- `save_user_analysis` - Save Big Five personality analysis
+  - All 5 traits (0.0-1.0) + summary
+- `get_user_analysis` - Get latest personality profile
+
+### Storage
+- SQLite table: `user_analyses`
+- Historical tracking: Compare analyses over time
+- Helper methods: `dominant_trait()`, `is_high()`
 
 ---
 
-## Layer 4a: Game Systems (Planned)
+## Layer 4a: Game Systems
 
 **Status**: 🔵 **Planned**
 
@@ -184,7 +196,7 @@ pub struct GameMemory {
 
 ---
 
-## Layer 4b: AI Companion (Planned)
+## Layer 4b: AI Companion
 
 **Status**: 🔵 **Planned**
 
@@ -236,21 +248,27 @@ pub struct Companion {
 - [x] Tests
 - [x] Documentation
 
-### Phase 2: Layer 2 (Next)
-- [ ] Add AI interpretation fields to schema
-- [ ] Implement priority scoring logic
-- [ ] Create `create_memory_with_ai` tool
-- [ ] Update MCP server
-- [ ] Write tests for AI features
+### Phase 2: Layer 2 ✅ (Complete)
+- [x] Add AI interpretation fields to schema
+- [x] Implement priority scoring logic
+- [x] Create `create_ai_memory` tool
+- [x] Update MCP server
+- [x] Automatic schema migration
+- [x] Backward compatibility
 
-### Phase 3: Layers 3-4 (Future)
-- [ ] User diagnosis system
-- [ ] Game mechanics
-- [ ] Companion system
+### Phase 3: Layer 3 ✅ (Complete)
+- [x] Big Five personality model
+- [x] UserAnalysis data structure
+- [x] user_analyses table
+- [x] `save_user_analysis` tool
+- [x] `get_user_analysis` tool
+- [x] Historical tracking support
 
-### Phase 4: Layer 5 (Future)
-- [ ] Sharing mechanisms
-- [ ] Public/private modes
+### Phase 4: Layers 4-5 (Next)
+- [ ] Game mechanics (Layer 4a)
+- [ ] Companion system (Layer 4b)
+- [ ] Sharing mechanisms (Layer 5)
+- [ ] Public/private modes (Layer 5)
 
 ## Design Principles
 
@@ -330,5 +348,5 @@ src/
 ---
 
 **Version**: 0.2.0
-**Last Updated**: 2025-11-05
-**Current Layer**: 1
+**Last Updated**: 2025-11-06
+**Current Status**: Layers 1-3 Complete, Layer 4 Planned
diff --git a/docs/archive/old-versions/ARCHITECTURE.md.layer1 b/docs/archive/old-versions/ARCHITECTURE.md.layer1
new file mode 100644
index 0000000..8875b0b
--- /dev/null
+++ b/docs/archive/old-versions/ARCHITECTURE.md.layer1
@@ -0,0 +1,334 @@
+# Architecture: Multi-Layer Memory System
+
+## Design Philosophy
+
+aigptは、独立したレイヤーを積み重ねる設計です。各レイヤーは：
+
+- **独立性**: 単独で動作可能
+- **接続性**: 他のレイヤーと連携可能
+- **段階的**: 1つずつ実装・テスト
+
+## Layer Overview
+
+```
+┌─────────────────────────────────────────┐
+│  Layer 5: Distribution & Sharing       │  Future
+│  (Game streaming, public/private)      │
+├─────────────────────────────────────────┤
+│  Layer 4b: AI Companion                │  Future
+│  (Romance system, personality growth)   │
+├─────────────────────────────────────────┤
+│  Layer 4a: Game Systems                │  Future
+│  (Ranking, rarity, XP, visualization)   │
+├─────────────────────────────────────────┤
+│  Layer 3: User Evaluation              │  Future
+│  (Personality diagnosis from patterns)  │
+├─────────────────────────────────────────┤
+│  Layer 2: AI Memory                    │  Future
+│  (Claude interpretation, priority_score)│
+├─────────────────────────────────────────┤
+│  Layer 1: Pure Memory Storage          │  ✅ Current
+│  (SQLite, ULID, CRUD operations)       │
+└─────────────────────────────────────────┘
+```
+
+## Layer 1: Pure Memory Storage (Current)
+
+**Status**: ✅ **Implemented & Tested**
+
+### Purpose
+正確なデータの保存と参照。シンプルで信頼できる基盤。
+
+### Technology Stack
+- **Database**: SQLite with ACID guarantees
+- **IDs**: ULID (time-sortable, 26 chars)
+- **Language**: Rust with thiserror/anyhow
+- **Protocol**: MCP (Model Context Protocol) via stdio
+
+### Data Model
+```rust
+pub struct Memory {
+    pub id: String,              // ULID
+    pub content: String,         // User content
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+```
+
+### Operations
+- `create()` - Insert new memory
+- `get(id)` - Retrieve by ID
+- `update()` - Update existing memory
+- `delete(id)` - Remove memory
+- `list()` - List all (sorted by created_at DESC)
+- `search(query)` - Content-based search
+- `count()` - Total count
+
+### File Structure
+```
+src/
+├── core/
+│   ├── error.rs    - Error types (thiserror)
+│   ├── memory.rs   - Memory struct
+│   ├── store.rs    - SQLite operations
+│   └── mod.rs      - Module exports
+├── mcp/
+│   ├── base.rs     - MCP server
+│   └── mod.rs      - Module exports
+├── lib.rs          - Library root
+└── main.rs         - CLI application
+```
+
+### Storage
+- Location: `~/.config/syui/ai/gpt/memory.db`
+- Schema: Single table with indexes on timestamps
+- No migrations (fresh start for Layer 1)
+
+---
+
+## Layer 2: AI Memory (Planned)
+
+**Status**: 🔵 **Planned**
+
+### Purpose
+Claudeが記憶内容を解釈し、重要度を評価。
+
+### Extended Data Model
+```rust
+pub struct AIMemory {
+    // Layer 1 fields
+    pub id: String,
+    pub content: String,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+
+    // Layer 2 additions
+    pub interpreted_content: String,  // Claude's interpretation
+    pub priority_score: f32,          // 0.0 - 1.0
+    pub psychological_factors: PsychologicalFactors,
+}
+
+pub struct PsychologicalFactors {
+    pub emotional_weight: f32,    // 0.0 - 1.0
+    pub personal_relevance: f32,  // 0.0 - 1.0
+    pub novelty: f32,             // 0.0 - 1.0
+    pub utility: f32,             // 0.0 - 1.0
+}
+```
+
+### MCP Tools (Additional)
+- `create_memory_with_ai` - Create with Claude interpretation
+- `reinterpret_memory` - Re-evaluate existing memory
+- `get_high_priority` - Get memories above threshold
+
+### Implementation Strategy
+- Feature flag: `--features ai-memory`
+- Backward compatible with Layer 1
+- Claude Code does interpretation (no external API)
+
+---
+
+## Layer 3: User Evaluation (Planned)
+
+**Status**: 🔵 **Planned**
+
+### Purpose
+メモリパターンからユーザーの性格を診断。
+
+### Diagnosis Types
+```rust
+pub enum DiagnosisType {
+    Innovator,      // 革新者
+    Philosopher,    // 哲学者
+    Pragmatist,     // 実用主義者
+    Explorer,       // 探検家
+    Protector,      // 保護者
+    Visionary,      // 未来志向
+}
+```
+
+### Analysis
+- Memory content patterns
+- Priority score distribution
+- Creation frequency
+- Topic diversity
+
+### MCP Tools (Additional)
+- `diagnose_user` - Run personality diagnosis
+- `get_user_profile` - Get analysis summary
+
+---
+
+## Layer 4a: Game Systems (Planned)
+
+**Status**: 🔵 **Planned**
+
+### Purpose
+ゲーム的要素で記憶管理を楽しく。
+
+### Features
+- **Rarity Levels**: Common → Uncommon → Rare → Epic → Legendary
+- **XP System**: Memory creation earns XP
+- **Rankings**: Based on total priority score
+- **Visualization**: Game-style output formatting
+
+### Data Additions
+```rust
+pub struct GameMemory {
+    // Previous layers...
+    pub rarity: RarityLevel,
+    pub xp_value: u32,
+    pub discovered_at: DateTime<Utc>,
+}
+```
+
+---
+
+## Layer 4b: AI Companion (Planned)
+
+**Status**: 🔵 **Planned**
+
+### Purpose
+育成可能な恋愛コンパニオン。
+
+### Features
+- Personality types (Tsundere, Kuudere, Genki, etc.)
+- Relationship level (0-100)
+- Memory-based interactions
+- Growth through conversations
+
+### Data Model
+```rust
+pub struct Companion {
+    pub id: String,
+    pub name: String,
+    pub personality: CompanionPersonality,
+    pub relationship_level: u8,  // 0-100
+    pub memories_shared: Vec<String>,
+    pub last_interaction: DateTime<Utc>,
+}
+```
+
+---
+
+## Layer 5: Distribution (Future)
+
+**Status**: 🔵 **Future Consideration**
+
+### Purpose
+ゲーム配信や共有機能。
+
+### Ideas
+- Share memory rankings
+- Export as shareable format
+- Public/private memory modes
+- Integration with streaming platforms
+
+---
+
+## Implementation Strategy
+
+### Phase 1: Layer 1 ✅ (Complete)
+- [x] Core memory storage
+- [x] SQLite integration
+- [x] MCP server
+- [x] CLI interface
+- [x] Tests
+- [x] Documentation
+
+### Phase 2: Layer 2 (Next)
+- [ ] Add AI interpretation fields to schema
+- [ ] Implement priority scoring logic
+- [ ] Create `create_memory_with_ai` tool
+- [ ] Update MCP server
+- [ ] Write tests for AI features
+
+### Phase 3: Layers 3-4 (Future)
+- [ ] User diagnosis system
+- [ ] Game mechanics
+- [ ] Companion system
+
+### Phase 4: Layer 5 (Future)
+- [ ] Sharing mechanisms
+- [ ] Public/private modes
+
+## Design Principles
+
+1. **Simplicity First**: Each layer adds complexity incrementally
+2. **Backward Compatibility**: New layers don't break old ones
+3. **Feature Flags**: Optional features via Cargo features
+4. **Independent Testing**: Each layer has its own test suite
+5. **Clear Boundaries**: Layers communicate through defined interfaces
+
+## Technology Choices
+
+### Why SQLite?
+- ACID guarantees
+- Better querying than JSON
+- Built-in indexes
+- Single-file deployment
+- No server needed
+
+### Why ULID?
+- Time-sortable (unlike UUID v4)
+- Lexicographically sortable
+- 26 characters (compact)
+- No collision concerns
+
+### Why Rust?
+- Memory safety
+- Performance
+- Excellent error handling
+- Strong type system
+- Great tooling (cargo, clippy)
+
+### Why MCP?
+- Standard protocol for AI tools
+- Works with Claude Code/Desktop
+- Simple stdio-based communication
+- No complex networking
+
+## Future Considerations
+
+### Potential Enhancements
+- Full-text search (SQLite FTS5)
+- Tag system
+- Memory relationships/links
+- Export/import functionality
+- Multiple databases
+- Encryption for sensitive data
+
+### Scalability
+- Layer 1: Handles 10K+ memories easily
+- Consider pagination for Layer 4 (UI display)
+- Indexing strategy for search performance
+
+## Development Guidelines
+
+### Adding a New Layer
+
+1. **Design**: Document data model and operations
+2. **Feature Flag**: Add to Cargo.toml
+3. **Schema**: Extend database schema (migrations)
+4. **Implementation**: Write code in new module
+5. **Tests**: Comprehensive test coverage
+6. **MCP Tools**: Add new MCP tools if needed
+7. **Documentation**: Update this file
+
+### Code Organization
+
+```
+src/
+├── core/           # Layer 1: Pure storage
+├── ai/             # Layer 2: AI features (future)
+├── evaluation/     # Layer 3: User diagnosis (future)
+├── game/           # Layer 4a: Game systems (future)
+├── companion/      # Layer 4b: Companion (future)
+└── mcp/            # MCP server (all layers)
+```
+
+---
+
+**Version**: 0.2.0
+**Last Updated**: 2025-11-05
+**Current Layer**: 1
diff --git a/docs/archive/old-versions/README.md.layer1 b/docs/archive/old-versions/README.md.layer1
new file mode 100644
index 0000000..0598e41
--- /dev/null
+++ b/docs/archive/old-versions/README.md.layer1
@@ -0,0 +1,94 @@
+# aigpt
+
+Simple memory storage for Claude with MCP support.
+
+**Layer 1: Pure Memory Storage** - A clean, SQLite-based memory system with ULID identifiers.
+
+## Features
+
+- 🗄️ **SQLite Storage**: Reliable database with ACID guarantees
+- 🔖 **ULID IDs**: Time-sortable, 26-character unique identifiers
+- 🔍 **Search**: Fast content-based search
+- 🛠️ **MCP Integration**: Works seamlessly with Claude Code
+- 🧪 **Well-tested**: Comprehensive test coverage
+
+## Quick Start
+
+### Installation
+
+```bash
+# Build
+cargo build --release
+
+# Install (optional)
+cp target/release/aigpt ~/.cargo/bin/
+```
+
+### CLI Usage
+
+```bash
+# Create a memory
+aigpt create "Remember this information"
+
+# List all memories
+aigpt list
+
+# Search memories
+aigpt search "keyword"
+
+# Show statistics
+aigpt stats
+```
+
+### MCP Integration with Claude Code
+
+```bash
+# Add to Claude Code
+claude mcp add aigpt /path/to/aigpt/target/release/aigpt server
+```
+
+Then use in Claude Code:
+- "Remember that tomorrow will be sunny"
+- "Search for weather information"
+- "Show all my memories"
+
+## Storage Location
+
+Memories are stored in: `~/.config/syui/ai/gpt/memory.db`
+
+## Architecture
+
+This is **Layer 1** of a planned multi-layer system:
+
+- **Layer 1** (Current): Pure memory storage
+- **Layer 2** (Planned): AI interpretation with priority scoring
+- **Layer 3** (Planned): User evaluation and diagnosis
+- **Layer 4** (Planned): Game systems and companion features
+
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for details.
+
+## Documentation
+
+- [Layer 1 Details](docs/LAYER1.md) - Technical details of current implementation
+- [Architecture](docs/ARCHITECTURE.md) - Multi-layer system design
+
+## Development
+
+```bash
+# Run tests
+cargo test
+
+# Build for release
+cargo build --release
+
+# Run with verbose logging
+RUST_LOG=debug aigpt server
+```
+
+## License
+
+MIT
+
+## Author
+
+syui