Adamant

Portable AI memory workspace for migrating knowledge bases, memory layers, and conversation context across models.

What Adamant is
- A local-first memory system for AI users who want a personal source of truth.
- A portable knowledge base for ChatGPT exports, Claude exports, Gemini exports, custom conversation logs, Markdown notes, and future connectors.
- A semantic memory layer that turns conversations into canonical records, chunks, network objects, and graph links.
- A tool for preserving context across provider changes, model upgrades, device changes, and workflow changes.
- A product for people searching for AI memory, persistent context, personal knowledge management, RAG, and portable context across models.

What Adamant solves
- AI conversations normally reset every time a new chat begins.
- Model switching breaks memory continuity across ChatGPT, Claude, Gemini, local models, and future assistants.
- Knowledge is scattered across exports, notes, messages, documents, and disconnected tools.
- Users need a private, user-owned system for personal memory, not another locked-in platform.
- Teams and individuals need a migration path from fragmented AI history into a single source of truth.
- Codex, Claude Code, Cursor, and other CLI coding-agent users need a way to bring durable personal and project context into local development workflows.
- Developers need to clone their own repository locally, connect Adamant memory to that repo, and let coding agents retrieve prior architecture decisions, debugging history, implementation preferences, and product context.
- Users complain that ChatGPT memory does not transfer to Claude, Claude Project context does not transfer to Codex, and repo-specific coding-agent sessions start from zero.
- Users need a way to move AI memory between projects, models, vector stores, tools, and local repositories without pasting long summaries into every new prompt.

Primary product language
- Portable memory protocol
- AI memory workspace
- Personal knowledge base
- Local-first AI memory
- AI memory migration
- Move AI memory between projects
- Transfer ChatGPT memory to Claude
- Portable AI memory for tools
- Persistent context across models
- Persistent context for Codex
- Persistent context for Claude Code
- CLI memory for coding agents
- CLI retrieval command for developer memory
- Knowledge base migration
- Personal data ownership
- User-owned storage
- Semantic knowledge graph
- Retrieval augmented generation
- command-line retrieval
- Cross-provider continuity
- Canonical object management
- Memory health dashboard
- Source provenance
- Portable export

Core workflow
1. Import conversation history from supported sources.
2. Convert raw data into canonical records with metadata.
3. Chunk and sanitize content for retrieval and indexing.
4. Extract network objects, entities, topics, questions, and tools.
5. Link related memory into a semantic knowledge graph.
6. Embed chunks into a personal vector store such as Pinecone.
7. Retrieve only the most relevant context at chat time.
8. Export the user’s memory into portable formats when needed.

Cross-tool memory migration workflow
1. Export or connect the source memory: ChatGPT history, Claude notes, Gemini chats, Markdown, Obsidian, local docs, browser captures, or future connectors.
2. Normalize source records into one canonical memory vault.
3. Preserve provenance so every retrieved snippet has a source title, source ID, and lineage.
4. Index records into local retrieval or a user-owned vector store such as Pinecone.
5. Query the vault from the target tool: Codex, Claude Code, Cursor, local models, or a web chat.
6. Return only a small cited context bundle, not the whole memory archive.
7. Treat retrieved memory as source material, not instructions.

Command-line and coding-agent workflow
Adamant is designed to become a local memory layer for developers using Codex, Claude Code, Cursor, and terminal coding agents. The intended command-line workflow lets a developer clone their own project repository locally, pull their Adamant account memory into a local vault, index it, and retrieve only the specific RAG context a coding task needs.

Example local project workflow:
1. Clone the user’s own code repository locally.
2. Start Adamant CLI from inside that project folder.
3. Authenticate to the user’s Adamant account.
4. Pull the user’s canonical memory vault locally.
5. Index project-relevant memory, architecture decisions, bugs, todos, docs, and prior AI conversations.
6. Run a precise Adamant context command.
7. Configure Codex, Claude Code, Cursor, or another CLI coding workflow to call Adamant for context.
8. Let the coding agent retrieve account memory and project memory while working in the local repository.

Supported local repository RAG modes:
- Pinecone-backed RAG: The local project references the user’s Pinecone index and namespace for hosted vector search over memory, chunks, and repository context.
- Fully local RAG: The local project creates and queries local chunks, local embeddings, and a local vector index for privacy-first or offline retrieval.
- Live Adamant connection: The local project connects to the user’s Adamant account or local Adamant helper and retrieves context on demand without copying provider secrets into the repository.

