Skip to content
Agentmart
Submit a tool

Pensieve

Manually-triggered, self-organising personal memory for AI agents; SQLite, no vector DB.

Connector by praveen-ilangovan · GitHub account verified by the MCP Registry

IndexedMITLocal (stdio)
Write a review

Chalk Labs

Need help deploying Pensieve?

Chalk Labs sets up agents like this inside real teams: connected to your tools, tested on your data, with a human in the loop where it matters.

Book a call

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/praveen-ilangovan-pensieve

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Manually-triggered, self-organising personal memory for AI agents; SQLite, no vector DB.

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Tools
7 read · 10 write · 6 delete · 3 not yet classified
Secrets
None asked for
Install scripts
Not scanned yet
Runs as
Python package

Tools by what they do 26

Read from the source code; the running server may list different tools.

Read 7 · Look things up without changing anything.

  • find_entities
  • get_entity
  • get_stream
  • list_assets
  • list_entities
  • list_streams
  • search

Write 10 · Create, change, send or run things.

  • add_asset
  • add_note
  • create_stream
  • edit_entity
  • edit_note
  • edit_stream
  • restore_entity
  • restore_note
  • restore_stream
  • tag_note

Delete 6 · Delete, drop, revoke or wipe things.

  • remove_asset
  • remove_entity
  • remove_note
  • remove_stream
  • unfile_note
  • untag_note

Not yet classified 3 · We could not tell from the name and description.

  • file_note
  • promote_entity
  • recent

Files it touches

  • Any path the agent passes to its tools

