claude-code-memory-obsidian-graphify

name	claude-code-memory-obsidian-graphify
description	Set up persistent memory and knowledge graphs for Claude Code using Obsidian Zettelkasten and Graphify to reduce tokens by up to 71.5x
triggers	["set up claude code memory with obsidian","configure persistent memory for coding agent","implement zettelkasten for claude code","reduce token usage with graphify","create knowledge graph for codebase","set up obsidian vault for claude","configure chat import pipeline","implement second brain for coding"]

Claude Code Memory with Obsidian + Graphify

Skill by ara.so — Claude Code Skills collection.

This skill enables you to set up a persistent memory system for Claude Code that reduces token consumption by up to 71.5x through Obsidian Zettelkasten notes and Graphify knowledge graphs. You'll maintain context across sessions, eliminate codebase re-reading, and preserve conversation history.

What This System Does

Solves Two Core Problems:

1. Session Amnesia: Claude Code forgets everything between sessions — you constantly re-explain your stack, decisions, and progress
2. Token Waste: Re-reading ~40 files costs ~20k tokens per session just for orientation

Three-Layer Solution:

• Obsidian Vault: Centralized Zettelkasten with atomic notes, wikilinks, and YAML frontmatter for persistent project memory
• Graphify: AST-based codebase knowledge graphs that replace file re-reading with efficient queries
• Chat Import Pipeline: Python script + cron job to preserve Claude conversation insights as vault notes

Prerequisites

# Required installations
pip install graphifyy
pip install claude-conversation-extractor

# Download Obsidian
# Visit: https://obsidian.md (free)

Installation & Setup

1. Install Graphify

# Install Graphify
pip install graphifyy

# Install Claude Code skill
graphify install --platform claude

# Verify skill installation
ls ~/.claude/skills/graphify/SKILL.md

2. Configure API Keys

# Add to ~/.bashrc or ~/.zshrc
export ANTHROPIC_API_KEY="sk-ant-your-key-here"
# OR for Moonshot (Kimi)
export MOONSHOT_API_KEY="your-moonshot-key"

# Reload shell
source ~/.bashrc

3. Create Obsidian Vault Structure

# Create single vault for all projects
mkdir -p ~/vault/{permanent,inbox,fleeting,templates,logs,references}
mkdir -p ~/vault/chats/{code,web}
mkdir -p ~/vault/graphify

# Create project structure (repeat for each project)
PROJECT_NAME="my-project"
mkdir -p ~/vault/$PROJECT_NAME/{architecture,pipeline,data,features,logs}

4. Create CLAUDE.md Configuration

Create ~/vault/CLAUDE.md:

# Vault — Instructions for Claude Code

## What is this vault
Centralized knowledge base for all projects.
Persistent memory across sessions using Zettelkasten method.

## Zettelkasten Rules

### Note creation
- Use wikilinks: [[note-name]] (not markdown links)
- Mandatory YAML frontmatter on every note
- Filenames in kebab-case: `auth-flow.md`, not `Auth Flow.md`
- 1 concept per permanent note (atomicity)
- Minimum 2 wikilinks per note (dense linking)

### Standard frontmatter
---
title: Note Name
tags: [project, topic]
created: YYYY-MM-DD
updated: YYYY-MM-DD
status: active
type: permanent
---

### Never do
- Don't delete notes without asking
- Don't use markdown links for internal notes
- Don't create notes without frontmatter
- Don't change folder structure without documenting

## Session Commands

### /resume
1. Read 3 most recent session logs in logs/
2. Read architecture/decisions.md for current project
3. Summarize current state and pending work

### /save
1. Create session log in logs/YYYY-MM-DD-description.md
2. Record: completed work, decisions, pending items
3. Add wikilinks to created/modified notes
4. Run git commit + push if in repository

5. Set Up Chat Import Pipeline

Create ~/scripts/claude_to_obsidian.py:

#!/usr/bin/env python3
import os
import re
import argparse
from pathlib import Path
from datetime import datetime

# Keyword to tag mapping
KEYWORD_TAG_MAP = {
    "python": "python",
    "react": "react",
    "typescript": "typescript",
    "supabase": "supabase",
    "deploy": "deploy",
    "bug": "debugging",
    "refactor": "refactoring",
    "api": "api",
    "database": "database",
    "auth": "authentication",
    "error": "debugging",
    "test": "testing",
}

def extract_tags_from_content(content):
    """Extract tags based on keywords in content."""
    tags = set(["chat-import"])
    content_lower = content.lower()
    
    for keyword, tag in KEYWORD_TAG_MAP.items():
        if keyword in content_lower:
            tags.add(tag)
    
    return sorted(list(tags))

