Pmll Memory MCP

PPM — Python Package Manager

pypm packaging CLI with shared PMLL memory + Q-promise. Sibling: drQedwards/pmll.

Live Stellar pmll-anchor IDs: docs/STELLAR.md · skills: SKILL.md · promises: Q_promise_lib/README.md.

TL;DR: PPM packages Python (C CLI). Shared PMLL owns memory/state (memory_silo_t, exact peek + semantic peek_semantic,

SAT bridge, init_pml). Q-promise owns temporal/control-flow (qpromise_*, libqpromise.so)

— it does not replace the silo. Optional Stellar commitments hash off-chain

CodeworkPayloads into 32-byte digests via pmll-anchor (ABI: init/store/get/bump).

Companion packaging CLI + MCP memory server live in-tree.

PMLL provides durable structured memory for agent workflows, alongside a PPM packaging CLI (hermetic bundles, plugins, signing) and the PMLL Memory MCP server. Long-term graph tools adapt Context+.

---

Table of Contents

1. Layers (post-merge)
2. Features
3. Building from Source
4. CLI Commands
5. GPU & Security Features
6. Plugin System
7. Configuration
8. PMLL Memory MCP Server
9. Stellar commitments
10. Architecture
11. Release Notes
12. Roadmap
13. Contributing & Sponsors

---

---

Layers (post-merge)

Two complementary layers — not substitutes for each other:

Q-promise does not replace the silo. A promise may *reference* a memory key (and optional SAT state id); results are committed back with silo_set / qpromise_resolve_commit.

Intended loop

retrieve (peek / peek_semantic)

→ compute / request work → promise PENDING → resolve / reject (optionally resolve_commit → silo) → continuation (then / catch / finally via qpromise_drain) → memory update → retrieve again

Thread safety: the C Q-promise drain is single-threaded. Continuations run only during qpromise_drain() on the calling thread; callers must externally serialize access. Details: Q_promise_lib/README.md.

C core (PMLL)

Headers: PMLL.h · implementation: PMLL.c

Q-promise library

Build / test / API: [`Q_promise_lib/README.md`](Q_promise_lib/README.md) (authoritative). Public symbols are qpromise_*; shared object is libqpromise.so. The old prototype (QMemNode / q_mem_* / memory-chain walker) is removed; Q_promises.h is a compatibility include redirecting to qpromise.h.

✨ Features

*Road-mapped:* SAT dependency solver (the standalone SAT.c CDCL solver exists but is not yet used for resolution), parallel wheel cache, workspaces with single lockfile, WASM wheel resolution, Conda & Poetry import plugins.

---

🔧 Building from Source

System dependencies

• C11 compiler (gcc, clang, or MSVC)
• libcurl (plugin downloads)
• libdl (dynamic loading — standard on Linux / macOS)
• tar / libarchive (optional, for pypylock bundles)

Build & first run

git clone https://github.com/drQedwards/PPM.git

cd PPM cc -Wall -Wextra -ldl -lcurl -o pypm Ppm.c ./pypm doctor # Diagnose your dev box ./pypm sandbox # Spin up a throw-away REPL playground

Q-promise shared library

cd Q_promise_lib

make clean && make test make shared # → libqpromise.so cd ..

Optional: CUDA-accelerated build

nvcc -O3 CLI/CLI.cu -lcuda -o ppm-gpu

./ppm-gpu import transformers torch --verbose

---

🖥 CLI Commands

Import packages

# Import a single package

ppm import transformers

Import with a specific version

ppm import transformers==4.43.3

Import multiple packages

ppm import transformers torch numpy

Scan a Python file for imports and install them

ppm import --from-file my_script.py

Verbose — watch what's happening

ppm import transformers --verbose

🔍 Resolving transformers...

⬇️ Downloading transformers-4.43.3-py3-none-any.whl

🔐 GPU integrity check: PASSED

✅ transformers==4.43.3 imported successfully

Project initialization

ppm init

Creates:

.ppm/

├── ledger.jsonl ← append-only operation log

├── state.json ← current state

├── lock.json ← dependency lockfile

└── snapshots/ ← rollback points

