Skip to content
Back to search

pensyve

Universal memory runtime for AI agents

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/major7apps/pensyve with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/major7apps/pensyve'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/major7apps--pensyve/badge.svg)](/listings/major7apps--pensyve)

HTML

<a href="/listings/major7apps--pensyve"><img src="/api/listings/major7apps--pensyve/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Python 3.10 or newer is required.

pip install pensyve

Create a local store, save a fact, and retrieve it:

import pensyve

p = pensyve.Pensyve(path="./memories", namespace="my-agent")
user = p.entity("user", kind="user")

p.remember(
    entity=user,
    fact="Prefers dark mode and vim keybindings",
    confidence=0.95,
)

for memory in p.recall("editor preferences", entity=user):
    print(memory.content)

Reuse the same path and namespace in a later process to retrieve saved memories. The Python SDK runs the engine in your process and does not need the HTTP gateway.

You can also record a conversation with the same `p` and `user`:

with p.episode(user) as episode:
    episode.message("user", "Use dark mode in my editor")
    episode.message("agent", "I updated the editor settings")
    episode.outcome("success")

groups = p.recall_grouped("editor settings", limit=10)
for group in groups:
    for memory in group.memories:
        print(memory.content)

`recall_grouped()` groups results by source session for use in an agent's prompt. See the [Python SDK guide](pensyve-python/README.md) and [recipes](docs/RECIPES.md) for more examples.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 27 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "pensyve",
  3. "owner": {
  4. "name": "Seth Hobson",
  5. "email": "seth@major7apps.com",
  6. "url": "https://github.com/major7apps/pensyve"
  7. },
  8. "metadata": {
  9. "description": "Universal memory runtime — ambient working-memory substrate for Claude Code. Proactive in-flight capture, thread-aware session continuity, three-type memory (semantic/episodic/procedural), and entity-aware recall. 7 commands, 7 skills, 2 agents, 6 lifecycle hooks.",
  10. "version": "1.3.0"
  11. },
  12. "plugins": [
  13. {
  14. "name": "pensyve",
  15. "source": "./integrations/claude-code",
  16. "description": "Universal memory runtime — ambient working-memory substrate for Claude Code. Memory is not a feature you invoke — it's the substrate the agent operates on.",
  17. "version": "1.3.0",
  18. "author": {
  19. "name": "Seth Hobson",
  20. "email": "seth@major7apps.com"
  21. },
  22. "homepage": "https://github.com/major7apps/pensyve",
  23. "license": "Apache-2.0",
  24. "category": "memory"
  25. }
  26. ]
  27. }
