# 1AIVault — full published content > 10 articles. Source: https://1aivault.com --- ## Your AI memory now follows you across devices — and arrives ready to work Source: https://1aivault.com/blog/vault-sync-and-focus-briefs Published: 2026-07-20 Tags: memory, sync, focus-briefs, cross-device, ai-context 1AIVault 1.12 keeps your memory vault current on every device with encrypted folder sync, and hands your AI tools a task-ready Focus Brief instead of a pile of search hits. You set your memory vault up on one machine — the Mac where you do your real work. Over weeks it learned your projects, the decisions you made, and the reasons behind them. Then you open your laptop, or sit down at a Windows box, and none of it is there. The vault that finally knew your context is stranded on a single computer. And even on the machine where it lives, reaching into that memory has always been a little blunt. An AI tool asks the vault a question, gets back twenty loosely related entries, and has to sift through them before it can start on the actual task. You built the context; the model still has to go digging for it. ## What changed 1AIVault 1.12 closes both gaps in the same release. Your vault can now stay current on every device you work from, and instead of handing your AI tools a search box, it can hand them a task-ready brief — the exact memories that matter for what you are doing right now, each with a note on why it was chosen and whether it can still be trusted. ![Neuron dashboard in 1AIVault showing the Context capsule builder, embedding-coverage and recall-latency metrics, and a live recall route diagram](/app-screenshots/1aivault-1.12.0-neuron-context-capsule-overview.jpg) ## Your vault, current on every device Open **Settings → Sync** and point 1AIVault at a folder your other tools already mirror — Dropbox, OneDrive, iCloud Drive, Syncthing, a mounted VPS, or a Notion export workflow. That folder becomes the shared home for your memories, topics, skills, links, packs, forgotten state, and freshness status. There is no new server to run and no account to create; you reuse the sync you already trust. You choose how the shared copy travels. Protect it with a separate passphrase and recovery key for **encrypted** sync, or keep plain, readable files in a folder you already control. When you add a second Mac, Windows, or Linux machine, you can create a fresh sync space or join an existing one — and either way the memory already on both devices is merged rather than overwritten, so nothing you built locally gets lost. ![1AIVault Sync settings showing an encrypted Personal Vault syncing through an iCloud Drive folder, with Pause and Sync now controls](/app-screenshots/1aivault-1.12.0-encrypted-icloud-folder-sync.jpg) Sync runs quietly in the background whenever 1AIVault is open, and normal vault use keeps working even if the folder goes offline — pending changes simply wait until it comes back. When two devices edit the same memory, you get a **Review conflicts** view to compare the versions, keep the current result, restore an older one, or dismiss it. You can pause and resume, sync on demand, see pending changes and known devices, reveal the shared folder, or disconnect a device without touching its vault. Folder sync is a Pro feature. ## Hand your AI a brief, not a search box The second half of this release lives in **Neuron**. Open the Context capsule — or the **Focus Brief** button — describe what you are working on, and 1AIVault assembles the memories that matter for that specific task instead of returning everything that vaguely matches. You steer the result with a couple of controls. Pick a **goal** — find a memory, continue work, make a decision, compare options, or prepare for a task — set how much **detail** you want with a hard token budget, and optionally scope it to a single project. Then build the brief. ![Focus Brief dialog with a task description, a goal set to Find a memory, an Extended 4,000-token detail budget, and an optional project scope](/app-screenshots/1aivault-1.12.0-focus-brief-task-builder.jpg) What comes back is not a flat list. Each result is a **pivot memory** with the reason it was selected — an exact keyword match, a semantic chunk match, a project tag — plus a freshness badge telling you whether it is fresh, unverified, needs review, or is stale. Below the pivots sit the related memories and topics that give them context. ![A ready Focus Brief showing pivot memory cards with their match reasons and freshness badges, plus Copy brief and Use in AI tool actions](/app-screenshots/1aivault-1.12.0-focus-brief-results-ai-tool-handoff.jpg) The payoff is the handoff. Instead of piecing context together from separate searches, Claude Desktop, Claude Code, Cursor, Cline, and other connected clients can ask the vault once for a focused brief. **Copy brief** drops it into any chat, or **Use in AI tool** builds a ready-to-paste prompt that tells the agent to read the pivots first and pull the full text of a memory only when it needs to — through a single `vault_get` call on the 1AIVault MCP server. The agent starts the task already oriented, and it spends its token budget on the work rather than on the search. ![An AI agent's verified summary after using vault context, re-deriving a top-3 issue list and saving it back to the vault as a new memory](/app-screenshots/1aivault-1.12.0-vault-context-improves-ai-results.jpg) ## Memory you can still trust A brief is only as good as the memories inside it, so 1.12 changes how staleness works. **Age alone never makes a memory stale.** Instead, memories created from older sources — or from Memory Improve work — are marked for review when the evidence behind them actually changes. You can compare a flagged memory with the source that moved, check it again, and confirm it is still correct, update it, or mark it stale. That status is not just for you. Connected tools receive a warning for any memory that needs review, while memory you have confirmed as stale stays out of normal recall entirely — so an out-of-date note can't quietly steer an agent's answer. And because freshness travels with portable exports and folder sync, every one of your devices shares the same understanding of what can still be trusted. ## Bring your Notion memory If your working knowledge lives in Notion, you can now seed the vault from it. Export your pages and databases, drop the Markdown and CSV into the guided importer, and preview what was found before anything lands. Notion joins ChatGPT exports, claude.ai memory, Obsidian vaults, and CLAUDE.md rule files in the same **Bring your memory** flow — and every imported entry stays clearly tagged as Notion content, so you always know where a memory came from. The same importer can also join a vault mirrored from your VPS in a couple of clicks. ![The Bring your memory importer with source cards for ChatGPT, claude.ai, Obsidian, Notion export, CLAUDE.md, and a VPS synced vault](/app-screenshots/1aivault-1.12.0-notion-import-and-vps-sync.jpg) ## Before and after | Task | Before 1.12 | With 1.12 | | --- | --- | --- | | Move memory to another device | Manual one-time export, then import | Continuous encrypted folder sync that merges both sides | | Give an AI tool context | It searches and gets a pile of loosely related hits | A Focus Brief of pivots, each with a reason and freshness | | Trust an older memory | Guess whether it still holds | Flagged when its evidence changes; verify before relying | | Seed from Notion | Not supported | Guided Notion export import, tagged by origin | ## Who benefits most **Developers who work across machines** get one vault that follows them from desktop to laptop to office box, without exporting anything by hand. **People who drive AI coding agents** — Claude Code, Cursor, Cline — get briefs that cut the token waste of blind search and start each session already focused on the task. And **anyone who has been burned by a confidently wrong old note** gets memory that flags itself for review the moment its evidence shifts, instead of aging silently in the background. ## Try it [Download 1AIVault](https://1aivault.com), open **Settings → Sync** to connect a folder and put your vault on every device, then head to **Neuron** and build your first Focus Brief. The app is free to download; encrypted cross-device folder sync is part of Pro. --- ## See How Your AI Recalls Your Memory — and Let It Improve While You Sleep Source: https://1aivault.com/blog/watch-your-ai-recall-memory Published: 2026-07-17 Tags: memory recall, observability, semantic search, vault automation, local-first Neuron replays every memory your AI tools recall so you can see what they used and why, while Dreaming consolidates your vault overnight — all on your machine. You gave every AI tool the same memory. You imported your conversations, let them classify into topics, and wired up MCP so Claude Code, Codex, Cursor, and the rest could pull from one vault. And then you had to take it on faith. When an answer came back thin, you couldn't tell whether your AI ignored the vault, searched it and found nothing, or found the right memory and buried it under three wrong ones. The vault was a black box, and the only signal you got was the quality of the reply. Two other things quietly worked against you. As the vault grew past a few thousand entries, keyword search started missing memories that were phrased differently from how you asked. And every week of imports left a little more sediment behind — near-duplicate entries, half-tagged topics, links that were never drawn — that nobody had time to clean up. The v1.11.0 release, "Memory That Thinks," goes after all three. It gives you a window into every recall your AI tools run, teaches search to match on meaning, and lets your vault consolidate itself overnight. ## What changed Two new capabilities anchor this release. **Neuron** is a new screen that records every memory search your connected AI tools run against the vault and lets you replay it — so you can see exactly what was searched, which memories were considered, which were dropped, and which made it into the reply. **Dreaming** lets your vault consolidate itself on a schedule: while you sleep, your own AI CLI reviews clusters of related memories, merges duplicates, fixes tags, and links what belongs together. Underneath Neuron, recall itself got smarter — searching now matches on meaning instead of just words, all on your machine. ## How it works in practice ### Replay any recall, stage by stage Open the new **Neuron** tab and you get a live feed of **Recalls** — every search your AI tools have run, newest first, each tagged with its source (Codex, Claude Code, and so on), the tokens it returned, and how long it took. Select one and the **Recall route** plays back on the right: the query fans out into a keyword leg and a semantic leg, the results fuse, get reranked, expand to pull in related context, and land on the final reply. A scrubber lets you scrub the whole route in slow motion, so "did my AI use my memory, and why that one?" stops being a guess. ![1AIVault Neuron replaying a recall: the Recalls list on the left and a live Recall route ribbon animating a query through keyword and semantic legs, fuse, rerank, expand, and reply stages.](/app-screenshots/05-neuron-live-recall-replay.jpg) ### Inspect why one memory won and another lost Click into any recall and the **Trace inspector** opens with a stage waterfall — embed, keyword, k-NN, rerank — showing where the time went, and a candidate table underneath. Every memory that was considered is listed with its BM25 score, cosine distance, rerank score, and a **route** verdict: `reply` if it made the answer, `dropped` if it didn't. At the bottom you see the recovery the client actually received and an estimate of how many tokens were avoided by returning a lean result instead of raw text. When a recall disappoints, this is where you find out it was a vault gap, not an AI mistake. ![Neuron Trace inspector showing the stage waterfall and a candidate table scoring each memory by BM25 and rerank, with a route column marking which candidate was used for the reply and which were dropped.](/app-screenshots/03-neuron-recall-trace-inspector.jpg) ### Follow the route from question to memory For the bigger picture, the **Route graph** draws the whole path — from your question, out to the entries it matched, down to the specific chunk inside each one, and across to the topics that tie them together. Keyword and semantic hops are colored differently, reply picks are circled, and dropped candidates fade into the background. It's the fastest way to see which corner of your vault an answer actually came from. ![Neuron Route graph mapping a question out to the entries, matching chunks, and topics behind an answer, with relevance scores on each node, reply picks highlighted, and dropped candidates dimmed.](/app-screenshots/04-neuron-recall-route-graph.jpg) ### Recall that understands meaning, not just words The reason recall got so much more legible is that it got smarter. Semantic recall now finds the right memory even when you phrase the question completely differently from how the memory was written. Long conversations are searched passage by passage, so a match points at the sentence that matters instead of the whole transcript, and related memories are pulled in automatically as extra context. Results come back far leaner, so your AI tool spends its context window on answers instead of raw text. All of it runs on your machine. Neuron splits your entries into searchable passages, builds a numeric meaning map for each one with a local model, and stores everything beside your vault — vault content never leaves your device. You can watch the catch-up happen: **Embedding coverage** ticks up as entries are chunked, and stat cards for tokens per recall, semantic leg health, and recall latency fill in as traced recalls come through. Completed entries are searchable by meaning immediately; anything still in the queue keeps using keyword search, so nothing breaks while it works. ![Neuron dashboard showing semantic recall readiness — embedding coverage at 18 percent, recall-health stat cards, and a live panel splitting vault entries into passages and indexing them locally on-device.](/app-screenshots/01-neuron-semantic-recall-indexing.jpg) ### Let your vault dream The other half of "memory that thinks" runs while you aren't watching. Open **Schedule**, create a new schedule, and pick the **Dream** action — "consolidate memories overnight with your AI CLI." You choose which installed CLI does the thinking (the Dreamer), how many drafts it may prepare each night, and how much freedom it gets: **suggest only**, where everything waits for your review; **safe changes**, where low-risk cleanups like retagging and linking apply automatically; or **full autonomy**. An only-when-idle threshold keeps it from running while you're at the keyboard. Each dream stages the highest-scoring memory clusters, drafts consolidations with your CLI, and saves a dream-diary entry you'll find on the Dashboard the next morning — showing what was reviewed, what was drafted, and what was applied. Anything it applies lands in Improve and is a single undo away. Merges, forgets, and skill changes always wait for you, no matter the autonomy level. ![New schedule dialog with the Dream action selected, configuring a nightly vault consolidation with a Dreamer CLI, drafts-per-night limit, suggest-only autonomy, and an only-when-idle threshold.](/app-screenshots/02-dreaming-schedule-setup.jpg) ## Before vs after | | Before v1.11.0 | With v1.11.0 | |---|---|---| | Did my AI use my memory? | Guess from the reply | Replay the exact recall in Neuron | | Why did it pick that memory? | No way to tell | Candidate scores + route in the Trace inspector | | Search phrased differently than the memory | Often missed | Semantic recall matches on meaning | | Long conversations | Whole transcript returned | Searched passage by passage | | Duplicate and mis-tagged entries | Manual cleanup, or never | Consolidated overnight by Dreaming | ## Who benefits most **Power users with large vaults** finally get a coverage meter and latency numbers instead of a vague sense that recall is "slower now" — and Dreaming keeps thousands of entries tidy without a weekend of manual grooming. **Anyone debugging a disappointing answer** can stop blaming the model. Neuron shows whether the right memory existed, was found, and was chosen — turning "the AI is dumb" into "that's a vault gap I can fix." **Privacy-conscious users** get all of it locally: passages, meaning maps, and traces are stored beside the vault, and the indexing activity log records counts only — never your entry titles or content. ## Try it Update to v1.11.0, open the Neuron tab, and ask one of your connected AI tools a question you know is in the vault. Watch the recall replay, then open the Trace inspector to see which memory won. When you're ready, set up a nightly Dream in suggest-only mode and check the dream diary in the morning. Your memory just stopped being a black box — and started taking care of itself. [Download 1AIVault free](https://1aivault.com/download) --- ## Open Saved Links and Files Without Leaving Your Vault Source: https://1aivault.com/blog/safe-link-and-file-actions Published: 2026-07-15 Tags: links, file paths, developer workflow Open web links, reveal local files, launch code files, or copy a path from saved memory without letting a click replace your vault. A saved memory often contains the exact thing you need next: a documentation URL, a repository path, a Markdown plan, or the configuration file behind a decision. Until now, following that reference could interrupt the work you were trying to continue. A normal click might hand the whole window to a link, leave you staring at an unusable page, or force you to copy a path and hunt for it manually. That friction is especially costly when your vault is acting as the connective tissue between projects. You are not opening a random link; you are moving from remembered context to the source that lets you act. The transition should keep the memory visible, respect the kind of target you clicked, and let you decide what happens next. ## What changed Link and File Actions now gives you a safe action menu whenever you click a URL or file path in memory details. You can open a web link in your default browser, reveal a local file in Finder or File Explorer, open supported text and source files in 1DevTool or your default code editor, or copy the original value without taking 1AIVault away from your vault. ![Memory detail view showing the safe link action menu for opening, revealing, or copying a saved file path.](/app-screenshots/safe-link-and-file-actions.jpg) ## How it works in practice ### Keep the memory open while you follow a web reference Click a web URL inside a saved conversation or memory. Instead of navigating the 1AIVault window to that address, the app opens a menu with **Open in default browser**. Choose it and your browser handles the page while the vault remains exactly where you left it. That separation matters when you are checking documentation against a past decision. You can read the external page, return to the same memory, and continue through the rest of its context without reconstructing your place. The vault stays a stable workspace rather than becoming a temporary browser tab. The app also blocks unhandled navigation as a safety net. Even if a malformed anchor does not follow the expected path, it cannot replace the vault document. You keep control of the desktop window and choose whether the link belongs outside it. ### Move from a remembered path to the real file Click a local path and choose **Reveal in Finder**, **Reveal in File Explorer**, or **Show in File Manager**, depending on your operating system. 1AIVault resolves the path and reveals the file on disk. If the exact target no longer exists but its parent directory does, you can still land near the location and investigate what changed. This is useful when a memory records where a design document, source file, exported model, or configuration lived. You do not need to select the path, remove an `@` prefix, open a terminal, and type a platform-specific command. The remembered reference becomes a direct bridge to the local filesystem. ### Open working files in the tool that fits the task When the target is an existing Markdown, text, source, or configuration file, the menu adds **Open with 1DevTool** and **Open with default code editor**. Choose 1DevTool when you want its focused file tools, or use your configured editor when you are ready to change the source. 1AIVault checks that the target exists and is a supported file before showing these actions. It also detects 1DevTool from normal application and command locations on macOS, Windows, and Linux. If 1DevTool is not available, the menu keeps the option disabled rather than pretending the launch succeeded. ### Copy the exact value when you need it elsewhere Choose **Copy** to place the original URL or path on the clipboard. This is the quiet fallback that keeps the workflow flexible: paste the value into a terminal, issue, message, or another AI tool without changing it first. The menu reclassifies the target in the privileged desktop process instead of trusting a label supplied by the visible page. For you, the result is simple: browser actions apply to browser URLs, file actions apply to paths, and the vault never turns a click into an unexpected navigation. ### Let unattended classification reach the vault again This release also repairs scheduled Claude Code classification. When a schedule runs without you at the keyboard, Claude Code can locate the required memory tools and save its classifications back to the vault. You do not need to rerun missed schedules manually or wonder whether an unattended pass silently lost access. ## Before vs After | Task | Before | Now | |---|---|---| | Follow a documentation link | Risk replacing the vault window or copy the URL manually | Choose **Open in default browser** and keep the memory open | | Locate a remembered file | Copy the path, open a file manager, and navigate by hand | Choose the platform-specific **Reveal** action | | Edit a referenced source file | Find the file again, then launch an editor separately | Choose **Open with 1DevTool** or **Open with default code editor** | | Reuse a path in another tool | Select the exact text and hope formatting does not change it | Choose **Copy** from the same action menu | | Run scheduled classification | Check whether Claude Code could still reach vault tools | Let the repaired schedule classify and save unattended | ## Who benefits most Developers who save paths alongside decisions can jump from the reason behind a change to the exact file that implements it. The memory remains visible while the editor opens, so you do not lose the constraint or tradeoff you were trying to honor. Researchers and operators who collect documentation URLs can inspect external references without turning 1AIVault into a browser. That makes a long memory easier to work through one source at a time. Anyone using scheduled Claude Code classification gets a more dependable background workflow. Fresh memories can be organized even when the job runs unattended, and the results are available when you return. ## Try it Open a memory that contains a URL or local path, click the reference, and choose the action that matches what you want to do. You keep the vault in place while the link, file manager, editor, or clipboard takes over only the next step. --- ## Train a Local AI Model on Your Own Memories Source: https://1aivault.com/blog/train-a-local-model-on-your-memories Published: 2026-07-13 Tags: 1AIVault, AI memory, local model, fine-tuning, offline AI, release 1AIVault 1.8.0 can fine-tune a compact AI model on your own memories — entirely on your machine — so you can load it in LM Studio and ask your own knowledge questions offline. You have spent months building up a vault of memories — decisions you made, problems you solved, the context behind why a project is shaped the way it is. It is all sitting there, searchable, feeding your AI tools through MCP. But there is one thing you still cannot do with it: hand the whole body of knowledge to a model and just *ask it* — the way you would ask a colleague who has been in every meeting with you. Retrieval gets you close. It finds the right memory and pastes it into context. But it is still fetch-then-answer, one snippet at a time, and it needs the vault reachable and online. What if the knowledge itself lived inside a model — one small enough to run on your laptop, private enough to keep on your laptop, and yours to keep even when you are offline? ## What changed 1AIVault can now **train a small AI model on your own memories** — built entirely on your machine and private by default. You pick the memories, the app fine-tunes a compact local model on them, and you end up with a model you can load in LM Studio and question offline, or export and share like any other file. No cloud training. No uploading your vault anywhere. On an Apple Silicon Mac, the whole thing happens on-device: your memories never leave the machine, and only a base model is downloaded once to build on. ![Train memory model wizard on the Memories step, choosing Selected topics from tagged topic chips with an estimate of 14 memories to about 32 training examples.](/app-screenshots/01-train-memory-model-select-memories.jpg) ## How it works in practice The whole flow is a four-step wizard — **Memories → Privacy → Model → Train** — that you can start from the memory model card on your Dashboard. ### Choose exactly what it learns You start by scoping the model. Pick **Whole vault** to train on every active memory, or **Selected topics** to hand-pick the topics that matter — just your ServerCompass work, say, or a single client project. A **Time range** control lets you narrow it further to the last 90 days or the last year, so a model can capture *recent* thinking rather than everything you have ever written. Before anything runs, you see the scope in plain numbers: how many memories are in play, roughly how many training examples they will produce, and a few sample titles so you know you selected the right slice. There is no guessing about what is about to be baked into the model. ### Keep secrets out before they are ever written This is the step that makes training on personal notes safe. With **Redact secrets** on, API keys, tokens, and private keys are detected and replaced with `[redacted]` *before* a single training example is written to disk or shown to a drafting engine. A pre-scan tells you exactly how many secrets it found and what kinds. You can also add your own terms to redact — an internal hostname, a codename, a person's name — so nothing you would not want inside a shareable model makes it in. ### Pick a base model and how the questions get written A model learns from question-and-answer pairs grounded in your memories, and you get to choose how good those questions are. Under **Q&A generation** you can use fast built-in templates offline, hand the job to a local Ollama model, lean on an installed AI CLI like **Claude Code** for richer questions, or route it through any MCP-connected tool with no per-run cap. Then you pick the base to fine-tune: **Qwen 2.5** in 0.5B, 1.5B, or 3B — smallest for quick experiments, 1.5B as the recommended balance of recall quality and speed, 3B for the highest quality. Choose a **Training depth** of Quick, Balanced, or Thorough, and the app shows an honest time estimate for *your* Mac before you commit. ![Model step showing three Qwen 2.5 base-model choices with 1.5B recommended, Balanced training depth, and Claude Code selected to draft the Q&A pairs.](/app-screenshots/02-train-memory-model-choose-model.jpg) ### Watch it train — and keep working Hit **Start training** and the run walks through five visible stages: building the dataset, downloading the base model, training, fusing weights, and packaging. A live log streams the actual iterations and loss as they happen, so you can see progress rather than stare at a spinner. If you would rather get back to work, **Run in background** tucks the run into a pill and the fine-tune keeps going while you use the rest of the app. ![Train step with the on-device pipeline running — dataset built, base model downloaded, and training at 1% with a live iteration-and-loss log.](/app-screenshots/03-train-memory-model-training-progress.jpg) ### Use the result anywhere When it finishes, you get a ready-to-use model with a one-line summary — how many memories and examples went in, its size, and how many secrets were redacted. From there you can **Import into LM Studio** with one click, **Reveal in Finder**, **Export model as ZIP** to share, or **Export dataset (JSONL)** if you want the training data itself. ![Finished run screen showing memories-2026-07-13 is ready with 744 examples and three secrets redacted, offering Import into LM Studio, Reveal in Finder, Export model as ZIP and Export dataset.](/app-screenshots/04-train-memory-model-ready-export.jpg) Once it is in LM Studio, your model shows up under the `1aivault/` namespace in the model list. Load it, and you can ask questions about your own knowledge with nothing connected — no vault open, no network, no API key. To share it with a teammate, you send the ZIP and they drop the folder into their own LM Studio. Every run is kept in a full history alongside its dataset and settings, ready to re-export or delete. ![LM Studio model picker listing the trained Memories 2026-07-13 model under the 1aivault namespace, ready to load and query offline.](/app-screenshots/05-memory-model-in-lm-studio.jpg) ## Before vs after | Getting an answer from your knowledge | Before | Now | |---|---|---| | Where the knowledge lives | Fetched snippet-by-snippet from the vault | Baked into a model you hold | | Works offline | Needs the vault reachable | Fully offline in LM Studio | | Sensitive details | You watch what you paste | Secrets redacted before training | | Sharing it | Export notes, re-explain context | Send one model ZIP | | Where it runs | Depends on the tool | On your machine, on-device | ## Who benefits most **People with large, well-classified vaults.** If you have hundreds of memories organized into topics, you can train a focused model per topic and query each one like a specialist. **Privacy-first users and regulated teams.** On-device training plus automatic secret redaction means personal or client context can become a usable model without any of it leaving the machine. **Anyone who works offline.** On a plane, in a secure environment, or just off the grid, your memory becomes something you can question without a connection. ## Try it Update to 1AIVault 1.8.0, open the memory model card on your Dashboard, and train your first model on a single topic — it is the fastest way to feel the difference. In a few minutes you go from a vault you *search* to a model you can simply *ask*, and it is yours to keep, offline, for good. [Download 1AIVault](https://1aivault.com/download) · [See all features](https://1aivault.com/features) --- ## Lock Your AI Memory Behind a Passphrase Source: https://1aivault.com/blog/lock-your-ai-memory-vault Published: 2026-07-12 Tags: vault lock, privacy, local-first, mcp, release Your AI memory vault is local-first — but local isn't the same as private. Vault Lock puts a passphrase in front of it, and while locked even MCP-connected AI tools can't read a thing. Your 1AIVault vault is the richest record you own of how you actually work with AI — every conversation, decision, and half-formed idea you have ever handed a tool, gathered in one place. It lives on your machine, local-first, which is exactly why you chose it. But "on your machine" and "private" were never quite the same thing. Anyone who opens your laptop can read the whole vault. So can any AI tool left connected in the background. For a scratchpad that would not matter. For the running memory of how you think, it does. You may have reached for a workaround already — quitting the app whenever you walk away, or simply trusting that nobody will look. Neither really scales. Quitting the app kills your running imports and MCP connections, and trust is not a security model. What was missing was a lock that treats the vault the way a password manager treats your credentials: sealed by default, opened deliberately. ## Now you can lock the vault behind a passphrase Turn on Vault Lock and 1AIVault behaves like a password manager: while it is locked, neither the app nor any AI tool connected over MCP can read your vault until you enter your passphrase. Your memory stays sealed until you choose to open it. ![1AIVault Settings → Security tab showing the Vault Lock setup with two passphrase fields, a strength meter, and a no-recovery acknowledgment before the Enable Vault Lock button](/app_screenshots/vault_lock_settings.jpg) ## How it works in practice ### Set a passphrase in Settings → Security Open **Settings → Security**, type a passphrase — a strength meter guides you — and confirm it. The screen makes one thing unmissable: there is **no recovery**. 1AIVault verifies your passphrase with an Argon2id key derivation and stores only a hash of the derived key, never the passphrase itself, so a lost passphrase means the vault stays shut for good. Tick the acknowledgment and hit **Enable Vault Lock**. Treat the passphrase like a password-manager master key, because that is effectively what it is. ### The lock covers your AI tools, not just the window This is the part that actually matters for a memory vault. Vault Lock is not a screen saver draped over the interface. The locked state is written to the same settings that 1AIVault's out-of-process MCP server reads, and while you are locked that server refuses every tool call. So a Claude Code or Cursor session that would normally pull context from your vault gets nothing back until you unlock. Your memory does not quietly leak to an agent just because the agent was left running overnight. Picture the common case: you have a Claude Code agent grinding through a long task, and you close the lid and head to lunch. Before Vault Lock, that agent could keep reading your vault the entire time. Now, once the vault auto-locks, the same agent's memory reads come back empty until you return and unlock — work pauses on your terms, not on an open door. ### Unlock when you sit back down When the vault is locked — on launch, or after it auto-locks — you get a single unlock screen. Enter your passphrase and you are back in, exactly where you left off. Nothing to reconfigure, no sessions to rebuild. ![1AIVault full-screen Vault locked screen with the app logo, a passphrase field, and an Unlock button](/app_screenshots/vault_lock_unlock.jpg) ### It re-locks itself when you step away You do not have to remember to lock it. Vault Lock re-arms after a stretch of inactivity — fifteen minutes by default — and it starts locked every time the app boots, so an enabled vault is never sitting open by accident. And because repeated wrong guesses are rate-limited, nobody unlocks it by hammering the passphrase field. ### What it does — and doesn't — protect It helps to be precise about the boundary. Vault Lock is an access control, not at-rest disk encryption: it stops reads through the app and the MCP server, which is the surface your AI tools and a passing glance actually use. It is not built to defend a stolen, powered-off disk against forensic recovery — a heavier guarantee that was deliberately left out of scope. For the everyday threat that actually applies to a memory vault — an open laptop and always-on agents — it is exactly the right lock. ## Before vs after | Situation | Before | With Vault Lock | |---|---|---| | Someone opens your laptop | Vault readable by anyone at the keyboard | Passphrase required to read anything | | A background MCP tool | Can pull vault context anytime | Refused every read while locked | | You step away from the desk | Vault stays open | Auto-locks after idle (15 min default) | | The app launches | Vault open immediately | Starts locked until you unlock | | You forget the passphrase | — | No recovery — by design | ## Who benefits most **Shared or shoulder-surfed machines.** If your laptop is ever open around other people — a shared desk, a coworking space, a home you do not have entirely to yourself — Vault Lock keeps years of accumulated AI memory from being one click away. **Anyone running always-on agents.** If you keep MCP-connected tools live in the background, the lock draws a hard line: a running agent cannot read what you have not unlocked. **Privacy-first users.** It fits the reason you are on a [local-first vault](https://1aivault.com/features/portable-ai-memory-vault) in the first place. One honest note: Vault Lock is an access lock, not at-rest disk encryption — it gates reads through the app and the MCP server, which is the surface an AI tool actually touches. ## Try it Update to the latest 1AIVault, open **Settings → Security**, and set a passphrase. Your vault — and everything your AI tools remember through it — stays yours to open. --- ## A redesigned AI memory vault for more tools and cleaner classification Source: https://1aivault.com/blog/redesigned-ai-memory-vault Published: 2026-07-05 Tags: 1AIVault, AI memory, MCP, classification, release 1AIVault 1.6.0 redesigns the vault interface, adds MCP connection support for more AI tools, and gives Classify safer controls for forgotten memory and topic cleanup. If your AI memory vault has been growing for a while, the problem is no longer only saving context. The harder problem is knowing what is in the vault, which tools can reach it, and which old memories should stay out of normal results. A vault can have thousands of useful entries and still feel uncertain if the interface does not show its shape. Version 1.6.0 focuses on that daily work. You can see the vault more clearly, connect more AI tools without hand-editing config files, and clean up classification without turning hidden memory into normal memory again. ## What changed 1AIVault now gives you a redesigned vault interface, expanded MCP support for more AI clients, and deeper controls for classification cleanup. You can understand the health of the vault before you ask an assistant to use it, then decide exactly which tools should read from it and which memories should stay hidden. ![Dashboard showing vault memory totals, activity heatmap, classification status, and connected sources.](/app-screenshots/dashboard.jpg) ## How it works in practice ### You start from a vault overview instead of a flat list The Dashboard now opens with the memory count, topic count, source count, classification progress, usage buckets, connected source chips, and recent activity. The activity heatmap shows when memories formed, so a busy week or project sprint becomes visible before you search. When you need a specific memory, the top search field previews matching entries before you commit to the full results view. That matters when your vault has grown beyond a few saved chats. You can answer, "Do I already have this context?" quickly, then open the right entry or move into Classify with the same selection. ### More AI tools can connect to the same vault The Connection screen now covers more of the tools developers actually rotate through. GitHub Copilot, Roo Code, Qoder, Trae, Factory Droid, Kilo Code, Warp, and Augment join the existing Claude, Codex, Gemini, Cursor, Cline, OpenCode, ChatGPT, Windsurf, and Antigravity flows. ![Connection Install MCP tab listing AI clients with installed and detected connection states.](/app-screenshots/connection_mcp_clients.jpg) Each supported client gets its own installer path, label, logo, and connection state. Instead of copying a server block into every config file yourself, you can see whether the client is installed, whether 1AIVault is already connected, and where the MCP entry lives. If something looks wrong, Diagnostics and Activity are next to the installer rather than hidden in logs. Auto-Inject also gets clearer. You can preview the managed memory context before it is written into startup files, see how fresh that context is, and decide whether a tool should start with minimal, standard, rich, or max vault memory. ![Connection Auto-Inject tab previewing managed memory context before it is written to tools.](/app-screenshots/connection_auto_inject.jpg) ### Classify can clean up without losing hidden memory Classify now separates normal work from forgotten memory. The Forgotten tab lists hidden entries and topics, lets you search them, remember them, select multiple items, or permanently clean them up after confirmation. Hidden memory stays out of normal dashboards, topic totals, source counts, searches, and MCP reads until you intentionally restore it. ![Classify Forgotten tab listing hidden entries and topics with Remember and Clean up actions.](/app-screenshots/classify_forgotten_tab.jpg) Reclassify All is safer as well. Before rebuilding visible topics, 1AIVault shows the visible entries, skipped forgotten entries, affected topics, and estimated AI usage. Forgotten and archived memory stay preserved while the visible classification map is rebuilt. When a topic has drifted, you can also merge topics and selected entries into a clearer canonical topic instead of dragging related memory around one entry at a time. ![Topic detail view showing selected entries and a reclassify workflow for topic cleanup.](/app-screenshots/topic_detail_reclassify.jpg) ### Chat and Skills now feel part of the same memory system Unified Chat can route through local agents with clearer model selection, and Skills Hub keeps reusable instructions visible across the tools you use. This release is not just a visual refresh; it makes the vault feel less like a background database and more like the operating surface for memory, tools, instructions, and cleanup. ![Unified Chat model picker showing local AI agent options before sending a vault-aware prompt.](/app-screenshots/chat_model_picker.jpg) ## Before vs After | Before | After | |---|---| | You checked separate screens to understand vault size, sources, and classification state. | Dashboard shows memory totals, topics, sources, activity by day, classification status, and recent activity together. | | New AI clients often meant finding the right config path and editing JSON by hand. | Connection lists supported MCP clients with installed/detected states and installer actions. | | Forgotten memory was harder to audit without mixing it back into normal results. | The Forgotten tab gives hidden entries and topics their own review, remember, and cleanup workflow. | | Rebuilding classifications could feel risky because hidden memory was part of the mental load. | Reclassify All previews what will be rebuilt and preserves forgotten and archived memory. | | Topic cleanup depended on manual one-off adjustments. | Topic and entry merge flows help combine related memory into a cleaner topic map. | ## Who benefits most If you move between several coding agents, the expanded Connection screen reduces the setup gap between the tool you want to use and the memory it should know. A new client can join the vault without becoming a separate memory island. If your vault already has thousands of entries, the redesigned Dashboard and search preview help you orient yourself before opening details. You can see whether memory is growing, whether topics need work, and whether tools are actually connected. If you curate sensitive or outdated context, the Forgotten tab gives you a review queue instead of forcing a choice between normal recall and permanent deletion. ## Try it Download 1AIVault 1.6.0, open the Dashboard, then visit Connection and Classify. Connect the AI clients you use today, preview what Auto-Inject will write, and clean up the memories that should no longer reach normal search or MCP reads. The result is a vault that is easier to understand before your next AI session starts. --- ## Forget Context Without Deleting Memory Source: https://1aivault.com/blog/forget-context-without-deleting-memory Published: 2026-07-05 Tags: 1AIVault, AI memory, MCP, Antigravity, Claude Code, Codex 1AIVault 1.5.0 adds forget and remember controls so stale, sensitive, or noisy memory can stay recoverable without being reused by search, topics, MCP reads, or injected context. 1AIVault 1.5.0 adds a control that matters once your vault starts working: the ability to forget memory without deleting it. Durable AI memory is useful only if you can govern it. A vault that captures every project note, prompt, mistake, decision, and imported session will eventually include things that are true but no longer useful, private but not worth deleting, or noisy enough that they should stay out of normal retrieval. Deleting those records is too destructive. Leaving them active pollutes search, topic views, MCP reads, and automatic context injection. The new forget and remember flow is built for that middle state. A forgotten entry stays in the local vault, but it is hidden from normal memory surfaces until you deliberately bring it back. ![1AIVault memory entry detail view showing the Forget entry toolbar action that hides one saved memory from search, topics, imports, MCP reads, and injected context.](/app_screenshots/forget_entry.jpg) ## Forget one entry In 1AIVault 1.5.0, every memory entry can be forgotten from the entry detail toolbar. Forgetting a single entry hides it from search results, topic timelines, imports, MCP reads, and injected memory. The record is not erased. It remains recoverable from Settings, and the vault remembers the source conversation so future imports of the same conversation do not quietly reactivate it. That distinction is important for real work. Sometimes a memory is no longer relevant, but you still want an audit trail. Sometimes a project detail is sensitive, but you may need to recover it later. Sometimes an imported chat contains one bad instruction that should not be recalled by Claude Desktop, Claude Code, Cursor, Cline, Codex, or another connected client. Forget lets you suppress that record without pretending it never existed. ## Forget a whole topic 1.5.0 also adds topic-level forgetting. If an entire project area, client, experiment, or obsolete direction should disappear from active recall, you can forget the topic and its assigned memories in one action. ![1AIVault topic classification view showing the Forget topic action for hiding a topic and its timeline from normal memory reuse.](/app_screenshots/forget_topic.jpg) Remembering the topic brings the timeline back. Entries that were individually forgotten stay forgotten, which keeps the hierarchy predictable: a broad restore should not undo a precise decision you made at the entry level. | Control | What it hides | What stays recoverable | | --- | --- | --- | | Forget entry | One saved memory | The original entry and source metadata | | Forget topic | A topic and its assigned timeline | The topic and entries, unless individually forgotten | | Remember | A forgotten entry or topic | The rest of the forget state remains intact | ## AI clients can forget when you ask The forget controls also reach connected AI clients through the vault. When you explicitly ask, clients such as Claude Desktop, Claude Code, Cursor, Cline, and other MCP clients can forget or remember entries and topics through 1AIVault. That makes memory maintenance part of the same workflow where the memory is used. If an assistant retrieves context and you notice one entry is stale, you do not have to switch modes, hunt through the vault manually, and delete the record. You can ask the connected client to forget it, and the vault applies the same local rules. The explicit-request requirement is the key product boundary. Memory control should be available to AI clients, but it should remain user-directed. ## Antigravity joins the vault This release also adds Antigravity CLI support. 1AIVault can import Antigravity conversations, launch chat with detected Antigravity models, label activity with the right source, and classify Antigravity sessions into the same topic and memory surfaces used by Claude Code, Codex, OpenCode, Cursor, and Cline. For users who move between CLI agents, that matters because the useful context often lives in the transitions. A decision made in one tool should still be findable when you are working in another. ## Faster live capture for Claude Code and Codex 1.5.0 improves live capture for Claude Code and Codex so new sessions become available sooner while the app is running. If 1AIVault was closed, saved sessions are detected and processed on the next launch. The background scanner still backfills anything the live path misses. Together, these changes make the vault more practical at higher volume. Capture is faster, more AI tools are covered, and the new forget controls keep active memory from becoming a junk drawer. Download 1AIVault 1.5.0 from the [pricing and download page](https://1aivault.com/pricing), or read the [release notes](https://github.com/stoicsoft/1aivault-releases/releases/tag/v1.5.0). --- ## Start Every AI Session With the Right Memory Source: https://1aivault.com/blog/start-sessions-with-vault-memory Published: 2026-07-04 Tags: auto-inject, AI context, Claude Code Give each new AI coding session a controlled brief of pinned memories, decisions, preferences, recent work, and known context gaps. A new AI session usually begins with a tax. Before useful work can start, you explain the project, restate the decisions already made, paste the preferences that should have been remembered, and warn the tool about the dead ends you found yesterday. If you switch from one coding assistant to another, you pay that tax again. Keeping a large instruction file helps only until it becomes stale. It may contain too much for the current project, too little from recent work, or edits you are afraid an automated process will overwrite. The real need is a brief that comes from your current vault, fits the tool you are opening, and stays under your control. ## What changed Auto-Inject Memory gives supported AI tools a compact working brief at the start of each new session. You can include pinned memories, preferences, decisions, facts, recent work, and classification gaps without copying them by hand, while previewing the exact managed block before anything is written. ![Auto-Inject Memory tab showing supported AI tools, context profiles, preview controls, and current injection status.](/app-screenshots/start-sessions-with-vault-memory.jpg) ## How it works in practice ### Preview the brief before you opt in Open **Connection**, choose **Auto-Inject**, and select **Preview block** while the master switch is off. You can inspect the exact context 1AIVault would provide before it touches an instruction file. The preview includes the working memory and the gaps the AI should notice, so you can decide whether the snapshot is useful rather than trusting a hidden export. Nothing is written until you explicitly enable the feature. That makes the first step reviewable: you can check for an outdated preference, an irrelevant project, or a memory that should be pinned before the same brief reaches another tool. ### Choose how much context each new session receives Under **How much to inject**, choose **Minimal**, **Standard**, **Rich**, or **Max**. Minimal keeps the brief to critical saved context. Larger profiles include more recent work and unclassified tail context, with the biggest budgets reserved for Pro. The profile controls the context budget rather than blindly dumping the vault. Each supported instruction target also respects its own file limits. Gemini CLI and Antigravity, for example, share a global rules file with a fixed character cap, so the generated block is sized to fit the environment that will read it. ### Enable only the tools you actually use Turn on injection for Claude Code, Codex CLI, Gemini CLI, Antigravity, Qwen Code, OpenCode, or Windsurf. Each target writes to the instruction file that tool already reads: `CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, `QWEN.md`, or the relevant global rules file. After enabling a target, use the built-in test flow. Start a fresh session, paste the provided audit prompt, and ask the AI to describe the context it already knows without calling any tools. If it can name the current projects, decisions, preferences, and gaps, you have direct evidence that the brief was loaded. Open sessions do not reread static instruction files automatically. When your vault changes, choose **Refresh now**, then begin a new session. The status row tells you whether the tool is off, injected, handled through the Claude Code hook, or skipped because the block was edited by hand. ### Scope the brief to one project Choose a project when you want the static block to include only memories tagged for that work. A focused coding session can receive the decisions and recent activity for one repository instead of unrelated context from your whole vault. This keeps instructions smaller and reduces accidental cross-project assumptions. You can return to all projects when the session needs broader personal preferences or work that spans multiple repositories. ### Give Claude Code fresh, project-aware memory at startup Install the **Claude Code session hook** when you want the newest context on every start. The hook is added to Claude Code’s `SessionStart` configuration and reads the vault database live, even when the 1AIVault window is closed. It uses the current working directory to include project-specific memories when they are available. While the hook is installed, 1AIVault removes its static `CLAUDE.md` block so the same context is not injected twice. If you remove the hook while Claude Code remains enabled, the static block is restored. You can move between the two approaches without cleaning up configuration by hand. ### Keep your own instruction edits safe 1AIVault manages only the text between its own markers. Content above and below that block stays untouched. If you edit the managed block yourself, the next automated rebuild recognizes the change and reports **Hand-edited — skipped** instead of overwriting it. The service also skips identical rewrites. If the current brief already matches the vault selection, it leaves the file alone. You get refreshed memory when something meaningful changes without noisy file churn on every background event. ## Before vs After | Task | Before | Now | |---|---|---| | Start a coding session | Paste the same project background and preferences again | Begin with a vault-generated working brief already loaded | | Control context size | Maintain one growing instruction file | Choose Minimal, Standard, Rich, or Max | | Focus on one repository | Remove unrelated notes manually | Scope static injection to a tagged project | | Check what an AI will receive | Open and inspect several tool-specific files | Use **Preview block** before enabling | | Refresh Claude Code context | Rewrite `CLAUDE.md` and restart the session | Use the project-aware `SessionStart` hook | | Preserve manual instructions | Risk an updater replacing your edits | Keep non-managed content untouched and hand-edited blocks skipped | ## Who benefits most Developers who move between Claude Code, Codex, Gemini, and OpenCode can carry the same durable decisions without turning every session into an onboarding conversation. Each tool reads the format it already understands. People managing several projects can keep context narrow. A client repository does not need the preferences and unresolved questions from a personal experiment, but both can still live in the same local vault. Teams of one who rely on detailed AI workflows gain a reviewable source of truth. The brief is generated from pinned and recent memory, while the preview and hand-edit guard keep automation from becoming opaque. ## Try it Open **Connection → Auto-Inject**, preview the block, choose a context profile, and enable one detected AI tool. Start a fresh session and use the test prompt to confirm that your current memory arrived before your first real request. --- ## See exactly which memories your AI is actually reading Source: https://1aivault.com/blog/see-which-memories-your-ai-actually-reads Published: 2026-06-01 Tags: memory-reads, mcp, claude-code, codex, vault-transfer, session-resume, observability Memory Reads turns raw MCP traffic into a timeline grouped by call, flags empty calls as vault gaps, and surfaces the memories your AI tools reach for most. Plus encrypted vault transfer to a new machine and one-click Claude Code & Codex session resume. You watch Claude Code pull context from your vault. You see the activity feed tick. A memory was read. Then another. Then six more — all in the same conversation turn. Which ones did Claude actually use? Which were noise? Which calls came back empty because the memory the AI was looking for didn't exist? The activity feed showed you that the AI was reading. It didn't show you what the AI was reading *for*. Every memory was an undifferentiated event in a stream — useful for confirming the connection works, useless for knowing whether your vault is doing its job. ## What changed Now you can see every memory your AI tools are actually reading, grouped by the call that triggered it, with the empty calls flagged as gaps. Memory Reads is a new tab inside Connection that turns the raw MCP traffic into a timeline you can read. ![Memory Reads tab showing a timeline of MCP calls from Claude Code and Claude Desktop, each call expanded with chips for the memories that were returned, an amber empty-call highlight, and filters for client, tool, and time range](/app_screenshots/memory_reads.jpg) ## How it works in practice ### See what each AI call actually pulled Every MCP call from Claude Desktop, Claude Code, Cursor, Cline, or Codex appears as a row in the timeline. The memories returned by that call show up as chips underneath. Click a chip and you jump straight to that memory in the entry detail view — the round-trip from "the AI used this" to "let me read what the AI used" is one click. Calls that returned a lot of chips collapse to the top five with a "+N more" expander, so a busy week doesn't drown the view. Pagination shows twenty calls at a time when you're catching up. ### Catch the gaps when nothing was returned When the AI calls `vault_search` and gets nothing back, that's an empty call — a moment when the AI was reaching for context that doesn't exist yet. Memory Reads flags those in amber. You see, in order, every question your AI asked that your vault couldn't answer. That's your shopping list for what to add next. ### Find the memories your AI reaches for most The Top Contributors sidebar ranks the memories your AI tools pulled most often this week. It's the answer to "which entries are pulling their weight." The "Read often, never updated" callout flags memories used a lot but untouched in 30+ days — likely stale, likely worth a refresh before they mislead the AI tools that rely on them. ### Filter to the call you care about Filter by client (just Claude Code), by tool (just `vault_search`), or by time window (24 hours / 7 days / 30 days). When you're debugging why an AI tool isn't surfacing the right memory, narrow to that one AI client and that one tool call and the noise drops to zero. ### Last used, on every memory Open any entry and the header now shows "Last used X ago by Source · Nx this week." You know without leaving the page whether the memory is still being touched and which AI tool is touching it. Follow a chip from Memory Reads into a memory, and the "Back to Memory Reads" chip in the header returns you to the same tab and filter you left from. ## Move your whole vault to a new machine You set up the vault, you imported six months of conversations, you tuned the topic classifier, you wrote a dozen skills — and then you buy a new laptop. Or you want to mirror the same context onto a second machine. Or you simply want a backup that's more portable than a database dump. ![Vault export dialog showing the selective sections checklist with memories, skills, topics, and activity, a passphrase field for encryption, and an export size summary](/app_screenshots/data_export_vault.jpg) The new Encrypted Cross-Device Vault Transfer (Pro) bundles your memories, skills, topics, links, and settings into a single passphrase-protected file. Drop the file into 1AIVault on another machine, type the passphrase, and your entire vault appears intact — entries, topics, skills, activity, connections. Pick what to include: memories only, memories plus skills, or the full vault including activity. Before you import, a preview screen shows the bundle's contents — entry count, topic count, skill count, last export date — so you know what you're about to add. If an export or import is interrupted mid-flight, the boot-time crash recovery picks it back up cleanly on the next launch. The bundle is encrypted with a passphrase-derived key, so even if the file leaks, the contents stay safe. ## Resume an AI conversation from where you left off Entries imported from Claude Code and Codex sessions now show a Resume button in the entry header. Click it and the exact `claude --resume ` or `codex resume ` command lands on your clipboard — paste it into your terminal and you're back in the same conversation. The Session ID chip next to it copies the raw ID for the cases where you want to script the resume yourself. Long-running investigations stop being one-shot chats. They become threads you can pick up across days. ## Before vs after | Before v1.1.0 | With v1.1.0 | |---|---| | Activity feed showed reads — couldn't tell which memories an AI used | Memory Reads groups each MCP call with the memories it returned | | No way to know which calls came back empty | Empty calls flagged in amber as vault gaps | | Stale memories hid in the long tail | "Read often, never updated" surfaces them | | Vault was stuck on one machine | Encrypted bundle moves the whole vault to a new computer | | Each Claude Code / Codex session was a one-shot | Resume button copies the exact CLI resume command | ## Try it Open the Connection view and switch to the Memory Reads tab. Let your AI tools run for a day and come back — you'll see the shape of how they actually use your vault. The empty-call flags will tell you what to write next. If you're on Pro, try exporting your vault to a bundle and importing it on a second machine to feel the transfer flow end to end. Download v1.1.0 at [1aivault.com](https://1aivault.com). --- ## Stop rebuilding context every time you switch AI tools Source: https://1aivault.com/blog/stop-rebuilding-context-across-ai-tools Published: 2026-05-31 Tags: ai-memory, mcp, claude-code, cursor, codex, cline, local-first, launch Save context once and every AI tool — Claude Desktop, Claude Code, Cursor, Cline, Codex — can read it through a single MCP connection. 1AIVault v1.0.0 ships your portable, local-first AI memory vault. You set up Claude Desktop with the project context. Then you open Claude Code and re-explain the same thing. Then Cursor needs it too. Then Codex. By the time you've finished onboarding the fifth AI tool to your codebase, you've typed the same decisions, the same constraints, and the same "we don't use class components anymore" reminder so many times that you wonder if the tools are even helping. The friction isn't the tools. It's that none of them share what you've told them. Every chat is a fresh start. Every preference, every quirk, every hard-won architectural decision lives in the head of whoever you last talked to — and the next AI tool doesn't get the briefing. ## What changed Now you can save context once and every AI tool you connect can read it. 1AIVault is a local vault for the memories, decisions, preferences, facts, and skills you want your AI tools to share — Claude Desktop, Claude Code, Cursor, Cline, and Codex all talk to the same vault through a single MCP connection. ![Vault dashboard showing recent memories, an activity feed of AI tool reads and writes, and a connections summary across Claude Desktop, Claude Code, Cursor, Cline, and Codex](/app_screenshots/dashboard.jpg) ## How it works in practice ### Save once, recall everywhere You drop a memory into the vault — "we use Tailwind, not styled-components" — and every connected AI client can pull it back through MCP the next time it needs it. Claude Desktop saves a preference; Claude Code reads it; Cursor reads it; nothing diverges. The vault is the canonical store and the AI tools are clients. Categories match the way you think about context: memory, decision, preference, fact, skill. Save a memory for a fact you want to remember, a decision for a choice you've made and don't want to relitigate, a preference for how you like things done. Each category surfaces differently in the AI tool that consumes it. ![Collect screen for capturing a new entry, with category, source, and topic fields ready for input](/app_screenshots/collect_screen.jpg) ### Connect every AI tool in one click The Connection view installs the MCP bridge for each AI client without you hand-editing JSON files. Pick Claude Desktop and the config file gets written. Pick Cursor and the settings entry appears. Cline gets the VS Code extension wired up. Codex CLI gets its config touched. Each install runs a diagnostic so you know the connection is alive before you walk away. For Claude Code specifically, your saved entries map to its native memory file shape: memory becomes user, decision becomes project, preference becomes feedback, fact becomes reference. The vault doesn't replace Claude Code's `.claude/memory/` files — it generates them. ### Pull conversations back in If you've been talking to AI tools for a while, the context is already there — it's just trapped in chat histories. The vault has importers for Claude Code (`~/.claude/projects/`), Cursor, Cline, Codex, plus a local HTTP receiver on `127.0.0.1:54330` that the paired browser extension uses for ChatGPT and Claude.ai chats. Point it at the source, hit import, and your past conversations become searchable memories. A file watcher keeps the door open after the initial import: new sessions land in the vault as they happen, so the next AI tool you open already has the chat you just finished elsewhere. ### Group memories into topics automatically Point 1AIVault at a local Ollama model (default `qwen2.5:7b`) and the topic classifier scans your vault, extracts topics, merges duplicates, and groups related memories together. A memory about "Postgres performance for the analytics dashboard" shows up under both Postgres and the dashboard project — cross-classification is the default, not the exception. ![Topics view showing extracted topics with counts and the most-used topics across the vault](/app_screenshots/topics.jpg) The topic graph view turns those connections into a map: clusters of related work, lines between topics that often appear together, drill-down into any node for a digest. It's the first time you can see the shape of what you and your AI tools have been working on. ![Topic graph view showing clusters of related topics connected by lines, with a focused topic and its neighbors highlighted](/app_screenshots/graph.jpg) ### Skills your AI can call Drop a `.skill.md` file into the skills folder and the vault picks it up automatically. Connected AI tools can load any skill on demand: code review, decision logs, email drafting, meeting summaries, weekly reviews — the starter set covers the routines most people repeat. Write your own and they sync the moment they hit disk. ### Watch the AI work The Activity feed is a live stream of every read, write, and classification across all connected AI tools. You can see Claude Code pulling a memory while you watch Cursor write a new one — useful for catching surprises, useful for noticing which memories your AI actually reaches for. ![Activity feed showing a live stream of MCP reads, writes, and classifications across Claude Desktop, Claude Code, Cursor, Cline, and Codex](/app_screenshots/logs.jpg) ## Before vs after | Before 1AIVault | With 1AIVault | |---|---| | Repeat the same context in every new AI chat | Save it once, every AI client can recall it | | Each AI tool keeps its own private memory file | One vault, every tool reads from and writes to it | | Past ChatGPT and Claude.ai conversations are trapped in the browser | Importers pull them into a searchable local store | | AI tools fall back to keyword search of your project | Semantic recall finds memories by meaning | | You guess which AI tool has which preference | The vault is the canonical source — no divergence | ## Who benefits most **Multi-tool AI users.** If you switch between Claude Desktop in the morning, Claude Code at the keyboard, Cursor for the IDE work, and Codex for the CLI tasks, the cost of re-briefing each tool eats hours a week. The vault collapses that to one source. **Long-running projects.** Decisions you made six months ago — about the auth stack, the deployment pipeline, the "we tried Redis Streams and it didn't work" lesson — survive across AI tool versions, model upgrades, and IDE rewrites because they live in the vault, not in any one chat window. **Privacy-conscious teams.** Everything stays local. The vault is on your machine, the MCP server runs on your machine, the optional Ollama classifier runs on your machine. Memories never leave unless you choose to export them. ## Try it Install 1AIVault, run the first-run onboarding to install your first MCP connection, and import a conversation from whichever AI tool you've been using. Free plan covers the full experience — Pro is a one-time $29 for unlimited entries and topics with twelve months of updates. No subscription. Download at [1aivault.com](https://1aivault.com).