AI memory for ChatGPT and Claude: how project memory works

Why do AI assistants lose context between conversations?

AI assistants lose context when earlier work is not present in the information available to the current request. Every response is limited by a context window. A client may also use context compaction to summarize a long conversation, which can omit details.

Some assistants offer built-in memory, but its scope, controls, retention and portability depend on that provider and can change by product or plan. A separate memory layer addresses a different need: keeping project context outside one conversation so supported tools can retrieve it again. It does not guarantee that every fact is saved or that every connected assistant will use retrieved context correctly.

How does a persistent AI memory layer work?

A persistent memory layer saves durable context separately from the chat, retrieves relevant items, and sends only the selected context to the AI tool. A practical workflow has five parts:

1. Capture. Save an established decision, fact, open question, todo or summary when it becomes useful.
2. Store. Keep those notes in a project-specific memory, separate from raw chat transcripts.
3. Index. Prepare project files for exact or semantic search without treating every source passage as a remembered fact.
4. Retrieve. Recall relevant notes and source passages at the start of a session or before answering a project question.
5. Trace. Keep file, page and chunk metadata with retrieved passages so a person can inspect the source.

How is an AI memory layer different from built-in chat memory?

Built-in chat memory belongs to one assistant, while an independent memory layer can serve multiple supported tools from a separate store. The best choice depends on whether you need simple personalization, application infrastructure or reusable project context.

These categories can overlap. A product may offer built-in memory and external connections, and an organization may combine local storage with optional cloud infrastructure. Compare the actual data boundary, export options, supported clients and retrieval behavior rather than relying on the word “memory” alone.

What should you look for in an AI memory layer?

Look for inspectable storage, controlled writes, cross-session retrieval, clear data boundaries and source traceability. Six practical checks help:

1. Human-readable records. You should be able to inspect and correct durable notes rather than treating an opaque index as the source of truth.
2. Explicit write boundaries. The product should distinguish tools that read source files from tools that write memory notes.
3. Supported connections. A standard such as MCP (Model Context Protocol) can make one store available to multiple clients, but compatibility and capabilities still vary by client and platform.
4. Deliberate checkpoints. A memory checkpoint should record an established item without copying an entire conversation.
5. Source traceability. Retrieved document passages should retain available file, page and chunk metadata. Traceability helps review; it does not prove that the source or generated answer is correct.
6. Clear data boundaries. A local-first default should state what remains on chosen storage, which connections send data elsewhere and which network calls are required.

How does Central Brain provide persistent AI memory?

Central Brain keeps project memory in human-readable local files and exposes recall, checkpoint and compaction tools through a project-specific MCP server. Its memory notes can record decisions, facts, open questions, todos and summaries. A separate project brief provides a compact starting point for a new session.

memory_checkpoint appends one established item. memory_recall searches saved notes and the brief. memory_compact replaces the project brief with a supplied updated summary and marks the included notes as compacted rather than deleting them. central_brain_ping confirms that the server is running and reports the project root. These tools support continuity, but the connected assistant must call them and people should review important records and outputs.

Central Brain also prepares PDF, DOCX, TXT, Markdown, CSV and XLSX files, can run optional OCR on scans when the build includes it, and embeds chunks with a bundled 384-dimension MiniLM model into a local vector index. The default preparation, embedding and search workflow does not require a cloud AI provider.

Can one AI memory work across Claude, ChatGPT, Copilot and Codex?

Yes, one project memory can serve multiple supported AI clients when each client is connected to that project's Central Brain MCP server. Central Brain provides project-specific setup for Claude Desktop, Claude Code, GitHub Copilot and GPT Desktop using standard MCP on Windows and Apple silicon Mac. Client features, setup and platform support can differ, so check the current getting-started guide for the combination you plan to use.

How can I add project memory for ChatGPT?

