AutoGineer
Generated banner for Memorizer
Generated logo for Memorizer

Memorizer

Memory serverOfficial Petabridge project

Created by Dario Griffo

Published in petabridge/memorizer. Publisher page

221 GitHub stars

What it is

Vector-search powered agent memory MCP server
— the description by Dario Griffo

AutoGineer overview, from the brain’s own files

Memorizer is a dedicated memory service designed to give AI agents persistent, long-term storage capabilities. It functions as an MCP server, allowing agents to store, retrieve, and semantically search through structured memories. Built on .NET and PostgreSQL with the pgvector extension, it supports advanced features like versioning, audit trails, relationship mapping for knowledge graphs, and workspace-based organization. It includes a web-based UI for manual management and provides a robust framework for agents to proactively manage their own knowledge base, ensuring that insights and context are preserved across sessions.

How it works

Memory model: Hybrid

AutoGineer overview, from the brain’s own files

Memorizer runs as a service that connects to an AI agent via the Model Context Protocol. It stores data in a PostgreSQL database, utilizing vector embeddings for semantic similarity searches. The system organizes information into workspaces and projects, supports metadata tagging, and tracks version history for all memory entries. Agents interact with the service through a set of defined tools for CRUD operations, metadata updates, and relationship creation, enabling the construction of an interconnected knowledge graph.

Folders
FolderRoleFiles
.githubagent-config4
docsdocs37
scriptsscripts3
srcsource-code195
.configfolder1

The agent writes

Requirements

Databases: PostgreSQL

Works with: Claude Code, OpenCode, Devin (ex-Windsurf)

Set it up

  1. Not scanned by AutoGineerThe author’s README also describes installing it with Docker Compose. Read its install section: AutoGineer did not scan that path. https://github.com/petabridge/memorizer/blob/d3e90fa8d6b50254d65a3ffa3acc35e0204c5c90/README.md#-quick-start-public-image

  2. Created by Dario Griffo. Published in petabridge/memorizer. Licence: MIT License.

Usage

AutoGineer overview, from the brain’s own files

  • Connects to AI agents via the Model Context Protocol (MCP) to provide persistent memory.
  • Enables semantic search to retrieve relevant context based on task descriptions.
  • Supports proactive memory management where agents store, update, and relate information autonomously.
  • Provides a web interface for human users to manage, audit, and organize memory entries.
  • Facilitates knowledge graph construction by creating explicit relationships between memory nodes.
“Search for previous instructions on how to configure the build pipeline.”
The agent queries the memory server using semantic similarity to find relevant 'how-to' notes and returns the specific configuration steps.
“Store this new insight about the project architecture as a reference.”
The agent saves the markdown content to the memory server with appropriate tags and metadata for future retrieval.
“Link this new task to the related project requirements memory.”
The agent creates a relationship edge between the new memory ID and the existing requirements memory ID.

Documentation by Dario Griffo

Memorizer

Image: Docker Pulls Image: GitHub License Image: GitHub Actions Workflow Status Image: GitHub Release

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.

Image: Memorizer - Memory List

Key features:

  • Workspaces & Projects - Organize memories into hierarchical workspaces and projects with status tracking

  • Store structured memories with vector embeddings

  • Retrieve memories by ID

  • Semantic search through memories using vector similarity

  • Filter search results using tags

  • Edit memory content with automatic versioning and change tracking

  • Update memory metadata (title, type, tags, confidence) independently

  • Revert memories to previous versions with full audit trail

  • Create relationships between memories to form knowledge graphs

  • Web UI for manually adding, editing, deleting, viewing memories, and managing versions

  • Provider Settings - Configure embedding and LLM providers through the UI (Ollama, OpenAI, and compatible APIs)

  • MCP (Model Context Protocol) integration for easy use with AI agents

  • Light & Dark theme support

Image: Memorizer - Workspace Detail

Technologies

  • .NET 10.0

  • PostgreSQL with pgvector extension

  • Model Context Protocol (MCP)

  • ASP.NET Core

  • Akka.NET for background jobs, such as re-embedding memories if you change algorithms

  • Npgsql for PostgreSQL connectivity

📖 Documentation

Installation with Docker

🐳 Quick Start (Public Image)

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

docker-compose up -d

This will:

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.

Upgrading to Memorizer 2.0

NOTE
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.

CAUTION
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.

Backup Instructions

NOTE
The container names below (e.g., memorizer-postgres) are based on the default docker-compose.yml. If you've customized your Docker Compose file, adjust the container name accordingly.

Before pulling the new Memorizer 2.0 image, create a PostgreSQL dump of your existing database:

# Create a full database backup
docker exec postgmem-postgres pg_dump -U postgres postgmem > memorizer-backup-$(date +%Y%m%d).sql

# Or use pg_dump with compression
docker exec postgmem-postgres pg_dump -U postgres -Fc postgmem > memorizer-backup-$(date +%Y%m%d).dump

To restore from a backup if needed:

# Restore from SQL dump
docker exec -i postgmem-postgres psql -U postgres postgmem < memorizer-backup-20250207.sql

