How do I use CogMemory MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@CogMemory MCP Server recall what we decided about the auth refactor" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

de en es ja ko ru zh

CogMemory MCP Server

by skylarng89

Overview Schema Related Servers Score Discussions

TypeScript

Local

CogMemory MCP Server

A unified Model Context Protocol server providing four context subsystems for AI coding agents:

Memory — decisions, conventions, errors, active context, changelog, plan, tasks, sessions
Knowledge Graph — entities, relations, observations
Specs — long-form documents (PRD/SRS), optionally linked to a KG entity
Code Graph — static structural graph (symbols/edges) + named execution traces + AI-generated annotations

Storage: SQLite via better-sqlite3. One .db file per scope.

Quick Start

Install

git clone <repo> && cd cogmemory-mcp
pnpm install
pnpm run build

Configure in VS Code

Add to .vscode/mcp.json (workspace-scoped):

{
  "servers": {
    "cogmemory": {
      "command": "node",
      "args": ["/absolute/path/to/cogmemory-mcp/dist/index.js"]
    }
  }
}

Or add to your user mcp.json for global availability.

Run with MCP Inspector (dev)

pnpm run inspect

Related MCP server: LumenCore

Scope Configuration

CogMemory resolves scope in priority order:

.cogmemory/config.json in workspace root:
```
{ "scope": "global" }
```
Environment variable: COGMEMORY_SCOPE=global
Default: workspace

Paths

Scope	Database Path
workspace	`<workspace_root>/.cogmemory/memory.db`
global	`~/.cogmemory/global.db`

Workspace Resolution & Multi-Root Support

CogMemory resolves the workspace root (where .cogmemory/memory.db lives) in this priority order:

--workspace <path> CLI argument (highest priority)
COGMEMORY_WORKSPACE environment variable
Walk up from CWD looking for the nearest parent containing a .cogmemory/ directory
Fallback to CWD

Multi-Root VS Code Workspaces

In a VS Code multi-root workspace, each folder is a separate workspace root. CogMemory handles this:

Single-root — Works automatically. VS Code sets CWD to the workspace folder, and --workspace is passed via mcp.json.
Multi-root — Each workspace folder can have its own .cogmemory/. Point each to CogMemory with different --workspace paths, or place a shared .cogmemory/ in a parent directory.

Recommended multi-root mcp.json (per-folder):

{
  "servers": {
    "cogmemory-frontend": {
      "command": "node",
      "args": [
        "/path/to/cogmemory-mcp/dist/index.js",
        "--workspace",
        "/path/to/frontend"
      ]
    },
    "cogmemory-backend": {
      "command": "node",
      "args": [
        "/path/to/cogmemory-mcp/dist/index.js",
        "--workspace",
        "/path/to/backend"
      ]
    }
  }
}

Or use a shared database (all roots in one place):

{
  "servers": {
    "cogmemory": {
      "command": "node",
      "args": [
        "/path/to/cogmemory-mcp/dist/index.js",
        "--workspace",
        "/shared/root"
      ]
    }
  }
}

Or use global scope to share across all workspaces:

{
  "servers": {
    "cogmemory": {
      "command": "node",
      "args": ["/path/to/cogmemory-mcp/dist/index.js"]
    }
  }
}

export COGMEMORY_SCOPE=global

Tool Reference

Memory Tools

Tool	Description
`start_session`	Begin a work session (returns session ID)
`end_session`	Close session, store summary
`get_session_summary`	Recall session details including decisions, errors, changelog
`remember_decision`	Log a decision with rationale and tags
`remember_convention`	Log/update a convention (design token, pattern, style, naming)
`log_error`	Record an error with signature and resolution
`set_active_context`	Upsert current focus/task by key
`get_active_context`	Read current focus by key
`log_change`	Append changelog entry
`add_plan_item`	Add a roadmap item
`update_plan_status`	Change plan item status
`create_task`	Create a task, optionally linked to a plan
`update_task_status`	Change task status
`recall`	Unified search across decisions/conventions/errors/changelog

Knowledge Graph Tools

Tool	Description
`create_entity`	Add entity (deduped on name+type)
`create_relation`	Link two entities with a typed relation
`add_observation`	Attach a fact to an entity
`search_knowledge`	Query entities, relations, observations

Specs Tools

Tool	Description
`create_spec`	Store a long-form document
`get_spec`	Retrieve by ID or exact title
`update_spec`	Update content/title, auto-bumps version

Code Graph Tools

Tool	Description
`index_codebase`	Walk workspace, extract symbols + edges via ts-morph (JS/TS)
`query_code_graph`	Look up a symbol's callers/callees/imports (1-hop)
`generate_codemap`	BFS from entry symbol, bounded subgraph with optional traces + annotations
`annotate_symbol`	Attach narrative text to a symbol or trace

