doobidoo/mcp-memory-service

Review signals: 1 connection review, 2 download and execute, 1 encoded blob, 29 hardcoded secret, 11 known vulnerability, 1 outside write. 3 static matches retained as context.

Repository processes attempted these non-loopback connections; proxies can hide the final hostname. 18 distinct locations. 5 attributed processes.

Source contains download and execute; review its purpose. 2 distinct locations. 2 findings.

Source contains encoded blob; review its purpose. site/demo/assets/sqlite3.wasm

Gitleaks found a possible hardcoded secret; value withheld. 15 distinct locations. 29 findings.

OSV reports a known vulnerability in this dependency version. 4 distinct locations. 10 findings.

Repository processes attempted these writes outside documented output/cache paths. 2 distinct locations. 1 attributed processes.

PID 3776: <guest-path> · memory

3 hardcoded secret matches retained as context; full list in the evidence.

OSV scanned supported lockfiles; unpinned dependencies and unsupported formats are outside this check.

A short run cannot establish that code is safe.

Connections show IP addresses; proxies can hide the final hostname.

Tracing covers dispatched commands and their children, not the whole OS; guest root can interfere with tracing.

Full safety evidence →

• Persistent memory: memories stored in one session can be retrieved later through the MCP server: Real input produced the expected result: the blue heron guards the north gate

  Source: Keep decisions, notes, and project context across sessions and agents.

  Input: {"tool": "memory_search", "arguments": {"query": "blue heron north gate"}}

  Expected: stored memory returned

  Command: <guest-path> server tools/call {"tool": "memory_search", "arguments": {"query": "blue heron north gate"}}

  Observed: the blue heron guards the north gate\n Hash: 68f94fe7bd77ff403d348a5f68be2b932516ea19a3788eec889889a38e4d8fe4\n Created: 2026-10-24T02:01:32.081062Z [untagged]"}], "isError": false}

Examples

• Quickstart: run the MCP server with the documented command and exercise a real tool: Covered by the probe and claim (memory server over stdio, memory_store then memory_search). The repository pytest suite was not run; no other runnable README example was executed.

  Source: README.md

  Expected: documented command completes successfully

  Observed: Covered by the probe and claim (memory server over stdio, memory_store then memory_search). The repository pytest suite was not run; no other runnable README example was executed.

Local or hosted: both

Store and retrieve a memory through the MCP stdio server (memory server) using memory_store and memory_search

cd <guest-path> && pwd && ls -la && id -u && python3 --version && cat README.md | head -200
cd <guest-path> && git status 2>&1 | head -3; ls /inputs 2>&1; ls <guest-path> 2>&1
cd <guest-path> && git init -q && git remote add origin https://github.com/doobidoo/mcp-memory-service && git fetch --depth 1 origin 441e0ee1a17be3d51cf12a2d7d2a936cee69aded 2>&1 | tail -3; git reset --mixed FETCH_HEAD 2>&1; git log --oneline -1; grep -n "requires-python\|^name\|^version" pyproject.toml | head; sed -n 200,400p README.md | grep -n "memory \|pip install\|^#" | head -80
cd /tmp && (python3 -m venv <guest-path> 2>&1 || (sudo apt-get update -qq && sudo apt-get install -y -qq python3-venv >/dev/null && python3 -m venv <guest-path>)) && <guest-path> install -q --upgrade pip 2>&1 | tail -2; <guest-path> install mcp-memory-service 2>&1 | tail -5; ls <guest-path> | grep -i memory
cd <guest-path> && sed -n 60,80p README.md; grep -n "memory_store\|retrieve_memory\|memory server\|memory store\|memory retrieve\|search_memory" README.md | head -30; <guest-path> --help 2>&1 | head -40
cd <guest-path> && grep -rn "name=\"store_memory\"\|\"store_memory\"\|name=\"retrieve_memory\"\|\"retrieve_memory\"\|\"search_by_tag\"" src | head; <guest-path> server --help 2>&1 | head -30; <guest-path> status 2>&1 | tail -15
mkdir -p <guest-path> && cat > <guest-path> <<'EOF'
import asyncio, json
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
async def main():
    p = StdioServerParameters(command="<guest-path>", args=["server"], cwd="/tmp")
    async with stdio_client(p) as (r, w):
        async with ClientSession(r, w) as s:
            await s.initialize()
            for t in (await s.list_tools()).tools:
                if t.name in ("store_memory","retrieve_memory","search_by_tag"):
                    print(t.name, json.dumps(t.inputSchema)[:400])
