feedback-memory MCP server
Commit Oct 3, 2026Allows AI agents to remember business context and learn from user corrections by storing and recalling feedback from past drafts.
Also known as ssap-pa/self-learning-agent-setup, self-learning-agent-setup
- Stars
- 1
- Tools
- 5
- Downloads, 30 days
- —
- Latest version
- 0.2.1
- Last commit
- Oct 3, 2026
- License
- MIT
What is feedback-memory MCP?
feedback-memory allows AI agents to remember business context and learn from user corrections by storing and recalling feedback from past drafts. It exposes 5 tools, such as recall_corrections, record_decision, add_rule.
Summary generated from the project's README
About feedback-memory MCP server
Helping AI agents retain business context and learn from user corrections is what feedback-memory enables. It allows developers to build a learning loop where agents recall past feedback before drafting new content, ensuring they do not repeat mistakes or ignore specific brand preferences. This system works by storing every approval, rejection, or edit provided by a human user into a local database.
Users can deploy this as an MCP server for Claude Desktop, Cursor, or Claude Code. It utilizes a local Postgres database via PGlite and pgvector stored in the user's home directory, meaning no external hosting is required. While it can function using simple word hashing for similarity, providing an OpenAI API key allows the server to use text-embedding-3-small for more accurate, meaning-based retrieval. The server provides specific tools including recall_corrections, record_decision, add_rule, list_memory, and forget to manage this growing knowledge base.
What you can do with it
- 1Preventing repetitive drafting errorsAn AI agent can recall a previous rejection to avoid making the same mistake in a new draft.
- 2Maintaining consistent brand voiceYou can establish standing rules that the agent always follows regardless of the specific task.
- 3Learning from specific user editsWhen you correct a draft, the agent stores the reason so it can apply that logic to similar future requests.
Written from the project's README. Every use case is checked against a quote from it.
feedback-memory MCP tools 5
Read from the server with tools/listrecall_correctionsCall this BEFORE you draft anything the user will review (posts, replies, emails, docs, commit messages, UI copy, code in a style they care about). Returns the user's standing rules and their past approve / edit / reject decisions on similar tasks, most similar first. Follow them.
record_decisionCall this right AFTER the user approves, edits or rejects something you drafted. Pass the user's reason in one line when they give one: the reason is what makes the next draft better. For an edit, pass the final text the user wanted.
add_ruleWhen the user states a preference that should ALWAYS apply ("never use exclamation marks", "prices only from the database"), save it as a rule. Rules come back first in every recall_corrections.
list_memoryShow the active rules, the most recent decisions with their ids, and how many approve / edit / reject decisions were stored in the last 7 days. Use it when the user asks what you remember, or to check that decisions are actually being stored.
forgetDelete one rule or one stored decision by id (ids come from list_memory). Use when the user says a rule or a past correction no longer applies.
Configuration
OPENAI_API_KEYSecretOptional. Match by meaning (text-embedding-3-small); empty means offline word hashing
FEEDBACK_MEMORY_DIRWhere the database lives (default ~/.feedback-memory)
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablessap-pa/self-learning-agent-setup is public and reachablegithub.com/ssap-pa/self-learning-agent-setup ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-10-03github.com/ssap-pa/self-learning-agent-setup ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubSelf-Learning Agent Setup
A small, practical pattern for making an AI agent remember your business and learn from every correction you give it. No framework required: a folder of brand files, your existing database, and a feedback table.
I run a one-person education business in Korea this way. Agents (Claude Code, Codex) draft posts and replies. I approve, edit or reject them from my phone. Every decision goes into a database, and the next draft reads that history before it writes a word.
This repo has the minimal schema and the prompts. The full walkthrough is a free 23-page field guide (link at the bottom).
What happened when this agent ran a business for 72 hours with one goal, in numbers: the postmortem on DEV. Short version: product was never the problem.
Try it in one minute
In your browser, no install: https://ssap-pa.github.io/self-learning-agent-setup/ (Postgres + pgvector via PGlite and the all-MiniLM-L6-v2 embedding model via Transformers.js, all running in the tab, no API key).

