OPEN SOURCE · MIT LICENSE

Useful context.
A place to keep it.

Give your next AI conversation a starting point. MemHarbor keeps project context, decisions, and next steps in Markdown files you own, with a history you can review.

Get started locallyCompare the three levels

Markdown + Git. Start with the tools you already use.

memharbor-vaultLOCAL GIT

reading/networking/

  • CONTEXT.md
  • STATE.md
  • DECISIONS.md
  • TODO.md
  • SOURCES.md

## Goal

Learn networking fundamentals.

## Next step

Choose the first book.

# Resume in a new session

Review · approve · commitYour files. Your history.
An example memory vault. No cloud account required.

01 / THE WORKFLOW

Keep the outcome.
Pick up the thread.

Save what will help you later: the decision, the verified fix, the unfinished work. Retrieve it when the next conversation needs it.

01

Draft the useful context

The Skill finds related memories and prepares an update. Review what it will keep before you ask it to save.

Draft a memory of this fix, including what we verified.
02

Save it with a history

Once authorized, the agent writes Markdown, commits it to your vault, and reads it back to check the result.

Save the approved draft and read it back to verify.
03

Resume with the right context

Point a new session at the same vault. Ask for the topic, the current state, or the decision you need.

Find the project’s blockers and next steps. Read only.

02 / THE FORMAT

Plain files.
Lasting context.

Organized around a topic, not a chat transcript. Open the files in your editor, inspect the diff, or read the Git history.

  • CONTEXT.mdThe goal and lasting background
  • STATE.mdWhat is true right now
  • DECISIONS.mdChoices and their reasoning
  • TODO.mdThe work still to do
  • SOURCES.mdEvidence and references

Start with the files a topic needs. Keep stable background separate from changing state.

reading/networking/CONTEXT.md
---
path: reading/networking
title: Networking fundamentals
status: active
---

# Networking fundamentals

Build a practical understanding of networks.
Read one technical book each week.

03 / THREE WAYS TO USE MEMHARBOR

Three levels.
Choose your setup.

Start with T0 for local files, choose T1 for a local MCP client, or deploy T2 for remote access. These are alternative setups using the same Markdown memory format; you do not need to deploy all three.

T1 / LOCAL MCP SERVICE

Node.js stdio MCP + GitHub

Build the service and let your MCP client launch a local Node.js process. It reads and writes your private GitHub data repository, with an in-memory serving cache. It does not expose an HTTP endpoint.

Best for
MCP clients that can launch a local process, when you want GitHub-backed memory without deploying Cloudflare resources.
You need
Node.js 22+, a private GitHub data repository, and a GitHub access token. Access defaults to read-only; enable writing explicitly with matching repository permissions.
AI client → local stdio MCP → private GitHub
Code repositoryMemHarborSetup guide · T1
T2 / REMOTE MCP / REST SERVICE

Cloudflare Worker + R2 + GitHub

Deploy your own Cloudflare Worker with authenticated HTTPS MCP and REST endpoints. GitHub keeps canonical Markdown and Git history; private R2 holds rebuildable serving snapshots.

Best for
Multiple devices or remote clients that need a shared HTTPS endpoint without running a local service on each device.
You need
A private GitHub data repository, a Cloudflare account, a Worker, a private R2 bucket, and service credentials. Configure synchronization and client access for your deployment.
AI client → HTTPS MCP / REST → Worker + R2 ↔ private GitHub
Code repositoryMemHarborSetup guide · T2

The links above are public MIT-licensed code repositories. T1 and T2 share the MemHarbor service source. Your T0 vault or T1/T2 private GitHub data repository is separate: neither public code repository stores your memories. This website does not provide hosted memory accounts.

04 / YOUR FIRST MEMORY

Start small. Stay local.

For T0, you need Git and an AI client with file access. The install command also needs Node.js/npm; the guide includes manual installation.

Read the first-use guide

1. Install the Skill

Use claude-code or cursor instead of codex for your client. Open a new session so it discovers the Skill.

npx skills add zyc945/memharbor-skill --skill memharbor --agent codex --copy

2. Create a separate Git vault

Initialize a new directory, check your Git identity, and give the agent access. Keep your vault separate from your software project.

Read the first-use guide

3. Ask for a draft

Review the draft, then ask: “Save the approved draft and read it back to verify.” In a new session, ask the agent to retrieve it from the same vault.

Use memharbor with /absolute/path/memharbor-vault as a local Git vault.
I plan to read one technical book each week. No book chosen yet.
Check for duplicates and show me a draft. Do not save yet.

Works with authorized file/Git access in Codex, Claude Code, and Cursor. Client setup and permissions vary.

A FEW PRACTICAL DETAILS

Before you begin.

Does it save every conversation?

No. Normal conversation is not saved automatically. Ask for a draft, then authorize the memory changes you want to keep. Existing authorization can cover the save.

Where does my memory go?

With T0, Markdown files and Git history stay in the vault you choose. Cross-device access and backups need separate setup. Optional service tiers use your private GitHub repository. This website does not receive your memories.

Do I need a vector database or another model?

The memory layer uses Markdown, Git, and optional storage adapters. It does not require a vector database, embeddings, or its own LLM. Your AI client does the reading and writing.

What happens if I stop using it?

Removing the Skill leaves your vault intact. You can keep reading and editing the Markdown files with ordinary tools. Git history remains available.

Is this a public cloud memory service?

No. This is an open-source Skill with optional service implementations. You run your own vault or deployment. Native client and remote write acceptance differ by setup; the repository documents the verification scope.

Let the next session start here.

Keep one useful memory. Retrieve it when you need it.

Get the MemHarbor Skill