Skip to content
Back to search

memorizer

Vector-search powered agent memory MCP server

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/petabridge--memorizer/badge.svg)](/listings/petabridge--memorizer)

HTML

<a href="/listings/petabridge--memorizer"><img src="/api/listings/petabridge--memorizer/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.

🐳 Quick Start (Public Image)

The easiest way to get started is using the pre-built Docker image and our [`docker-compose.yml`](docker-compose.yml) file:

docker-compose up -d

This will: - Download and run the latest [`petabridge/memorizer` image from Docker Hub](https://hub.docker.com/r/petabridge/memorizer) - Start PostgreSQL with pgvector (port 5432) - Start PgAdmin (port 5050) - Start Ollama (port 11434) - Start Memorizer API (port 5000)

**View the Memorizer Web UI on http://localhost:5000**.

πŸš€ Local Development Builds

If you want to build and run from source:

Prerequisites

- Docker and Docker Compose - .NET 10.0 SDK

1. Build and Publish Local Container

# From solution root directory
# Build and publish the .NET container
dotnet publish -c Release /t:PublishContainer

This creates a container image named `memorizer:latest`.

2. Start Infrastructure and Application

docker-compose -f docker-compose.local.yml up -d

This starts the same services but uses your locally built image.

---

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.

README.md Β· README Β· 228 lines

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

  1. # Memorizer
  2. [![Docker Pulls](https://img.shields.io/docker/pulls/petabridge/memorizer)](https://hub.docker.com/r/petabridge/memorizer) ![GitHub License](https://img.shields.io/github/license/petabridge/memorizer) ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/petabridge/memorizer/pr_validation.yml) ![GitHub Release](https://img.shields.io/github/v/release/petabridge/memorizer)
  3. Memorizer is a .NET-based service that allows AI agents to store, retrieve, and search through memories using vector embeddings. It leverages PostgreSQL with the pgvector extension to provide efficient similarity search capabilities.
  4. ![Memorizer - Memory List](https://raw.githubusercontent.com/petabridge/memorizer/refs/heads/dev/docs/images/memory-list-dark.png)
  5. Key features:
  6. - **Workspaces & Projects** - Organize memories into hierarchical workspaces and projects with status tracking
  7. - Store structured memories with vector embeddings
  8. - Retrieve memories by ID
  9. - Semantic search through memories using vector similarity
  10. - Filter search results using tags
  11. - Edit memory content with automatic versioning and change tracking
  12. - Update memory metadata (title, type, tags, confidence) independently
  13. - Revert memories to previous versions with full audit trail
  14. - Create relationships between memories to form knowledge graphs
  15. - Web UI for manually adding, editing, deleting, viewing memories, and managing versions
  16. - **Provider Settings** - Configure embedding and LLM providers through the UI (Ollama, OpenAI, and compatible APIs)
  17. - MCP (Model Context Protocol) integration for easy use with AI agents
  18. - **Light & Dark theme** support
  19. ![Memorizer - Workspace Detail](https://raw.githubusercontent.com/petabridge/memorizer/refs/heads/dev/docs/images/workspace-detail-dark.png)
  20. ## Technologies
  21. - .NET 10.0
  22. - PostgreSQL with pgvector extension
  23. - Model Context Protocol (MCP)
  24. - ASP.NET Core
  25. - [Akka.NET](https://getakka.net/) for background jobs, such as re-embedding memories if you change algorithms
  26. - Npgsql for PostgreSQL connectivity
  27. ---
  28. ## πŸ“– Documentation
  29. - [Feature Gallery (Screenshots)](docs/FEATURES.md)
  30. - [Configuration & Advanced Setup](docs/configuration.md)
  31. - [Security Configuration](docs/security.md)
  32. - [Embedding Models & Dimensions](docs/embedding-models.md)
  33. - [Embedding Dimension Migration](docs/embedding-migration.md)
  34. - [Local Development](docs/local-development.md)
  35. - [Schema Migrations](docs/schema-migrations.md)
  36. - [Architecture Decision Records](docs/adr/README.md)
  37. ---
  38. ## Installation with Docker
  39. ### 🐳 Quick Start (Public Image)
  40. The easiest way to get started is using the pre-built Docker image and our [`docker-compose.yml`](docker-compose.yml) file:
  41. ```bash
  42. docker-compose up -d
  43. ```
  44. This will:
  45. - Download and run the latest [`petabridge/memorizer` image from Docker Hub](https://hub.docker.com/r/petabridge/memorizer)
  46. - Start PostgreSQL with pgvector (port 5432)
  47. - Start PgAdmin (port 5050)
  48. - Start Ollama (port 11434)
  49. - Start Memorizer API (port 5000)
  50. **View the Memorizer Web UI on http://localhost:5000**.
  51. ### πŸš€ Local Development Builds
  52. If you want to build and run from source:
  53. #### Prerequisites
  54. - Docker and Docker Compose
  55. - .NET 10.0 SDK
  56. #### 1. Build and Publish Local Container
  57. ```bash
  58. # From solution root directory
  59. # Build and publish the .NET container
  60. dotnet publish -c Release /t:PublishContainer
  61. ```
  62. This creates a container image named `memorizer:latest`.
  63. #### 2. Start Infrastructure and Application
  64. ```bash
  65. docker-compose -f docker-compose.local.yml up -d
  66. ```
  67. This starts the same services but uses your locally built image.
  68. ---
  69. ## Upgrading to Memorizer 2.0
  70. > [!NOTE]
  71. > **The upgrade from Memorizer 1.x to 2.0 is designed to work automatically.** All schema migrations run on startup and have been thoroughly tested. Your existing memories will be preserved and continue to work as expected.
  72. > [!CAUTION]
  73. > **We recommend backing up your database before upgrading**, as a standard best practice. Memorizer 2.0 runs automatic schema migrations on startup that alter tables and add new columns. While we've tested these migrations extensively, having a backup ensures you can recover in the unlikely event that something goes wrong.
  74. ### Backup Instructions
  75. > [!NOTE]
  76. > The container names below (e.g., `memorizer-postgres`) are based on the default [`docker-compose.yml`](docker-compose.yml). If you've customized your Docker Compose file, adjust the container name accordingly.
  77. Before pulling the new Memorizer 2.0 image, create a PostgreSQL dump of your existing database:
  78. ```bash
  79. # Create a full database backup
  80. docker exec postgmem-postgres pg_dump -U postgres postgmem > memorizer-backup-$(date +%Y%m%d).sql
  81. # Or use pg_dump with compression
  82. docker exec postgmem-postgres pg_dump -U postgres -Fc postgmem > memorizer-backup-$(date +%Y%m%d).dump
  83. ```
  84. To restore from a backup if needed:
  85. ```bash
  86. # Restore from SQL dump
  87. docker exec -i postgmem-postgres psql -U postgres postgmem < memorizer-backup-20250207.sql
  88. # Or restore from compressed dump
  89. docker exec -i postgmem-postgres pg_restore -U postgres -d postgmem memorizer-backup-20250207.dump
  90. ```
  91. ### Updating
  92. ```bash
  93. # make sure you have created a backup before starting here
  94. git pull
  95. docker-compose down
  96. docker-compose pull memorizer
  97. docker-compose up -d
  98. ```
  99. ### Breaking Changes in 2.0
  100. - **MCP endpoint moved from `/` to `/mcp`**. Update your MCP client configurations from `http://localhost:5000` to `http://localhost:5000/mcp`.
  101. - **Web UI moved from `/ui` to `/`**. The Web UI is now at the root path.
  102. - **New database tables**: Workspaces, projects, provider settings, data migrations, and archetype tracking are added automatically on first startup.
  103. - **Existing memories are preserved**: All your V1 memories will continue to work. They will appear as "Unfiled" until you organize them into workspaces and projects.
  104. ### After Upgrading
  105. > [!TIP]
  106. > Once the upgrade is complete, ask your AI agent to suggest workspaces and projects to organize your existing memories into. Memorizer 2.0's workspace and project system helps you keep memories structured and easy to find - and your agent can analyze your existing memories to recommend a good organizational scheme.
  107. ---
  108. ## πŸ”Œ MCP Configuration Example
  109. To use Memorizer with any MCP-compatible client, add the following to your configuration (e.g., `mcp.json`):
  110. ```json
  111. {
  112. "memorizer": {
  113. "url": "http://localhost:5000/mcp"
  114. }
  115. }
  116. ```
  117. This uses the modern Streamable HTTP transport (MCP spec 2025-03-26+). Note that the MCP endpoint is at `/mcp` (changed from `/` in 2.0).
  118. ---
  119. ## πŸ–₯️ Web UI
  120. Memorizer includes a web-based user interface for managing memories through your browser.
  121. ### Access the Web UI
  122. Once the application is running (via `docker-compose up -d`), you can access the Web UI at:
  123. **http://localhost:5000/**
  124. ### Features
  125. - **Memory Management**: Create, view, edit, and delete memories with full CRUD operations
  126. - **Version Control**: View version history, compare versions with visual diffs, and revert to previous versions
  127. - **Search & Filter**: Search memories using semantic similarity and filter by tags
  128. - **Statistics Dashboard**: View memory counts, tag distributions, and system statistics
  129. - **MCP Configuration**: Get the MCP configuration JSON for connecting clients at `/mcp-config`
  130. The Web UI provides a user-friendly interface for all Memorizer functionality, making it easy to manage your AI agent's memory without needing to use the MCP tools directly.
  131. ---
  132. ## 🧠 Example System Prompt for LLMs
  133. > [!IMPORTANT]
  134. > **⚑ Pro Tip:** Add this system prompt to your `AGENT.md`, Cursor Rules files, or any AI agent configuration! This will dramatically improve how often and effectively your LLM uses the Memorizer service for persistent memory management.
  135. > You have access to a long-term memory system via the Model Context Protocol (MCP) at the endpoint `memorizer`. Use the following tools:
  136. >
  137. > **Storage & Retrieval:**
  138. > - `store`: Store a new memory. Parameters: `type`, `text` (markdown), `source`, `title`, `tags`, `confidence`, `relatedTo` (optional, memory ID), `relationshipType` (optional).
  139. > - `searchMemories`: Search for similar memories using semantic similarity. Parameters: `query`, `limit`, `minSimilarity`, `filterTags`.
  140. > - `get`: Retrieve a memory by ID. Parameters: `id`, `includeVersionHistory`, `versionNumber`.
  141. > - `getMany`: Retrieve multiple memories by their IDs. Parameter: `ids` (list of IDs).
  142. > - `delete`: Delete a memory by ID. Parameter: `id`.
  143. >
  144. > **Editing & Updates:**
  145. > - `edit`: Edit memory content using find-and-replace (ideal for checking off to-do items, updating sections). Parameters: `id`, `old_text`, `new_text`, `replace_all`.
  146. > - `updateMetadata`: Update memory metadata (title, type, tags, confidence) without changing content. Parameters: `id`, `title`, `type`, `tags`, `confidence`.
  147. >
  148. > **Relationships & Versioning:**
  149. > - `createRelationship`: Create a relationship between two memories. Parameters: `fromId`, `toId`, `type` (e.g., 'example-of', 'explains', 'related-to').
  150. > - `revertToVersion`: Revert a memory to a previous version. Parameters: `id`, `versionNumber`, `changedBy`.
  151. >
  152. > All edits and updates are automatically versioned, allowing you to track changes and revert if needed. Use these tools to remember, recall, edit, relate, and manage information as needed to assist the user.
  153. ---
  154. ## License
  155. MIT
  156. ---
  157. ## πŸ’– Attribution
  158. Made with ❀️ by [Petabridge](https://petabridge.com/)
  159. Originally forked from [Dario Griffo](https://dario.griffo.io/)'s [`postg-mem`](https://github.com/dariogriffo/postg-mem) server

Ratings and comments

Sign in to rate this skill.

Sign in

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