Locally:
git clone https://github.com/ssap-pa/self-learning-agent-setup
cd self-learning-agent-setup/demo
npm install
npm run demo
It starts an in-memory Postgres (PGlite + pgvector), feeds in three days of feedback for a made-up candle shop (one edit, one reject, one plain approval), then prints what the agent would read before its next drafts. No database or API key needed. npm test runs the tests the same way.
Day 3 new comment: "How long does shipping to Canada take for the lavender set?"
before drafting, the agent reads:
Feedback on similar past tasks (most similar first):
- task: "Do you ship to Canada? Love the lavender candle" -> edited to: "We do! Canada usually takes 5-7 days." (why: don't promise speed, give the real shipping time)
Day 3 new comment: "Could you gift wrap a candle for a birthday?"
before drafting, the agent reads:
Feedback on similar past tasks (most similar first):
- task: "Can you gift wrap the vanilla set for my mom?" -> rejected (why: we don't gift wrap, offer the gift note instead)
Day 3 new comment: "What wax do you use?"
before drafting, the agent reads:
(nothing yet: no feedback on anything similar)
The demo embeds text by hashing words, so "similar" here means shared words. Run EMBED=openai OPENAI_API_KEY=... npm run demo to use real embeddings, or point Loop at your own Postgres / Supabase with pg.
Use it in Claude Code, Cursor or Claude Desktop (MCP server)
feedback-memory is a small MCP server built on the same loop. Your agent calls recall_corrections before it drafts and record_decision after you approve, edit or reject. Everything lives in a local Postgres (PGlite + pgvector) in ~/.feedback-memory, so there's nothing to host.
Claude Code, as a plugin (the easiest way). Your standing rules load when a session starts (and again after /clear or compaction), and the closest past corrections are added to each prompt by a hook, so they apply even when Claude doesn't call a tool:
/plugin marketplace add https://github.com/ssap-pa/self-learning-agent-setup.git
/plugin install feedback-memory@ssap-pa
(The short form /plugin marketplace add ssap-pa/self-learning-agent-setup works too if you have an SSH key set up for GitHub.)
In a real run with the plugin, Claude made no tool calls and still answered a new "how long does shipping to Canada take?" comment with "Thanks for asking. Shipping to Canada usually takes 5-7 business days for the lavender set.": the shipping time from a past edit (reason: don't promise speed) and no exclamation marks, from a stored rule.

Claude Code, MCP server only:
claude mcp add feedback-memory -- npx -y github:ssap-pa/self-learning-agent-setup
Claude Desktop, one click: download feedback-memory.mcpb and open it. The OpenAI key field is optional.
Cursor, or Claude Desktop by hand (under mcpServers in the config JSON):
"feedback-memory": { "command": "npx", "args": ["-y", "github:ssap-pa/self-learning-agent-setup"] }
Then tell the agent when to use it, e.g. two lines in CLAUDE.md / AGENTS.md:
Before drafting anything I'll review, call recall_corrections with the task and follow what comes back.
When I approve, edit or reject your draft, call record_decision with my reason.

Tools: recall_corrections, record_decision, add_rule (standing rules that always come back first), list_memory, forget. Set OPENAI_API_KEY in the server's env to match by meaning (text-embedding-3-small); without it, words are hashed offline (with light stemming, so "shipping" matches "ship") and only shared words match. One database folder per running client (set FEEDBACK_MEMORY_DIR if you run several), so install it one way, not as both the plugin and a separate MCP server. npm test runs an end-to-end test over stdio, and npm run bundle builds the Claude Desktop bundle.
If it helps, a star on the repo helps other people find it, and an issue about what didn't work helps me fix it.
The problem
Anyone can pay for the same model you use. What nobody else can buy is:
- what your agent knows about your business, and
- the record of every correction you've given it.
Most people give feedback in chat and lose it. The next session starts from zero, and you fix "stunning blooms" for the tenth time.
Layer 1: the knowledge layer (what it knows)

| Type | Example | Where it lives |
|---|---|---|
| Constants | Brand, voice, customer, founder story | Markdown files in a brand/ folder |
| Variables | Price, stock, seats, schedule | Your site's database, read live |
| Large knowledge | Lessons, ebooks, FAQs | Same database, embedded for search (RAG) |
Rules that matter:
- Files for who you are, database for what's true right now. Prices in a text file go stale, and the agent quotes last month's promo with confidence.
- The agent can only say what your admin page stores. "3 seats left" requires a seats field.
- Enforce it in code. A rule that only lives in
AGENTS.mdcan be skipped. Programs that run on their own should call the database and search directly.
Layer 2: the learning loop (how it improves)

- Store every approve (+1), reject (−1) and edit (0, with the correction), linked to the run it judges.
- Generate candidates. Repeated feedback becomes a proposed rule, not an active one.
- Score with a rubric per goal.
- Compare the candidate against current behavior.
- Promote or drop.
Plus two details that made it actually work for me:
- Rules vs. memory. "Your tone sounds robotic" always applies (rule). "For funeral orders, no emojis" only applies when the situation matches (memory). Memories that keep repeating get promoted.
- Search feedback by meaning. Keyword search missed feedback phrased differently. Embeddings pull in corrections from similar situations.
And the human part: a Telegram bot sends each draft to my phone with Approve / Reject / Edit buttons, and the taps land in the learning database (not just the bot's log). Check that they actually do. Mine silently wasn't storing approvals at first.
What's here
schema.sql: Postgres / Supabase tables (runs,feedbackwith situation and reason embeddings,rules) andmatch_feedback()for similarity search, with pgvectordemo/loop.ts: the core loop in about 100 lines of TypeScript: store each decision, pull feedback from similar past tasks into the next prompt. Works withpgor PGlitedemo/demo.tsanddemo/loop.test.ts: the one-minute demo and testsprompts.md: the prompts I use with Claude Code / Codex to build and check each layer
Start small
- Run one goal with low limits (mine: 1 post and up to 3 replies a day for two weeks).
- Keep approval on until there's nothing left to correct.
- Measure purchases or signups, not likes.
More
- Need it across machines or a team, or approvals from your phone? The free plugin keeps its memory in one folder on one machine. The Self-Learning Agent Kit runs the same loop on your own Postgres / Supabase so every machine and teammate shares one memory, adds a Telegram bot to approve / edit / reject from your phone (every tap is stored before anything publishes), proposes rules from reasons that keep coming back, and ships Python and TypeScript versions of the library + CLI, an MCP server and its own Claude Code plugin whose hooks read that shared database (by meaning, with OpenAI embeddings), an end-to-end example and 28 tests ($39): https://payhip.com/b/grc25
- Prefer video? A free 22-minute lesson where I build this system with an agent (Korean audio, English subtitles, no account): https://ssapable.com/courses/ai-agent?lang=en&utm_source=github&utm_medium=readme#free-preview
- Free field guide (23 pages, PDF): the full walkthrough with a worked example and a 7-day plan: https://payhip.com/b/QHgfJ
- The book: Just Say "Do It", an 11-step playbook for running a one-person business with AI agents (English edition of my Korean course): https://payhip.com/b/xmZvu. Pay what you want until Sunday, Oct 4 (US Pacific), and $0 is fine; if you read it, an honest review on that page helps a lot.
- Want it set up around your business? Done-for-you automation blueprint: https://payhip.com/b/BzSRC
Text and diagrams (this README, prompts.md, img/) © 2026 AI SSAPABLE, shared under CC BY-NC 4.0. The MIT License in LICENSE covers the code: schema.sql, demo/, docs/, mcp/, hooks/, bundle/ and .claude-plugin/.
feedback-memory MCP questions
What tools does feedback-memory MCP provide?
It exposes 5 tools, including recall_corrections, record_decision, add_rule, list_memory, forget.
How does the server store data?
Everything is stored in a local Postgres database using PGlite and pgvector located in your home directory.
Which AI clients can use this server?
It is compatible with Claude Code, Cursor, and Claude Desktop.
What tools are provided by the server?
The server provides tools to recall corrections, record decisions, add standing rules, list memory, and forget information.