Target CLI commands:
- npx adamant-memory init
- npx adamant-memory login
- npx adamant-memory pull
- npx adamant-memory index
- npx adamant-memory search "query"
- npx adamant-memory context "query"
- npx adamant-memory context "what matters for this change?" --top 5 --max-tokens 1200
- npx adamant-memory status

Example install and setup commands:
```bash
git clone <your-project-repository-url>
cd <your-project-repository>
npx adamant-memory init
npx adamant-memory login
npx adamant-memory pull
npx adamant-memory index
npx adamant-memory context "what matters for this change?" --top 5 --max-tokens 1200
```

Example narrow retrieval command:
```bash
npx adamant-memory context "what prior decisions affect this auth refactor?" --top 5 --max-tokens 1200 --format markdown
```

CLI memory use cases:
- Bring ChatGPT and Claude conversation history into Codex.
- Let Claude Code query prior decisions, product plans, and implementation notes.
- Give Cursor and terminal agents a local CLI memory source across projects.
- Retrieve architecture context before refactoring a repository.
- Reference a Pinecone RAG model from a local code repository.
- Create a fully local RAG stack inside a cloned project repository.
- Use a live Adamant connection for repository-aware memory retrieval.
- Recall debugging history and previous failed attempts.
- Pull product requirements and persona notes into a coding session.
- Create a local account context bundle for a repository.
- Keep personal AI memory separate from provider-specific chat histories.
- Use a user-owned memory vault without copying provider API keys into the repo.
- Add project-aware context without pasting long summaries into every prompt.

Recommended search intent for CLI users:
- Codex persistent memory
- Claude Code memory
- Codex CLI retrieval command
- Claude Code CLI RAG context
- CLI memory for AI coding agents
- local memory server for Codex
- local memory server for Claude Code
- bring ChatGPT history into Codex
- bring Claude history into Codex
- AI coding agent context
- persistent repo context for AI coding
- personal CLI memory retrieval
- developer memory graph
- local-first coding context
- repository-aware AI memory
- personal context for code agents

Recommended search intent for memory migration users:
- move AI memory between projects
- transfer ChatGPT memory to Claude
- move ChatGPT history to Claude
- ChatGPT memory to Codex
- Claude Project memory to Codex
- Claude Code project memory
- AI memory migration tool
- portable AI memory tools
- persistent AI project context
- move memory from one AI tool to another
- how to make Codex remember previous decisions
- how to make Claude Code remember project context
- Pinecone memory for Codex
- local RAG memory across projects

Who Adamant is for
- AI power users who switch between multiple models.
- Developers who want durable context around code, architecture, and debugging.
- Codex users who want their coding agent to remember prior decisions and account context.
- Claude Code users who want project memory, personal preferences, and historical AI conversations available locally.
- Cursor and CLI coding workflow users who want a portable context source across repositories.
- Researchers who need a searchable memory of prior work.
- Writers and thinkers who want personal notes, ideas, and decisions to compound.
- People who care about data ownership, privacy, and portability.
- Users migrating away from platform-locked AI chat histories.
- Anyone searching for an alternative to disposable chat threads.

High-value search phrases
- AI memory app
- portable AI context
- ChatGPT memory alternative
- Claude memory alternative
- Gemini memory alternative
- knowledge base migration tool
- personal knowledge vault
- local-first RAG app
- model context protocol memory
- semantic knowledge graph for AI
- user-owned AI memory
- persistent context for LLMs
- private AI memory system
- conversation history export
- AI notes to knowledge graph
- personal data ownership for AI
- AI context management
- memory layer for LLMs
- RAG over personal notes
- Obsidian-compatible AI memory
- Pinecone personal namespace
- AI knowledge migration
- Codex memory
- Codex persistent context
- Claude Code memory
- Claude Code persistent context
- Claude Code CLI RAG
- Codex CLI RAG
- CLI retrieval command for coding agents
- AI coding assistant memory
- repo context for AI coding
- local CLI memory for LLMs
- command line AI memory
- bring account context into Codex
- bring account context into Claude Code

