MemoGrafter - Long-Term Memory for Chatbots 🧠

MemoGrafter is a server-side TypeScript library that gives chatbots long-term, topic-aware memory without replaying the full conversation history into every prompt.

It turns conversations into structured memory nodes, links related topics in a graph, and injects only the most relevant memory when the chatbot needs context.

📌 Project Snapshot

Area	Details
Type	TypeScript / Node.js library
Focus	Chatbot memory, graph retrieval, memory grafting
Storage	PostgreSQL + pgvector
Providers	OpenAI, Anthropic, Gemini, custom adapters
GitHub	mayhemking007/memo-grafter
NPM	https://www.npmjs.com/package/memo-grafter

💡 Why It Matters

Most chatbots forget anything outside the current context window. MemoGrafter solves this by converting long conversations into compact, searchable topic memory.

Its key idea is memory grafting: one chatbot or session can selectively absorb useful memory from another without copying the entire history.

🧩 Architecture

                         +----------------------+
                         |     Chatbot App      |
                         |  invoke(user input)  |
                         +----------+-----------+
                                    |
                                    v
                         +----------------------+
                         |  MemoGrafterAgent    |
                         |  memory-aware chat   |
                         +----------+-----------+
                                    |
                 +------------------+------------------+
                 |                                     |
                 v                                     v
        +------------------+                  +------------------+
        | Ingest Pipeline  |                  | Grafter Pipeline |
        | build memory     |                  | retrieve memory  |
        +--------+---------+                  +--------+---------+
                 |                                     |
                 v                                     v
        +------------------+                  +------------------+
        | Topic Detection  |                  | Relevant Nodes   |
        | Segmentation     |                  | Graph Neighbours |
        | Summarization    |                  | Token Budgeting  |
        +--------+---------+                  +--------+---------+
                 |                                     |
                 +------------------+------------------+
                                    |
                                    v
                         +----------------------+
                         | PostgresGraphStore   |
                         | messages, nodes,     |
                         | embeddings, edges    |
                         +----------+-----------+
                                    |
                                    v
                         +----------------------+
                         | PostgreSQL + pgvector|
                         +----------------------+

External adapters:
  - LLM adapter: summarizes segments and generates chatbot responses
  - Embedding adapter: converts messages and memory nodes into vectors

🧱 Core Components

Component	Role
`MemoGrafter`	Low-level memory core.
`MemoGrafterAgent`	Chatbot wrapper with `invoke()`, ingestion, and grafting.
`IngestPipeline`	Converts conversations into topic memory.
`TopicDriftDetector`	Detects topic changes and reentry.
`GrafterPipeline`	Builds memory prompts from retrieved nodes.
`PostgresGraphStore`	Stores messages, embeddings, nodes, and graph edges.
`MemoGrafterFleet`	Enables memory sharing across multiple chatbots.

🔄 Application Flow

A chatbot receives messages through MemoGrafterAgent.invoke().
Messages are stored and embedded.
Topic drift detection groups messages into segments.
Segments become summarized memory nodes.
Related nodes are connected in a graph.
Relevant nodes are retrieved when memory is needed.
MemoGrafter builds a token-budget-aware memory prompt.
Another chatbot can graft selected memory into its own graph.

⚙️ Key Features

Topic-based long-term memory
Relevant memory injection without full-history replay
Memory grafting between chatbots or sessions
PostgreSQL + pgvector graph storage
Provider adapters for OpenAI, Anthropic, Gemini, and custom models
Optional BullMQ + Redis background ingestion
Fleet API for multi-chatbot memory sharing

✅ Summary

MemoGrafter is my flagship AI infrastructure project. It shows my ability to design reusable backend systems for LLM applications, especially around memory, retrieval, embeddings, graph storage, and prompt construction.