Dependency resolution & locking

ppm add transformers torch==2.4.0 --lock

ppm plan

{ "plan": "install", "packages": { "transformers": "4.43.3", ... } }

ppm apply --note "Added ML stack"

Snapshot & rollback

ppm snapshot --name "before-upgrade"

ppm snapshots ppm rollback before-upgrade

Environment diagnostics

ppm doctor

✅ Python dev headers found

✅ C compiler available

✅ CUDA toolkit available

🏁 Diagnostics complete (0 issues found)

Sandbox

ppm sandbox                 # ephemeral temp directory

ppm sandbox -d /tmp/mydir # custom directory

Hermetic packaging

ppm pypylock -o production-env.tar.gz

---

🔐 GPU & Security Features

GPU-accelerated hash verification

ppm import torch --verbose

🚀 GPU hash verification: SHA-256 computed on device

✅ Integrity verified: e3b0c44298fc1c149afbf4c8996fb924...

GPU backend selection

ppm ensure transformers --gpu auto    # auto-detect CUDA

ppm ensure transformers --gpu cu121 # force CUDA 12.1 ppm ensure transformers --gpu cpu # CPU-only

Ed25519 cryptographic signing

ppm keygen --out-priv ed25519.priv --out-pub ed25519.pub

ppm sign --sk ed25519.priv --file torch-2.4.0-*.whl --gpu ./libbreath_gpu.so ppm verify --receipt torch-2.4.0-*.whl.receipt.json --file torch-2.4.0-*.whl

Provenance & SBOM

ppm sbom        --out project-sbom.json

ppm provenance --out provenance.json ppm graph --dot | dot -Tpng -o deps.png

---

🔌 Plugin System

# Install a plugin

ppm plugin add auditwheel https://cdn.example.com/auditwheel.so

Run it

ppm plugin run auditwheel repair --wheel torch-2.4.0-cp310-linux_x86_64.whl

Writing a plugin (C)

// hello.c

#include int pypm_plugin_main(int argc, char **argv) { puts("Hello from a plugin 👋"); return 0; }

cc -shared -fPIC -o hello.so hello.c

mv hello.so ~/.pypm/plugins/ pypm plugin run hello

---

⚙️ Configuration

pypm.toml

[tool.ppm]

python = "^3.10" default_gpu = "auto"

[tool.ppm.backends] cpu.index = "https://download.pytorch.org/whl/cpu" cu121.index = "https://download.pytorch.org/whl/cu121" cu122.index = "https://download.pytorch.org/whl/cu122"

torch_prefer = "2.4.*" transformers_prefer = "4.43.*"

Environment variables

export PYP_WORKSPACE_ROOT=/path/to/project   # override workspace detection

export PYP_DEBUG=1 # enable debug output export CUDA_VISIBLE_DEVICES=0 # control GPU usage

---

🧠 PMLL Memory MCP Server

**Persistent memory logic loop with short-term KV context memory, Q-promise

deduplication, and Context+ long-term

memory graph designed to improve context retention and retrieval for coding agents.**

pmll-memory-mcp is a Model Context Protocol (MCP) server with complementary short-term KV and optional long-term graph layers. Server construction prefers MCPServer (mcp 2.x) and falls back to FastMCP (mcp 1.x) — see mcp/pmll_memory_mcp/server.py.

Ground tool names in code: TypeScript (mcp/src/index.ts) has 15 tools including graphql and names like create_relation; Python (mcp/pmll_memory_mcp/server.py) has 14 tools (no graphql) with several longer names such as create_memory_relation. A ctypes demo in Ppm-lib/pmll_mcp/ loads libqpromise.so via qpromise_*.

Memory layers:

• Short-term KV cache (5 tools) — session-isolated key-value memory with Q-promise deduplication, mirroring PMLL.c::memory_silo_t.
• Long-term memory graph (6 tools) — adapted from Context+ by @ForLoopCodes, providing a SQLite-backed property graph with typed nodes, weighted edges, temporal decay scoring (e^(-λt)), and semantic search via stable hashing embeddings.
• Solution engine (3 tools) — bridges both layers with unified context