My Friend Has Five ChatGPT Accounts and Zero Shared Memory, So I Built LocalClip

Kavyansh Kumar Baghel — Mon, 05 Oct 2026 15:06:22 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

LocalClip is a local-first memory for ChatGPT. I built it for my friend mushe, who uses several free ChatGPT accounts. Each account is a silo, so when he hits a limit and switches, he has to re-explain everything from scratch.

LocalClip captures his chats automatically and turns them into a linked Obsidian vault on his own machine:

A Tampermonkey userscript captures each ChatGPT turn and tags it with an account label.
A local Python server queues the turns, and a local model extracts a title, topic and bullets for each one.
The vault gets one note per turn, with Prev/Next links and a hub note per topic that merges turns from every account.
A handoff command (python -m server.handoff --topic "...") builds a brief he can paste into a fresh chat to continue where he left off.

His problem was never "move to another AI provider". It was "my context is scattered across accounts, and I don't want it on someone else's server."

What already exists: I compared this with the native memory-import tools from Anthropic and Google, browser extensions like MemoryPlugin and Promptive Sentry, hosted memory services, and the open-source OmniContext. Most of them handle switching between providers, often through a cloud service. LocalClip targets several accounts on one provider, with automatic capture and fully local storage. I'm not claiming it's the first tool in this space.

Demo

LocalClip running on my machine: captured ChatGPT turns turned into linked notes in the Obsidian vault.

The workflow in short: chat as usual, LocalClip captures each closed turn, the vault updates with notes and topic hubs, and python -m server.handoff --topic "Quantum Computing" writes a brief he can paste into a fresh chat.

Code

krish007code / localclip

this is a ease tool that let you utilize multiple chatgpt free acounts and save that context in form of obsidian knowledge graph make it easy to interpret for human and ai agents

LocalClip

Capture ChatGPT conversations turn by turn into a local Obsidian vault — with [[wiki links]], Prev/Next navigation, and topic hubs. Processed by a local LLM (Ollama). Nothing leaves your machine.

Quick start

# 1. Clone and enter the repo
git clone <repo-url> localclip
cd localclip
# 2. Create your personal config
cp config.example.json config.json

# 3. Generate a token — paste it in BOTH places shown below
openssl rand -hex 16

#   → open config.json and set:  "token": "<your-token>"
#   → open userscript/localclip.user.js and set:  const TOKEN = "<your-token>";

# 4. Install Ollama and pull a model (first time only)
#   https://ollama.com/download
ollama pull llama3.2

# 5. Start the LocalClip server
uv run python -m server.server

# 6. Install the userscript in Tampermonkey
#   a. Open Tampermonkey → Dashboard → click the + tab
#   b. Delete the placeholder code
#   c. Paste the entire contents

…

View on GitHub

The userscript's token is a placeholder in the repo. Each user generates their own with openssl rand -hex 16.

How I Built It

Built with Kiro as the coding agent.

Open-source AI: the model is llama3.2, run locally through Ollama. It reads each closed turn and returns JSON with a title, topic and bullet points.

Architecture:

Capture: a Tampermonkey userscript reads the ChatGPT page, converts messages to markdown with Turndown, and posts them to 127.0.0.1 with a token.
Server: a local Python server dedupes and queues each turn. A turn counts as complete once the next question exists, so no streaming detection is needed.
Storage: an append-only nodes.jsonl. The next link is derived, never stored.
Rendering: the LLM returns JSON only, and my code writes every file. That keeps a small local model's output predictable.
Accounts: the label is part of the dedupe key, so the same conversation from two accounts stays distinct. Topic hubs merge all accounts.
Handoff: the brief is built deterministically from stored nodes, ordered by time across accounts. No extra model call is needed.

Bugs I hit and fixed: a wrong Turndown @require path, an import error from running the server directly, slow Ollama calls causing timeouts, resends and duplicate nodes (fixed with a queue and idempotency), and over-aggressive LLM skipping (now gated in code). The project has 199 passing tests (162 Python, 37 Node).

Limitations:

Tested live with one account so far. The multi-account path is covered by unit tests but not yet by two live accounts.
ChatGPT only. The Claude and Gemini selectors are stubs.
It depends on ChatGPT's page structure, which can change.
The account label is set per browser profile, so he needs one profile per account.
It needs Ollama and a running local server, which is more setup than an extension.
A small local model produces plainer summaries than a hosted one.

Why Does Open Innovation Matter?

My friend's chats are personal: study notes, half-formed ideas, questions he'd rather not hand to another company. Because the model runs locally, LocalClip never sends his chats anywhere beyond the ChatGPT page he already uses.

A closed API would have meant:

his conversations leaving his machine again just to be summarized,
a per-call cost or rate limit, for someone who is already working around free-tier limits,
no way for him to inspect or change what happens to his data.

With an open model, he can swap llama3.2 for any model Ollama runs, read every line of the code, and keep working offline.

DEV Community: Kavyansh Kumar Baghel