Skip to content

RedPlanetHQ/core

BranchesTags

Repository files navigation

CORE logo

CORE: Memory + Actions for Your AI Tools

Add to Cursor Deploy on Railway

Website Docs Discord

❌ 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.

Create/Read GitHub, Linear issues from claude
Draft/Send/Read an email and store relevant info in CORE from claude
Manage your calendar, update spreadsheet from claude

actions

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.

Search core memory for architecture decisions on the payment service
What my content guidelines from core to create the blog?

core_as_memory

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.

What did we discuss about the checkout flow? Summarize from memory.
Refer to past discussions and remind me where we left off on the API refactor

claude-code-in-core

🚀 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
  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

Or with Docker

  1. Clone the repository:
git clone https://github.com/RedPlanetHQ/core.git
cd core
  1. Configure environment variables in core/.env:
OPENAI_API_KEY=your_openai_api_key
  1. 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

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:
claude mcp add --transport http --scope user core-memory https://mcp.getcore.me/api/v1/mcp?source=Claude-Code
  1. Type /mcp and open core-memory MCP for authentication
Install in Codex CLI

Option 1 (Recommended): Add to your ~/.codex/config.toml file:

[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:

[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 → Settings → API Key, then run: codex mcp memory login

Install in Gemini CLI

See Gemini CLI Configuration 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:
{
  "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:

{
  "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

OR

  1. Go to: Settings -> Tools & Integrations -> Add Custom MCP
  2. Enter the below in mcp.json file:
{
  "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:

{
  "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:

{
  "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:

{
  "mcpServers": {
    "core-memory": {
      "serverUrl": "https://mcp.getcore.me/api/v1/mcp/source=windsurf",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
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
{
  "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:

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:

{
  "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:
{
  "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:
{
  "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:

{
  "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 for details.

Add to ~/.qwen/settings.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:

{
  "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:

{
  "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:

{
  "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:
{
  "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:

{
  "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:

{
  "$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
  1. Navigate to Settings → Connectors → Click Add custom connector
  2. 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
  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
  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:
{
  "core-memory": {
    "command": "npx",
    "args": ["-y", "mcp-remote", "https://mcp.getcore.me/api/v1/mcp?source=perplexity"]
  }
}
  1. Click Save to apply the changes
  2. Core will be available in your Perplexity sessions

Development Tools

Install in Factory

Run in terminal:

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:
acli rovodev mcp
  1. Add to your Rovo Dev MCP configuration:
{
  "mcpServers": {
    "core-memory": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Rovo-Dev"
    }
  }
}
Install in Trae

Add to your Trae MCP configuration:

{
  "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

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 — A task manager agent that connects to CORE for memory and syncs with Linear, GitHub Issues.

holo — Turn your CORE memory into a personal website with chat.

Get Started

🔥 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 for more info.

benchmark (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

🔒 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 [email protected]

For detailed security information, see our Security Policy.

🧑‍💻 Support

Have questions or feedback? We're here to help:

Usage Guidelines

Store:

  • Conversation history
  • User preferences
  • Task context
  • Reference materials

Don't Store:

  • Sensitive data (PII)
  • Credentials
  • System logs
  • Temporary data

👥 Contributors

About

Build your personal memory system to power your AI apps.

getcore.me

Topics

nodejs redis typescript postgresql remix neo4j-graph prisma tailwind-css

Resources

Readme

License

View license

Security policy

Security policy
Activity
Custom properties

Stars

1.1k stars

Watchers

7 watching

Forks

105 forks
Report repository

Releases 34

0.1.33 Latest
Dec 9, 2025
+ 33 releases

Packages

No packages published

Contributors 11

Languages