Practical Claude Code Tools: Token Usage Tracker, Memory Compiler, and Obsidian Knowledge Manager

Claude Code is an official Anthropic command‑line programming assistant that runs in the terminal, understands your codebase, and can write code, debug, and manage Git workflows. While powerful, users often need to track token consumption, accumulate conversation memory, and organize the resulting knowledge.

What is Claude Code

Claude Code executes commands, reads and writes files, scans entire repositories for context, integrates with Git (commit, branch, merge), and can invoke browsers, search, and file‑system tools.

Code execution : run commands and manipulate files directly from the terminal.

Context understanding : scans the whole codebase to grasp project structure.

Git integration : automates commits, branches, merges, etc.

Multi‑tool coordination : can call browsers, search engines, and the file system.

Project 1: Token Usage Dashboard

Stars : 853 | Forks : 120 | Language : Python

GitHub: https://github.com/phuryn/claude-usage

Problem addressed

Claude Code writes detailed JSONL logs for each session, including token counts, model used, and project info, but these logs are scattered and hard to read.

Core features

Usage tracking : records input, output, and cache read/write tokens per model.

Cost estimation : embeds the April 2026 Anthropic API pricing to calculate model‑wise costs.

Progress bar : shows monthly usage progress for Pro/Max subscribers.

Session history : organizes all past sessions by project.

Data filtering : filter charts by model; URLs are shareable.

Usage

git clone https://github.com/phuryn/claude-usage
cd claude-usage
# Scan log files and build the database
python cli.py scan
# View today’s usage summary in the terminal
python cli.py today
# View cumulative statistics
python cli.py stats
# Launch the browser dashboard (default http://localhost:8080)
python cli.py dashboard

Value

The tool is free, transparent, and requires no extra dependencies, giving both API and Pro/Max users clear visibility into token consumption and preventing surprise bills.

Project 2: Memory Compiler

Stars : 565 | Forks : 148 | Language : Python

GitHub: https://github.com/coleam00/claude-memory-compiler

Problem addressed

Each Claude Code conversation is a one‑off learning episode; without persistence, users must repeat context in later sessions. The memory compiler turns Claude Code into a learning partner that automatically captures experience, compiles it into a knowledge base, and injects relevant facts into future chats.

The idea draws from Karpathy’s LLM Knowledge Base architecture.

Core features

Automatic memory capture : SessionEnd and PreCompact hooks write daily logs without user intervention.

Smart extraction : Claude Agent SDK extracts valuable items (design decisions, pitfalls, new patterns) from the logs.

Knowledge compilation : Daily logs are periodically compiled into structured knowledge articles with cross‑references.

Retrieval Q&A : query.py lets you ask the knowledge base directly, returning answers derived from your own experience.

Health checks : lint.py runs seven checks (broken links, orphan pages, contradictory statements, outdated content, etc.).

Usage

# Clone the repository
git clone https://github.com/coleam00/claude-memory-compiler
# Install dependencies
cd claude-memory-compiler && uv sync
# Compile the new daily log
uv run python scripts/compile.py
# Query the knowledge base
uv run python scripts/query.py "How did I handle Redis cache penetration before?"
# Run health checks
uv run python scripts/lint.py

After setup, the first Claude Code session after 18:00 each day automatically triggers log compilation.

Value

The compiler makes Claude Code a long‑term partner that retains project context, turning repetitive explanations into a reusable knowledge asset for large, long‑lived codebases.

Why not use RAG?

The author notes that for personal knowledge bases of 50‑500 articles, LLMs can directly read index files and outperform vector similarity search. Retrieval‑Augmented Generation becomes necessary only when the knowledge base exceeds the model’s context window.

Project 3: Obsidian Knowledge Partner

Stars : 513 | Forks : 49 | Language : Shell

GitHub: https://github.com/AgriciDaniel/claude-obsidian

Problem addressed

While the memory compiler accumulates experience, this tool manages the resulting knowledge, turning raw logs into a structured, searchable vault.

Core features

Batch ingestion : drops documents into Obsidian, Claude creates 8‑15 dimensional wiki pages, updates indexes and logs, and supports parallel processing.

Intelligent Q&A : understands questions, traverses linked pages, and cites the exact wiki article source.

Session memory : updates a “hot cache” after each session; the next session automatically restores context.

Health checks : eight checks detect orphan pages, dead links, outdated statements, missing cross‑references, etc.

Autoresearch : the /autoresearch command runs multi‑turn web searches to fill knowledge gaps and archives results.

Command suite : includes /wiki, /save, /autoresearch, /canvas, covering the full workflow from initialization to daily use.

Installation – Method 1 (Vault clone)

git clone https://github.com/AgriciDaniel/claude-obsidian
cd claude-obsidian
bash bin/setup-vault.sh

Then open the folder as an Obsidian vault and run /wiki inside Claude Code.

Installation – Method 2 (Claude Code plugin)

# Add the plugin marketplace entry
claude plugin marketplace add AgriciDaniel/claude-obsidian
# Install the plugin
claude plugin install claude-obsidian@claude-obsidian-marketplace
# Verify installation
claude plugin list

Value

Unlike most Obsidian AI plugins that only provide a chat interface, claude‑obsidian acts as a “knowledge engine” that automatically creates, organizes, maintains, and evolves a structured knowledge base, dramatically reducing manual effort for heavy readers and organizers.

How the Three Tools Complement Each Other

The tools cover three dimensions of Claude Code usage:

Token Usage Dashboard → shows exactly how many tokens you spend.

Memory Compiler → makes Claude Code remember what it has learned.

Obsidian Knowledge Partner → turns accumulated knowledge into a systematic vault.

A typical workflow: write code daily with Claude Code; the memory compiler silently captures experience; periodically (weekly or monthly) review and consolidate knowledge in Obsidian; the usage dashboard continuously informs you of token consumption.

Suitable Audience

Heavy Claude Code users : interact with the terminal daily and need better usage and experience management.

Long‑term project maintainers : large codebases and team turnover demand systematic knowledge handling.

Knowledge workers : require extensive reading, organization, and retrospection, benefiting from AI‑assisted knowledge management.

Individual developers : want AI efficiency without paying for multiple services.

All three projects are open source, low‑threshold, and ready to try.