Studiomeyer Memory

SSE

by studiomeyer-io

4 201 downloads Not rated yet MIT

GitHub Website

About

AI memory server with 56 tools. Knowledge Graph, semantic search, session tracking, multi-agent support. Free tier available.

Details

Transport: SSE
License: MIT

Explore

- TypeScript: npm install @studiomeyer/memory-sdk (GitHub)
- Python: pip install nex-memory (GitHub)
- OpenAPI Spec: openapi.yaml — generate clients for any language
- Duplicate detection — 5-factor admission control prevents noise
- 10 learning categories — pattern, mistake, insight, research, architecture, and more

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Studiomeyer Memory

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

From the repository

The README includes setup instructions such as npx mcp-remote https://memory.studiomeyer.io/mcp.

`nex_guide`

IMPORTANT: Call this tool on first use to learn how StudioMeyer Memory works. Returns the onboarding guide that teaches you all 50+ tools. Call with topic="quickstart" for new users, or a specific topic for help. Topics: quickstart (start here), session, search, entities, learn, import, analytics, maintenance, tips, all.

`nex_session_start`

Start a new session. Call this FIRST in every conversation. Returns context from previous sessions. ⚠ If response includes isFirstTimeUser:true or onboardingHint, you MUST call nex_guide("quickstart") + nex_guide("autopilot") before responding to the user — they are a brand-new Memory user and need onboarding plus hook-setup explained proactively. Follow up with nex_proactive for smart suggestions. For usage help: nex_guide(topic).

`nex_session_end`

End the current session. Logs a summary and completed tasks. Without args: closes the active auto-session. With sessionId+summary: closes specific session.

`nex_decide`

Log or delete a decision. Default action: create. Use action="delete" with id to remove a decision permanently.

`nex_learn`

Store a learning with built-in duplicate prevention. Gatekeeper checks for similar existing learnings: >95% = SKIP (duplicate), >90% = UPDATE existing, <90% = ADD new. Categories: pattern (recurring success), mistake (what went wrong), insight (strategic realization), research (external knowledge), architecture, infrastructure, tool, workflow, performance, security. Searchable via full-text + trigram + semantic.

`nex_recall`

Quick full-text search across decisions + learnings + sessions. Lightweight alternative to nex_search (no RRF ranking, no semantic, no entity search). Use nex_search for precision, nex_recall for speed. Without query: returns most recent memories (time-ordered).

`nex_sprint`

Read or update the active sprint. Use action "read" for status overview. To update, provide new content.

`nex_improve`

Self-improvement analysis + memory consolidation + embedding backfill. Actions: analyze (default), consolidate, backfill-embeddings.

`nex_export`

Export all StudioMeyer Memory knowledge as structured text or Markdown file. format=markdown generates a human-readable, editable Markdown document with Knowledge Graph, Learnings, Decisions, Skills, Sessions.

`nex_context`

Load rich session context (auto-context primer). Returns: recent session summaries, active sprint, decisions, learnings, relevant skills, evolution status. Use at session start for seamless continuity.

`nex_summarize`

PERSIST a session summary (NOT a text summarizer). Saves structured metadata (topics, decisions, learnings, mood) so the next session has continuity. Call at session end alongside nex_session_end.

`nex_skill`

Track, recall, or find recipe for skills — what tools/patterns work for what tasks. Use "track" to log successful patterns, "recall" to find what works for a domain, "search" to fuzzy-find, "recipe" to get best tool-chain for a task.

`nex_evolve`

Log a self-improvement. When I change my behavior, learn a better approach, or fix a recurring mistake — track it here. This builds my evolution history.

`nex_evolve_status`

Analyze my self-improvement history. Shows: total improvements, verified vs unverified, improvements by category, suggestions for areas to focus on.

`nex_link`

Link two decisions together to build a decision graph. Shows how decisions relate: led_to, replaced, depends_on, contradicts, extends, caused_by.

`nex_search`

Unified search with temporal decay across ALL knowledge (decisions, learnings, sessions, skills, evolution, entity observations). Uses trigram + full-text + LIKE. Recent memories rank higher. Finds "das Ding mit SSL" even if stored as "certbot renewal". Supports question-conditioned retrieval: episodic queries ("was ist passiert?") auto-filter episodic memories, semantic queries ("wie funktioniert X?") auto-filter semantic facts.

`nex_entity_create`

Create entities in the knowledge graph WITH their facts in ONE call. Use this to register people, projects, systems, tools etc. BEST PRACTICE: always pass `observations` array — skipping it leaves the entity empty and causes the "0 observations on entity" anti-pattern (facts scattered across learnings instead of on the entity itself). Auto-dedupes: exact name+type match, alias match, suffix-pattern ("X (Y)" merged into existing "X" as alias), trigram similarity warning. Idempotent.

