From 9d150a0433153b5e7bc6b0a09af9681654ebe3a6 Mon Sep 17 00:00:00 2001 From: Manik Date: Wed, 22 Oct 2025 17:01:28 +0530 Subject: [PATCH] Fix: Updated docs; added agents.md instruction in agents guide --- docs/docs.json | 3 +- docs/opensource/changelog.mdx | 77 +++++++++++++ docs/providers/claude-code.mdx | 13 ++- docs/providers/codex.mdx | 193 +++++++++++++++++++++++++++++++++ docs/providers/cursor.mdx | 118 +++++++++++++++++++- docs/providers/kilo-code.mdx | 118 +++++++++++++++++++- docs/providers/vscode.mdx | 120 +++++++++++++++++++- docs/providers/zed.mdx | 118 +++++++++++++++++++- 8 files changed, 749 insertions(+), 11 deletions(-) create mode 100644 docs/providers/codex.mdx diff --git a/docs/docs.json b/docs/docs.json index 33dd350..2d2bcb3 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -57,7 +57,8 @@ { "group": "CLI", "pages": [ - "providers/claude-code" + "providers/claude-code", + "providers/codex" ] }, { diff --git a/docs/opensource/changelog.mdx b/docs/opensource/changelog.mdx index 8fc0e09..a4b4dae 100644 --- a/docs/opensource/changelog.mdx +++ b/docs/opensource/changelog.mdx @@ -3,6 +3,83 @@ title: "Changelog" description: "Product updates and announcements" --- + + +## 🎯 New Features + +**Deep Search** + +- Advanced search capability for Browser Extension and Obsidian +- Surface insights from your memory with greater precision and context +- Connect related information across different sources more effectively + +**Account Management 2.0** + +- Once-click full account deletion with complete data cleanup +- Automatic removal of all data from both **PostgreSQL** and **Neo4j** graph databases +- Peace of mind with complete data control and privacy management + +**Enhanced Onboarding** + +- New guided flow for faster setup and first memory ingestion +- Direct integration setup via **MCP configuration links** + +**Session Compaction for Smarter Memory** + +- Automatically summarizes long conversations for efficient memory storage +- Compacted sessions now appear in search with Markdown formatting +- Improves long-term recall without losing important context + +**AWS Bedrock Support** + +- Connect your own AWS Bedrock account for AI model access +- Choose from Claude, Titan, and other AWS models +- Greater flexibility in model selection and deployment options + +## ⚡ Performance & Reliability + +**Faster, more stable experience** + +- **Improved Search Quality**: Structured, faster, and more relevant results +- **Optimized Graph Performance**: Reduced iterations for quicker retrieval +- **Better Memory Recall**: Session compaction models improve long-term context retention +- **Streamlined Credit Management**: Proper error handling when credits are exhausted + +## 🔧 Improvements + +- **Spaces**: + + - Option to remove episodes from spaces for better organization + - Removed restrictive space description requirements + - Queue-based space assignment for improved reliability + +- **MCP Tooling**: + - Clear error messages when credits run low + - Improved tool descriptions for better AI assistant understanding + - Resolved profile summary edge cases affecting MCP connections + +## 🐛 Fixes + +- Fixed API key deletion not working properly +- Resolved document view breaking in log viewer +- Fixed semantic search inconsistencies affecting result quality +- Resolved login attribute conflicts in authentication flow +- Fixed graph visualization issues in Chrome 140 +- Corrected ingestion queue handling for deleted episodes +- Fixed MCP tool call failures for (`get_user_profile`) +- Resolved space description validation blocking space creation + +## 🔒 Security & Privacy + +**Data protection updates** + +- **Complete Account Wipe**: Account deletion now removes all traces from both relational and graph databases +- **Cascade Delete Logic**: Simplified deletion flows with proper relationship cleanup for users and workspaces +- **Neo4j Graph Cleanup**: Automated cleanup of knowledge graph nodes when deleting accounts +- **Proper Resource Cleanup**: Removes all associated API keys, spaces, and episodes + + + ## 🎯 New Features diff --git a/docs/providers/claude-code.mdx b/docs/providers/claude-code.mdx index 7c7c84a..3cfd8e9 100644 --- a/docs/providers/claude-code.mdx +++ b/docs/providers/claude-code.mdx @@ -290,7 +290,18 @@ Configure Claude Code to automatically search and store memories for seamless pr } ``` -### Troubleshooting +## How It Works + +Once installed, the plugin works automatically: + +- **At session start**: Memory search agent retrieves relevant context from your CORE memory +- **During conversation**: Claude has access to your full memory graph and codebase knowledge +- **After interaction**: Memory ingest agent stores the conversation summary +- **Across tools**: Your memory is shared across Claude Code, Cursor, ChatGPT, and other CORE-connected tools + +You don’t need to manually trigger memory operations—the plugin handles everything! + +## Troubleshooting **Connection Issues:** diff --git a/docs/providers/codex.mdx b/docs/providers/codex.mdx new file mode 100644 index 0000000..c40814c --- /dev/null +++ b/docs/providers/codex.mdx @@ -0,0 +1,193 @@ +--- +title: "Codex CLI" +description: "Connect your Codex CLI to CORE's memory system" +--- + +### Prerequisites + +- [Codex CLI](https://codex.so) installed +- CORE account - [Sign up at core.heysol.ai](https://core.heysol.ai) + +### Step 1: Configure CORE MCP Server + +Create or open your Codex configuration file at `~/.codex/config.toml`: + +```bash +# Create config directory if needed +mkdir -p ~/.codex + +# Open config file in your editor +code ~/.codex/config.toml -r +``` + +### Step 2: Add CORE MCP Configuration + +Add the following to your `config.toml` file: + +```toml +[mcp_servers.corememory] +command = "npx" +args = ["-y", "mcp-remote", "https://core.heysol.ai/api/v1/mcp?source=codex", "--header", "Authorization:${AUTH_HEADER}"] +env = { "AUTH_HEADER" = "Bearer YOUR_API_KEY_HERE" } +``` + +What this does: This registers CORE's MCP server with Codex, establishing the connection endpoint for memory operations using Bearer token authentication. + +### Step 3: Get Your API Key + +1. Log into your CORE dashboard at [core.heysol.ai](https://core.heysol.ai) +2. Navigate to **Settings** (bottom left) + ![CORE Settings](/images/core-settings.png) +3. Go to **API Key** → **Generate new key** → Name it "codex" + ![Create API Key](/images/create-api-key.png) +4. Copy the generated key and replace `YOUR_API_KEY_HERE` in your config file + +### Step 4: Verify Connection + +Start Codex CLI and test your setup: + +1. **Start Codex CLI** - The CORE memory MCP server should now be available +2. **Test memory storage**: Ask Codex to create a comprehensive summary of your codebase and add it to CORE memory for future reference +3. **Test memory retrieval**: Ask Codex to search your memory for the stored summary + +## Enable Automatic Memory Integration (Recommended) + +To make Codex automatically search and store memories for seamless project continuity: + +1. **Create Agents configuration** in your project root: + ```bash + mkdir -p .codex + touch .codex/Agents.md + ``` + +2. **Add memory instructions** - Open `.codex/Agents.md` and add the following: + +```markdown +I am an AI coding assistant with access to a sophisticated memory system. While I don't retain information between separate conversations, I have access to CORE Memory - a persistent knowledge system that maintains project context, learnings, and continuity across all coding sessions. + +**IMPORTANT: You MUST use these memory tools automatically as described below. This is not optional.** + +## Memory Tools Integration + +### Memory Search (`memory_search`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY conversation, BEFORE responding to the user, you MUST search memory for: +- Previous discussions about the current topic +- Related project context and decisions +- User preferences and patterns +- Similar problems solved before + +**Also search when:** +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- You need context to provide better assistance + +**Cognitive approach:** +- **Surface Layer**: Query for specific knowledge about the topic +- **Pattern Layer**: Search for how the user usually thinks, works, or prefers things +- **Wisdom Layer**: Look for lessons learned from similar situations + +**Search triggers:** +- Starting any new conversation or task +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- Maintaining continuity across sessions + +**Quality questions to ask yourself:** +- "What don't I know that I should?" +- "What does this user care about that I might miss?" +- "What went right/wrong in similar situations?" + +### Memory Ingest (`memory_ingest`) + +**AUTOMATIC BEHAVIOR:** At the END of EVERY conversation, AFTER fully responding to the user, you MUST store the conversation in memory. This is the FINAL action before completing your response. + +**Storage protocol:** +- MANDATORY: Execute after completing every interaction +- This is NON-NEGOTIABLE - you must always store conversation context +- Memory storage happens as the last step, not during the conversation + +**What to capture:** + +FROM USER: +- Their specific question, request, or problem statement +- Project context and situation they provided +- What they're trying to accomplish +- Technical challenges or constraints mentioned + +FROM ASSISTANT: +- Detailed explanation of solution/approach taken +- Step-by-step processes and methodologies +- Technical concepts and principles explained +- Reasoning behind recommendations and decisions +- Alternative approaches discussed +- Problem-solving methodologies applied + +**Exclude from storage:** +- Code blocks and code snippets +- File contents or file listings +- Command examples or CLI commands +- Raw data or logs + +**Include in storage:** +- All conceptual explanations and theory +- Technical discussions and analysis +- Problem-solving approaches and reasoning +- Decision rationale and trade-offs +- Implementation strategies (described conceptually) +- Learning insights and patterns + +**Quality check:** +- Can I quickly understand project context from memory alone? +- Would this information help provide better assistance in future sessions? +- Does stored context capture key decisions and reasoning? + +### Project Space Context (`memory_get_space`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY session, you MUST retrieve the current project's space context: + +1. **Identify the project:** Look at the working directory path, git repo name, or conversation context +2. **Get space context:** Use `memory_get_space` with `spaceName: core` +3. **Use as foundation:** The space summary is a living document that's continuously updated - it contains the most current, comprehensive context about this project + +**What spaces provide:** +- Live, evolving documentation that updates with every interaction +- Consolidated project knowledge and current state +- Organized context specific to this domain +- Most up-to-date understanding of the project + +**Also retrieve space context when:** +- User asks about a specific project or domain +- You need comprehensive context about a topic +- Switching between different work areas +``` + +## How It Works + +Once installed, CORE memory integrates seamlessly with Codex: + +- **During conversation**: Codex has access to your full memory graph and stored context +- **Memory operations**: Use natural language to store and retrieve information across sessions +- **Across tools**: Your memory is shared across Codex, Claude Code, Cursor, ChatGPT, and other CORE-connected tools +- **Project continuity**: Context persists across all your AI coding sessions + +## Troubleshooting + +**Connection Issues:** + +- Verify your API key is correct and hasn't expired +- Check that the `config.toml` file is properly formatted (valid TOML syntax) +- Ensure the Bearer token format is correct: `Bearer YOUR_API_KEY_HERE` +- Restart Codex CLI if the connection seems stuck + +**API Key Issues:** + +- Make sure you copied the complete API key from CORE dashboard +- Try regenerating your API key if authentication fails +- Check that the key is active in your CORE account settings + +### Need Help? + +Join our [Discord community](https://discord.gg/YGUZcvDjUa) and ask questions in the **#core-support** channel. + +Our team and community members are ready to help you get the most out of CORE's memory capabilities. diff --git a/docs/providers/cursor.mdx b/docs/providers/cursor.mdx index 1821ab2..c64cac0 100644 --- a/docs/providers/cursor.mdx +++ b/docs/providers/cursor.mdx @@ -44,11 +44,125 @@ description: "Connect your Cursor Desktop app to CORE's memory system" ## Enable Automatic Memory Integration (Recommended) -To make Cursor automatically use your CORE memory in conversations: +### Option 1: Using Agents.md (Recommended) + +This approach provides comprehensive memory instructions that work across multiple AI tools. + +1. **Create Agents configuration** in your project root: + ```bash + mkdir -p .cursor + touch .cursor/Agents.md + ``` + +2. **Add memory instructions** - Open `.cursor/Agents.md` and add the following: + +```markdown +I am an AI coding assistant with access to a sophisticated memory system. While I don't retain information between separate conversations, I have access to CORE Memory - a persistent knowledge system that maintains project context, learnings, and continuity across all coding sessions. + +**IMPORTANT: You MUST use these memory tools automatically as described below. This is not optional.** + +## Memory Tools Integration + +### Memory Search (`memory_search`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY conversation, BEFORE responding to the user, you MUST search memory for: +- Previous discussions about the current topic +- Related project context and decisions +- User preferences and patterns +- Similar problems solved before + +**Also search when:** +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- You need context to provide better assistance + +**Cognitive approach:** +- **Surface Layer**: Query for specific knowledge about the topic +- **Pattern Layer**: Search for how the user usually thinks, works, or prefers things +- **Wisdom Layer**: Look for lessons learned from similar situations + +**Search triggers:** +- Starting any new conversation or task +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- Maintaining continuity across sessions + +**Quality questions to ask yourself:** +- "What don't I know that I should?" +- "What does this user care about that I might miss?" +- "What went right/wrong in similar situations?" + +### Memory Ingest (`memory_ingest`) + +**AUTOMATIC BEHAVIOR:** At the END of EVERY conversation, AFTER fully responding to the user, you MUST store the conversation in memory. This is the FINAL action before completing your response. + +**Storage protocol:** +- MANDATORY: Execute after completing every interaction +- This is NON-NEGOTIABLE - you must always store conversation context +- Memory storage happens as the last step, not during the conversation + +**What to capture:** + +FROM USER: +- Their specific question, request, or problem statement +- Project context and situation they provided +- What they're trying to accomplish +- Technical challenges or constraints mentioned + +FROM ASSISTANT: +- Detailed explanation of solution/approach taken +- Step-by-step processes and methodologies +- Technical concepts and principles explained +- Reasoning behind recommendations and decisions +- Alternative approaches discussed +- Problem-solving methodologies applied + +**Exclude from storage:** +- Code blocks and code snippets +- File contents or file listings +- Command examples or CLI commands +- Raw data or logs + +**Include in storage:** +- All conceptual explanations and theory +- Technical discussions and analysis +- Problem-solving approaches and reasoning +- Decision rationale and trade-offs +- Implementation strategies (described conceptually) +- Learning insights and patterns + +**Quality check:** +- Can I quickly understand project context from memory alone? +- Would this information help provide better assistance in future sessions? +- Does stored context capture key decisions and reasoning? + +### Project Space Context (`memory_get_space`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY session, you MUST retrieve the current project's space context: + +1. **Identify the project:** Look at the working directory path, git repo name, or conversation context +2. **Get space context:** Use `memory_get_space` with `spaceName: core` +3. **Use as foundation:** The space summary is a living document that's continuously updated - it contains the most current, comprehensive context about this project + +**What spaces provide:** +- Live, evolving documentation that updates with every interaction +- Consolidated project knowledge and current state +- Organized context specific to this domain +- Most up-to-date understanding of the project + +**Also retrieve space context when:** +- User asks about a specific project or domain +- You need comprehensive context about a topic +- Switching between different work areas +``` + +### Option 2: Using Cursor Project Rules + +Alternatively, you can use Cursor's native Rules & Memories feature: 1. Go to **Settings** → **Rules & Memories** → **Project Rules** -2. Click **+Add Rule"** and add below rule instruction: +2. Click **+Add Rule** and add below rule instruction: ```text --- diff --git a/docs/providers/kilo-code.mdx b/docs/providers/kilo-code.mdx index 74ceca9..b789da4 100644 --- a/docs/providers/kilo-code.mdx +++ b/docs/providers/kilo-code.mdx @@ -43,9 +43,123 @@ Before connecting CORE to Kilo-Code, ensure you have: ![Core Kilo Code](/images/kilo-code-auth.png) - Confirm that "core-memory" appears as an active, connected server in Kilo-Code -### Enable Automatic Memory Integration (Recommended) +## Enable Automatic Memory Integration (Recommended) -To get the most out of CORE, configure Kilo-Code to automatically search and store memories for seamless project continuity: +### Option 1: Using Agents.md (Recommended) + +This approach provides comprehensive memory instructions that work across multiple AI tools. + +1. **Create Agents configuration** in your project root: + ```bash + mkdir -p .kilo-code + touch .kilo-code/Agents.md + ``` + +2. **Add memory instructions** - Open `.kilo-code/Agents.md` and add the following: + +```markdown +I am an AI coding assistant with access to a sophisticated memory system. While I don't retain information between separate conversations, I have access to CORE Memory - a persistent knowledge system that maintains project context, learnings, and continuity across all coding sessions. + +**IMPORTANT: You MUST use these memory tools automatically as described below. This is not optional.** + +## Memory Tools Integration + +### Memory Search (`memory_search`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY conversation, BEFORE responding to the user, you MUST search memory for: +- Previous discussions about the current topic +- Related project context and decisions +- User preferences and patterns +- Similar problems solved before + +**Also search when:** +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- You need context to provide better assistance + +**Cognitive approach:** +- **Surface Layer**: Query for specific knowledge about the topic +- **Pattern Layer**: Search for how the user usually thinks, works, or prefers things +- **Wisdom Layer**: Look for lessons learned from similar situations + +**Search triggers:** +- Starting any new conversation or task +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- Maintaining continuity across sessions + +**Quality questions to ask yourself:** +- "What don't I know that I should?" +- "What does this user care about that I might miss?" +- "What went right/wrong in similar situations?" + +### Memory Ingest (`memory_ingest`) + +**AUTOMATIC BEHAVIOR:** At the END of EVERY conversation, AFTER fully responding to the user, you MUST store the conversation in memory. This is the FINAL action before completing your response. + +**Storage protocol:** +- MANDATORY: Execute after completing every interaction +- This is NON-NEGOTIABLE - you must always store conversation context +- Memory storage happens as the last step, not during the conversation + +**What to capture:** + +FROM USER: +- Their specific question, request, or problem statement +- Project context and situation they provided +- What they're trying to accomplish +- Technical challenges or constraints mentioned + +FROM ASSISTANT: +- Detailed explanation of solution/approach taken +- Step-by-step processes and methodologies +- Technical concepts and principles explained +- Reasoning behind recommendations and decisions +- Alternative approaches discussed +- Problem-solving methodologies applied + +**Exclude from storage:** +- Code blocks and code snippets +- File contents or file listings +- Command examples or CLI commands +- Raw data or logs + +**Include in storage:** +- All conceptual explanations and theory +- Technical discussions and analysis +- Problem-solving approaches and reasoning +- Decision rationale and trade-offs +- Implementation strategies (described conceptually) +- Learning insights and patterns + +**Quality check:** +- Can I quickly understand project context from memory alone? +- Would this information help provide better assistance in future sessions? +- Does stored context capture key decisions and reasoning? + +### Project Space Context (`memory_get_space`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY session, you MUST retrieve the current project's space context: + +1. **Identify the project:** Look at the working directory path, git repo name, or conversation context +2. **Get space context:** Use `memory_get_space` with `spaceName: core` +3. **Use as foundation:** The space summary is a living document that's continuously updated - it contains the most current, comprehensive context about this project + +**What spaces provide:** +- Live, evolving documentation that updates with every interaction +- Consolidated project knowledge and current state +- Organized context specific to this domain +- Most up-to-date understanding of the project + +**Also retrieve space context when:** +- User asks about a specific project or domain +- You need comprehensive context about a topic +- Switching between different work areas +``` + +### Option 2: Using Kilo-Code Rules + +Alternatively, you can use Kilo-Code's native rules feature: Create a new file `core-memory.md` at `.kilo-code/rules` and add the following: diff --git a/docs/providers/vscode.mdx b/docs/providers/vscode.mdx index 5248919..2cbdbf6 100644 --- a/docs/providers/vscode.mdx +++ b/docs/providers/vscode.mdx @@ -38,12 +38,126 @@ description: "Connect your VS Code editor to CORE's memory system via MCP" ![Core vscode](/images/authenticate-vscode.png) - Once authenticated, CORE Memory will show as a running MCP server -### Enable Automatic Memory Integration (Recommended) +## Enable Automatic Memory Integration (Recommended) -Configure Copilot to automatically search and store memories for seamless project continuity +### Option 1: Using Agents.md (Recommended) + +This approach provides comprehensive memory instructions that work across multiple AI tools. + +1. **Create Agents configuration** in your project root: + ```bash + mkdir -p .github + touch .github/Agents.md + ``` + +2. **Add memory instructions** - Open `.github/Agents.md` and add the following: + +```markdown +I am an AI coding assistant with access to a sophisticated memory system. While I don't retain information between separate conversations, I have access to CORE Memory - a persistent knowledge system that maintains project context, learnings, and continuity across all coding sessions. + +**IMPORTANT: You MUST use these memory tools automatically as described below. This is not optional.** + +## Memory Tools Integration + +### Memory Search (`memory_search`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY conversation, BEFORE responding to the user, you MUST search memory for: +- Previous discussions about the current topic +- Related project context and decisions +- User preferences and patterns +- Similar problems solved before + +**Also search when:** +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- You need context to provide better assistance + +**Cognitive approach:** +- **Surface Layer**: Query for specific knowledge about the topic +- **Pattern Layer**: Search for how the user usually thinks, works, or prefers things +- **Wisdom Layer**: Look for lessons learned from similar situations + +**Search triggers:** +- Starting any new conversation or task +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- Maintaining continuity across sessions + +**Quality questions to ask yourself:** +- "What don't I know that I should?" +- "What does this user care about that I might miss?" +- "What went right/wrong in similar situations?" + +### Memory Ingest (`memory_ingest`) + +**AUTOMATIC BEHAVIOR:** At the END of EVERY conversation, AFTER fully responding to the user, you MUST store the conversation in memory. This is the FINAL action before completing your response. + +**Storage protocol:** +- MANDATORY: Execute after completing every interaction +- This is NON-NEGOTIABLE - you must always store conversation context +- Memory storage happens as the last step, not during the conversation + +**What to capture:** + +FROM USER: +- Their specific question, request, or problem statement +- Project context and situation they provided +- What they're trying to accomplish +- Technical challenges or constraints mentioned + +FROM ASSISTANT: +- Detailed explanation of solution/approach taken +- Step-by-step processes and methodologies +- Technical concepts and principles explained +- Reasoning behind recommendations and decisions +- Alternative approaches discussed +- Problem-solving methodologies applied + +**Exclude from storage:** +- Code blocks and code snippets +- File contents or file listings +- Command examples or CLI commands +- Raw data or logs + +**Include in storage:** +- All conceptual explanations and theory +- Technical discussions and analysis +- Problem-solving approaches and reasoning +- Decision rationale and trade-offs +- Implementation strategies (described conceptually) +- Learning insights and patterns + +**Quality check:** +- Can I quickly understand project context from memory alone? +- Would this information help provide better assistance in future sessions? +- Does stored context capture key decisions and reasoning? + +### Project Space Context (`memory_get_space`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY session, you MUST retrieve the current project's space context: + +1. **Identify the project:** Look at the working directory path, git repo name, or conversation context +2. **Get space context:** Use `memory_get_space` with `spaceName: core` +3. **Use as foundation:** The space summary is a living document that's continuously updated - it contains the most current, comprehensive context about this project + +**What spaces provide:** +- Live, evolving documentation that updates with every interaction +- Consolidated project knowledge and current state +- Organized context specific to this domain +- Most up-to-date understanding of the project + +**Also retrieve space context when:** +- User asks about a specific project or domain +- You need comprehensive context about a topic +- Switching between different work areas +``` + +### Option 2: Using Copilot Instructions + +Alternatively, you can use GitHub Copilot's native instructions feature: Create a new rules file in your project root: -.github/copilot-instructions.md +`.github/copilot-instructions.md` ```text --- diff --git a/docs/providers/zed.mdx b/docs/providers/zed.mdx index e60dd8c..3a4df06 100644 --- a/docs/providers/zed.mdx +++ b/docs/providers/zed.mdx @@ -47,9 +47,123 @@ Enter below code in configuraiton file and click on `Add server` button - Once authenticated CORE Memory will show in the MCP server connected ![Core Cursor](/images/zed-core-connected.png) -### Step 4: Enable Automatic Memory Search and Ingest in Zed (Recommended) +## Enable Automatic Memory Integration (Recommended) -To make Zed automatically use your CORE memory in conversations: +### Option 1: Using Agents.md (Recommended) + +This approach provides comprehensive memory instructions that work across multiple AI tools. + +1. **Create Agents configuration** in your project root: + ```bash + mkdir -p .zed + touch .zed/Agents.md + ``` + +2. **Add memory instructions** - Open `.zed/Agents.md` and add the following: + +```markdown +I am an AI coding assistant with access to a sophisticated memory system. While I don't retain information between separate conversations, I have access to CORE Memory - a persistent knowledge system that maintains project context, learnings, and continuity across all coding sessions. + +**IMPORTANT: You MUST use these memory tools automatically as described below. This is not optional.** + +## Memory Tools Integration + +### Memory Search (`memory_search`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY conversation, BEFORE responding to the user, you MUST search memory for: +- Previous discussions about the current topic +- Related project context and decisions +- User preferences and patterns +- Similar problems solved before + +**Also search when:** +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- You need context to provide better assistance + +**Cognitive approach:** +- **Surface Layer**: Query for specific knowledge about the topic +- **Pattern Layer**: Search for how the user usually thinks, works, or prefers things +- **Wisdom Layer**: Look for lessons learned from similar situations + +**Search triggers:** +- Starting any new conversation or task +- User mentions past work or previous discussions +- Working on ongoing projects that have history +- Maintaining continuity across sessions + +**Quality questions to ask yourself:** +- "What don't I know that I should?" +- "What does this user care about that I might miss?" +- "What went right/wrong in similar situations?" + +### Memory Ingest (`memory_ingest`) + +**AUTOMATIC BEHAVIOR:** At the END of EVERY conversation, AFTER fully responding to the user, you MUST store the conversation in memory. This is the FINAL action before completing your response. + +**Storage protocol:** +- MANDATORY: Execute after completing every interaction +- This is NON-NEGOTIABLE - you must always store conversation context +- Memory storage happens as the last step, not during the conversation + +**What to capture:** + +FROM USER: +- Their specific question, request, or problem statement +- Project context and situation they provided +- What they're trying to accomplish +- Technical challenges or constraints mentioned + +FROM ASSISTANT: +- Detailed explanation of solution/approach taken +- Step-by-step processes and methodologies +- Technical concepts and principles explained +- Reasoning behind recommendations and decisions +- Alternative approaches discussed +- Problem-solving methodologies applied + +**Exclude from storage:** +- Code blocks and code snippets +- File contents or file listings +- Command examples or CLI commands +- Raw data or logs + +**Include in storage:** +- All conceptual explanations and theory +- Technical discussions and analysis +- Problem-solving approaches and reasoning +- Decision rationale and trade-offs +- Implementation strategies (described conceptually) +- Learning insights and patterns + +**Quality check:** +- Can I quickly understand project context from memory alone? +- Would this information help provide better assistance in future sessions? +- Does stored context capture key decisions and reasoning? + +### Project Space Context (`memory_get_space`) + +**AUTOMATIC BEHAVIOR:** At the start of EVERY session, you MUST retrieve the current project's space context: + +1. **Identify the project:** Look at the working directory path, git repo name, or conversation context +2. **Get space context:** Use `memory_get_space` with `spaceName: core` +3. **Use as foundation:** The space summary is a living document that's continuously updated - it contains the most current, comprehensive context about this project + +**What spaces provide:** +- Live, evolving documentation that updates with every interaction +- Consolidated project knowledge and current state +- Organized context specific to this domain +- Most up-to-date understanding of the project + +**Also retrieve space context when:** +- User asks about a specific project or domain +- You need comprehensive context about a topic +- Switching between different work areas +``` + +### Option 2: Using Zed Rules + +Alternatively, you can use Zed's native Rules Library feature: 1. **Open the Rules Library:**