# Or restore from compressed dump
docker exec -i postgmem-postgres pg_restore -U postgres -d postgmem memorizer-backup-20250207.dump
Updating
# make sure you have created a backup before starting here
git pull
docker-compose down
docker-compose pull memorizer
docker-compose up -d
Breaking Changes in 2.0

  • MCP endpoint moved from / to /mcp. Update your MCP client configurations from http://localhost:5000 to http://localhost:5000/mcp.

  • Web UI moved from /ui to /. The Web UI is now at the root path.

  • New database tables: Workspaces, projects, provider settings, data migrations, and archetype tracking are added automatically on first startup.

  • 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.

After Upgrading

TIP
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.

🔌 MCP Configuration Example

To use Memorizer with any MCP-compatible client, add the following to your configuration (e.g., mcp.json):

{
  "memorizer": {
    "url": "http://localhost:5000/mcp"
  }
}

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).

🖥️ Web UI

Memorizer includes a web-based user interface for managing memories through your browser.

Access the Web UI

Once the application is running (via docker-compose up -d), you can access the Web UI at:

http://localhost:5000/

Features

  • Memory Management: Create, view, edit, and delete memories with full CRUD operations

  • Version Control: View version history, compare versions with visual diffs, and revert to previous versions

  • Search & Filter: Search memories using semantic similarity and filter by tags

  • Statistics Dashboard: View memory counts, tag distributions, and system statistics

  • MCP Configuration: Get the MCP configuration JSON for connecting clients at /mcp-config

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.

🧠 Example System Prompt for LLMs

IMPORTANT
⚡ 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.

You have access to a long-term memory system via the Model Context Protocol (MCP) at the endpoint memorizer. Use the following tools:

Storage & Retrieval:

  • store: Store a new memory. Parameters: type, text (markdown), source, title, tags, confidence, relatedTo (optional, memory ID), relationshipType (optional).

  • searchMemories: Search for similar memories using semantic similarity. Parameters: query, limit, minSimilarity, filterTags.

  • get: Retrieve a memory by ID. Parameters: id, includeVersionHistory, versionNumber.

  • getMany: Retrieve multiple memories by their IDs. Parameter: ids (list of IDs).

  • delete: Delete a memory by ID. Parameter: id.

Editing & Updates:

  • 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.

  • updateMetadata: Update memory metadata (title, type, tags, confidence) without changing content. Parameters: id, title, type, tags, confidence.

Relationships & Versioning:

  • createRelationship: Create a relationship between two memories. Parameters: fromId, toId, type (e.g., 'example-of', 'explains', 'related-to').

  • revertToVersion: Revert a memory to a previous version. Parameters: id, versionNumber, changedBy.

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.

License

MIT

💖 Attribution

Made with ❤️ by Petabridge

Originally forked from Dario Griffo's postg-mem server

docs/configuration.md

Configuration & Advanced Setup

This document contains detailed configuration, setup, and advanced usage instructions for Memorizer.

Database Configuration

  1. Create a PostgreSQL database for the application

  2. Install the pgvector extension in your database:

    CREATE EXTENSION vector;

  3. Create the memories table:

    CREATE TABLE memories (
    id UUID PRIMARY KEY,
    type TEXT NOT NULL,
    content JSONB NOT NULL,
    source TEXT NOT NULL,
    embedding VECTOR(384) NOT NULL,
    tags TEXT[] NOT NULL,
    confidence DOUBLE PRECISION NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
    updated_at TIMESTAMP WITH TIME ZONE NOT NULL
);

Environment Configuration

Note: When setting configuration via environment variables (such as in Docker or cloud environments), you must prefix all variable names with MEMORIZER_. This is required for the application to recognize the settings. For example, use MEMORIZER_Server__CanonicalUrl instead of Server__CanonicalUrl.

Configure the application settings in the .env file or as environment variables:

MEMORIZER_ConnectionStrings__Storage=Host=localhost;Port=5432;Database=postgmem;Username=postgres;Password=postgres
MEMORIZER_Embeddings__ApiUrl=http://localhost:11434
MEMORIZER_Embeddings__Model=all-minilm:33m-l12-v2-fp16
MEMORIZER_Embeddings__Dimensions=384
MEMORIZER_Server__CanonicalUrl=example.com:8080

  • MEMORIZER_ConnectionStrings__Storage: PostgreSQL connection string

  • MEMORIZER_Embeddings__ApiUrl: URL of your embedding API (defaults to Ollama)

  • MEMORIZER_Embeddings__Model: The embedding model to use

  • MEMORIZER_Embeddings__Dimensions: The dimension size for embeddings (default: 384)

  • MEMORIZER_Server__CanonicalUrl: (Optional) The canonical URL/hostname for this server. Used for generating MCP configuration. Defaults to localhost:{port} where port is extracted from ASPNETCORE_URLS

For security-related configuration (CORS, database security, etc.), see docs/security.md.

Search Settings

Configure how MCP search results are returned to agents:

MEMORIZER_Search__ReturnFullContent=false

  • MEMORIZER_Search__ReturnFullContent: When false (default), MCP search returns lightweight results containing only ID, title, type, tags, similarity score, and creation date. Agents should use Get or GetMany tools to retrieve full memory content. When true, search returns the full memory body in results. Default is false to optimize context window usage for LLM agents.