`nex_entity_observe`

Add observations (facts) to entities. Deduplicates automatically — if a similar observation exists (>50% trigram similarity), it is skipped. Use this to record facts about people, projects, systems, etc.

`nex_entity_relate`

Create relations (edges) between entities in the knowledge graph. Supports bi-temporal validity (valid_from/valid_to), causal relation types (causes, led_to, prevented, triggered, etc.), and evidence/metadata. Idempotent — duplicate active relations are skipped.

`nex_entity_open`

Open specific entities with ALL their observations and relations. This is the primary way to load context about known objects. Supports fuzzy name matching. Accepts "name" (string) or "names" (array).

`nex_entity_search`

Search the knowledge graph by entity names or observation content. Uses trigram fuzzy matching + full-text search (German + English). Finds "das mit SSL" even if stored as "Certbot renewal".

`nex_entity_deep_search`

Graph-Traversal search — find an entity and follow relations up to N hops deep. Supports causal mode to trace cause→effect chains (only follows causal relation types like "causes", "led_to", "prevented"). Example: "Halim" with depth 2 returns Halim → project → server.

`nex_entity_history`

Bi-temporal timeline — see ALL changes to an entity over time, including invalidated facts. Shows what changed, when it changed, and what replaced it. Like git log for entity knowledge.

`nex_entity_invalidate`

Soft-delete an observation — marks it as no longer valid (sets valid_to timestamp) instead of deleting. Preserves history. Optionally creates a replacement observation.

`nex_entity_graph`

Read the knowledge graph overview: entities with observation counts, relations, and statistics. Supports temporal queries (asOf), causal mode (mode=causal), and focused subgraph via entityId+depth.

`nex_entity_delete`

Delete entities, observations, or relations from the knowledge graph. Use with care — cascade deletes remove all connected data. Accepts entityNames (fuzzy matched) as alternative to entityIds.

`nex_entity_merge`

Merge two duplicate entities: moves all observations + relations from source → target. Source name becomes an alias on target, source entity is deleted. Use when nex_entity_create warns about duplicates, or to clean up the knowledge graph.

`nex_synthesize`

Generate GUIDES from learning clusters (NOT a text summarizer). Groups learnings by category, then creates synthesis documents. Different from nex_summarize (session persistence) and nex_consolidate (dedup/merge). Actions: generate (create/refresh syntheses), list (show all guides), search (find by topic).

`nex_learn_link`

Connect two learnings that together produce a new insight (A + B = C). Creates emergent knowledge from combinations. Actions: link (connect two learnings), links (get links for a learning), search (find linked insights).

`nex_learn_search`

Usage-weighted learning search. Combines text relevance + trigram similarity + usage frequency. More-used learnings rank higher. Pass query="" (or omit) to list top-used learnings — combine with verified:false to find the unverified backlog. SIDE EFFECT: by default every call increments usageCount on returned rows and auto-verifies them when usageCount reaches 3 AND confidence >= 0.8 (threshold strictly above nex_learn default 0.7, so auto-verify requires an explicit confidence boost). Pass t…

`nex_learn_stats`

Learning Intelligence stats: total learnings, syntheses, links, top-used learnings, syntheses by topic.

`nex_learn_update`

Update an existing learning. Change content, category, tags, confidence, project, source, or verified status. Regenerates search index when content changes. Cannot update archived learnings.

`nex_learn_archive`

Archive or unarchive learnings (soft-delete, reversible). Archived learnings are hidden from all searches. Supports single (id) or bulk (ids[]) operations. Actions: archive (hide), unarchive (restore), list (show archived).

`nex_registry`

Central registry for ALL tools, generators, MCP servers, services, and output types. Search instantly instead of browsing files. Default action="stats". Actions: register (add/update entry), search (fuzzy find), list (by category/tags), info (full detail), stats (overview).

`nex_delegate`

Delegate tasks to agents or manage existing tasks. Actions: create (new task), update (change status/result), list (show tasks), search (find tasks), stats (overview). Agents: aklow-ceo, marketing, ops, support, researcher.

`nex_goal`

Track business goals with measurable targets. Default action="stats". Actions: create (new goal), measure (add measurement), update (change status), list (show goals), detail (goal with trajectory), stats (overview).

`nex_health`

Run a system health check. Checks DB connectivity, orphaned sessions, stale learnings, overdue tasks, goals behind schedule, contradictions, decay stats. Returns status (ok/warning/critical), checks, stats, and warnings.

`nex_communities`

Detect communities (connected clusters) in the Knowledge Graph. Returns entity clusters with optional AI-generated labels. Use to understand how entities are connected. Default action="detect".

`nex_contradictions`

