🌐 Language

### CORE: Memory + Actions for Your AI Tools

--- ## ❌ Without CORE - ❌ Re-explain your project context to each AI tool - ❌ Lost conversations and decisions across ChatGPT, Claude, Cursor - ❌ No memory of past discussions, preferences, or project history - ❌ Can't take actions in Linear, GitHub, Slack, Gmail from your AI tools ## ✅ With CORE CORE gives your AI tools persistent memory and the ability to act in the apps you use. - ✅ Remember everything across Claude, Cursor, ChatGPT, Claude Code - ✅ Take actions in Linear, GitHub, Slack, Gmail, Google Sheets - ✅ Connect once, works everywhere via MCP - ✅ Your data, your control: open-source and self-hostable --- ## What You Can Do ### 1. Perform actions in your apps from Claude/Cursor Connect your apps once, take actions from anywhere. ```txt Create/Read GitHub, Linear issues from claude ``` ```txt Draft/Send/Read an email and store relevant info in CORE from claude ``` ```txt Manage your calendar, update spreadsheet from claude ``` ![actions](https://github.com/user-attachments/assets/60295a77-bdfd-4d57-aff5-d77ecb41e72d) --- ### 2. Get on-demand context from CORE so you never have to repeat yourself CORE becomes your personal knowledge base. Ask any AI tool to pull relevant context. ```txt Search core memory for architecture decisions on the payment service ``` ```txt What my content guidelines from core to create the blog? ``` ![core_as_memory](https://github.com/user-attachments/assets/7ac5d3f3-ca36-428d-8e97-3412c398f74b) --- ### 3. Catch up on past context for any feature in claude code/cursor Switching back to a feature after a week? Get caught up instantly. ```txt What did we discuss about the checkout flow? Summarize from memory. ``` ```txt Refer to past discussions and remind me where we left off on the API refactor ``` ![claude-code-in-core](https://github.com/user-attachments/assets/0bd9566b-a8cc-49d9-a3cf-368658906c39) --- ## 🚀 Quick Start Choose your path: | | **CORE Cloud** | **Self-Host** | |---|---|---| | Setup time | 5 minutes | 15 minutes | | Best for | Try quickly, no infra | Full control, your servers | | Requirements | Just an account | Docker, 4GB RAM | ### Cloud 1. **Sign up** at [app.getcore.me](https://app.getcore.me) 2. **Connect a source** (Claude, Cursor, or any MCP-compatible tool) 3. **Start using** CORE to perform any action or store about you in memory ### Self-Host **Quick Deploy** [![Deploy on Railway](https://railway.app/button.svg)](https://railway.com/deploy/core) **Or with Docker** 1. Clone the repository: ``` git clone https://github.com/RedPlanetHQ/core.git cd core ``` 2. Configure environment variables in `core/.env`: ``` OPENAI_API_KEY=your_openai_api_key ``` 3. Start the service ``` docker-compose up -d ``` Once deployed, you can configure your AI providers (OpenAI, Anthropic) and start building your memory graph. 👉 [View complete self-hosting guide](https://docs.getcore.me/self-hosting/docker) > Note: We tried open-source models like Ollama or GPT OSS but facts generation were not good, we are still figuring out how to improve on that and then will also support OSS models. ## 🛠️ Installation ### CLIs

Install in Claude Code CLI

1. Run this command in your terminal to connect CORE with Claude Code: ```sh claude mcp add --transport http --scope user core-memory https://mcp.getcore.me/api/v1/mcp?source=Claude-Code ``` 2. Type `/mcp` and open core-memory MCP for authentication

Install in Codex CLI