README.md · README · 250 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ![Pensyve logo](docs/images/logo.png)
  2. # Pensyve
  3. [![CI](https://github.com/major7apps/pensyve/actions/workflows/ci.yml/badge.svg)](https://github.com/major7apps/pensyve/actions/workflows/ci.yml)
  4. [![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
  5. [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
  6. [![Rust 1.94+](https://img.shields.io/badge/rust-1.94+-orange.svg)](https://www.rust-lang.org/)
  7. Pensyve is an open-source runtime for persistent AI agent memory. It stores facts,
  8. conversations, observations, and action outcomes so an agent can retrieve them
  9. in later sessions. You can use it through Python, a Model Context Protocol
  10. (MCP) server, a command-line tool, or a REST API.
  11. The Rust engine uses SQLite for local storage and runs embedding models
  12. locally to search by meaning. TypeScript and Go clients connect to a gateway
  13. you run yourself. Local use does not require a Pensyve account or API key.
  14. Your application or client integration calls Pensyve to save and retrieve
  15. memories.
  16. ## Choose a setup
  17. | Use case | Start here |
  18. | --- | --- |
  19. | Add persistent memory to a Python agent | [Python quick start](#python-quick-start) |
  20. | Give Claude Code, Cursor, or Codex access to memory tools | [MCP server](#mcp-server) and [client setup guides](#sdks-and-integrations) |
  21. | Share a memory store through TypeScript, Go, or REST | [HTTP gateway](#http-gateway) |
  22. | Use a LangChain or LangGraph adapter | [Python integration](integrations/langchain/README.md) or [TypeScript integration](integrations/langchain-ts/README.md) |
  23. ## Project status
  24. Pensyve Cloud closed on October 1, 2026. The open-source project continues in
  25. this repository under the Apache 2.0 license, with the engine, SDKs,
  26. integrations, and documentation available here.
  27. Pensyve is in maintenance mode. Releases cover security fixes and dependency
  28. updates, with no new features planned. See the [maintenance policy](MAINTENANCE.md)
  29. for contribution and support expectations. If you have a saved Cloud export,
  30. the [self-hosting guide](docs/self-host.md#dropping-in-an-exported-store)
  31. explains how to use it with your own gateway.
  32. ## What you can do
  33. - Store facts about users, projects, or other named entities, and record conversations as episodes.
  34. - Search memories using text matching, embeddings, and relationships between entities.
  35. - Record observations and action outcomes, and use consolidation to promote repeated facts and update memory retention.
  36. - Keep data in local SQLite storage, or run the HTTP gateway with SQLite or PostgreSQL.
  37. Embedding models may download when first loaded unless they are already
  38. cached. Running without network access requires preparing the model files
  39. first. See the [model setup and deployment guide](docs/self-host.md).
  40. ## How agent memory works
  41. Pensyve stores memory outside the language model. Your application saves
  42. facts or conversations, searches for relevant records, and adds the results
  43. to a later prompt. Reusing the same storage path and namespace lets the
  44. agent retrieve information across processes and sessions. Saving a memory
  45. does not train the language model or change its weights.
  46. The store holds four kinds of records: facts (semantic memory), conversations
  47. (episodic memory), action outcomes (procedural memory), and observations.
  48. Your integration decides what to record and when to retrieve it. Recording
  49. a conversation does not automatically turn it into a successful procedure.
  50. See [how storage and retrieval work](docs/ARCHITECTURE.md#data-model) and
  51. the [usage recipes](docs/RECIPES.md) for the APIs and their limits.
  52. ## Python quick start
  53. Python 3.10 or newer is required.
  54. ```bash
  55. pip install pensyve
  56. ```
  57. Create a local store, save a fact, and retrieve it:
  58. ```python
  59. import pensyve
  60. p = pensyve.Pensyve(path="./memories", namespace="my-agent")
  61. user = p.entity("user", kind="user")
  62. p.remember(
  63. entity=user,
  64. fact="Prefers dark mode and vim keybindings",
  65. confidence=0.95,
  66. )
  67. for memory in p.recall("editor preferences", entity=user):
  68. print(memory.content)
  69. ```
  70. Reuse the same path and namespace in a later process to retrieve saved
  71. memories. The Python SDK runs the engine in your process and does not need
  72. the HTTP gateway.
  73. You can also record a conversation with the same `p` and `user`:
  74. ```python
  75. with p.episode(user) as episode:
  76. episode.message("user", "Use dark mode in my editor")
  77. episode.message("agent", "I updated the editor settings")
  78. episode.outcome("success")
  79. groups = p.recall_grouped("editor settings", limit=10)
  80. for group in groups:
  81. for memory in group.memories:
  82. print(memory.content)
  83. ```
  84. `recall_grouped()` groups results by source session for use in an agent's
  85. prompt. See the [Python SDK guide](pensyve-python/README.md) and
  86. [recipes](docs/RECIPES.md) for more examples.
  87. ## MCP server
  88. Pensyve's local MCP memory server lets clients such as Claude Code, Codex,
  89. and Cursor store and retrieve memories across sessions. From a checkout of
  90. this repository, install the server with Rust 1.94 or newer:
  91. ```bash
  92. git clone https://github.com/major7apps/pensyve.git
  93. cd pensyve
  94. cargo install --path pensyve-mcp --locked
  95. ```
  96. Make sure Cargo's binary directory is on your client's `PATH`, then add a
  97. stdio server entry to its MCP configuration:
  98. ```json
  99. {
  100. "mcpServers": {
  101. "pensyve": {
  102. "command": "pensyve-mcp",
  103. "args": ["--stdio"],
  104. "env": {
  105. "PENSYVE_NAMESPACE": "my-project"
  106. }
  107. }
  108. }
  109. }
  110. ```
  111. The server provides tools such as `pensyve_remember`, `pensyve_recall`,
  112. `pensyve_observe`, and `pensyve_inspect`. It stores data locally and needs no
  113. API key. The configuration file location depends on your client. See the
  114. [MCP setup guide](docs/GETTING_STARTED.md#mcp-server) and
  115. [integration guides](integrations/README.md).
  116. ## HTTP gateway
  117. Run the gateway to access Pensyve over REST or MCP HTTP, including from the
  118. TypeScript and Go SDKs. From the repository root, start a local instance:
  119. ```bash
  120. HOST=127.0.0.1 PENSYVE_API_KEYS=psy_local_example \
  121. cargo run --release -p pensyve-mcp-gateway
  122. ```
  123. In another terminal, save and recall a fact:
  124. ```bash
  125. curl http://localhost:3000/v1/remember \
  126. -H "Authorization: Bearer psy_local_example" \
  127. -H "Content-Type: application/json" \
  128. -d '{"entity":"user","fact":"Prefers Python","confidence":0.95}'
  129. curl http://localhost:3000/v1/recall \
  130. -H "Authorization: Bearer psy_local_example" \
  131. -H "Content-Type: application/json" \
  132. -d '{"query":"programming language","entity":"user"}'
  133. ```
  134. The MCP HTTP endpoint is `http://localhost:3000/mcp`. Use the same API key in
  135. your client's `Authorization: Bearer` header.
  136. The example key is for local testing. For a deployment, choose your own key
  137. with the required `psy_` prefix and configure HTTPS and allowed hosts. See
  138. the [self-hosting guide](docs/self-host.md),
  139. [gateway configuration](pensyve-mcp-gateway/README.md), and
  140. [security documentation](docs/SECURITY.md).
  141. ## SDKs and integrations
  142. The TypeScript and Go SDKs require a running gateway. Configure its URL and,
  143. when authentication is enabled, an API key from that gateway.
  144. | Interface | Installation or guide |
  145. | --- | --- |
  146. | Python | `pip install pensyve`, [SDK guide](pensyve-python/README.md) |
  147. | TypeScript | `npm install @pensyve/sdk`, [SDK guide](pensyve-ts/README.md) |
  148. | Go | `go get github.com/major7apps/pensyve/pensyve-go/v5@latest`, [SDK guide](pensyve-go/README.md) |
  149. | Claude Code | [Plugin setup](integrations/claude-code/README.md) |
  150. | Cursor | [MCP setup and rules](integrations/cursor/README.md) |
  151. | Codex | [Plugin setup](integrations/codex-plugin/README.md) |
  152. | LangChain and LangGraph | [Python adapter](integrations/langchain/README.md), [TypeScript adapter](integrations/langchain-ts/README.md) |
  153. | Other clients and frameworks | [Integration index](integrations/README.md) |
  154. ## Command-line tool
  155. From the repository root, install the CLI and inspect its commands:
  156. ```bash
  157. cargo install --path pensyve-cli --locked
  158. pensyve --help
  159. pensyve status
  160. pensyve recall "editor preferences" --entity user
  161. ```
  162. The binary is named `pensyve`. Its default output is JSON, and `--format text`
  163. selects text output. The CLI uses its own default local storage location;
  164. it does not automatically open the `./memories` directory from the Python
  165. example. See the [CLI source and command definitions](pensyve-cli/src/main.rs)
  166. for storage and namespace options.
  167. ## Documentation
  168. | Guide | Contents |
  169. | --- | --- |
  170. | [Documentation index](docs/README.md) | Choose a setup, find API guides, and identify historical plans |
  171. | [Getting started](docs/GETTING_STARTED.md) | Setup by client or SDK |
  172. | [Self-hosting](docs/self-host.md) | Gateway deployment, model files, backups, and saved Cloud exports |
  173. | [Recipes](docs/RECIPES.md) | Recall, facts, episodes, observations, and other API examples |
  174. | [Architecture](docs/ARCHITECTURE.md) | Storage, retrieval, and component boundaries |
  175. | [Security](docs/SECURITY.md) | Authentication, namespace isolation, and execution limits |
  176. | [Reliability](docs/RELIABILITY.md) | Tests and runtime guarantees |
  177. | [Changelog](CHANGELOG.md) | Release history and breaking changes |
  178. ## Development and contributions
  179. Start with [CONTRIBUTING.md](CONTRIBUTING.md) for prerequisites and setup.
  180. From the repository root:
  181. ```bash
  182. uv sync --extra dev
  183. make build
  184. make check
  185. ```
  186. `make build` compiles Rust and builds the Python extension. `make check`
  187. runs the Rust and Python lint and test commands. TypeScript and Go have
  188. separate checks documented in the contribution guide.
  189. Issues and pull requests follow the [maintenance policy](MAINTENANCE.md).
  190. Report security issues through [private vulnerability reporting](SECURITY.md).
  191. ## License
  192. Pensyve is licensed under [Apache 2.0](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.