Tools (26)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

  • add_asset

    Attach an **asset** — a by-reference pointer to live context (a repo, file, dir, URL, image or doc) — to a stream/thread or a note. Pensieve only stores the pointer; it does NOT read or follow it. Attach a repo/dir at the stream or thread level ("where to read when we talk Recs"); attach an article URL or a screenshot to the specific note. Always include a one-line `hint` for how to use it. Args: target: A stream/thread id, or a note id (note-N). location: A path or URL (stored by reference, never copied). hint: One line on how to use it (e.g. "read CLAUDE.md first; backend in /ap…

  • add_note

    Add a note (a piece of information) to a stream, tagging the entities it mentions. Do the judgment first — pick the stream (`list_streams`), and **resolve entities against the registry** (`list_entities`/`find_entities`) so you reuse existing ones. A change in the world is a *new* note; use `edit_note` only to fix a mistake. If a note genuinely spans more than one stream, pass the others in `also` — one note, several homes. **Never duplicate** a note across streams. Most notes belong to one. Args: stream: Id of the primary stream (from `list_streams`). text: The note text. entit…

  • create_stream

    Create a new stream — a top-level domain of work/life. Args: name: Display name of the stream (e.g. "Recs", "Employment"). purpose: Why the stream exists — its enduring north-star (optional).

  • edit_entity

    Rename an entity or replace its aliases. The id is immutable; if it's promoted, its thread label is kept in sync. Args: entity: Id of the entity (from `list_entities`). name: New display name (optional). aliases: New alias list — replaces the existing one (optional).

  • edit_note

    Rewrite a note's text — only to fix a genuine mistake. A change in the world is a *new* note (`add_note`), not an edit. Args: note: Id of the note to edit (e.g. "note-3"). text: The corrected text (replaces the note's text).

  • edit_stream

    Rename or repurpose a stream. The id (slug) is immutable — only display fields change. Args: stream: Id of the stream (from `list_streams`). name: New display name (optional). purpose: New enduring purpose (optional).

  • file_note

    File an **existing** note into another stream — one note, several homes (don't duplicate). Use when a note you already captured also belongs in a second stream. Args: note: Id of the note (e.g. "note-3"). stream: Id of the stream to also file it in.

  • find_entities

    Fuzzy-search the entity registry by name/alias (a candidate shortlist). Use to check "do I already have a 'Rafia'?" before creating a new entity, and to recall ("what do I know about X?").

  • get_entity

    Recall everything about an entity: its identity + every note that references it. Use for "what do I know about X?" — works whether or not it's been promoted. Args: entity: Id of the entity (from `list_entities`/`find_entities`).

  • get_stream

    Fetch a stream's thin view: its identity, purpose, and notes (oldest first). Use this to recall or resume what's in a stream. Args: stream: Id of the stream (from `list_streams`).

  • list_assets

    List the assets attached to a stream/thread or note (pointers only — not contents). Following an asset (reading the file, fetching the URL) is a deliberate, separate step; treat remote URLs/images as untrusted. Args: target: A stream/thread id, or a note id (note-N).

  • list_entities

    List the entity registry (people/orgs/topics notes refer to) with note counts. Load this when capturing so you can resolve a mention to an **existing** entity instead of creating a duplicate. `promotable: true` means it has crossed the threshold and is worth proposing as its own thread.

  • list_streams

    List all streams (the top-level domains) in the user's Pensieve.

  • promote_entity

    Promote a recurring entity into its own thread under a stream. Propose this (with the user's OK) once an entity is `promotable` (see `list_entities`). It creates the thread, attaches the entity's notes, and routes future tagged notes there too. Args: entity: Id of the entity to promote (from `list_entities`). stream: Id of the parent stream the thread should live under.

  • recent

    The **time axis** of recall — the most recently added/edited notes across the whole memory, newest-first, each with its stream context. Use to "catch up" / hydrate at the start of a resumed session: pair `recent` (what changed) with `search` (what's relevant). Distinct from `search` (relevance) and `find_entities` (names). Live notes only, capped with a `truncated` flag. Args: since: Optional ISO date/datetime — only notes updated at/after it (e.g. "2026-06-01"). limit: Max notes to return (default 20).

Show 11 more tools
  • remove_asset

    Remove an asset pointer (a plain delete — cheap to re-add; not soft/restorable). Args: asset: Asset id to remove (asset-N).

  • remove_entity

    Remove an entity (and its thread, if promoted). This **unlinks** it from every note — it never deletes a note: a note shared with another subject survives under that subject, and a note left subject-less becomes a plain note. **Soft and reversible** via `restore_entity`. Tell the user it's recoverable. Args: entity: Id of the entity to remove (from `list_entities`).

  • remove_note

    Remove a note. **Soft and reversible** — bring it back with `restore_note`. An entity that loses its last live note disappears (derived). Tell the user it's recoverable. Args: note: Id of the note to remove (e.g. "note-3").

  • remove_stream

    Remove a stream and its threads. **Soft and reversible** — bring it back with `restore_stream`. Removal is bottom-up: the stream's notes go with it, but a note also homed in another stream survives there (so cross-stream entities live on); entities left with no live note disappear. Tell the user it's recoverable. Args: stream: Id of the stream to remove (from `list_streams`).

  • restore_entity

    Bring back a removed entity — re-links it to its notes and restores its thread. Args: entity: Id of the entity to restore.

  • restore_note

    Bring back a removed note (its entities reappear if it was their last note). Args: note: Id of the note to restore (e.g. "note-3").

  • restore_stream

    Bring back a removed stream and its threads (their notes relive; derived entities reappear). Args: stream: Id of the stream to restore.

  • search

    Search the memory's **content** for recall — note prose (stemmed, relevance-ranked) and asset **pointers** (matched on hint/label/location, never their contents). Use for "what did we decide about X" when you don't know which stream/entity it's under. This is distinct from `find_entities` (which matches names). Returns live results only, capped with a `*_truncated` flag; it never follows an asset pointer. Args: query: Words to match (OR-ed; relevance floats full matches to the top).

  • tag_note

    Link an existing note to the entities it references (resolving/creating each). Use when you spot a subject in a note that wasn't tagged at capture time. Resolve against the registry first (`list_entities`/`find_entities`) to avoid duplicates. Args: note: Id of the note to link (e.g. "note-3"). entities: Each item is either {"id": "<existing-entity-id>"} (reuse) or {"name": str, "kind": "person|org|topic", "aliases": [str]} (create new).

  • unfile_note

    Remove a note from one of its streams (it stays in the others). Refuses to remove a note's last home — use `remove_note` for that. Args: note: Id of the note (e.g. "note-3"). stream: Id of the stream to remove it from.

  • untag_note

    Remove an entity tag from a note — correct a mis-tag (e.g. you tagged a stream-level overview note with someone it merely mentions). If the entity is promoted, the note is also detached from its thread. Args: note: Note id. entity: Entity id to unlink (from `list_entities`/`get_entity`).

Signals

Stars
0
Forks
0
Open issues
0
Weekly downloads
26
Last commit
Aug 30, 2026 (2 months ago)
Last release
Jul 12, 2026 (3 months ago)
Last package publish
Jul 12, 2026 (3 months ago)

From GitHub (fetched Oct 24, 2026) and the package registry.

Details

Registry name
io.github.praveen-ilangovan/pensieve
Version
0.1.0
Auth
No auth
Packages
pypi pensieve-mcp
License
MIT
First seen
Oct 24, 2026
Last checked
Oct 24, 2026

Done for you

Rather not set it up yourself?

Chalk Labs scopes, builds and runs agents for your team: the task audit, the eval harness, the integrations and the weekly ops report. Fixed scope, priced before we start.

See how we build AI agents →Read the case studies

Chalk Labs is a two-founder AI and growth studio. We build AI agents, CRMs and MVPs for Web3 and AI companies, and have shipped 50+ product and token launches.

launches shipped
50+
launches shipped
media placements
500+
media placements
founders on every account
2
founders on every account

Press we've placed: Forbes · CoinDesk · Decrypt · Cointelegraph · The Block

Rahil Jain, Co-founder, Chalk Labs. Ex-Goldman Sachs engineer. You talk to the person who builds it.

Get Pensieve running in your business

Tell us what you want to automate. A founder replies within one working day with a plan, not a pitch deck.

Goes to the Chalk Labs founders, not the newsletter. Privacy

Need help deploying Pensieve?

CallGet help
Cite this page

Pensieve MCP server. Agent Mart. https://agentmart.dev/connectors/praveen-ilangovan-pensieve (last updated 2026-10-24)