Architecture

cogmemory-mcp/
├── src/
│   ├── index.ts                 # entry point, server bootstrap
│   ├── config.ts                # scope resolution, path resolution
│   ├── types.ts                 # shared TS types mirroring schema
│   ├── db/
│   │   ├── connection.ts        # DB open/close, pragma setup
│   │   ├── schema.sql           # full schema (reference)
│   │   └── migrate.ts           # idempotent schema application
│   ├── tools/
│   │   ├── memory.ts            # decisions/conventions/errors/context/changelog/recall
│   │   ├── plan-tasks.ts        # plan + tasks tools
│   │   ├── sessions.ts          # start/end session, summary
│   │   ├── knowledge-graph.ts   # entities/relations/observations
│   │   ├── specs.ts             # spec CRUD
│   │   ├── code-graph.ts        # index_codebase, query_code_graph
│   │   └── codemap.ts           # generate_codemap, annotate_symbol
│   └── indexing/
│       ├── ts-analyzer.ts       # ts-morph symbol/edge extraction
│       └── walker.ts            # file discovery, gitignore respect
├── schema.sql                   # reference copy
├── package.json
├── tsconfig.json
└── README.md

Schema (15 tables)

Memory (8): sessions, decisions, conventions, errors, context, changelog, plan, tasks
Knowledge Graph (3): entities, relations, observations
Specs (1): specs
Code Graph (4): symbols, edges, execution_traces, codemap_annotations

Pragmas

Set on every connection open:

PRAGMA journal_mode = WAL;
PRAGMA foreign_keys = ON;

Development

pnpm run dev        # Run with tsx (no build step)
pnpm run build      # Compile TypeScript
pnpm run start      # Run compiled output
pnpm run inspect    # Launch MCP Inspector
pnpm run smoke-test # Run smoke test script

License

MIT

This server cannot be installed

license - permissive license

Not graded

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

DevFlow MCP
Knowledge & Memory Developer Tools Autonomous Agents
Takin-Profit
A
license
Not graded
quality
D
maintenance
Provides AI agents with persistent, searchable memory using a knowledge graph stored in SQLite. Features semantic search, temporal awareness, and workflow-aware prompts for development projects.
Updated 10 months ago (2025-11-03 16:28 UTC)
13
MIT
LumenCore
Knowledge & Memory Developer Tools Autonomous Agents
arclightdynamics
A
license
Not graded
quality
C
maintenance
Provides AI coding assistants with persistent project memory to retain architectural decisions, code patterns, and domain knowledge across sessions. It stores data locally in a SQLite database, allowing agents to remember, recall, and manage project-specific context using full-text search.
Updated 2 months ago (2026-06-14 18:44 UTC)
8
Apache 2.0
Tages
Knowledge & Memory Developer Tools
ryantlee25-droid
A
license
Not graded
quality
A
maintenance
Enables AI coding agents to maintain persistent, cross-session memory of codebase architecture, naming conventions, and decisions through MCP tools. Eliminates repetitive project re-explanation by automatically injecting stored context into every session with local-first SQLite storage and optional team sharing capabilities.
Updated 5 days ago (2026-08-18 23:34 UTC)
4
MIT
Memory MCP
Knowledge & Memory Developer Tools
nerdyaustin
A
license
A
quality
B
maintenance
Provides persistent cross-session memory and full-text search for AI coding assistants, storing project context, decisions, and preferences while enabling searchable access to conversation history via local SQLite.
Updated 19 days ago (2026-08-04 18:57 UTC)
8
1
MIT

View all related MCP servers

Related MCP Connectors

Penfield Memory
Persistent memory and knowledge graphs for AI agents. Hybrid search, context checkpoints, and more.
AI Context Flow
Universal memory for AI agents and tools. Save, organize and search context anywhere.
Umtri
Give your AI agent a persistent map of your project's structure, dependencies, and bugs.

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/skylarng89/cogmemory-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

CogMemory MCP Server

Quick Start

Install

Configure in VS Code

Run with MCP Inspector (dev)

Scope Configuration

Paths

Workspace Resolution & Multi-Root Support

Multi-Root VS Code Workspaces

Tool Reference

Memory Tools

Knowledge Graph Tools

Specs Tools

Code Graph Tools

Architecture

Schema (15 tables)

Pragmas

Development

License

Maintenance

Resources

Looking for Admin?

Related MCP Servers

DevFlow MCP

LumenCore

Tages

Memory MCP

Related MCP Connectors

Latest Blog Posts

MCP directory API