Central Brain provides project memory for the supported GPT Desktop through a local MCP connection. It keeps decisions, facts, questions, todos and summaries in readable project files, with a brief that a new session can retrieve. Connect the project using Central Brain's setup workflow, confirm the memory tools are available, and test one saved fact before relying on the connection.

For example, ask the connected assistant to save an approved project deadline with memory_checkpoint. In a new session connected to the same project, ask it to call memory_recall for that deadline and inspect the saved note. This is a separate project store; Central Brain does not change ChatGPT's account memory settings or automatically import every past chat.

The local connection requires a supported desktop configuration. A browser chat does not automatically gain access to a local server or local configuration. OpenAI documents that distinction in its MCP connection guide. Retrieved context is sent to the connected AI tool, so a local memory store does not make ChatGPT an offline service. See Central Brain setup and downloads for current compatibility.

How can I add shared project memory for Claude?

Connect Claude Desktop or Claude Code to the same Central Brain project to retrieve saved memory and search project files over MCP. A decision checkpointed during work in Claude can then be recalled by another supported client connected to that project. This is useful when a project moves between assistants and you want its durable notes to remain in files you can inspect.

Start by recalling the project brief and relevant notes, use source-traceable search for document questions, then checkpoint decisions as they become established. Before a handoff, review the saved notes and update the brief with memory_compact when needed. Central Brain's file tools are read-only; its memory tools can append notes and replace the brief.

Claude also offers its own chat search and memory. Central Brain supplies an independent project store through tools, with no automatic synchronization of Claude's built-in memory. Local MCP setup is specific to the supported desktop or coding client; it does not by itself connect claude.ai or a mobile chat. See Anthropic's Claude Desktop local MCP guide and Central Brain's setup guide.

Does local-first AI memory keep everything private and offline?

Central Brain itself runs air-gapped between 14-day license checks, but a connected cloud AI tool still receives what it retrieves. In Central Brain's default project workflow, source files, prepared output, memory files, the bundled embedding model and the local vector index remain on storage you choose. File tools can read or search permitted project files but do not modify, move or delete those source documents; memory tools can append notes and update the project brief.

Data crosses that local boundary when you send retrieved context to a connected AI tool or configure cloud embeddings, Pinecone, Postgres, Redis or another optional destination. License activation and periodic verification contact Keygen and can exchange licensing and device information, but they do not require project documents. People and software with access to your device, folders, backups or synced storage may also be able to access the data. Review Security and data boundaries before using sensitive material.

Is AI memory the same as a second brain?

An AI memory layer can be part of a second brain, but the terms are not identical. A second brain for AI usually combines durable notes, searchable source files and a retrieval path for assistants. Central Brain is designed so a person can inspect the memory while supported AI tools can retrieve from the same project store.

Who needs an AI memory layer?

An AI memory layer is most useful for people who revisit the same projects across many sessions or supported AI tools. Typical use cases include:

• Consultants and analysts juggling client folders who are tired of re-uploading the same PDFs into every chat.
• Teams evaluating sensitive workflows that need inspectable storage and explicit data boundaries. Local-first architecture does not itself provide a compliance certification or determine legal suitability.
• Developers using more than one supported assistant on the same repository who want a shared record of project decisions.
• Researchers whose mixed folders of papers, notes and spreadsheets should be searchable by meaning, with page numbers attached.
• Small teams that want project-specific memory and source-traceable retrieval without making a hosted memory service the default store.

How can I test an AI memory layer on one project?

Start with a short brief, one approved decision and one supporting document. Name the project owner, current goal and unresolved question. Prepare and index the source, then save the decision through the connected client's memory tools. Inspect the actual record before ending the session.

In a fresh session, verify the project and ask the assistant to retrieve the decision without pasting it back. Compare the tool result with the saved note and the supporting source. If the answer is stale, correct the record and repeat the check. This small pilot tests persistence, retrieval and source review together. Use the plain-file project-notes guide to structure the human record, or compare local memory with hosted APIs before choosing a data boundary.

What do people ask about AI memory and MCP?