⚠️ IMPORTANT: Changing the Dimensions configuration after the database has been initialized will cause runtime errors. PostgreSQL's pgvector extension uses fixed-dimension columns that cannot accept vectors of different sizes. If you need to change dimensions:

  1. For new deployments: Set the desired dimension value before first run

  2. For existing databases: You must manually migrate the database by either:

    • Dropping and recreating the tables with new vector dimensions

    • Creating new columns with the desired dimensions and migrating data

    • Re-embedding all existing content with the new model

Search Evaluation

The internal /api/search-eval endpoints are disabled by default and return HTTP 404. To enable the evaluation tools for local development, set SearchEval:Enabled to true in configuration or set this environment variable:

MEMORIZER_SearchEval__Enabled=true

This enables corpus seeding, deletion, status, evaluation runs, and search comparisons. Keep the setting disabled in production: these endpoints can write test data and make compute-intensive search requests.

MCP Configuration

The server now provides an endpoint to get the MCP configuration JSON at /ui/mcp-config. This endpoint uses the MEMORIZER_Server__CanonicalUrl setting to generate the proper transport URL for MCP clients.

Container Information

The Memorizer application is containerized with the following settings:

  • Repository: memorizer

  • Tags: latest (and version when specified)

  • OS: Linux

  • Supported architectures: linux-x64, linux-arm64, linux-arm

Accessing PostgreSQL

PostgreSQL is configured with the following credentials:

  • Host: localhost

  • Port: 5432

  • Database: memorizer

  • Username: postgres

  • Password: postgres

You can also use PgAdmin to manage the database at http://localhost:5050.

Embedding Model

The system uses the all-minilm:33m-l12-v2-fp16 model from Ollama for generating embeddings.

Shutting Down

To stop the infrastructure services, run:

docker-compose down

To stop and remove all volumes (which will delete all data), run:

docker-compose down -v

Implementation Details

  • Memory.cs: Defines the data model for memories

  • Storage.cs: Handles database operations for storing and retrieving memories

  • EmbeddingService.cs: Generates vector embeddings for text

  • MemoryTools.cs: Implements MCP tools for interacting with the memory storage

MCP Tools

The following MCP tools are available:

Store

Store a new memory in the database.

  • type (string): The type of memory (e.g., 'conversation', 'document', etc.)

  • content (string): The content of the memory as a JSON object

  • source (string): The source of the memory (e.g., 'user', 'system', etc.)

  • tags (string[]): Optional tags to categorize the memory

  • confidence (double): Confidence score for the memory (0.0 to 1.0)

Search

Search for memories similar to the provided text.

  • query (string): The text to search for similar memories

  • limit (int): Maximum number of results to return (default: 10)

  • minSimilarity (double): Minimum similarity threshold (0.0 to 1.0) (default: 0.7)

  • filterTags (string[]): Optional tags to filter memories

Get

Retrieve a specific memory by ID.

  • id (Guid): The ID of the memory to retrieve

Delete

Delete a memory by ID.

  • id (Guid): The ID of the memory to delete

Docker Compose Networking

If you're running both your client application and Memorizer in Docker containers using Docker Compose, ensure they're on the same network. Use the service name as the hostname:

{
  "memorizer": {
    "url": "http://memorizer-api:5000"
  }
}

Testing MCP Connectivity

To test if your MCP connection is working:

  1. Start the Memorizer server

  2. Send a simple curl request to verify the server is responding:

curl http://localhost:5000

You should receive a response from the MCP endpoint.

MCP Configuration Endpoint

The server provides an endpoint to get the MCP configuration JSON at /ui/mcp-config. This endpoint generates the proper configuration using the Server__CanonicalUrl setting:

curl http://localhost:5000/ui/mcp-config

This will return JSON suitable for configuring MCP clients with the correct server URL.

For Contributors

If you want to customize or extend the database schema, see docs/schema-migrations.md for details on how migrations work, how to add new migrations, and best practices for schema changes.

260 files · 244 not served here

Advantages

  • Provides persistent, long-term memory that survives agent session resets. evidence: README.md
  • Supports semantic search through vector embeddings, allowing for context-aware retrieval. evidence: README.md
  • Includes full versioning and audit trails for all memory modifications. evidence: README.md
  • Allows for the creation of knowledge graphs by linking related memories. evidence: README.md

Limitations

  • Requires external infrastructure including PostgreSQL with pgvector and an embedding provider. evidence: README.md
  • Requires manual configuration of MCP clients to point to the correct endpoint. evidence: README.md
  • Upgrades may require database backups and potential schema migrations. evidence: README.md

Security

Risk level: No risk found

This brain runs

This brain runs nothing: AutoGineer found no hooks, scripts, plugin code or MCP servers in its files.

Attribution and licence

Created by
Dario Griffo
Publisher
Petabridge (Official Petabridge project)
Source
petabridge/memorizer · commit d3e90fa
Licence
MIT License (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Dario Griffo or Petabridge.

Install from source

244 of its files are not served here, so there is no ZIP. petabridge/memorizer at d3e90fa