def find_wikilinks(content, vault_dir):
    
    vault_path = Path(vault_dir)
    existing_notes = {}
    
    
     md_file  vault_path.rglob():
        note_name = md_file.stem
        existing_notes[note_name.lower()] = note_name
    
    
     note_lower, note_name  existing_notes.items():
        
        pattern = 
        content = re.sub(
            pattern,
            ,
            content,
            flags=re.IGNORECASE
        )
    
     content

 ():
    
     (file_path, , encoding=)  f:
        content = f.read()
    
    
    title_match = re.search(, content, re.MULTILINE)
    title = title_match.group()  title_match  Path(file_path).stem
    
    
    date_match = re.search(, Path(file_path).stem)
    date = date_match.group()  date_match  datetime.now().strftime()
    
    
    tags = extract_tags_from_content(content)
    
    
     origin == :
        tags.append()
     origin == :
        tags.append()
    
    
    content = find_wikilinks(content, vault_dir)
    
    
    frontmatter = 
    
    
     content.startswith():
        
        content = re.sub(, , content, flags=re.DOTALL)
    
    final_content = frontmatter + content.strip()
    
     final_content, title, date

 ():
    parser = argparse.ArgumentParser(description=)
    parser.add_argument(, required=, =)
    parser.add_argument(, required=, =)
    parser.add_argument(, action=, =)
    
    args = parser.parse_args()
    
    export_dir = Path(args.export_dir)
    vault_dir = Path(args.vault_dir)
    
    
     origin  [, ]:
        source_dir = export_dir / origin
        target_dir = vault_dir /  / origin
        
          source_dir.exists():
            
        
        target_dir.mkdir(parents=, exist_ok=)
        
         chat_file  source_dir.glob():
            :
                processed_content, title, date = process_chat(
                    chat_file, vault_dir, origin
                )
                
                
                safe_title = re.sub(, , title)
                safe_title = re.sub(, , safe_title).strip()
                filename = 
                
                target_file = target_dir / filename
                
                
                 (target_file, , encoding=)  f:
                    f.write(processed_content)
                
                ()
                
                
                 args.move:
                    chat_file.unlink()
                    
             Exception  e:
                ()

 __name__ == :
    main()

Make executable:

chmod +x ~/scripts/claude_to_obsidian.py

6. Create Automation Script

Create ~/scripts/sync_claude_obsidian.sh:

#!/bin/bash
EXPORT_DIR="$HOME/claude-exports"
VAULT_DIR="$HOME/vault"
SCRIPT_DIR="$HOME/scripts"
LOG="$SCRIPT_DIR/sync.log"

echo "[$(date)] Sync started" >> "$LOG"

# Create export directories
mkdir -p "$EXPORT_DIR/code" "$EXPORT_DIR/web"

# Export Claude Code chats
claude-extract --all --output "$EXPORT_DIR/code" 2>> "$LOG"

# Process and import to vault
python3 "$SCRIPT_DIR/claude_to_obsidian.py" \
    --export-dir "$EXPORT_DIR" \
    --vault-dir "$VAULT_DIR" \
    --move 2>> "$LOG"

echo "[$(date)] Sync completed" >> "$LOG"

Make executable and schedule:

chmod +x ~/scripts/sync_claude_obsidian.sh

# Run daily at 10 PM
(crontab -l 2>/dev/null; echo "0 22 * * * $HOME/scripts/sync_claude_obsidian.sh") | crontab -

Using Graphify

Generate Knowledge Graph for a Project

Inside Claude Code:

/graphify . --obsidian --obsidian-dir ~/vault/graphify/my-project

From Terminal (AST-only mode, 0 tokens):

cd /path/to/project
graphify extract . --out ./graphify-out --no-cluster

With Semantic Extraction (uses LLM):

# Full semantic analysis
graphify extract . --out ./graphify-out --deep

# With custom model
graphify extract . --out ./graphify-out --deep --model claude-3-5-sonnet-20241022

Graphify Commands Reference

# Basic extraction
graphify extract <path> --out <output-dir>

# Obsidian export
graphify extract <path> --obsidian --obsidian-dir ~/vault/graphify/project-name

# Skip LLM clustering
graphify extract <path> --out ./out --no-cluster

# Deep semantic analysis
graphify extract <path> --out ./out --deep

# Specify model
graphify extract <path> --model claude-3-5-sonnet-20241022

# Query the graph
graphify query <graph-dir> "find all auth functions"

# Supported languages (via tree-sitter)
# Python, JavaScript, TypeScript, Go, Rust, Java, C, C++, Ruby, C#, 
# Kotlin, Scala, PHP, Swift, Lua, Zig, and more

Graph Output Structure

graphify-out/
├── graph.json              # Full knowledge graph
├── nodes.json             # Node index
├── edges.json             # Edge index
└── obsidian/              # Obsidian-formatted notes (if --obsidian)
    ├── components/
    ├── functions/
    └── relationships/

Workflow Patterns

Starting a New Session

/resume

This command makes Claude Code:

1. Read the 3 most recent session logs
2. Read architecture/decisions.md for your project
3. Summarize current state and pending work

Ending a Session

/save

This command makes Claude Code:

1. Create a session log in logs/YYYY-MM-DD-description.md
2. Document completed work, decisions, and pending items
3. Add wikilinks to created/modified notes
4. Commit and push to git if in a repository

Creating Project Notes

Create a new note about our authentication flow in [[my-project/architecture/auth-flow]]. 

Include:
- OAuth provider integration
- Session management
- Token refresh strategy

Link to [[supabase-setup]] and [[api-design]].

Querying the Knowledge Graph

Query the Graphify graph for my-project:
- Find all functions that interact with the database
- Show dependencies for the auth module
- List unused utility functions

Updating the Graph

# Re-run after significant code changes
cd /path/to/project
/graphify . --obsidian --obsidian-dir ~/vault/graphify/my-project

Zettelkasten Best Practices

Atomic Notes

Good:

---
title: JWT Token Refresh Strategy
tags: [my-project, authentication, api]
created: 2024-01-15
updated: 2024-01-15
status: active
type: permanent
---

# JWT Token Refresh Strategy

## Context
We use sliding window refresh to minimize user disruption.

## Implementation
- Access token: 15 min expiry
- Refresh token: 7 day expiry
- Auto-refresh at 80% of access token lifetime

## Related
- [[authentication-flow]]
- [[supabase-auth-config]]

Bad (not atomic):

# Everything About Authentication

Contains JWT, OAuth, session management, password reset...
(Too many concepts in one note)

Dense Linking

Every permanent note should have at least 2 wikilinks to other notes. This creates the knowledge graph structure.

## Related
- [[parent-concept]]
- [[sibling-concept]]
- [[implementation-detail]]

Frontmatter Standards

---
title: Human Readable Title
tags: [project-name, topic, subtopic]
created: YYYY-MM-DD
updated: YYYY-MM-DD
status: active|draft|archived
type: permanent|fleeting|reference|chat
---

Troubleshooting

Graphify Skill Not Found

# Reinstall skill
graphify install --platform claude

# Verify installation
cat ~/.claude/skills/graphify/SKILL.md

API Key Issues

# Check environment variables
echo $ANTHROPIC_API_KEY
echo $MOONSHOT_API_KEY

# Test API key
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello"}]
  }'

Chat Import Not Working

# Test extractor
claude-extract --help

# Check permissions
chmod +x ~/scripts/claude_to_obsidian.py
chmod +x ~/scripts/sync_claude_obsidian.sh

# Manual run
~/scripts/sync_claude_obsidian.sh

# Check logs
tail -f ~/scripts/sync.log

Obsidian Wikilinks Not Resolving

1. Ensure filenames are in kebab-case
2. Check that wikilinks match exact filename without .md
3. Use relative paths for cross-folder links: [[folder/note-name]]
4. Verify YAML frontmatter is valid

Graph Query Returns Empty Results

# Verify graph generation
ls ~/vault/graphify/my-project/

# Check graph.json exists
cat ~/vault/graphify/my-project/graph.json | head

# Re-extract with verbose output
graphify extract . --out ./out --verbose

Token Count Still High

Checklist:

• ✅ Generated Graphify graph for project
• ✅ CLAUDE.md exists in vault root
• ✅ Using /resume and /save commands
• ✅ Session logs contain wikilinks to relevant notes
• ✅ Graph is up-to-date (re-run after major code changes)

Cron Job Not Running

# Check cron is active
sudo systemctl status cron

# Verify crontab entry
crontab -l

# Test manual execution
~/scripts/sync_claude_obsidian.sh

# Check cron logs
grep CRON /var/log/syslog

Configuration Examples

Multi-Project Setup

~/vault/
├── CLAUDE.md
├── project-a/
│   ├── architecture/
│   ├── features/
│   └── logs/
├── project-b/
│   ├── architecture/
│   ├── features/
│   └── logs/
└── graphify/
    ├── project-a/
    └── project-b/

Custom Tag Mapping

Edit ~/scripts/claude_to_obsidian.py:

KEYWORD_TAG_MAP = {
    # Your stack
    "nextjs": "nextjs",
    "tailwind": "tailwind",
    "prisma": "prisma",
    "vercel": "deploy",
    
    # Your patterns
    "hook": "react-hooks",
    "component": "components",
    "util": "utilities",
    
    # Your workflow
    "review": "code-review",
    "optimize": "performance",
}

Graphify Model Selection

# Use cheaper model for large codebases
graphify extract . --model claude-3-haiku-20240307

# Use most capable model for complex projects
graphify extract . --model claude-3-opus-20240229

# Use latest Sonnet (recommended)
graphify extract . --model claude-3-5-sonnet-20241022

Expected Results

• Initial session: ~20k tokens for codebase orientation
• With Graphify + Obsidian: ~280 tokens per session
• Reduction: 71.5x fewer tokens
• Memory persistence: 100% context retention across sessions
• Chat preservation: Zero conversation insights lost

Resources

• Graphify GitHub
• Obsidian Documentation
• Zettelkasten Method
• Claude Code Skills