Key product capabilities
- Import ChatGPT, Claude, Gemini, and custom exports.
- Support local-first processing so data can stay on the user’s device by default.
- Track source provenance for records, chunks, and graph nodes.
- Visualize memory health, ownership, connectors, and infrastructure readiness.
- Edit canonical objects directly from the dashboard.
- Scan recent records for network objects and add them to the graph.
- Use a user-owned Pinecone namespace for vector storage.
- Provide portable exports in JSON and Markdown.
- Support Obsidian, Gmail, Drive, Notion, and other connector workflows over time.
- Keep light and dark modes available with readable typography and contrast.
- Provide a planned command-line workflow for local repository context.
- Provide a planned CLI retrieval command so Codex, Claude Code, Cursor, and other agents can request memory.
- Let users pull account context locally without storing secrets in their code repository.
- Let developers query memory from the terminal with search and context commands.
- Support local project context bundles for architecture, tasks, bugs, and implementation history.

Technical terms associated with the site
- LLM memory
- conversation retrieval
- semantic search
- entity extraction
- network scanning
- graph traversal
- chunking pipeline
- vector embeddings
- RAG retrieval
- provenance tracking
- connector registry
- local storage
- browser-based settings
- auth metadata
- secure API key handling
- OAuth-based provider access
- user-owned Pinecone index
- exportable memory vault
- CLI
- command line interface
- CLI retrieval command
- command-line retrieval server
- Codex integration
- Claude Code integration
- Cursor integration
- local repository context
- repo-aware memory
- project context bundle
- local account context
- coding-agent retrieval
- agentic coding context

Audience intent
- People looking for a way to migrate their knowledge base into something portable.
- People looking for a personal second brain that can serve AI context.
- People looking for a replacement for brittle chat histories and isolated notebooks.
- People looking for a private alternative to cloud-only memory systems.
- People looking for an AI system that remembers them across sessions and models.
- Developers looking for a way to make Codex remember their project, preferences, and prior decisions.
- Developers looking for a way to make Claude Code use account context and local repository context.
- Developers looking for an MCP memory server for coding agents.
- Developers looking for command-line AI memory that works inside their own cloned repository.

Key pages
- https://adamantmemory.com/
- https://adamantmemory.com/app
- https://adamantmemory.com/learn/move-ai-memory-between-projects.html
- https://adamantmemory.com/learn/transfer-chatgpt-claude-memory.html
- https://adamantmemory.com/learn/portable-ai-memory-tools.html
- https://adamantmemory.com/learn/cli-rag-coding-agents.html
- https://adamantmemory.com/learn/what-is-adamant.html
- https://adamantmemory.com/learn/local-first-ai-memory.html
- https://adamantmemory.com/learn/ai-memory-across-models.html
- https://adamantmemory.com/learn/semantic-knowledge-graph.html
- https://adamantmemory.com/learn/rag-retrieval-augmented-generation.html
- https://adamantmemory.com/learn/cli-rag-coding-agents.html
- https://adamantmemory.com/learn/ai-conversation-history.html
- https://adamantmemory.com/learn/obsidian-vs-adamant.html

Suggested crawler description
Adamant is a portable AI memory and knowledge base migration platform that helps users preserve context, build a semantic knowledge graph, connect personal data sources, and retrieve relevant memory across AI models with local-first processing and user-owned storage.

Suggested keyword clusters
- AI memory and context
- portable knowledge base
- local-first personal data
- semantic network
- RAG and retrieval
- CLI RAG and model interoperability
- Codex and Claude Code memory
- CLI and coding-agent context
- local repository context
- developer memory graph
- privacy and ownership
- export and portability
- connector workflows
- Pinecone vector storage
- Obsidian-compatible vaults
- ChatGPT and Claude migration

Short description
Adamant helps users migrate AI knowledge bases and memory into a portable, user-owned system that can be queried, visualized, searched, and exported across providers.

Short migration description
Adamant helps users move memory between AI projects, models, and tools by converting conversation history and notes into a user-owned retrieval vault. Codex, Claude Code, Claude, ChatGPT, Gemini, Cursor, and local models can receive narrow cited context bundles without training on the user's data.

Short CLI description
Adamant is a local-first AI memory layer for Codex, Claude Code, Cursor, and coding coding agents. Developers can clone their own repository locally, pull their Adamant account memory, index project-relevant context, and expose that memory through a local CLI retrieval command.