asyncio.run(main())
EOF
cd /tmp && timeout 120 <guest-path> -I <guest-path> 2>&1 | tail -20
cd /tmp && sed -i 's/if t.name in ("store_memory","retrieve_memory","search_by_tag"):/if True:/' <guest-path> && timeout 120 <guest-path> -I <guest-path> 2>/dev/null | cut -c1-300; echo rc=$?
cat > <guest-path> <<'EOF'
import asyncio, json, sys
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
async def main():
    p = StdioServerParameters(command="<guest-path>", args=["server"], cwd="/tmp")
    async with stdio_client(p) as (r, w):
        async with ClientSession(r, w) as s:
            await s.initialize()
            res = await s.call_tool("memory_store", {"content": "coldpass pin test: the blue heron guards the north gate"})
            print("STORE:", res.content[0].text[:600])
            res = await s.call_tool("memory_search", {"query": "blue heron north gate", "mode": "exact"})
            print("SEARCH:", res.content[0].text[:800])
asyncio.run(main())
EOF
cd /tmp && timeout 180 <guest-path> -I <guest-path> 2>/dev/null; echo rc=$?
cat > <guest-path> <<'EOF'
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
async def main():
    p = StdioServerParameters(command="<guest-path>", args=["server"], cwd="/tmp")
    async with stdio_client(p) as (r, w):
        async with ClientSession(r, w) as s:
            await s.initialize()
            print("STORE:", (await s.call_tool("memory_store", {"content": "coldpass pin test: the blue heron guards the north gate"})).content[0].text[:200])
            print("SEARCH-default:", (await s.call_tool("memory_search", {"query": "blue heron north gate"})).content[0].text[:500])
            print("LIST:", (await s.call_tool("memory_list", {})).content[0].text[:500])
asyncio.run(main())
EOF
cd /tmp && timeout 180 <guest-path> -I <guest-path> 2>/dev/null; echo rc=$?; <guest-path> info 2>/dev/null | head -5
cd /tmp && <guest-path> install -q 'mcp-memory-service[sqlite-ml]' 2>&1 | tail -5; echo rc=$?; <guest-path> info 2>/dev/null | grep -i "path\|database\|model\|Status" | head; env | grep -i "MCP_MEMORY\|MCP_" | head
cd /tmp && <guest-path> show onnxruntime sentence-transformers 2>/dev/null | grep -E "^(Name|Version)"; <guest-path> status 2>&1 | tail -12; ls -la ~/.local/share/mcp-memory* 2>/dev/null
rm -rf ~/.local/share/mcp-memory && cd /tmp && timeout 240 <guest-path> -I <guest-path> 2>/dev/null; echo rc=$?
cd <guest-path> && grep -n "Persistent memory\|Semantic and keyword\|ingest-document\|consolidat\|cron\|schedul\|--once\|--now" README.md | cut -c1-250; grep -rn "def _run_scheduler\|CronTrigger\|IntervalTrigger" src | head -5
cat > <guest-path> <<'EOF'
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
async def main():
    p = StdioServerParameters(command="<guest-path>", args=["server"], cwd="/tmp")
    async with stdio_client(p) as (r, w):
        async with ClientSession(r, w) as s:
            await s.initialize()
            print("RUN:", (await s.call_tool("memory_consolidate", {"action": "run", "time_horizon": "daily"})).content[0].text[:700])
            print("SEARCH:", (await s.call_tool("memory_search", {"query": "blue heron north gate"})).content[0].text[:300])
