memro
OfficialConnects GitHub Copilot to Memro via MCP, enabling shared long-term memory of project context and preferences across sessions and AI tools.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Memro — Verified Memory Infrastructure for AI Agents
One long-term memory for all your AI tools. Claude Code, Cursor, Codex, GitHub Copilot and any MCP client remember your decisions, preferences and project context across sessions. Tell one tool once, and they all know.
npx memro-cli connect # sign in and add Memro to the AI tools on this machine
npx memro-cli doctor # check which config each tool really uses, and that the key works⭐ If Memro saves you from re-explaining your project, a star helps other developers find it.
License (Source Available)
Memro is licensed under the PolyForm Noncommercial License 1.0.0.
Free for Non-Commercial Use: Personal study, experiments, hobby projects, research, and testing without commercial application.
Commercial Use: Using Memro for commercial products or production services requires a managed subscription on Memro Cloud or an enterprise commercial license.
How to Get a Commercial License: Visit memro.co/pricing or contact
subal@memro.co.
Repository Notice:
github.com/memrohq/memrois the single public repository for Memro. It contains the Go server, official SDKs (Python, JavaScript/TypeScript, Go), Model Context Protocol (MCP) server, and the CLI.
Claude Code plugin
/plugin install memro --marketplace memrohq/memroAdds Memro's MCP server and recalls the project's memory at the start of every session. See integrations/claude-code.
Related MCP server: contextforge-mcp
Quickstart
Option A: Memro Cloud with Claude Code, Cursor, or Codex (< 10 lines)
# 1. Connect installed agent tools via device login:
npx memro-cli connect
# 2. Check connection status:
npx memro-cli statusIn your assistant, say: "Remember that our primary database is PostgreSQL 16 with pgvector."
Restart your session and ask: "What database and extensions do we use?"
Option B: Self-Host with Docker Compose (Source Available)
Run the full Memro API server and PostgreSQL with pgvector on your own infrastructure:
Option 1: Clone the repository (works today)
git clone https://github.com/memrohq/memro && cd memro
cp .env.example .env # add OPENAI_API_KEY for hybrid search; set METRICS_TOKEN
docker compose up -d # API on :8081, dashboard on :5173, Postgres on 127.0.0.1:55432
curl http://localhost:8081/healthOption 2: Prebuilt images (no clone required, after v0.1.0 release)
curl -fsSL https://raw.githubusercontent.com/memrohq/memro/v0.1.0/docker-compose.release.yml -o docker-compose.yml && docker compose up -d
curl http://localhost:8081/health(Note: The prebuilt image one-liner downloads docker-compose.release.yml with pinned ghcr.io/memrohq/memro:0.1.0 and ghcr.io/memrohq/memro-dashboard:0.1.0 images, available once v0.1.0 is published.)
Backend API:
http://localhost:8081Dashboard:
http://localhost:5173Postgres Database: Port
55432on localhost (Option 1 clone) to avoid port 5432 collisions with existing local Postgres setups.Metrics Token: Set
METRICS_TOKEN(min 32 characters) in.envto protectGET /metricsandGET /stats/cache; the server logs a warning if unset.Verify Signatures: Verify published container images keylessly using Cosign:
cosign verify ghcr.io/memrohq/memro:0.1.0 \ --certificate-identity-regexp 'https://github.com/memrohq/memro/' \ --certificate-oidc-issuer https://token.actions.githubusercontent.com
For complete deployment options, production topologies, and configuration tables, see docs/self-hosting.md.
Architecture
┌──────────────────────────────────────┐
│ Clients & MCP Tools │
│ Claude Code · Cursor · Codex · SDKs│
└──────────────────┬───────────────────┘
│ HTTP REST / Stdio MCP
┌──────────────────▼───────────────────┐
│ Memro API (Go) │
│ Sovereign Ed25519 Identity · RRF │
└──────────────────┬───────────────────┘
│ SQL & Embeddings
┌──────────────────▼───────────────────┐
│ PostgreSQL 16 + pgvector │
│ pgvector Dense Search + tsvector FTS│
└──────────────────────────────────────┘Memro runs a Go HTTP API backed by PostgreSQL and pgvector. Search queries combine vector cosine similarity and full-text keyword search using Reciprocal Rank Fusion (RRF, $k=60$). Agents authenticate using sovereign Ed25519 keypairs solved via local proof-of-work (private keys never leave the host) or standard Bearer API tokens.
Repository Layout
memrohq/memro holds all components in one mono-repository:
Path | Description | Documentation |
Go API server, PostgreSQL + pgvector engine | ||
One-command connector ( | ||
Model Context Protocol server (stdio & SSE HTTP) | ||
Official Python SDK (PyPI: | ||
Official JavaScript / TypeScript SDK (npm: | ||
Official Go SDK ( | ||
Runnable integrations (Claude Code, Cursor, Codex) | ||
Reproducible benchmark harness and test suites | ||
Architecture, concepts, API reference, decisions |
Official SDKs & Runnable Examples
Python (sdk/python)
# PyPI (once published) or install from source: pip install ./sdk/python
pip install memrofrom memro import Agent
agent = Agent.create() # local sovereign Ed25519 identity
mem = agent.remember("The billing service was rewritten in Go", type="semantic")
results = agent.recall("billing service language")
print(results[0].content)See runnable script at examples/python/register_remember_recall.py.
JavaScript / TypeScript (sdk/js)
# npm (once published) or install from local build: npm install ./sdk/js
npm install @memro/sdkimport { Agent } from '@memro/sdk';
const agent = await Agent.create(); // local sovereign Ed25519 identity
const mem = await agent.remember('The billing service was rewritten in Go', { type: 'semantic' });
const results = await agent.recall('billing service language');
console.log(results[0].content);See runnable script at examples/typescript/index.js.
Go (sdk/go)
go get github.com/memrohq/memro/sdk/go@v0.1.0package main
import (
"context"
"fmt"
memro "github.com/memrohq/memro/sdk/go"
)
func main() {
ctx := context.Background()
agent, _ := memro.CreateAgent(nil)
mem, _ := agent.Remember(ctx, "The billing service was rewritten in Go", nil)
results, _ := agent.Recall(ctx, "billing service language", nil)
fmt.Println(results[0].Content)
}See runnable script at examples/go/main.go.
Integration Guides
Step-by-step guides for connecting coding tools with full session-restart memory verification:
Advanced Memory Features
Memro includes structured primitives and cognitive graphs beyond basic vector search:
Typed Memories: Categorize observations as
semantic(facts),episodic(events/conversations),procedural(runbooks/recipes), orprofile(agent guardrails). See Memory Concepts.Temporal Search & Evolution: Query memories with timestamp weighting and trace how beliefs evolve over time. See API Reference.
Conflict Analysis & Resolution: Identify contradictory facts across sessions and mark superseded memories using
resolve_conflict(). See Conflict Resolution.Reasoning Graphs: Trace memory provenance, causal chains, and dependencies between stored observations. See Opinionated Guide.
Measurable Verification & Benchmarks
Memro publishes empirical evaluations and methodology:
LongMemEval Benchmark: Evaluated across 500 questions testing multi-session recall and knowledge updates. See LongMemEval Report.
Empirical Failure & Boundary Evaluations: Runnable test suite for identity boundaries, contradictory facts, stale facts, and distractor rejection. See Measurable Evaluations.
Clean-Machine Verification: Full transcript verifying every quickstart command in a container without local caches. See Verification Transcript.
Contributing & Development
# 1. Start PostgreSQL with pgvector
docker compose up -d db
# 2. Run backend API server
cd server
DATABASE_URL=postgres://memro:memro@localhost:55432/memro go run ./cmd/memro-api
# 3. Run tests
MEMRO_TEST_DATABASE_URL=postgres://memro:memro@localhost:55432/memro go test -race ./...Please review CONTRIBUTING.md and SECURITY.md before submitting pull requests.
Repository: github.com/memrohq/memro · Documentation: https://memro.co License: Source available under PolyForm Noncommercial 1.0.0. Free for non-commercial use; commercial use requires Memro Cloud or a commercial license.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Shared AI memory. ChatGPT, Claude, Cursor and any MCP app read and write the same memory.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Hosted MCP memory for coding agents: persistent across sessions, editable markdown, team sharing.
Related MCP Servers
- AlicenseAqualityCmaintenancePersistent cloud memory for AI coding assistants. 28 MCP tools for semantic search, auto-learning, task tracking, correction patterns, knowledge graphs, and session replay across Claude Code, Cursor, Windsurf, Cline, and any MCP client. Encrypted at rest. Team shared memory with author attribution.35236 npm7MIT
- AlicenseAqualityBmaintenancePersistent memory MCP server for Claude Code, Cursor, and GitHub Copilot. Semantic search, Git sync, project-based, Persistent memory MCP server for Claude Code, Cursor, and GitHub Copilot. Semantic search, Git sync, project-based organization, and team collaboration via Model Context Protocol.15342 npm2MIT
- FlicenseNot gradedqualityDmaintenancePersistent memory server for AI assistants with semantic search and three-layer context (global, project, personality). Works with MCP-compatible AI tools like Claude Code, Cursor, Continue, Cline, and more.1-
- AlicenseAqualityCmaintenanceShared, versioned memory for your agents across Claude Code, Cursor, Kiro and Grok. One MCP server, sourced answers, full history.3MIT