memo-grafter 0.1.1 → 0.2.0

package/.env.example

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

package/README.md

@@ -1,95 +1,187 @@
-# MemoGrafter
-[![npm version](https://img.shields.io/npm/v/memo-grafter.svg)](https://www.npmjs.com/package/memo-grafter)
-
-Structured memory for TypeScript chatbots.
-
-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.
-
-It is a memory framework, not an autonomous agent runtime. It does not run tools, schedule tasks, or decide goals for an agent.
-
-## What You Can Build
-
-- 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
-  -> memory nodes
-  -> graph links
-  -> relevant memory injection
-  -> optional memory grafting
-```
-
-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.
-
-## Install
-
-```bash
-npm install memo-grafter
-```
-
-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-...
-```
-
-## Minimal Example
-
-```ts
-import "dotenv/config";
-
-import {
-  MemoGrafterAgent,
-  OpenAIEmbedAdapter,
-  OpenAILLMAdapter,
-} from "memo-grafter";
-
-const agent = new MemoGrafterAgent({
-  db: { connectionString: process.env.DATABASE_URL! },
-  llm: new OpenAILLMAdapter("gpt-4o"),
-  embedder: new OpenAIEmbedAdapter("text-embedding-3-small"),
-});
-
-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."));
-console.log(await agent.invoke("What do you remember about my travel preferences?"));
-
-await agent.close();
-```
-
-## Memory Grafting
-
-Memory grafting is the core idea behind the name: one chatbot can build memory, and another chatbot can absorb only the useful parts.
-
-```ts
-await writingBot.absorbFromAgent(travelBot, {
-  prompt: "Japan travel preferences",
-  limit: 3,
-});
-```
-
-## Learn More
-
-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:
-
-```text
-examples/chatbot-memory-demo
-```
-
-## License
-
-MIT
+# MemoGrafter
+[![npm version](https://img.shields.io/npm/v/memo-grafter.svg)](https://www.npmjs.com/package/memo-grafter)
+
+Structured memory for TypeScript chatbots.
+
+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.
+
+It is a memory framework, not an autonomous agent runtime. It does not run tools, schedule tasks, or decide goals for an agent.
+
+## What You Can Build
+
+- 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
+  -> memory nodes
+  -> graph links
+  -> relevant memory injection
+  -> optional memory grafting
+```
+
+MemoGrafter stores conversation turns, detects topic shifts, summarizes segments into memory nodes, links related nodes, and injects relevant memory into future LLM calls. Drift detection uses embedding distance, sharp message pivots, short-message dampening, and structural phrases like "by the way" or "going back to" to split conversations into useful topic segments. Memory grafting lets one chatbot or session copy selected memory from another.
+
+## Install
+
+```bash
+npm install memo-grafter
+```
+
+MemoGrafter runs server-side on Node.js. The built-in storage implementation is `PostgresGraphStore`, which requires PostgreSQL with `pgvector`. Included provider adapters require their matching API keys.
+
+```bash
+DATABASE_URL=postgres://postgres:postgres@localhost:5432/memo_grafter
+ANTHROPIC_API_KEY=sk-ant-...
+GEMINI_API_KEY=...
+OPENAI_API_KEY=sk-...
+```
+
+## Minimal Example
+
+```ts
+import "dotenv/config";
+
+import {
+  MemoGrafterAgent,
+  OpenAIEmbedAdapter,
+  OpenAILLMAdapter,
+} from "memo-grafter";
+
+const agent = new MemoGrafterAgent({
+  db: { connectionString: process.env.DATABASE_URL! },
+  llm: new OpenAILLMAdapter("gpt-4o"),
+  embedder: new OpenAIEmbedAdapter("text-embedding-3-small"),
+});
+
+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."));
+console.log(await agent.invoke("What do you remember about my travel preferences?"));
+
+const recall = await agent.recall("travel preferences", {
+  limit: 5,
+  minSimilarity: 0.6,
+});
+
+console.log(recall.facts);
+console.log(recall.systemPrompt);
+
+await agent.close();
+```
+
+## Adapters
+
+MemoGrafter includes provider adapters such as `OpenAILLMAdapter`, `OpenAIEmbedAdapter`, `AnthropicLLMAdapter`, `GeminiLLMAdapter`, and `GeminiEmbedAdapter`. You can also bring any provider by implementing the public adapter interfaces:
+
+```ts
+import {
+  type EmbedAdapter,
+  type LLMAdapter,
+  type Message,
+} from "memo-grafter";
+
+class MyLLMAdapter implements LLMAdapter {
+  async complete(messages: Message[], system?: string): Promise<string> {
+    // Call your model provider here.
+    return "Assistant response";
+  }
+}
+
+class MyEmbedAdapter implements EmbedAdapter {
+  async embed(text: string): Promise<number[]> {
+    // Return an embedding vector matching your storage schema.
+    return [];
+  }
+}
+```
+
+## Storage
+
+MemoGrafter uses a public `GraphStore` interface internally. The default implementation is `PostgresGraphStore`, backed by PostgreSQL and `pgvector`, and this is what `MemoGrafter` and `MemoGrafterAgent` construct from the `db.connectionString` config today.
+
+```ts
+import {
+  PostgresGraphStore,
+  type GraphStore,
+} from "memo-grafter";
+
+const store: GraphStore = new PostgresGraphStore(process.env.DATABASE_URL!);
+```
+
+The interface boundary keeps the Postgres implementation isolated and gives future storage backends a clear contract to implement.
+
+## Targeted Recall
+
+Use `agent.recall()` when you want structured memory back without asking the LLM to answer yet. It searches atomic memory nodes by meaning, filters stale memories, groups them with their parent topic summaries, and returns a prompt block you can inspect or pass to your own model call.
+
+```ts
+const result = await agent.recall("deployment config", {
+  limit: 8,
+  minSimilarity: 0.55,
+  tokenBudget: 1000,
+});
+
+console.log(result.facts);
+console.log(result.nodes);
+console.log(result.systemPrompt);
+console.log(result.tokenCount);
+```
+
+`recall()` is side-effect free. It does not call `invoke()`, does not mutate chat history, and does not inject anything automatically.
+
+## Memory Grafting
+
+Memory grafting is the core idea behind the name: one chatbot can build memory, and another chatbot can absorb only the useful parts.
+
+```ts
+await writingBot.absorbFromAgent(travelBot, {
+  prompt: "Japan travel preferences",
+  limit: 3,
+});
+```
+
+## Drift And Reentry
+
+Use `driftSensitivity` for developer-friendly topic segmentation:
+
+```ts
+const agent = new MemoGrafterAgent({
+  db: { connectionString: process.env.DATABASE_URL! },
+  llm,
+  embedder,
+  drift: {
+    mode: "intent",
+    driftSensitivity: "medium",
+    minSegmentMessages: 3,
+    reentryDetection: true,
+  },
+});
+```
+
+Sensitivity presets are `"low"`, `"medium"`, and `"high"`. The older numeric `threshold` option is still accepted for compatibility, but `driftSensitivity` is preferred.
+
+When a conversation returns to an earlier topic, MemoGrafter can create a `reentry` edge between the new topic node and the earlier related topic node. For example, a chat can move from database decisions to authentication, then back to database pooling; the later database segment is linked back to the original database topic instead of becoming an isolated duplicate.
+
+## Learn More
+
+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:
+
+```text
+examples/chatbot-memory-demo
+```
+
+## License
+
+MIT

package/USER_GUIDE.md

@@ -12,11 +12,12 @@ The most important idea is memory grafting. A chatbot can build useful memory du
 
 - Node.js 18 or newer.
 - TypeScript or modern JavaScript using ES modules.
-- PostgreSQL with the `pgvector` extension enabled.
+- PostgreSQL with the `pgvector` extension enabled for the built-in `PostgresGraphStore`.
 - An LLM adapter.
 - An embedding adapter.
 - An OpenAI API key only if using the included OpenAI adapters.
 - An Anthropic API key only if using the included Anthropic LLM adapter.
+- A Gemini API key only if using the included Gemini adapters.
 - Redis only if enabling queue mode.
 
 MemoGrafter is server-side only. Do not run it in browser code.
@@ -51,16 +52,19 @@ Create a `.env` file in your app:
 ```bash
 DATABASE_URL=postgres://postgres:postgres@localhost:5432/memo_grafter
 ANTHROPIC_API_KEY=sk-ant-...
+GEMINI_API_KEY=...
 OPENAI_API_KEY=sk-...
 REDIS_URL=redis://localhost:6379
 ```
 
-`DATABASE_URL` is required.
+`DATABASE_URL` is required when using the built-in PostgreSQL storage.
 
 `OPENAI_API_KEY` is required only when using `OpenAILLMAdapter` or `OpenAIEmbedAdapter`.
 
 `ANTHROPIC_API_KEY` is required only when using `AnthropicLLMAdapter`.
 
+`GEMINI_API_KEY` is required only when using `GeminiLLMAdapter` or `GeminiEmbedAdapter`.
+
 `REDIS_URL` is optional and only needed when you pass `queue` config.
 
 Enable `pgvector` in PostgreSQL:
@@ -69,7 +73,7 @@ Enable `pgvector` in PostgreSQL:
 CREATE EXTENSION IF NOT EXISTS vector;
 ```
 
-MemoGrafter creates its own tables during `initialize()`.
+The built-in `PostgresGraphStore` creates its own tables during `initialize()`.
 
 Current v1 tables:
 
@@ -77,6 +81,8 @@ Current v1 tables:
 - `mg_segments`
 - `mg_topic_nodes`
 - `mg_topic_edges`
+- `mg_memory_nodes`
+- `mg_memory_edges`
 - `mg_fleets`
 - `mg_fleet_agents`
 
@@ -140,6 +146,14 @@ export interface Message {
 
 A segment is a range of messages that belong to the same topic. MemoGrafter uses drift detection to decide where topic boundaries are.
 
+Drift detection combines several signals:
+
+- how far the current message is from the current topic embedding,
+- whether the current message is a sharp pivot from the previous user message,
+- whether the message contains structural phrases such as "by the way", "different topic", or "going back to",
+- short-message dampening so filler like "okay" or "got it" is less likely to create false boundaries,
+- optional LLM classification for ambiguous topic-shift scores.
+
 Example:
 
 ```text
@@ -166,9 +180,29 @@ Important fields:
 
 Topic nodes are stored in `mg_topic_nodes`.
 
+### Memory Nodes
+
+Memory nodes are typed atomic memories attached to topic nodes. They are the units used by targeted recall.
+
+Important fields:
+
+- `memoryType`: `"fact"`, `"insight"`, `"question"`, `"task"`, or `"reference"`.
+- `subject`, `predicate`, `value`: the structured memory triple.
+- `confidence`: confidence score from `0` to `1`.
+- `topicNodeId`: parent topic node ID.
+- `decayed`: whether the memory is stale.
+- `supersededBy`: newer memory ID when this memory has been replaced.
+
+Memory nodes are stored in `mg_memory_nodes`.
+
 ### Graph Edges
 
-Edges connect related topic nodes. They can represent temporal, semantic, or grafted relationships.
+Edges connect related topic nodes. They can represent temporal, semantic, grafted, or reentry relationships.
+
+- `temporal`: one topic followed another in the conversation.
+- `semantic`: two topics are similar by embedding search.
+- `grafted`: a topic was copied from another session or chatbot.
+- `reentry`: the conversation returned to an earlier topic after discussing something else.
 
 Edges are stored in `mg_topic_edges`.
 
@@ -226,6 +260,40 @@ On every call, `invoke()`:
 
 On the first turn there may be no memory to inject. Later turns can use memory created from earlier turns.
 
+### Targeted Recall
+
+Use `recall()` when you want to retrieve structured memory by meaning without asking the LLM to produce an answer.
+
+```ts
+const result = await agent.recall("deployment config", {
+  limit: 8,
+  minSimilarity: 0.55,
+  tokenBudget: 1000,
+});
+
+console.log(result.facts);
+console.log(result.nodes);
+console.log(result.systemPrompt);
+console.log(result.tokenCount);
+```
+
+`recall()` returns a `RetrievalResult`:
+
+- `facts`: matching memory nodes with a `similarity` score.
+- `nodes`: parent topic nodes for the included facts.
+- `systemPrompt`: a formatted memory block that can be passed to an LLM if you choose.
+- `tokenCount`: approximate token count for the included fact blocks.
+
+Options:
+
+- `limit`: max memory nodes to fetch before filtering. Defaults to `10`.
+- `minSimilarity`: cosine similarity floor. Defaults to `0.6`.
+- `tokenBudget`: max approximate tokens for included fact blocks. Defaults to `1200`.
+
+`recall()` is side-effect free. It does not call `invoke()`, does not trigger a new LLM completion, does not mutate local history, and does not inject the result automatically. Your application decides whether to display the memories, add `result.systemPrompt` to a model call, or ignore the result.
+
+If you call `recall()` immediately after `invoke()`, it only sees memory that has already been ingested into storage. In queue mode, wait for your background worker to finish before expecting newly created memories to appear.
+
 ## Inspecting Memory
 
 Read active topic nodes:
@@ -368,8 +436,11 @@ const agent = new MemoGrafterAgent({
   drift: {
     mode: "intent",
     windowSize: 5,
-    threshold: 0.3,
+    driftSensitivity: "medium",
     minSegmentMessages: 3,
+    llmAmbiguityDetection: false,
+    reentryDetection: true,
+    reentryThreshold: 0.85,
   },
   graph: {
     topK: 5,
@@ -390,7 +461,27 @@ db: {
 }
 ```
 
-PostgreSQL connection string.
+PostgreSQL connection string used by the built-in `PostgresGraphStore`.
+
+MemoGrafter currently constructs `PostgresGraphStore` from this config internally. Advanced users can also import the storage contract directly:
+
+```ts
+import {
+  PostgresGraphStore,
+  type GraphStore,
+} from "memo-grafter";
+
+const store: GraphStore = new PostgresGraphStore(process.env.DATABASE_URL!);
+```
+
+`GraphStore` is the public storage interface. `PostgresGraphStore` is the default PostgreSQL and pgvector implementation.
+
+Useful store inspection methods include:
+
+- `getNodesBySession(sessionId)`: read topic nodes for a session.
+- `getTopicNode(topicNodeId, sessionId?)`: read one topic node by ID.
+- `getSegmentsBySession(sessionId)`: read topic segments for a session.
+- `getEdgesByType(sessionId, type)`: inspect graph edges such as `"reentry"`, `"semantic"`, `"temporal"`, or `"grafted"`.
 
 ### `llm`
 
@@ -406,6 +497,12 @@ Anthropic models can be used with the included Anthropic adapter:
 llm: new AnthropicLLMAdapter("claude-sonnet-4-5")
 ```
 
+Gemini models can be used with the included Gemini adapter:
+
+```ts
+llm: new GeminiLLMAdapter("gemini-2.5-flash")
+```
+
 ### `embedder`
 
 ```ts
@@ -416,14 +513,25 @@ Adapter used to create vectors for semantic search.
 
 Anthropic does not provide a native embedding API. Pair `AnthropicLLMAdapter` with `OpenAIEmbedAdapter` or another custom `EmbedAdapter`.
 
+Gemini embeddings can be used with the included Gemini embedder:
+
+```ts
+embedder: new GeminiEmbedAdapter("gemini-embedding-001")
+```
+
+`GeminiEmbedAdapter` requests 1536-dimensional embeddings by default to match MemoGrafter's current `vector(1536)` database schema. If you change the schema dimension, pass the matching value as the second constructor argument.
+
 ### `drift`
 
 ```ts
 drift: {
   mode: "intent",
   windowSize: 5,
-  threshold: 0.3,
+  driftSensitivity: "medium",
   minSegmentMessages: 3,
+  llmAmbiguityDetection: false,
+  reentryDetection: true,
+  reentryThreshold: 0.85,
 }
 ```
 
@@ -431,11 +539,39 @@ Controls topic boundary detection.
 
 - `mode`: `"intent"` or `"window"`.
 - `windowSize`: message window size for window mode.
-- `threshold`: drift sensitivity.
+- `driftSensitivity`: preferred sensitivity preset, one of `"low"`, `"medium"`, or `"high"`.
+- `threshold`: deprecated numeric threshold. It still works when `driftSensitivity` is not set, but MemoGrafter logs a one-time warning.
 - `minSegmentMessages`: minimum messages before a boundary.
+- `llmAmbiguityDetection`: optional LLM check for borderline topic shifts. Defaults to `false`.
+- `reentryDetection`: whether to link later topic returns back to earlier topic nodes. Defaults to `true`.
+- `reentryThreshold`: embedding similarity threshold for reentry detection. Defaults to `0.85`.
 
 Use `"intent"` for most chatbot memory demos. In intent mode, user messages drive topic shifts.
 
+Sensitivity presets resolve internally to numeric thresholds:
+
+- `"low"`: `0.25`
+- `"medium"`: `0.35`
+- `"high"`: `0.50`
+
+Use `"medium"` first. Boundaries are cut when a drift score exceeds the resolved threshold, so lower numeric thresholds split more readily and higher numeric thresholds require stronger evidence.
+
+If both `driftSensitivity` and `threshold` are provided, `driftSensitivity` wins.
+
+#### Reentry Detection
+
+Reentry detection handles conversations that leave a topic and later return to it:
+
+```text
+database choice -> authentication flow -> database connection pooling
+```
+
+Without reentry detection, the later database discussion is just another topic node. With reentry detection, MemoGrafter creates a `reentry` edge from the later database node back to the earlier database node.
+
+This helps graph traversal and memory injection recover earlier related context. A later question about connection pooling can still be connected to the original PostgreSQL/ACID discussion.
+
+Reentry edges are written between the current rebuilt topic nodes. They do not point at deleted nodes from previous ingestion passes.
+
 ### `graph`
 
 ```ts
@@ -531,6 +667,34 @@ const agent = new MemoGrafterAgent({
 
 Your embedding vector dimension must match the vector dimension expected by the database schema.
 
+## Storage Backends
+
+MemoGrafter exposes storage through the `GraphStore` interface. The built-in implementation is `PostgresGraphStore`, which stores relational data, graph edges, and vector search data in PostgreSQL with `pgvector`.
+
+Most users do not need to instantiate a store directly. `MemoGrafter` and `MemoGrafterAgent` use `PostgresGraphStore` from the `db.connectionString` config:
+
+```ts
+const agent = new MemoGrafterAgent({
+  db: {
+    connectionString: process.env.DATABASE_URL!,
+  },
+  llm,
+  embedder,
+});
+```
+
+If you are extending MemoGrafter, use `GraphStore` as the contract and keep concrete storage details behind an implementation:
+
+```ts
+import type { GraphStore } from "memo-grafter";
+
+class MyGraphStore implements GraphStore {
+  // Implement the full GraphStore contract.
+}
+```
+
+Future storage implementations can use the same interface without changing pipeline or fleet code. For example, a SQLite plus vector-database implementation would implement `GraphStore` while preserving the same behavior expected by ingestion, grafting, and fleet APIs.
+
 ## Fleet API
 
 Fleets let you group color-scoped worker chatbots and use a conductor to graft memory across workers.
@@ -641,11 +805,31 @@ For small demos, try:
 ```ts
 drift: {
   mode: "intent",
-  threshold: 0.3,
+  driftSensitivity: "medium",
   minSegmentMessages: 3,
 }
 ```
 
+If segments are too coarse, try a lower resolved threshold:
+
+```ts
+drift: {
+  mode: "intent",
+  driftSensitivity: "low",
+  minSegmentMessages: 2,
+}
+```
+
+If segments are too fragmented, try a higher resolved threshold:
+
+```ts
+drift: {
+  mode: "intent",
+  driftSensitivity: "high",
+  minSegmentMessages: 4,
+}
+```
+
 ### Absorb Copies Zero Nodes
 
 Inspect the source memory:
@@ -664,6 +848,24 @@ await targetAgent.absorbFromAgent(sourceAgent, {
 });
 ```
 
+### Recall Returns Zero Facts
+
+`recall()` searches atomic memory nodes, not raw chat messages. If it returns no facts:
+
+- Make sure ingestion has completed.
+- Confirm memory nodes exist for the session.
+- Try a lower `minSimilarity`.
+- Try a more specific query that uses the same vocabulary as the original conversation.
+
+Example:
+
+```ts
+const result = await agent.recall("Japan travel preferences", {
+  minSimilarity: 0.3,
+  limit: 5,
+});
+```
+
 ### Redis Warnings
 
 Redis is only required when you pass `queue` config. If you do not need background ingestion, remove the `queue` section.
@@ -697,10 +899,24 @@ Main exports:
 - `WorkerAgent`
 - `ConductorAgent`
 - `AnthropicLLMAdapter`
+- `GeminiLLMAdapter`
+- `GeminiEmbedAdapter`
 - `OpenAILLMAdapter`
 - `OpenAIEmbedAdapter`
+- `PostgresGraphStore`
+- `GraphStore`
+- `FleetAgentRecord`
+- `RetrievalResult`
+- `RetrieverConfig`
 - public shared and fleet types
 
+Useful `GraphStore` inspection methods:
+
+- `getTopicNode(topicNodeId, sessionId?)`
+- `getNodesBySession(sessionId)`
+- `getSegmentsBySession(sessionId)`
+- `getEdgesByType(sessionId, type)`
+
 Common `MemoGrafterAgent` methods:
 
 - `initialize()`: initialize storage.
@@ -709,6 +925,7 @@ Common `MemoGrafterAgent` methods:
 - `getSessionId()`: read the current session ID.
 - `getActiveNodes()`: inspect topic nodes.
 - `getActiveSegments()`: inspect topic segments.
+- `recall(query, options?)`: retrieve structured memory by semantic query.
 - `graft(topicIds?)`: preview memory injection.
 - `ingestGraftedNodes(nodes)`: copy provided nodes into this agent.
 - `absorbFromAgent(sourceAgent, options)`: select and copy memory from another agent.

package/dist/MemoGrafter.d.ts

@@ -1,6 +1,6 @@
-import { GraphStore } from "./store/GraphStore.js";
 import { MemoGrafterFleet } from "./fleet/MemoGrafterFleet.js";
 import type { MemoGrafterFleetOptions } from "./fleet/types.js";
+import type { GraphStore } from "./store/index.js";
 import type { AbsorbFromAgentOptions, EmbedAdapter, InjectionResult, LLMAdapter, MemoGrafterConfig, Message, TopicNode, TopicSegment } from "./types.js";
 export declare class MemoGrafter {
     readonly llm: LLMAdapter;