asyncio.run(main())
EOF
cd /tmp && timeout 240 <guest-path> -I <guest-path> 2>/dev/null; echo rc=$?
cd <guest-path> && grep -rn "Consolidation is disabled" src | head -3; grep -rn "CONSOLIDATION_ENABLED\|consolidation.*enabled" src/mcp_memory_service/config.py 2>/dev/null | head -5; grep -rln "CONSOLIDATION_ENABLED" src | head -3; grep -n "CONSOLIDATION" .env.example | head -10
cd /tmp && MCP_CONSOLIDATION_ENABLED=true timeout 300 <guest-path> -I <guest-path> 2>/dev/null; echo rc=$?
cd <guest-path> && sed -n 465,480p src/mcp_memory_service/server/handlers/consolidation.py; grep -rn "CONSOLIDATION_ENABLED" src | head -5
cd <guest-path> && grep -rn "^CONSOLIDATION_ENABLED\|CONSOLIDATION_ENABLED =" src | head; grep -rn "MCP_CONSOLIDATION_ENABLED" src/mcp_memory_service/config* 2>/dev/null | head -3; grep -rn "def _env_bool\|CONSOLIDATION_ENABLED" src/mcp_memory_service/consolidation/*.py | head -5
cd /tmp && sed -i 's/args=\["server"\], cwd="\/tmp")/args=["server"], cwd="\/tmp", env={"HOME": "<host-path>", "PATH": "\/usr\/bin:\/bin", "MCP_CONSOLIDATION_ENABLED": "true"})/' <guest-path> && grep -n StdioServerParameters <guest-path> | tail -1 && timeout 300 <guest-path> -I <guest-path> 2>/dev/null; echo rc=$?
echo HOME=$HOME; cd <guest-path> && grep -rn "Consolidation system not available" src | head -2; cd /tmp && <guest-path> -c "
import mcp_memory_service.consolidation as c; print('ok', c.__file__)" 2>&1 | tail -3; <guest-path> -c "import sklearn" 2>&1 | tail -1; ls -la ~/.local/share/mcp-memory 2>&1 | head -3
cd <guest-path> && sed -n 25,50p src/mcp_memory_service/server/handlers/consolidation.py
cd <guest-path> && sed -n '/optional-dependencies/,/^\[tool/p' pyproject.toml | head -60; grep -rn "consolidator = \|self.consolidator =" src | head -5
cd <guest-path> && grep -n "@router\.\(post\|get\)<email>(\"/api/memories\"\<email>(\"/memories\"\|router.post(\"/\"" src/mcp_memory_service/web/api/memories.py | head -3
cd <guest-path> && sed -n 70,122p src/mcp_memory_service/web/api/consolidation.py; grep -n "consolidation" src/mcp_memory_service/web/app.py | grep -i "include_router\|prefix" | head
cd /tmp && (HOME=<guest-path> MCP_ALLOW_ANONYMOUS_ACCESS=true MCP_CONSOLIDATION_ENABLED=true nohup <guest-path> server --http --http-port 8765 > <guest-path> 2>&1 &) ; sleep 25; curl -s -m 10 http://127.0.0.1:8765/api/health; echo; curl -s -m 10 http://127.0.0.1:8765/api/consolidation/status; echo; tail -3 <guest-path> | cut -c1-300
sleep 30; curl -s -m 10 -i http://127.0.0.1:8765/api/health | head -12; echo; curl -s -m 10 http://127.0.0.1:8765/api/consolidation/status | head -c 400; echo; tail -5 <guest-path> | cut -c1-300; pgrep -af "memory server" | head
curl -s -m 120 -X POST http://127.0.0.1:8765/api/consolidation/trigger -H 'Content-Type: application/json' -d '{"time_horizon":"daily"}'; echo; echo rc=$?; grep -i "consolidat\|scheduler" <guest-path> | tail -5 | cut -c1-250
pkill -f "memory server --http --http-port 8765"; sleep 3; (curl -s -m 5 http://127.0.0.1:8765/api/health || echo "port 8765 closed"); cd <guest-path> && mkdir -p .coldpass/.. && cat > .coldpass/probe.json <<'EOF'
{"kind":"mcp","argv":["<guest-path>","server"],"cwd":"<guest-path>","env":{"HOME":"<guest-path>"},"tool":"memory_search","arguments":{"query":"blue heron north gate"},"expected_text":"the blue heron guards the north gate"}
EOF
cat > .coldpass/claims.json <<'EOF'
[{"kind":"claim","claim":"Persistent memory: memories stored in one session can be retrieved later through the MCP server","source":"README.md","quote_source":"Keep decisions, notes, and project context across sessions and agents.","input":"blue heron north gate","expected":"stored memory returned","probe_kind":"mcp","argv":["<guest-path>","server"],"env":{"HOME":"<guest-path>"},"tool":"memory_search","arguments":{"query":"blue heron north gate"},"expected_text":"the blue heron guards the north gate","cwd":"<guest-path>"}]
EOF
cat > .coldpass/cycles.json <<'EOF'
{"detected":false,"reason":"Entry points inspected: src/mcp_memory_service/consolidation/scheduler.py uses APScheduler CronTrigger/IntervalTrigger, but in this guest the scheduler reported 'Scheduler not available' under `memory server --http` with MCP_CONSOLIDATION_ENABLED=true, and the stdio MCP server has no consolidator ('Consolidation system not available'). A manual cycle was triggered by hand via POST /api/consolidation/trigger ({\"time_horizon\":\"daily\"}) and returned status completed, processed 1. That manual HTTP trigger is not a product schedule and cannot be replayed as a cli check here.","checks":[]}
EOF
cat > .coldpass/examples.json <<'EOF'
[{"kind":"example","claim":"Quickstart example: run the MCP server with the documented command and exercise a real tool","source":"README.md","reason":"Covered by the probe and claim above (memory server over stdio, memory_store then memory_search). The repository's pytest suite was not run within this task; no other runnable README example was executed."}]
EOF
python3 -I -c "import json;[json.load(open('.coldpass/'+f)) for f in ['probe.json','claims.json','cycles.json','examples.json']];print('json ok')"
ps -eo pid,args | grep "[m]emory server --http" | grep -v "bash -c" | cut -c1-120; curl -s -m 5 http://127.0.0.1:8765/api/health || echo "port 8765 closed"
cd <guest-path> && mkdir -p .coldpass && cat > .coldpass/probe.json <<'EOF'
{"kind":"mcp","argv":["<guest-path>","server"],"cwd":"<guest-path>","env":{"HOME":"<guest-path>"},"tool":"memory_search","arguments":{"query":"blue heron north gate"},"expected_text":"the blue heron guards the north gate"}
EOF
cat > .coldpass/claims.json <<'EOF'
[{"kind":"claim","claim":"Persistent memory: memories stored in one session can be retrieved later through the MCP server","source":"Keep decisions, notes, and project context across sessions and agents.","input":"blue heron north gate","expected":"stored memory returned","probe_kind":"mcp","argv":["<guest-path>","server"],"env":{"HOME":"<guest-path>"},"tool":"memory_search","arguments":{"query":"blue heron north gate"},"expected_text":"the blue heron guards the north gate","cwd":"<guest-path>"}]
EOF
cat > .coldpass/cycles.json <<'EOF'
{"detected":false,"reason":"Entry points inspected: src/mcp_memory_service/consolidation/scheduler.py uses APScheduler CronTrigger/IntervalTrigger, but in this guest the scheduler reported 'Scheduler not available' under memory server --http with MCP_CONSOLIDATION_ENABLED=true, and the stdio MCP server has no consolidator ('Consolidation system not available'). A manual cycle was triggered by hand via POST /api/consolidation/trigger with time_horizon daily, which returned status completed, processed 1. That manual HTTP trigger is not a product schedule and cannot be replayed as a cli check here.","checks":[]}
EOF
cat > .coldpass/examples.json <<'EOF'
[{"kind":"example","claim":"Quickstart: run the MCP server with the documented command and exercise a real tool","source":"README.md","reason":"Covered by the probe and claim (memory server over stdio, memory_store then memory_search). The repository pytest suite was not run; no other runnable README example was executed."}]
EOF
python3 -I -c "import json;[json.load(open('.coldpass/'+f)) for f in ['probe.json','claims.json','cycles.json','examples.json']];print('json ok')"; grep -c "Keep decisions, notes, and project context across sessions and agents." README.md
cd <guest-path> && cat > .coldpass/report.json <<'EOF'
{"outcome":"working","fault_owner":"repo","operation":"Store and retrieve a memory through the MCP stdio server (memory server) using memory_store and memory_search","operation_scope":"Linux Ubuntu guest, Python 3.12.3, pinned commit 441e0ee, mcp-memory-service 12.3.1 in <guest-path>, SQLite-vec storage with ONNX all-MiniLM-L6-v2 embeddings, stdio transport, local only","steps":["git init; git remote add origin https://github.com/doobidoo/mcp-memory-service; git fetch --depth 1 origin 441e0ee1a17be3d51cf12a2d7d2a936cee69aded; git reset --mixed FETCH_HEAD","python3 -m venv <guest-path> (failed: ensurepip missing; installed python3-venv via sudo apt-get, then recreated venv)","<guest-path> install mcp-memory-service","<guest-path> install 'mcp-memory-service[sqlite-ml]'","<guest-path> server (MCP stdio) -> memory_store, memory_search","<guest-path> server --http --http-port 8765 with MCP_ALLOW_ANONYMOUS_ACCESS=true MCP_CONSOLIDATION_ENABLED=true; GET /api/health; POST /api/consolidation/trigger"],"deviations":["Base pip install mcp-memory-service alone stored a memory with hash pseudo-embeddings, then refused all later reads and writes with 'refusing to write hash pseudo-vectors'; fixed by installing the documented extra mcp-memory-service[sqlite-ml] (onnxruntime and tokenizers). I deleted the test database I had created (~/.local/share/mcp-memory under HOME=<guest-path>) to get a clean state.","python3 -m venv failed on missing ensurepip; installed python3-venv with sudo apt-get and recreated the venv.","Consolidation through the stdio MCP server returns 'Consolidation system not available' (no consolidator). The HTTP server's scheduler reported 'Scheduler not available', so the cycle was triggered manually via POST /api/consolidation/trigger rather than by a scheduler.","Did not run the repository pytest suite or the interactive install.py; did not install the ML extra or torch."],"stuck_step":null,"main_blocker":null,"plain_failure":"On a plain install from the README (pip install mcp-memory-service), the first save succeeds but the service then refuses every later read and write, because it has no real embedding model. Installing the documented sqlite-ml extra fixes it. Also, the background consolidation scheduler did not start in this guest, so the cycle was triggered by hand.","suggested_fix":"Make the README quickstart install the sqlite-ml extra (pip install 'mcp-memory-service[sqlite-ml]'), or fail at install time instead of allowing a first write that poisons the database. Also check why the consolidation scheduler reports 'Scheduler not available' when MCP_CONSOLIDATION_ENABLED=true."}
EOF
python3 -I -c "import json;json.load(open('.coldpass/report.json'));print('report ok')"; <env-var>=<guest-path> python3 -I <guest-path> --validate --replay 2>&1 | tail -40