View and manage contradictions in Knowledge Graph AND potential duplicates/conflicts in Learnings. Default action="stats" (safe overview). Entity actions: list, pending, resolve, stats. Learning actions: scan_learnings (finds SIMILAR learnings via embedding cosine similarity — high similarity means same topic, which may be duplicates, agreements, or subtle conflicts — NOT guaranteed logical contradictions, review pairs manually), list_learnings (show found pairs), resolve_learning (mark as: m…

`nex_decay`

Manage confidence decay, importance scores, and lifecycle states. Default action="stats" (safe, read-only). Actions: run (process decay + importance + lifecycle), stats (show health), boost (manually boost confidence), lifecycle (show/process lifecycle state distribution).

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "studiomeyer memory": {
            "studiomeyer-memory": {
                "command": "npx",
                "args": [
                    "mcp-remote",
                    "https://memory.studiomeyer.io/mcp"
                ]
            }
        }
    }
}

McpServers

{
    "studiomeyer-memory": {
        "command": "npx",
        "args": [
            "mcp-remote",
            "https://memory.studiomeyer.io/mcp"
        ]
    }
}

> Persistent, intelligent memory for AI agents. 56 MCP tools (incl. interactive 3D knowledge graph visualization). Knowledge Graph included in every plan.

A note from us

We have been building tools and systems for ourselves for the past two years. The fact that this repo is small and has few stars is not because it is new. It is because we only just decided to share what we have built. It is not a fresh experiment, it is a long story with a recent commit.

We love building things and sharing them. We do not love social media tactics, growth hacks, or chasing stars and followers. So this repo is small. The code is real, it gets used, issues get answered. Judge for yourself.

If it helps you, sharing, testing, and feedback help us. If it could be better, an issue is more useful. If you build something with it, tell us at [email protected]. That genuinely makes our day.

From a small studio in Palma de Mallorca.

What is this?

StudioMeyer Memory gives AI agents persistent memory across sessions. Instead of starting fresh every conversation, your agents learn, remember, and improve over time.

56 MCP tools for learning, search, knowledge graph, session tracking, multi-agent support, contradiction detection, self-improvement — plus interactive 3D visualization (nex_graph_view, nex_recall_timeline, nex_session_replay) via MCP Apps.

Connect in 10 Seconds

Claude Desktop / Cowork

Settings → Connectors → Add URL:

https://memory.studiomeyer.io/mcp

Claude Code

claude mcp add --transport http memory https://memory.studiomeyer.io/mcp

Cursor / VS Code / Windsurf / Zed

npx mcp-remote https://memory.studiomeyer.io/mcp

MCPize

npx mcp-remote https://studiomeyer-memory.mcpize.run

REST API

For custom agents, scripts, and integrations:

```bash

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Explore

Setting up with Highlight

From the repository

nex_guide

nex_session_start

nex_session_end

nex_decide

nex_learn

nex_recall

nex_sprint

nex_improve

nex_export

nex_context

nex_summarize

nex_skill

nex_evolve

nex_evolve_status

nex_link

nex_search

nex_entity_create

nex_entity_observe

nex_entity_relate

nex_entity_open

nex_entity_search

nex_entity_deep_search

nex_entity_history

nex_entity_invalidate

nex_entity_graph

nex_entity_delete

nex_entity_merge

nex_synthesize

nex_learn_link

nex_learn_search

nex_learn_stats

nex_learn_update

nex_learn_archive

nex_registry

nex_delegate

nex_goal

nex_health

nex_communities

nex_contradictions

nex_decay

Claude Desktop / Cursor

McpServers

A note from us

What is this?

Connect in 10 Seconds

Claude Desktop / Cowork

Claude Code

Cursor / VS Code / Windsurf / Zed

MCPize

REST API

More like this

@mendableai/firecrawl Mcp Server

Playwright

Sequential Thinking

Aws Kb Retrieval Server

`nex_guide`

`nex_session_start`

`nex_session_end`

`nex_decide`

`nex_learn`

`nex_recall`

`nex_sprint`

`nex_improve`

`nex_export`

`nex_context`

`nex_summarize`

`nex_skill`

`nex_evolve`

`nex_evolve_status`

`nex_link`

`nex_search`

`nex_entity_create`

`nex_entity_observe`

`nex_entity_relate`

`nex_entity_open`

`nex_entity_search`

`nex_entity_deep_search`

`nex_entity_history`

`nex_entity_invalidate`

`nex_entity_graph`

`nex_entity_delete`

`nex_entity_merge`

`nex_synthesize`

`nex_learn_link`

`nex_learn_search`

`nex_learn_stats`

`nex_learn_update`

`nex_learn_archive`

`nex_registry`

`nex_delegate`

`nex_goal`

`nex_health`

`nex_communities`

`nex_contradictions`

`nex_decay`