memo-grafter 0.1.0 → 0.1.1

package/.env.example

@@ -1,3 +1,4 @@
-DATABASE_URL=postgres://postgres:postgres@localhost:5432/memograffer
-OPENAI_API_KEY=
-REDIS_URL=redis://localhost:6379
+DATABASE_URL=postgres://postgres:postgres@localhost:5432/memograffer
+ANTHROPIC_API_KEY=
+OPENAI_API_KEY=
+REDIS_URL=redis://localhost:6379

package/README.md

@@ -1,73 +1,49 @@
 # MemoGrafter
+[![npm version](https://img.shields.io/npm/v/memo-grafter.svg)](https://www.npmjs.com/package/memo-grafter)
 
-Experimental structured memory for TypeScript chatbots.
+Structured memory for TypeScript chatbots.
 
-MemoGrafter turns chatbot conversations into topic segments, topic nodes, and graph edges, then injects relevant memory into future turns. Its core idea is memory grafting: copying useful conversational memory from one chatbot or session into another.
+MemoGrafter helps chatbot applications remember conversations without stuffing every old message back into the prompt. It turns conversations into topic-based memory, retrieves the relevant parts later, and can copy useful memory from one chatbot or session into another.
 
-MemoGrafter is a chatbot memory framework. It is not an autonomous agent runtime.
+It is a memory framework, not an autonomous agent runtime. It does not run tools, schedule tasks, or decide goals for an agent.
 
-## Why MemoGrafter?
+## What You Can Build
 
-Most chatbots either forget old context or keep stuffing long chat history back into the prompt. MemoGrafter explores a different shape:
-
-- store conversations as structured memory
-- detect topic shifts
-- summarize topic segments into memory nodes
-- connect related nodes in a graph
-- inject only relevant memory into later calls
-- graft selected memory into another chatbot/session
-
-The project is early-stage and experimental, but it is useful for demos, prototypes, and exploring memory workflows beyond plain chat history.
+- Chatbots that remember user preferences across long conversations.
+- Support or tutoring assistants that recall prior topics without replaying full history.
+- Multi-chatbot demos where one bot can absorb selected memory from another.
+- Prototypes for graph-based conversational memory, retrieval, and memory transfer.
+- Server-side TypeScript apps that need reusable LLM memory primitives.
 
 ## How It Works
 
+At a high level:
+
 ```text
 chat messages
   -> topic segments
-  -> topic nodes
-  -> graph edges
-  -> memory injection
-  -> selective grafting into another chatbot
+  -> memory nodes
+  -> graph links
+  -> relevant memory injection
+  -> optional memory grafting
 ```
 
-On each chatbot call, MemoGrafter can retrieve existing topic memory and pass it to the LLM as a system prompt. After the response, it ingests the updated conversation so future turns have better memory.
+MemoGrafter stores conversation turns, detects topic shifts, summarizes segments into memory nodes, links related nodes, and injects relevant memory into future LLM calls. Memory grafting lets one chatbot or session copy selected memory from another.
 
-## Installation
+## Install
 
 ```bash
 npm install memo-grafter
 ```
 
-For local development from this repository:
-
-```bash
-git clone <repo-url> project-memoGrafter
-cd project-memoGrafter
-npm install
-npm run build
-```
-
-Then install it from a local app:
-
-```bash
-npm install D:/cohort/projects/project-memoGrafter
-```
-
-## Environment
+MemoGrafter runs server-side on Node.js and requires PostgreSQL with `pgvector`. The included OpenAI adapters also require `OPENAI_API_KEY`.
 
 ```bash
 DATABASE_URL=postgres://postgres:postgres@localhost:5432/memo_grafter
 OPENAI_API_KEY=sk-...
-REDIS_URL=redis://localhost:6379
 ```
 
-`DATABASE_URL` is required. PostgreSQL must have `pgvector` enabled.
-
-`OPENAI_API_KEY` is only needed when using the included OpenAI adapters.
-
-`REDIS_URL` is optional and only needed for queue mode.
-
-## Minimal Usage
+## Minimal Example
 
 ```ts
 import "dotenv/config";
@@ -79,9 +55,7 @@ import {
 } from "memo-grafter";
 
 const agent = new MemoGrafterAgent({
-  db: {
-    connectionString: process.env.DATABASE_URL!,
-  },
+  db: { connectionString: process.env.DATABASE_URL! },
   llm: new OpenAILLMAdapter("gpt-4o"),
   embedder: new OpenAIEmbedAdapter("text-embedding-3-small"),
 });
@@ -90,86 +64,25 @@ await agent.initialize();
 
 console.log(await agent.invoke("I am planning a Japan trip."));
 console.log(await agent.invoke("I like quiet towns, bookstores, and local cafes."));
-
-const nodes = await agent.getActiveNodes();
-console.log(nodes.map((node) => ({ label: node.label, summary: node.summary })));
+console.log(await agent.invoke("What do you remember about my travel preferences?"));
 
 await agent.close();
 ```
 
-Run with:
-
-```bash
-npx tsx --env-file=.env src/index.ts
-```
-
 ## Memory Grafting
 
-Memory grafting copies selected memory from one chatbot/session into another.
+Memory grafting is the core idea behind the name: one chatbot can build memory, and another chatbot can absorb only the useful parts.
 
 ```ts
-const travelBot = new MemoGrafterAgent(config);
-const writingBot = new MemoGrafterAgent(config);
-
-await travelBot.initialize();
-await writingBot.initialize();
-
-await travelBot.invoke("I am planning a Japan trip.");
-await travelBot.invoke("I like quiet towns, bookstores, and local cafes.");
-await travelBot.invoke("My budget is around 2500 dollars.");
-
 await writingBot.absorbFromAgent(travelBot, {
   prompt: "Japan travel preferences",
-  minSimilarity: 0.6,
   limit: 3,
 });
-
-const intro = await writingBot.invoke(
-  "Suggest a reflective blog intro for my Japan trip."
-);
-
-console.log(intro);
-
-await travelBot.close();
-await writingBot.close();
 ```
 
-You can also preview a graft before copying it:
-
-```ts
-const graft = await travelBot.graft();
-
-console.log(graft.systemPrompt);
-console.log(graft.nodes);
-console.log(graft.tokenCount);
-```
-
-## Key Features
-
-- Structured chatbot memory over PostgreSQL and pgvector.
-- Topic drift detection for splitting conversations into segments.
-- Topic nodes with summaries, embeddings, message ranges, and graph edges.
-- Automatic memory injection during chatbot calls.
-- Selective memory grafting by topic ID or semantic prompt.
-- Optional BullMQ/Redis queue mode for background ingestion.
-- OpenAI adapters included.
-- Custom LLM and embedding adapters supported.
-- Minimal fleet API for color-scoped worker chatbots and conductor grafting.
-
-## Requirements
-
-- Node.js 18 or newer.
-- Server-side Node.js runtime.
-- PostgreSQL with `pgvector`.
-- An LLM adapter and embedding adapter.
-- OpenAI API key if using `OpenAILLMAdapter` or `OpenAIEmbedAdapter`.
-- Redis only if using queue mode.
-
-MemoGrafter does not run in browser code.
-
 ## Learn More
 
-Read the full [USER_GUIDE.md](./USER_GUIDE.md) for setup, concepts, configuration, queue mode, custom adapters, fleet usage, examples, and troubleshooting.
+Read [USER_GUIDE.md](https://github.com/mayhemking007/memo-grafter/blob/main/USER_GUIDE.md) for setup, configuration, queue mode, custom adapters, fleet APIs, examples, and troubleshooting.
 
 This repository also includes a runnable demo: