System pamięci Claude Code

System pamięci Claude Code przekształca zarządzanie kontekstem projektu z ręcznego obciążenia w inteligentną, hierarchiczną bazę wiedzy. Wykorzystując pliki CLAUDE.md i strategiczne umieszczanie pamięci, tworzysz trwały kontekst, który sprawia, że Claude rozumie twój projekt tak głęboko jak ty.

Architektura systemu pamięci

Claude Code używa zaawansowanego wielopoziomowego systemu pamięci, który ładuje się automatycznie przy starcie:

Pamięć projektu

Lokalizacja: ./CLAUDE.md
Dzielona wiedza zespołu - architektura, standardy, przepływy pracy

Pamięć użytkownika

Lokalizacja: ~/.claude/CLAUDE.md
Osobiste preferencje stosowane do wszystkich projektów

Pamięć trwała

Lokalizacja: .claude/memory.json
Dynamiczna pamięć aktualizowana przez Claude podczas sesji

Pamięć lokalna

Lokalizacja: ./CLAUDE.local.md
Osobiste ustawienia specyficzne dla projektu (przestarzałe - używaj importów)

Trwała pamięć JSON

Claude Code może utrzymywać trwałą pamięć między sesjami używając .claude/memory.json:

{
  "project_facts": {
    "internal_library": "Używamy LibraryY do wszystkich wywołań HTTP",
    "deployment_server": "Produkcja wdrażana na AWS us-east-1",
    "test_database": "Baza testowa resetuje się codziennie o 3:00 UTC"
  },
  "session_context": {
    "current_feature": "Implementacja integracji OAuth2",
    "blocked_by": "Czekamy na zgodę zespołu bezpieczeństwa",
    "last_error": "Timeout połączenia Redis na staging"
  },
  "team_patterns": {
    "pr_reviewer": "Alice przegląda wszystkie zmiany auth",
    "deploy_schedule": "Tylko wtorki i czwartki"
  }
}

Ta pamięć przetrwa między sesjami i może być aktualizowana programowo przez Claude lub hooks.

Jak działa odkrywanie pamięci

Claude Code wykorzystuje strategię rekurencyjnego wyszukiwania dla maksymalnej elastyczności:

graph TD A[Aktualny katalog] --> B{CLAUDE.md istnieje?} B -->|Tak| C[Załaduj do kontekstu] B -->|Nie| D[Sprawdź katalog nadrzędny] D --> E{Osiągnięto root /?} E -->|Nie| B E -->|Tak| F[Zatrzymaj wyszukiwanie] C --> G[Przeszukaj podkatalogi] G --> H[Ładuj na żądanie przy dostępie do plików]

Tworzenie efektywnych plików pamięci

Szybkie dodawanie pamięci

Najszybszy sposób dodawania pamięci to skrót #:

# Zawsze używaj snake_case dla zmiennych Python

Claude poprosi cię o wybór pliku pamięci, który powinien przechować tę instrukcję, czyniąc dokumentację bezwysiłkową podczas rozwoju.

Kompleksowa pamięć projektu

Zainicjuj poleceniem /init
Okno terminala
```
claude> /init
```
Claude analizuje twój projekt i generuje kompleksowy szablon CLAUDE.md.

Ustrukturyzuj pamięć hierarchicznie

# Architektura projektu
- Frontend: Next.js 14 z App Router
- Backend: Node.js Express API
- Baza danych: PostgreSQL z Prisma ORM

# Polecenia budowania
- `npm run dev` - Uruchom serwer deweloperski
- `npm run build` - Build produkcyjny
- `npm test` - Uruchom zestaw testów

# Standardy kodowania
- Używaj trybu ścisłego TypeScript
- Preferuj named exports nad default exports
- Wszystkie odpowiedzi API następują wzorzec { data, error }

# Kluczowe pliki
- `/src/lib/auth.ts` - Narzędzia uwierzytelniania
- `/src/db/schema.prisma` - Schemat bazy danych
- `/docs/API.md` - Dokumentacja API

Dodaj kontekst specyficzny dla projektu Uwzględnij informacje oszczędzające powtarzanie wyjaśnień:
- Typowe problemy i obejścia
- Procedury wdrażania
- Strategie testowania
- Względy wydajnościowe

Zaawansowany system importów

Pliki CLAUDE.md obsługują potężną funkcjonalność importu używając składni @path/to/file:

Podstawowe importy

# Zobacz @README.md dla przeglądu projektu
# Dokumentacja API: @docs/api/endpoints.md
# Schemat bazy danych: @src/db/schema.sql

## Przepływ pracy Git
Postępuj zgodnie z naszą strategią branching @docs/git-workflow.md

Personalizacja członków zespołu

Włącz indywidualne preferencje bez zanieczyszczania repozytorium:

# Konfiguracja zespołu
- Współdzielone standardy: @docs/team-standards.md
- Ustawienia indywidualne: @~/.claude/project-name-personal.md

Członkowie zespołu tworzą swoje własne ~/.claude/project-name-personal.md:

# Moje środowisko deweloperskie
- Lokalny URL API: http://localhost:3001
- Baza testowa: postgresql://user@localhost/myapp_test
- Preferowany użytkownik testowy: alice@example.com

Rekurencyjne łańcuchy importów

Importy mogą odwoływać się do innych importów (maks. głębokość: 5):

FolderCLAUDE.md (importuje @config/base.md)
- Folderconfig/
  - Folderbase.md (importuje @config/tools.md)
    Foldertools.md (importuje @config/shortcuts.md)
    shortcuts.md

Wzorce hierarchii pamięci

Organizacja monorepo

Dla złożonych monorepo, wykorzystaj hierarchiczną pamięć:

project/
├── CLAUDE.md                 # Standardy poziomu root
├── packages/
│   ├── frontend/
│   │   └── CLAUDE.md        # Wzorce specyficzne dla frontend
│   ├── backend/
│   │   └── CLAUDE.md        # Konwencje API
│   └── shared/
│       └── CLAUDE.md        # Dokumentacja narzędzi współdzielonych

Podczas uruchamiania Claude z packages/frontend/, ładuje:

/project/CLAUDE.md (nadrzędny)
/project/packages/frontend/CLAUDE.md (aktualny)
Pamięci podkatalogów na żądanie

Architektura mikrousług

Ustrukturyzuj pamięci aby odzwierciedlić granice usług:

## Usługa uwierzytelniania
- Port: 3001
- Baza danych: auth_db
- Kluczowe endpointy:
  - POST /login
  - POST /refresh
  - POST /logout

## Testowanie
Uruchom testy z: `npm test -- --service=auth`

## Zależności
- Biblioteka JWT: @auth0/node-jsonwebtoken
- Hashowanie haseł: bcrypt

Najlepsze praktyki

Konkretne polecenia z dokładną składnią
Decyzje architektoniczne z uzasadnieniem
Typowe wzorce używane przez twój zespół
Problemy i obejścia dla znanych problemów
Lokalizacje plików dla kluczowych komponentów
Procedury testowe i wymagania
Checklista wdrażania

Przykład:

# Obsługa błędów API
Zawsze opakuj wywołania bazy danych w try-catch:
- Zwracaj { error: error.message, code: 'DB_ERROR' }
- Loguj pełny błąd do serwisu monitorowania
- Nigdy nie ujawniaj stack trace klientom

Niejasne instrukcje jak “pisz dobry kod”
Nieaktualne informacje ze starych wersji
Wrażliwe dane (hasła, klucze API)
Długa dokumentacja (zamiast tego linkuj)
Osobiste preferencje w plikach współdzielonych
Tymczasowe obejścia bez dat

Zły przykład:

# Styl kodu
Upewnij się, że kod jest czysty i następuje najlepsze praktyki

Utrzymanie pamięci

Przeglądaj kwartalnie - Ustaw przypomnienia kalendarza do aktualizacji pamięci
Wersjonuj z git - Śledź zmiany w współdzielonych plikach CLAUDE.md
Testuj skuteczność - Poproś Claude o wykonanie zadań używając tylko pamięci
Zbieraj feedback - Ankietuj zespół o brakujące lub mylące instrukcje
Regularnie czyść - Usuwaj nieaktualne lub nieużywane instrukcje

Monitorowanie użycia pamięci

Użyj polecenia /memory aby sprawdzić załadowane pamięci:

claude> /memory

Załadowane pliki pamięci:
1. /Users/you/.claude/CLAUDE.md (451 tokenów)
2. /project/CLAUDE.md (823 tokeny)
3. /project/frontend/CLAUDE.md (312 tokenów)

Łączne tokeny pamięci: 1,586

Wybierz plik do edycji: [1-3]

Hierarchiczna pamięć dla monorepo

W dużych monorepo, Claude Code obsługuje zaawansowane wzorce hierarchicznej pamięci:

Foldermonorepo/
- CLAUDE.md (standardy poziomu root)
- Folderbackend/
  - CLAUDE.md (wzorce specyficzne dla backend)
  - Folderservices/
    Folderauth/
    CLAUDE.md (specyfika usługi auth)
    Folderpayments/
    CLAUDE.md (reguły przetwarzania płatności)
- Folderfrontend/
  - CLAUDE.md (konwencje frontend)
  - Folderapps/
    Folderweb/
    CLAUDE.md (specyfika aplikacji web)
    Foldermobile/
    CLAUDE.md (wzorce mobile)
- Foldershared/
  - CLAUDE.md (wytyczne biblioteki współdzielonej)

Dziedziczenie i nadpisywanie pamięci

Pliki pamięci kaskadują od ogólnych do specyficznych:

# Root CLAUDE.md
Wszystkie usługi używają formatu błędów: { code: string, message: string }

Nadpisanie dla auth: Uwzględnij pole `retryAfter` dla limitów szybkości

Claude automatycznie stosuje najbardziej specyficzną pamięć dla aktualnego kontekstu pracy.

Wzorce pamięci przedsiębiorstwa

# WYMAGANIA ZGODNOŚCI
OBOWIĄZKOWE: Wszystkie PII muszą być szyfrowane w spoczynku i w tranzycie
OBOWIĄZKOWE: Loguj wszystkie dostępy do danych z ID użytkownika i timestampem
OBOWIĄZKOWE: Uruchom skanowanie bezpieczeństwa przed każdym wdrożeniem

# Automatyczne hooks zgodności
Podczas edycji plików w /src/api/user/*:
- Upewnij się, że wszystkie endpointy mają dekorator @RequireAuth
- Zweryfikuj walidację wejścia we wszystkich żądaniach POST/PUT
- Sprawdź luki SQL injection

# Zgodność GDPR
- Usuwanie danych użytkownika musi kaskadowo przechodzić na wszystkie usługi
- Eksportuj dane użytkownika w formacie JSON w ciągu 30 dni
- Utrzymuj log audytu przez 7 lat

# WYMAGANIA WYDAJNOŚCI
- Odpowiedzi API muszą powracać w ciągu 200ms (p95)
- Zapytania do bazy danych muszą używać indeksów (bez table scan)
- Rozmiar bundla frontend < 250KB gzipped

# Wzorce wydajności
## Zapytania do bazy danych
@./docs/query-optimization.md

## Strategia cachowania
- Redis dla danych sesji (15 min TTL)
- CDN dla zasobów statycznych (1 rok TTL)
- Odpowiedzi API cachowane przez 5 minut

## Monitorowanie
- Dodaj performance.mark() dla kluczowych operacji
- Loguj powolne zapytania (>100ms) do monitorowania
- Alert przy użyciu pamięci >80%

# PROTOKOŁY BEZPIECZEŃSTWA
KRYTYCZNE: Nigdy nie commituj poświadczeń lub sekretów
KRYTYCZNE: Wszystkie wejścia użytkownika muszą być sanitized
KRYTYCZNE: Używaj prepared statements dla wszystkich SQL

# Standardy uwierzytelniania
@~/.claude/security-standards.md

# Checklist bezpieczeństwa
Przed każdym PR:
[ ] Uruchom `npm audit` i napraw luki
[ ] Zweryfikuj brak hardcoded secrets (użyj skanera)
[ ] Sprawdź uwierzytelnianie na wszystkich nowych endpointach
[ ] Waliduj i sanitized wszystkie wejścia
[ ] Zaktualizuj dokumentację bezpieczeństwa

# Reakcja na incydent
Przy incydencie bezpieczeństwa:
1. Natychmiast powiadom zespół bezpieczeństwa
2. Nie próbuj napraw bez zgody
3. Dokumentuj wszystkie działania w logu incydentu

Integracja z systemem hooks

Połącz pamięć z hooks dla inteligentnej automatyzacji:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [{
          "type": "command",
          "command": "node scripts/update-memory.js '$CLAUDE_FILE_PATHS'"
        }]
      }
    ],
    "Stop": [
      {
        "hooks": [{
          "type": "command",
          "command": "node scripts/save-session-context.js"
        }]
      }
    ]
  }
}

Przykład skryptu aktualizacji pamięci:

const fs = require('fs');
const path = require('path');

const memoryPath = '.claude/memory.json';
const memory = JSON.parse(fs.readFileSync(memoryPath, 'utf8'));

// Zaktualizuj ostatnio modyfikowane pliki
const files = process.argv[2]?.split(',') || [];
memory.session_context.last_modified = files;
memory.session_context.last_update = new Date().toISOString();

fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));

Szablony pamięci ze świata rzeczywistego

Aplikacja web full-stack

# Stos technologiczny
- Frontend: React 18 + TypeScript + Vite
- Stan: Zustand dla globalnego, React Query dla serwera
- Backend: Express + TypeScript
- Baza danych: PostgreSQL + Prisma
- Auth: JWT z refresh tokens

# Rozwój
- Instalacja: `npm install` w root (uruchamia wszystkie workspaces)
- Tryb dev: `npm run dev` (uruchamia wszystkie usługi)
- Sprawdzanie typów: `npm run type-check`
- Baza danych: `npm run db:push` (sync schema)

# Wzorce architektury
## Odpowiedzi API
Wszystkie endpointy zwracają: `{ success: boolean, data?: T, error?: string }`

## Pobieranie danych frontend
- Używaj React Query dla wszystkich wywołań API
- Implementuj optymistic updates dla mutacji
- Klucze unieważnienia cache: ['users'], ['posts', postId]

## Zapytania do bazy danych
- Zawsze używaj Prisma `include` dla relacji
- Implementuj soft deletes (pole deletedAt)
- Dodaj indeksy dla częstych klauzul WHERE

# Strategia testowania
- Testy jednostkowe: Tylko krytyczna logika biznesowa
- Integracja: Endpointy API z bazą testową
- E2E: Krytyczne przepływy użytkownika z Playwright

Projekt AI/ML

# Przegląd potoku ML
- Przetwarzanie danych: Apache Spark na Databricks
- Trenowanie: PyTorch z logowaniem Weights & Biases
- Serwowanie: TorchServe za API Gateway
- Monitorowanie: Prometheus + Grafana

# Konfiguracja środowiska
@~/.claude/ml-credentials.md  # Osobiste klucze API

# Rozwój modelu
1. Eksploracja danych: notebooks/exploration/
2. Feature engineering: src/features/
3. Trenowanie modelu: src/models/
4. Ewaluacja: src/evaluation/

# Kluczowe polecenia
- `make dataset` - Buduj zestaw treningowy
- `make train MODEL=transformer` - Trenuj model
- `make evaluate` - Uruchom zestaw ewaluacji
- `make deploy ENV=staging` - Wdróż model

# Standardy kodu
- Type hints wymagane (mypy strict)
- Docstrings z sekcją Examples
- Testy jednostkowe dla wszystkich transformów
- Reprodukowalność: Ustaw wszystkie random seeds

Rozwiązywanie problemów z pamięcią

Pamięć się nie ładuje

Sprawdź nazwę pliku - Musi być dokładnie CLAUDE.md (case-sensitive)
Zweryfikuj lokalizację - Uruchom pwd aby potwierdzić aktualny katalog
Testuj z /memory - Listuje wszystkie załadowane pliki pamięci
Sprawdź uprawnienia - Plik musi być czytelny

Błędy importu

# Debug problemów z importem
1. Ścieżki absolutne muszą istnieć: @/absolute/path/file.md
2. Ścieżki względne od lokalizacji pliku pamięci: @../docs/api.md
3. Ekspansja katalogu domowego działa: @~/documents/notes.md
4. Maksymalna głębokość to 5 poziomów importów

Wpływ na wydajność

Monitoruj użycie tokenów jeśli doświadczasz spowolnień:

# Sprawdź zużycie tokenów pamięci
claude> /memory stats

Podsumowanie użycia pamięci:
- Pamięci projektu: 2,341 tokenów
- Pamięć użytkownika: 567 tokenów
- Importowane pliki: 1,823 tokeny
- Łącznie: 4,731 tokenów (4.7% kontekstu)

Największe pliki:
1. ./CLAUDE.md (1,234 tokeny)
2. ~/.claude/CLAUDE.md (567 tokenów)

Migracja z CLAUDE.local.md

Przestarzały wzorzec CLAUDE.local.md jest zastępowany przez importy dla lepszego wsparcia przepływu pracy git:

Stary sposób
Nowy sposób

project/
├── CLAUDE.md          # Współdzielony
├── CLAUDE.local.md    # Osobisty (gitignored)
└── .gitignore         # Zawiera CLAUDE.local.md

project/
├── CLAUDE.md          # Zawiera: @~/.claude/project-personal.md
└── ~/.claude/
    └── project-personal.md  # Ustawienia osobiste

Korzyści nowego podejścia:

Działa w wielu git worktrees
Centralizuje konfigurację osobistą
Eliminuje zarządzanie gitignore
Umożliwia selektywne importy na projekt

Następne kroki

Automatyzacja hooks

Wyzwalaj aktualizacje pamięci automatycznie z hooks

Przepływy zespołowe

Implementuj strategie pamięci dla dużych zespołów

Dostrajanie wydajności

Optymalizuj pamięć dla szybszych odpowiedzi Claude