CalvinBackup/claude-howto
1
0
Fork 0
mirror of https://github.com/luongnv89/claude-howto.git synced 2026-04-30 21:57:48 +02:00
Code Issues Packages Projects Releases Wiki Activity

Update memory doc with the update from offical claude code website

Browse Source
This commit is contained in:
Luong NGUYEN
2025-11-23 22:30:36 +01:00
parent cbfc41228f
commit 27ad9da05e
1 changed files with 369 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files
02-memory/README.md
+369 -16
View File
@@ -16,6 +16,176 @@ Memory in Claude Code provides persistent context that carries across multiple s
The memory system operates at multiple levels, from global personal preferences down to specific subdirectories, allowing for fine-grained control over what Claude remembers and how it applies that knowledge.
## Memory Commands Quick Reference
| Command | Purpose | Usage | When to Use |
|---------|---------|-------|-------------|
| `/init` | Initialize project memory | `/init` | Starting new project, first-time CLAUDE.md setup |
| `/memory` | Edit memory files in editor | `/memory` | Extensive updates, reorganization, reviewing content |
| `#` prefix | Quick single-line memory add | `# Your rule here` | Adding quick rules during conversation |
| `# new rule into memory` | Explicit memory addition | `# new rule into memory<br/>Your detailed rule` | Adding complex multi-line rules |
| `# remember this` | Natural language memory | `# remember this<br/>Your instruction` | Conversational memory updates |
| `@path/to/file` | Import external content | `@README.md` or `@docs/api.md` | Referencing existing documentation in CLAUDE.md |
## Quick Start: Initializing Memory
### The `/init` Command
The `/init` command is the fastest way to set up project memory in Claude Code. It initializes a CLAUDE.md file with foundational project documentation.
**Usage:**
```bash
/init
```
**What it does:**
- Creates a new CLAUDE.md file in your project (typically at `./CLAUDE.md` or `./.claude/CLAUDE.md`)
- Establishes project conventions and guidelines
- Sets up the foundation for context persistence across sessions
- Provides a template structure for documenting your project standards
**When to use `/init`:**
- Starting a new project with Claude Code
- Establishing team coding standards and conventions
- Creating documentation about your codebase structure
- Setting up memory hierarchy for collaborative development
**Example workflow:**
```markdown
# In your project directory
/init
# Claude creates CLAUDE.md with structure like:
# Project Configuration
## Project Overview
- Name: Your Project
- Tech Stack: [Your technologies]
- Team Size: [Number of developers]
## Development Standards
- Code style preferences
- Testing requirements
- Git workflow conventions
```
### Quick Memory Updates with `#`
You can quickly add information to memory during any conversation by starting your message with `#`:
**Syntax:**
```markdown
# Your memory rule or instruction here
```
**Examples:**
```markdown
# Always use TypeScript strict mode in this project
# Prefer async/await over promise chains
# Run npm test before every commit
# Use kebab-case for file names
```
**How it works:**
1. Start your message with `#` followed by your rule
2. Claude recognizes this as a memory update request
3. Claude asks which memory file to update (project or personal)
4. The rule is added to the appropriate CLAUDE.md file
5. Future sessions automatically load this context
**Alternative patterns:**
```markdown
# new rule into memory
Always validate user input with Zod schemas
# remember this
Use semantic versioning for all releases
# add to memory
Database migrations must be reversible
```
### The `/memory` Command
The `/memory` command provides direct access to edit your CLAUDE.md memory files within Claude Code sessions. It opens your memory files in your system editor for comprehensive editing.
**Usage:**
```bash
/memory
```
**What it does:**
- Opens your memory files in your system's default editor
- Allows you to make extensive additions, modifications, and reorganizations
- Provides direct access to all memory files in the hierarchy
- Enables you to manage persistent context across sessions
**When to use `/memory`:**
- Reviewing existing memory content
- Making extensive updates to project standards
- Reorganizing memory structure
- Adding detailed documentation or guidelines
- Maintaining and updating memory as your project evolves
**Comparison: `/memory` vs `/init`**
| Aspect | `/memory` | `/init` |
|--------|-----------|---------|
| **Purpose** | Edit existing memory files | Initialize new CLAUDE.md |
| **When to use** | Update/modify project context | Begin new projects |
| **Action** | Opens editor for changes | Generates starter template |
| **Workflow** | Ongoing maintenance | One-time setup |
**Example workflow:**
```markdown
# Open memory for editing
/memory
# Claude presents options:
# 1. Enterprise Policy Memory
# 2. Project Memory (./CLAUDE.md)
# 3. User Memory (~/.claude/CLAUDE.md)
# 4. Local Project Memory
# Choose option 2 (Project Memory)
# Your default editor opens with ./CLAUDE.md content
# Make changes, save, and close editor
# Claude automatically reloads the updated memory
```
**Using Memory Imports:**
CLAUDE.md files support the `@path/to/file` syntax to include external content:
```markdown
# Project Documentation
See @README.md for project overview
See @package.json for available npm commands
See @docs/architecture.md for system design
```
**Import features:**
- Supports both relative and absolute paths
- Enables recursive nesting up to 5 levels deep
- Helps avoid duplication by referencing existing documentation
- Automatically includes referenced content in Claude's context
## Memory Architecture
Memory in Claude Code follows a hierarchical system where different scopes serve different purposes:
@@ -35,6 +205,26 @@ graph TB
## Memory Hierarchy in Claude Code
Claude Code uses a four-tier hierarchical memory system. Memory files are automatically loaded when Claude Code launches, with higher-level files taking precedence.
**Complete Memory Hierarchy (in order of precedence):**
1. **Enterprise Policy** - Organization-wide instructions
- macOS: `/Library/Application Support/ClaudeCode/CLAUDE.md`
- Linux: `/etc/claude-code/CLAUDE.md`
- Windows: `C:\ProgramData\ClaudeCode\CLAUDE.md`
2. **Project Memory** - Team-shared context (version controlled)
- `./.claude/CLAUDE.md` or `./CLAUDE.md` (in repository root)
3. **User Memory** - Personal preferences
- `~/.claude/CLAUDE.md`
4. **Local Project Memory** - Personal project-specific preferences (deprecated)
- `./CLAUDE.local.md`
**Memory Discovery Behavior:**
Claude searches for memory files in this order, with earlier locations taking precedence:
```mermaid
@@ -54,11 +244,14 @@ graph TD
| Location | Scope | Priority | Shared | Access | Best For |
|----------|-------|----------|--------|--------|----------|
| `/Library/Application Support/ClaudeCode/CLAUDE.md` (macOS) | Enterprise | Highest | Organization | System | Company-wide policies |
| `/etc/claude-code/CLAUDE.md` (Linux) | Enterprise | Highest | Organization | System | Organization standards |
| `C:\ProgramData\ClaudeCode\CLAUDE.md` (Windows) | Enterprise | Highest | Organization | System | Corporate guidelines |
| `./CLAUDE.md` | Project | High | Team | Git | Team standards, shared architecture |
| `./.claude/CLAUDE.md` | Project | High | Team | Git | Alternative project location |
| `./subdir/CLAUDE.md` | Directory | Medium | Team | Git | Directory-specific rules |
| `~/.claude/CLAUDE.md` | Personal | Low | Individual | Filesystem | Personal preferences |
| `~/.claude/my-project.md` | Personal | Low | Individual | Import | Project-specific personal notes |
| `./CLAUDE.local.md` | Project Local | Deprecated | Individual | Git (ignored) | Personal project notes (deprecated) |
## Memory Update Lifecycle
@@ -322,7 +515,9 @@ Claude has not save the rule because I did not have any `Claude.md` file anywher
### Example 4: Memory Update During Session
**Session Interaction:**
You can add new rules to memory during an active Claude Code session. There are two ways to do this:
#### Method 1: Direct Request
```markdown
User: Remember that I prefer using React hooks instead of class components
@@ -347,6 +542,38 @@ Added to ./CLAUDE.md:
- Use useMemo for expensive computations
```
#### Method 2: Using "# new rule into memory" Pattern
You can also use the explicit pattern "# new rule into memory" to trigger memory updates:
```markdown
User: # new rule into memory
Always validate user input with Zod schemas before processing.
Claude: I'm saving this rule to memory. Which memory file should I use?
1. Project memory (./CLAUDE.md)
2. Personal memory (~/.claude/CLAUDE.md)
User: Project memory
Claude: ✅ Memory saved!
Added to ./CLAUDE.md:
---
### Input Validation
- Always validate user input with Zod schemas before processing
- Define schemas at the top of each API handler file
- Return 400 status with validation errors
```
#### Tips for Adding Memory
- Be specific and actionable in your rules
- Group related rules together under a section header
- Update existing sections instead of duplicating content
- Choose the appropriate memory scope (project vs. personal)
## Memory Features Comparison
| Feature | Claude Web/Desktop | Claude Code (CLAUDE.md) |
@@ -406,29 +633,110 @@ graph LR
### Do's - What To Include
- **Keep organized**: Structure memory files with clear sections
- **Keep up-to-date**: Review and update memory regularly as standards change
- **Use project memory for**: Team standards, architecture, coding conventions
- **Use personal memory for**: Preferences, communication style, tooling choices
- **Use directory memory for**: Module-specific rules and overrides
- **Version control**: Commit CLAUDE.md files to git for team benefit
- **Import docs**: Reference external files with @docs/file.md syntax
- **Be specific**: Provide concrete examples and clear expectations
- **Be specific and detailed**: Use clear, detailed instructions rather than vague guidance
- ✅ Good: "Use 2-space indentation for all JavaScript files"
- ❌ Avoid: "Follow best practices"
- **Keep organized**: Structure memory files with clear markdown sections and headings
- **Use appropriate hierarchy levels**:
- **Enterprise memory**: Company-wide policies, security standards, compliance requirements
- **Project memory**: Team standards, architecture, coding conventions (commit to git)
- **User memory**: Personal preferences, communication style, tooling choices
- **Directory memory**: Module-specific rules and overrides
- **Leverage imports**: Use `@path/to/file` syntax to reference existing documentation
- Supports up to 5 levels of recursive nesting
- Avoids duplication across memory files
- Example: `See @README.md for project overview`
- **Document frequent commands**: Include commands you use repeatedly to save time
- **Version control project memory**: Commit project-level CLAUDE.md files to git for team benefit
- **Review periodically**: Update memory regularly as projects evolve and requirements change
- **Provide concrete examples**: Include code snippets and specific scenarios
### Don'ts - What To Avoid
- **Don't store secrets**: Never include API keys, passwords, or credentials
- **Don't duplicate**: Avoid repeating content across memory files
- **Don't create too many**: Keep subdirectory overrides minimal and focused
- **Don't make it too long**: Keep memory files under 500 lines
- **Don't store secrets**: Never include API keys, passwords, tokens, or credentials
- **Don't include sensitive data**: No PII, private information, or proprietary secrets
- **Don't forget to update**: Memory becomes stale if not maintained
- **Don't over-organize**: Use hierarchy strategically, not excessively
- **Don't duplicate content**: Use imports (`@path`) to reference existing documentation instead
- **Don't be vague**: Avoid generic statements like "follow best practices" or "write good code"
- **Don't make it too long**: Keep individual memory files focused and under 500 lines
- **Don't over-organize**: Use hierarchy strategically; don't create excessive subdirectory overrides
- **Don't forget to update**: Stale memory can cause confusion and outdated practices
- **Don't exceed nesting limits**: Memory imports support up to 5 levels of nesting
### Memory Management Tips
**Choose the right memory level:**
| Use Case | Memory Level | Rationale |
|----------|-------------|-----------|
| Company security policy | Enterprise | Applies to all projects organization-wide |
| Team code style guide | Project | Shared with team via git |
| Your preferred editor shortcuts | User | Personal preference, not shared |
| API module standards | Directory | Specific to that module only |
**Quick update workflow:**
1. For single rules: Use `#` prefix in conversation
2. For multiple changes: Use `/memory` to open editor
3. For initial setup: Use `/init` to create template
**Import best practices:**
```markdown
# Good: Reference existing docs
@README.md
@docs/architecture.md
@package.json
# Avoid: Copying content that exists elsewhere
# Instead of copying README content into CLAUDE.md, just import it
```
## Installation Instructions
### Setup Project Memory
#### Method 1: Using `/init` Command (Recommended)
The fastest way to set up project memory:
1. **Navigate to your project directory:**
```bash
cd /path/to/your/project
```
2. **Run the init command in Claude Code:**
```bash
/init
```
3. **Claude will create and populate CLAUDE.md** with a template structure
4. **Customize the generated file** to match your project needs
5. **Commit to git:**
```bash
git add CLAUDE.md
git commit -m "Initialize project memory with /init"
```
#### Method 2: Manual Creation
If you prefer manual setup:
1. **Create a CLAUDE.md in your project root:**
```bash
cd /path/to/your/project
@@ -458,6 +766,20 @@ graph LR
git commit -m "Add project memory configuration"
```
#### Method 3: Quick Updates with `#`
Once CLAUDE.md exists, add rules quickly during conversations:
```markdown
# Use semantic versioning for all releases
# Always run tests before committing
# Prefer composition over inheritance
```
Claude will prompt you to choose which memory file to update.
### Setup Personal Memory
1. **Create ~/.claude directory:**
@@ -525,6 +847,37 @@ graph LR
3. **Test with Claude Code** by starting a new session in your project
## Official Documentation
This guide is based on official Claude Code documentation. For the most up-to-date information, refer to:
- **[Memory Documentation](https://code.claude.com/docs/en/memory.md)** - Complete memory system reference
- **[Slash Commands Reference](https://code.claude.com/docs/en/slash-commands.md)** - All built-in commands including `/init` and `/memory`
- **[Quickstart Guide](https://code.claude.com/docs/en/quickstart.md)** - Getting started with Claude Code
- **[Documentation Map](https://code.claude.com/docs/en/claude_code_docs_map.md)** - Complete documentation index
### Key Technical Details from Official Docs
**Memory Loading:**
- All memory files are automatically loaded when Claude Code launches
- Claude traverses upward from the current working directory to discover CLAUDE.md files
- Subtree files are discovered and loaded contextually when accessing those directories
**Import Syntax:**
- Use `@path/to/file` to include external content
- Supports both relative and absolute paths
- Recursive nesting supported up to 5 levels deep
- Automatically includes referenced content in Claude's context
**Memory Hierarchy Precedence:**
1. Enterprise Policy (highest precedence)
2. Project Memory
3. User Memory
4. Local Project Memory (deprecated, lowest precedence)
## Related Concepts Links
### Core Memory Concepts