**Option 1 (Recommended):** Add to your `~/.codex/config.toml` file: ```toml [features] rmcp_client=true [mcp_servers.memory] url = "https://mcp.getcore.me/api/v1/mcp?source=codex" ``` Then run: `codex mcp memory login` **Option 2 (If Option 1 doesn't work):** Add API key configuration: ```toml [features] rmcp_client=true [mcp_servers.memory] url = "https://mcp.getcore.me/api/v1/mcp?source=codex" http_headers = { "Authorization" = "Bearer CORE_API_KEY" } ``` Get your API key from [app.getcore.me](https://app.getcore.me) → Settings → API Key, then run: `codex mcp memory login`

Install in Gemini CLI

See [Gemini CLI Configuration](https://google-gemini.github.io/gemini-cli/docs/tools/mcp-server.html) for details. 1. Open the Gemini CLI settings file. The location is `~/.gemini/settings.json` (where `~` is your home directory). 2. Add the following to the `mcpServers` object in your `settings.json` file: ```json { "mcpServers": { "corememory": { "httpUrl": "https://mcp.getcore.me/api/v1/mcp?source=geminicli", "timeout": 5000 } } } ``` If the `mcpServers` object does not exist, create it.

Install in Copilot CLI

Add the following to your `~/.copilot/mcp-config.json` file: ```json { "mcpServers": { "core": { "type": "http", "url": "https://mcp.getcore.me/api/v1/mcp?source=Copilot-CLI", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

### IDEs

Install in Cursor

> Since Cursor 1.0, you can click the install button below for instant one-click installation. [![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=core-memory&config=eyJ1cmwiOiJodHRwczovL2NvcmUuaGV5c29sLmFpL2FwaS92MS9tY3A/c291cmNlPWN1cnNvciJ9Cg==) OR 1. Go to: `Settings` -> `Tools & Integrations` -> `Add Custom MCP` 2. Enter the below in `mcp.json` file: ```json { "mcpServers": { "core-memory": { "url": "https://mcp.getcore.me/api/v1/mcp?source=cursor", "headers": {} } } } ```

Install in VS Code

Enter the below in `mcp.json` file: ```json { "servers": { "core-memory": { "url": "https://mcp.getcore.me/api/v1/mcp?source=Vscode", "type": "http", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

Install in VS Code Insiders

Add to your VS Code Insiders MCP config: ```json { "mcp": { "servers": { "core-memory": { "type": "http", "url": "https://mcp.getcore.me/api/v1/mcp?source=VSCode-Insiders", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } } ```

Install in Windsurf

Enter the below in `mcp_config.json` file: ```json { "mcpServers": { "core-memory": { "serverUrl": "https://mcp.getcore.me/api/v1/mcp/source=windsurf", "headers": { "Authorization": "Bearer " } } } } ```

Install in Zed

1. Go to `Settings` in Agent Panel -> `Add Custom Server` 2. Enter below code in configuration file and click on `Add server` button ```json { "core-memory": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.getcore.me/api/v1/mcp?source=Zed"] } } ```

### Coding Agents

Install in Amp

Run this command in your terminal: ```sh amp mcp add core-memory https://mcp.getcore.me/api/v1/mcp?source=amp ```

Install in Augment Code

Add to your `~/.augment/settings.json` file: ```json { "mcpServers": { "core-memory": { "type": "http", "url": "https://mcp.getcore.me/api/v1/mcp?source=augment-code", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

Install in Cline

1. Open Cline and click the hamburger menu icon (☰) to enter the MCP Servers section 2. Choose Remote Servers tab and click the Edit Configuration button 3. Add the following to your Cline MCP configuration: ```json { "mcpServers": { "core-memory": { "url": "https://mcp.getcore.me/api/v1/mcp?source=Cline", "type": "streamableHttp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

Install in Kilo Code

1. Go to `Settings` → `MCP Servers` → `Installed tab` → click `Edit Global MCP` to edit your configuration. 2. Add the following to your MCP config file: ```json { "core-memory": { "type": "streamable-http", "url": "https://mcp.getcore.me/api/v1/mcp?source=Kilo-Code", "headers": { "Authorization": "Bearer your-token" } } } ```

Install in Kiro

Add in Kiro → MCP Servers: ```json { "mcpServers": { "core-memory": { "url": "https://mcp.getcore.me/api/v1/mcp?source=Kiro", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

Install in Qwen Coder

See [Qwen Coder MCP Configuration](https://qwenlm.github.io/qwen-code-docs/en/tools/mcp-server/#how-to-set-up-your-mcp-server) for details. Add to `~/.qwen/settings.json`: ```json { "mcpServers": { "core-memory": { "httpUrl": "https://mcp.getcore.me/api/v1/mcp?source=Qwen", "headers": { "Authorization": "Bearer YOUR_API_KEY", "Accept": "application/json, text/event-stream" } } } } ```

Install in Roo Code

Add to your Roo Code MCP configuration: ```json { "mcpServers": { "core-memory": { "type": "streamable-http", "url": "https://mcp.getcore.me/api/v1/mcp?source=Roo-Code", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

Install in Opencode

Add to your Opencode configuration: ```json { "mcp": { "core-memory": { "type": "remote", "url": "https://mcp.getcore.me/api/v1/mcp?source=Opencode", "headers": { "Authorization": "Bearer YOUR_API_KEY" }, "enabled": true } } } ```

Install in Copilot Coding Agent

Add to Repository Settings → Copilot → Coding agent → MCP configuration: ```json { "mcpServers": { "core": { "type": "http", "url": "https://mcp.getcore.me/api/v1/mcp?source=Copilot-Agent", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

Install in Qodo Gen

1. Open Qodo Gen chat panel in VSCode or IntelliJ 2. Click Connect more tools, then click + Add new MCP 3. Add the following configuration: ```json { "mcpServers": { "core-memory": { "url": "https://mcp.getcore.me/api/v1/mcp?source=Qodo-Gen" } } } ```

### Terminals

Install in Warp

Add in Settings → AI → Manage MCP servers: ```json { "core": { "url": "https://mcp.getcore.me/api/v1/mcp?source=Warp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } ```

Install in Crush

Add to your Crush configuration: ```json { "$schema": "https://charm.land/crush.json", "mcp": { "core": { "type": "http", "url": "https://mcp.getcore.me/api/v1/mcp?source=Crush", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } } ```

### Desktop Apps

Install in Claude Desktop

1. Copy CORE MCP URL: ``` https://mcp.getcore.me/api/v1/mcp?source=Claude ``` 2. Navigate to Settings → Connectors → Click Add custom connector 3. Click on "Connect" and grant Claude permission to access CORE MCP

Install in ChatGPT

Connect ChatGPT to CORE's memory system via browser extension: 1. [Install Core Browser Extension](https://chromewebstore.google.com/detail/core-extension/cglndoindnhdbfcbijikibfjoholdjcc) 2. Generate API Key: Go to Settings → API Key → Generate new key → Name it "extension" 3. Add API Key in Core Extension and click Save

Install in Gemini

Connect Gemini to CORE's memory system via browser extension: 1. [Install Core Browser Extension](https://chromewebstore.google.com/detail/core-extension/cglndoindnhdbfcbijikibfjoholdjcc) 2. Generate API Key: Go to Settings → API Key → Generate new key → Name it "extension" 3. Add API Key in Core Extension and click Save

Install in Perplexity Desktop

1. Add in Perplexity → Settings → Connectors → Add Connector → Advanced: ```json { "core-memory": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.getcore.me/api/v1/mcp?source=perplexity"] } } ``` 2. Click Save to apply the changes 3. Core will be available in your Perplexity sessions

### Development Tools

Install in Factory

Run in terminal: ```sh droid mcp add core https://mcp.getcore.me/api/v1/mcp?source=Factory --type http --header "Authorization: Bearer YOUR_API_KEY" ``` Type /mcp within droid to manage servers and view available tools.

Install in Rovo Dev CLI

1. Edit mcp config: ```sh acli rovodev mcp ``` 2. Add to your Rovo Dev MCP configuration: ```json { "mcpServers": { "core-memory": { "url": "https://mcp.getcore.me/api/v1/mcp?source=Rovo-Dev" } } } ```

Install in Trae

Add to your Trae MCP configuration: ```json { "mcpServers": { "core": { "url": "https://mcp.getcore.me/api/v1/mcp?source=Trae" } } } ```

## 🔨 Available Tools CORE Memory MCP provides the following tools that LLMs can use: - `memory_search`: Search relevant context from CORE Memory. - `memory_ingest`: Add an episode in CORE Memory. - `memory_about_user`: Fetches user persona from CORE Memory. - `initialise_conversation_session`: Initialise conversation and assign session id to a conversation. - `get_integrations`: Fetches what relevant integration should be used from the connected integrations. - `get_integrations_actions`: Fetches what tool to be used from that integrations tools for the task. - `execute_integrations_actions`: Execute the tool for that integration . --- ## Why CORE? 1. **Your AI tools understand context evolution**: "We decided X, then changed to Y because of Z" — CORE preserves the full story, not just the latest state. 2. **Recall that handles complex queries**: "What did we discuss about payments before we switched to Stripe?" — CORE handles temporal and multi-hop reasoning. 88.24% on LoCoMo (SOTA). 3. **One auth, every tool**: Connect GitHub once. Create issues from Claude. Read PRs from Cursor. Search code from Claude Code. Same for Linear, Slack, Gmail. 4. **No vendor lock-in**: Open-source. Self-host on your infra. Export your data anytime. --- ## How it Works ### How CORE create memory memory-ingest-diagram

CORE’s ingestion pipeline has four phases designed to capture evolving context: 1. **Normalization**: Links new information to recent context, breaks long documents into coherent chunks while keeping cross-references, and standardizes terms so by the time CORE extracts knowledge, it’s working with clean, contextualized input instead of messy text. 2. **Extraction**: Pulls meaning from normalized text by identifying entities (people, tools, projects, concepts), turning them into statements with context, source, and time, and mapping relationships. For example, “We wrote CORE in Next.js” becomes: Entities (Core, Next.js), Statement (CORE was developed using Next.js), and Relationship (was developed using). 3. **Resolution**: Detects contradictions, tracks how preferences evolve, and preserves multiple perspectives with provenance instead of overwriting them so memory reflects your full journey, not just the latest snapshot. 4. **Graph Integration**: Connects entities, statements, and episodes into a temporal knowledge graph that links facts to their context and history, turning isolated data into a living web of knowledge agents can actually use. The Result: Instead of a flat database, CORE gives you a memory that grows and changes with you - preserving context, evolution, and ownership so agents can actually use it. ![memory-ingest-eg](https://github.com/user-attachments/assets/1d0a8007-153a-4842-9586-f6f4de43e647) ### How CORE recalls from memory memory-search-diagram

When you ask CORE a question, it doesn’t just look up text - it digs into your whole knowledge graph to find the most useful answers. 1. **Search**: CORE looks through memory from multiple angles at once - keyword search for exact matches, semantic search for related ideas even if phrased differently, and graph traversal to follow links between connected concepts. 2. **Re-Rank**: The retrieved results are reordered to highlight the most relevant and diverse ones, ensuring you don’t just see obvious matches but also deeper connections. 3. **Filtering**: CORE applies smart filters based on time, reliability, and relationship strength, so only the most meaningful knowledge surfaces. 4. **Output**: You get back both facts (clear statements) and episodes (the original context they came from), so recall is always grounded in context, time, and story. The result: CORE doesn’t just recall facts - it recalls them in the right context, time, and story, so agents can respond the way you would remember. --- ## 🛠️ For Agent Builders Building AI agents? CORE gives you memory infrastructure + integrations infrastructure so you can focus on your agent's logic. ### What You Get **Memory Infrastructure** - Temporal knowledge graph with 88.24% LoCoMo accuracy - Hybrid search: semantic + keyword + graph traversal - Tracks context evolution and contradictions **Integrations Infrastructure** - Connect GitHub, Linear, Slack, Gmail once - Your agent gets MCP tools for all connected apps - No OAuth flows to build, no API maintenance ### Examples **[core-cli](https://github.com/RedPlanetHQ/core-cli)** — A task manager agent that connects to CORE for memory and syncs with Linear, GitHub Issues. **[holo](https://github.com/RedPlanetHQ/holo)** — Turn your CORE memory into a personal website with chat. ### Get Started - [API Reference](https://docs.getcore.me/api-reference) - [SDK Documentation](https://docs.getcore.me) - Need a specific integration? [Open a GitHub issue](https://github.com/RedPlanetHQ/core/issues) --- ## 🔥 Research Highlights CORE memory achieves **88.24%** average accuracy in Locomo dataset across all reasoning tasks, significantly outperforming other memory providers. Check out this [blog](https://blog.heysol.ai/core-build-memory-knowledge-graph-for-individuals-and-achieved-sota-on-locomo-benchmark/) for more info.

(1) Single-hop questions require answers based on a single session; (2) Multi-hop questions require synthesizing information from multiple different sessions; (3) Open-domain knowledge questions can be answered by integrating a speaker’s provided information with external knowledge such as commonsense or world facts; (4) Temporal reasoning questions can be answered through temporal reasoning and capturing time-related data cues within the conversation; --- ## Documentation Explore our documentation to get the most out of CORE - [Self Hosting](https://docs.getcore.me/self-hosting/overview) - [Basic Concepts](https://docs.getcore.me/overview) - [Memory Graph](https://docs.getcore.me/concepts/memory_graph) - [API Reference](https://docs.getcore.me/api-reference/get-user-profile) ## 🔒 Security CORE takes security seriously. We implement industry-standard security practices to protect your data: - **Data Encryption**: All data in transit (TLS 1.3) and at rest (AES-256) - **Authentication**: OAuth 2.0 and magic link authentication - **Access Control**: Workspace-based isolation and role-based permissions - **Vulnerability Reporting**: Please report security issues to harshith@poozle.dev For detailed security information, see our [Security Policy](SECURITY.md). ## 🧑‍💻 Support Have questions or feedback? We're here to help: - Discord: [Join core-support channel](https://discord.gg/YGUZcvDjUa) - Documentation: [docs.getcore.me](https://docs.getcore.me) - Email: manik@poozle.dev ## Usage Guidelines **Store:** - Conversation history - User preferences - Task context - Reference materials **Don't Store:** - Sensitive data (PII) - Credentials - System logs - Temporary data ## 👥 Contributors