@coreidentitylabs/open-graph-memory-mcp 1.0.1

package/Implementation Plan.md

@@ -0,0 +1,358 @@
+# Open-Memory MCP Server — Implementation Plan
+
+A graph-based agent memory MCP server that **extends AI coding assistant memory** for developers using Google Antigravity or VS Code GitHub Copilot.
+
+## Problem Statement
+
+1. **Context window loss** — all LLM-based coding assistants lose context as conversations grow, forcing developers to re-explain code architecture and past changes repeatedly
+2. **Rapid code evolution** — frequent features/bug fixes cause project documentation to become outdated quickly
+3. **No persistent developer memory** — conversations are ephemeral; valuable decisions, patterns, and context are lost between sessions
+
+## Solution
+
+An MCP server that captures conversations, extracts entities/relationships into a knowledge graph, and provides relevant historical context back to the agent _before_ API calls — effectively giving the AI a persistent project memory.
+
+---
+
+## Architecture
+
+```mermaid
+graph TB
+    subgraph IDE["IDE (Antigravity / Copilot)"]
+        Agent["AI Agent"]
+    end
+
+    subgraph MCP["open-memory-mcp-server (stdio)"]
+        Tools["MCP Tools Layer"]
+        Resources["MCP Resources"]
+        Encoder["Encoding Pipeline"]
+        Retriever["Retrieval Engine"]
+        Evolve["Evolution Engine"]
+    end
+
+    subgraph Storage["Storage Backend (configurable)"]
+        JSON["Local JSON File"]
+        Neo4j["Neo4j Graph DB"]
+    end
+
+    subgraph LLM["LLM Provider (pluggable)"]
+        OpenAI["OpenAI"]
+        Gemini["Google Gemini"]
+        Claude["Anthropic Claude"]
+        Ollama["Ollama (local)"]
+    end
+
+    Agent <-->|stdio| Tools
+    Agent -->|read| Resources
+    Tools --> Encoder
+    Tools --> Retriever
+    Tools --> Evolve
+    Encoder --> LLM
+    Retriever --> LLM
+    Encoder --> Storage
+    Retriever --> Storage
+    Evolve --> Storage
+```
+
+### Key Design Decisions
+
+| Decision         | Choice                  | Rationale                                                      |
+| ---------------- | ----------------------- | -------------------------------------------------------------- |
+| **Storage**      | Both JSON + Neo4j       | JSON for zero-config dev; Neo4j for production graph queries   |
+| **LLM Provider** | Pluggable via config    | Adapts to user's model selection in IDE                        |
+| **Transport**    | stdio                   | Standard for local IDE integrations                            |
+| **Language**     | TypeScript              | Best SDK support, good AI code generation                      |
+| **Encoding**     | LLM-based extraction    | Outperforms NER for novel entity types and implicit relations  |
+| **Retrieval**    | Hybrid semantic + graph | Vector similarity finds anchors; graph traversal finds context |
+
+---
+
+## Proposed Changes
+
+### 1. Project Scaffolding
+
+#### [NEW] [package.json](file:///d:/Projects/open-memory/package.json)
+
+Dependencies:
+
+- `@modelcontextprotocol/sdk` — MCP protocol
+- `zod` — input validation
+- `openai` — default LLM provider (OpenAI-compatible API)
+- `neo4j-driver` — Neo4j graph database driver
+- `uuid` — unique node IDs
+- `dotenv` — environment config
+
+#### [NEW] [tsconfig.json](file:///d:/Projects/open-memory/tsconfig.json)
+
+#### [NEW] [.env.example](file:///d:/Projects/open-memory/.env.example)
+
+#### [NEW] [README.md](file:///d:/Projects/open-memory/README.md)
+
+---
+
+### 2. Core Data Model
+
+#### [NEW] [src/types.ts](file:///d:/Projects/open-memory/src/types.ts)
+
+```typescript
+// --- Memory Nodes ---
+interface MemoryNode {
+  id: string; // UUID
+  name: string; // canonical entity name
+  type: "entity" | "concept" | "event" | "code_pattern" | "decision";
+  description: string;
+  embedding: number[]; // vector for semantic retrieval
+  metadata: Record<string, unknown>; // flexible attrs (file paths, languages, etc.)
+  createdAt: string; // ISO timestamp (transaction time)
+  updatedAt: string;
+  validFrom?: string; // bi-temporal: when fact became true
+  validUntil?: string; // bi-temporal: when fact expired
+  source?: string; // "conversation" | "code_change" | "manual"
+  accessCount: number; // for retrieval ranking
+  lastAccessedAt?: string;
+}
+
+// --- Memory Edges ---
+interface MemoryEdge {
+  id: string;
+  source: string; // node ID
+  target: string; // node ID
+  relation: string; // e.g. "works_on", "depends_on", "decided_to"
+  description: string;
+  weight: number; // 0-1 confidence/strength
+  metadata: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// --- Storage Backend Interface ---
+interface StorageBackend {
+  initialize(): Promise<void>;
+  addNode(node: MemoryNode): Promise<void>;
+  updateNode(id: string, updates: Partial<MemoryNode>): Promise<void>;
+  deleteNode(id: string): Promise<void>;
+  getNode(id: string): Promise<MemoryNode | null>;
+  findNodesByName(name: string): Promise<MemoryNode[]>;
+  findNodesByEmbedding(
+    embedding: number[],
+    topK: number,
+  ): Promise<ScoredNode[]>;
+  getNeighborhood(nodeId: string, depth: number): Promise<Subgraph>;
+  addEdge(edge: MemoryEdge): Promise<void>;
+  deleteEdge(id: string): Promise<void>;
+  getEdgesForNode(nodeId: string): Promise<MemoryEdge[]>;
+  getAllNodes(filter?: NodeFilter): Promise<MemoryNode[]>;
+  getStats(): Promise<GraphStats>;
+  close(): Promise<void>;
+}
+
+// --- LLM Provider Interface ---
+interface LLMProvider {
+  extractEntitiesAndRelations(
+    text: string,
+    existingEntities: string[],
+  ): Promise<ExtractionResult>;
+  generateEmbedding(text: string): Promise<number[]>;
+  generateEmbeddingBatch(texts: string[]): Promise<number[][]>;
+}
+```
+
+---
+
+### 3. Storage Backends
+
+#### [NEW] [src/storage/json-store.ts](file:///d:/Projects/open-memory/src/storage/json-store.ts)
+
+Local JSON file storage implementing `StorageBackend`:
+
+- Atomic file writes with temp-file rename
+- In-memory index for fast lookups
+- Brute-force cosine similarity for embedding search (sufficient for <10K nodes)
+- Configurable file path via `MEMORY_STORE_PATH`
+
+#### [NEW] [src/storage/neo4j-store.ts](file:///d:/Projects/open-memory/src/storage/neo4j-store.ts)
+
+Neo4j storage implementing `StorageBackend`:
+
+- Cypher queries for CRUD + multi-hop traversal
+- Neo4j vector index for embedding search
+- Connection config via `NEO4J_URI`, `NEO4J_USER`, `NEO4J_PASSWORD`
+- Auto-creates schema constraints/indexes on first run
+
+#### [NEW] [src/storage/factory.ts](file:///d:/Projects/open-memory/src/storage/factory.ts)
+
+Factory function: reads `STORAGE_BACKEND` env var (`"json"` | `"neo4j"`) and returns the appropriate implementation.
+
+---
+
+### 4. LLM Provider Abstraction
+
+#### [NEW] [src/llm/provider.ts](file:///d:/Projects/open-memory/src/llm/provider.ts)
+
+Interface + factory for LLM providers. Reads `LLM_PROVIDER` env var.
+
+#### [NEW] [src/llm/openai-provider.ts](file:///d:/Projects/open-memory/src/llm/openai-provider.ts)
+
+OpenAI-compatible provider (works with OpenAI, Azure OpenAI, local Ollama with OpenAI-compat API):
+
+- Entity/relation extraction via chat completion (structured JSON output)
+- Embeddings via embeddings API
+- Configurable model names via `LLM_CHAT_MODEL` and `LLM_EMBEDDING_MODEL`
+
+#### [NEW] [src/llm/prompts.ts](file:///d:/Projects/open-memory/src/llm/prompts.ts)
+
+System prompts for entity extraction and relationship extraction, optimized for developer conversations (code patterns, architecture decisions, file references, dependencies).
+
+---
+
+### 5. Encoding Pipeline
+
+#### [NEW] [src/encoding/pipeline.ts](file:///d:/Projects/open-memory/src/encoding/pipeline.ts)
+
+Orchestrates the full encoding flow:
+
+1. **Extract** entities + relationships from message text (via LLM)
+2. **Resolve** entities against existing graph (fuzzy name match + embedding similarity)
+3. **Embed** new entity descriptions
+4. **Store** nodes and edges with temporal metadata
+5. **Return** summary of what was stored
+
+---
+
+### 6. Retrieval Engine
+
+#### [NEW] [src/retrieval/search.ts](file:///d:/Projects/open-memory/src/retrieval/search.ts)
+
+Hybrid retrieval:
+
+1. Embed query → find top-K nodes by cosine similarity (semantic anchors)
+2. From anchors, traverse 2-hop neighborhood (graph context)
+3. Apply temporal filtering (prefer recent, valid facts)
+4. Rank: `score = α·semantic + β·proximity + γ·recency + δ·access_frequency`
+5. Format as structured context ready for injection into LLM prompt
+
+---
+
+### 7. Memory Evolution
+
+#### [NEW] [src/evolution/consolidator.ts](file:///d:/Projects/open-memory/src/evolution/consolidator.ts)
+
+- **Duplicate merging**: Detect similar nodes (embedding similarity > threshold) and merge
+- **Conflict resolution**: Temporal invalidation of contradicted facts
+- **Edge inference**: Transitive relationship detection
+- **Pruning**: Remove stale, low-access nodes past a configurable age
+
+---
+
+### 8. MCP Tools & Resources
+
+#### [NEW] [src/tools/memory-tools.ts](file:///d:/Projects/open-memory/src/tools/memory-tools.ts)
+
+| Tool                   | Action                                                        | Annotations |
+| ---------------------- | ------------------------------------------------------------- | ----------- |
+| `memory_save_message`  | Ingest conversation text → extract & store entities/relations | write       |
+| `memory_search`        | Hybrid semantic + graph search for relevant context           | read-only   |
+| `memory_get_entity`    | Get specific entity with its relationships                    | read-only   |
+| `memory_list_entities` | List entities with pagination & type filter                   | read-only   |
+| `memory_get_relations` | Get all relationships for an entity                           | read-only   |
+| `memory_delete`        | Remove a memory node and its edges                            | destructive |
+| `memory_consolidate`   | Trigger manual memory consolidation                           | write       |
+| `memory_status`        | Node/edge counts, storage type, last consolidation            | read-only   |
+
+#### [NEW] [src/resources/context-resource.ts](file:///d:/Projects/open-memory/src/resources/context-resource.ts)
+
+MCP Resource exposing a `memory://context/recent` URI that returns the most relevant recent memories — enabling automatic context injection without explicit tool calls.
+
+---
+
+### 9. Server Entry Point
+
+#### [NEW] [src/index.ts](file:///d:/Projects/open-memory/src/index.ts)
+
+- Load env config (dotenv)
+- Initialize storage backend (JSON or Neo4j)
+- Initialize LLM provider
+- Register all tools + resources
+- Connect via `StdioServerTransport`
+
+---
+
+## File Tree Summary
+
+```
+open-memory/
+├── package.json
+├── tsconfig.json
+├── .env.example
+├── README.md
+└── src/
+    ├── index.ts                      # entry point
+    ├── types.ts                      # data models & interfaces
+    ├── constants.ts                  # config constants
+    ├── storage/
+    │   ├── factory.ts                # backend constructor
+    │   ├── json-store.ts             # local JSON backend
+    │   └── neo4j-store.ts            # Neo4j backend
+    ├── llm/
+    │   ├── provider.ts               # LLM abstraction + factory
+    │   ├── openai-provider.ts        # OpenAI-compatible provider
+    │   └── prompts.ts                # extraction prompts
+    ├── encoding/
+    │   └── pipeline.ts               # extract → resolve → embed → store
+    ├── retrieval/
+    │   └── search.ts                 # hybrid semantic + graph search
+    ├── evolution/
+    │   └── consolidator.ts           # merge, prune, infer
+    ├── tools/
+    │   └── memory-tools.ts           # 8 MCP tools
+    └── resources/
+        └── context-resource.ts       # auto-inject context resource
+```
+
+---
+
+## Environment Configuration
+
+```env
+# Storage (required)
+STORAGE_BACKEND=json                   # "json" or "neo4j"
+MEMORY_STORE_PATH=./memory.json        # for json backend
+
+# Neo4j (required if STORAGE_BACKEND=neo4j)
+NEO4J_URI=bolt://localhost:7687
+NEO4J_USER=neo4j
+NEO4J_PASSWORD=password
+
+# LLM (required)
+LLM_PROVIDER=openai                    # "openai" (OpenAI-compatible)
+LLM_API_KEY=sk-...
+LLM_BASE_URL=https://api.openai.com/v1 # change for Ollama, Azure, etc.
+LLM_CHAT_MODEL=gpt-4o-mini
+LLM_EMBEDDING_MODEL=text-embedding-3-small
+```
+
+---
+
+## Verification Plan
+
+### Build Verification
+
+```bash
+cd d:/Projects/open-memory && npm run build
+```
+
+### MCP Inspector
+
+```bash
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+### Smoke Test Scenario
+
+1. `memory_status` → `{ nodes: 0, edges: 0, storage: "json" }`
+2. `memory_save_message` with `"We decided to use React Query for data fetching in the dashboard module"`
+3. `memory_list_entities` → should show `React Query`, `dashboard module` entities
+4. `memory_search` with `"What did we decide about data fetching?"` → returns the decision context
+5. `memory_save_message` with `"Actually, we switched from React Query to SWR for the dashboard"`
+6. `memory_search` again → should show SWR as current, React Query as outdated (temporal invalidation)
+7. `memory_consolidate` → completes without errors

package/README.md

@@ -0,0 +1,187 @@
+# Open-Memory MCP Server
+
+**Graph-based agent memory for AI coding assistants** — extends context windows by storing entities, relationships, and decisions in a persistent knowledge graph.
+
+## Problem
+
+AI coding assistants (Google Antigravity, VS Code GitHub Copilot) lose context as conversations grow. Developers repeatedly re-explain code architecture and past decisions. Open-Memory solves this by giving your AI a persistent, structured memory.
+
+## How It Works
+
+### Agent-Driven Flow (no API key needed)
+
+```
+You chat with your AI assistant
+  ↓ Agent extracts entities/decisions from conversation
+  ↓ Calls memory_add_entities / memory_add_relations
+  ↓ Entities stored in knowledge graph (JSON or Neo4j)
+  ↓ Before next task, agent calls memory_search or memory_get_context
+  ↓ Relevant historical context injected into prompt
+  = AI remembers your project across sessions
+```
+
+### Server-Side Encoding Flow (optional, requires LLM API key)
+
+```
+You pass raw text to memory_encode_text
+  ↓ Server-side LLM extracts entities + relationships automatically
+  ↓ Entity resolution against existing graph (dedup)
+  ↓ LLM-quality embeddings generated
+  ↓ Nodes + edges stored
+  = Fully automated — no manual entity extraction needed
+```
+
+## Installation & Usage
+
+You can run **Open-Memory** directly without manual installation using `npx`. This is the recommended way for both VS Code and Claude Desktop.
+
+### 1. VS Code (via MCP Extension)
+
+1. Install the [MCP](https://marketplace.visualstudio.com/items?itemName=mcp.mcp) extension for VS Code.
+2. Open the extension settings or click the MCP icon in the status bar.
+3. Click "Add MCP Server" and enter:
+   - **Command**: `npx`
+   - **Arguments**: `-y @coreidentitylabs/open-graph-memory-mcp` (or `npx -y github:YOUR_USERNAME/open-memory` if not on NPM yet)
+
+### 2. Claude Desktop / Antigravity Desktop
+
+Add the following to your MCP configuration file (e.g., `%APPDATA%\Claude\claude_desktop_config.json` or `config.json` for Antigravity):
+
+```json
+{
+  "mcpServers": {
+    "open-memory": {
+      "command": "npx",
+      "args": ["-y", "@coreidentitylabs/open-graph-memory-mcp"],
+      "env": {
+        "STORAGE_BACKEND": "json",
+        "MEMORY_STORE_PATH": "C:/path/to/your/memory.json"
+      }
+    }
+  }
+}
+```
+
+### 3. Manual Development Setup
+
+If you want to contribute or run from source:
+
+```bash
+# Clone and install dependencies
+git clone https://github.com/YOUR_USERNAME/open-memory.git
+cd open-memory
+npm install
+
+# Build
+npm run build
+
+# Run (stdio mode)
+node dist/index.js
+```
+
+### Environment Variables
+
+```bash
+# Storage backend: "json" (default) or "neo4j"
+STORAGE_BACKEND=json
+MEMORY_STORE_PATH=./memory.json
+
+# Neo4j (only if STORAGE_BACKEND=neo4j)
+NEO4J_URI=bolt://localhost:7687
+NEO4J_USER=neo4j
+NEO4J_PASSWORD=password
+
+# Optional: Server-side encoding (memory_encode_text tool)
+# Works with OpenAI, Azure OpenAI, Ollama (OpenAI-compat), etc.
+# LLM_API_KEY=sk-...
+# LLM_BASE_URL=https://api.openai.com/v1
+# LLM_CHAT_MODEL=gpt-4o-mini
+# LLM_EMBEDDING_MODEL=text-embedding-3-small
+```
+
+### MCP Client Configuration
+
+Add to your MCP config (e.g. `mcp_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "open-memory": {
+      "command": "node",
+      "args": ["d:/Projects/open-memory/dist/index.js"],
+      "env": {
+        "STORAGE_BACKEND": "json",
+        "MEMORY_STORE_PATH": "./memory.json"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+### Write
+
+| Tool                       | Description                                                        | LLM Required |
+| -------------------------- | ------------------------------------------------------------------ | :----------: |
+| `memory_add_entities`      | Store entities (people, tools, concepts, code patterns, decisions) |      ❌      |
+| `memory_add_relations`     | Store relationships between entities                               |      ❌      |
+| `memory_save_conversation` | Save conversation snapshots for history                            |      ❌      |
+| `memory_encode_text`       | **Auto-extract entities & relations from raw text via LLM**        |      ✅      |
+
+### Read
+
+| Tool                   | Description                                |
+| ---------------------- | ------------------------------------------ |
+| `memory_search`        | Hybrid semantic + graph search             |
+| `memory_get_entity`    | Get entity details with relationships      |
+| `memory_list_entities` | List entities with filtering/pagination    |
+| `memory_get_relations` | Get relationships for an entity            |
+| `memory_get_context`   | Get formatted context for prompt injection |
+
+### Management
+
+| Tool                   | Description                                      |
+| ---------------------- | ------------------------------------------------ |
+| `memory_delete_entity` | Remove entity and its edges                      |
+| `memory_consolidate`   | Merge duplicates, prune stale nodes, infer edges |
+| `memory_status`        | Graph health stats                               |
+
+## Architecture
+
+```
+src/
+├── index.ts                  # Entry point (stdio transport)
+├── types.ts                  # Core type definitions
+├── constants.ts              # Configuration constants
+├── storage/
+│   ├── json-store.ts         # Local JSON file backend
+│   ├── neo4j-store.ts        # Neo4j graph database backend
+│   └── factory.ts            # Storage backend factory
+├── encoding/
+│   ├── embedder.ts           # Offline n-gram embeddings
+│   └── pipeline.ts           # Server-side encoding pipeline
+├── llm/
+│   ├── provider.ts           # LLM provider factory
+│   ├── openai-provider.ts    # OpenAI-compatible provider
+│   └── prompts.ts            # Extraction prompts
+├── retrieval/
+│   └── search.ts             # Hybrid search engine
+├── evolution/
+│   └── consolidator.ts       # Memory consolidation
+├── tools/
+│   └── memory-tools.ts       # MCP tool definitions
+└── resources/
+    └── context-resource.ts   # MCP resources
+```
+
+- **Storage**: Pluggable backend — JSON file (zero-config) or Neo4j (production)
+- **Embeddings**: Offline n-gram hashing by default, LLM embeddings when configured
+- **Retrieval**: Hybrid text + semantic + graph traversal with weighted scoring
+- **Evolution**: Duplicate merging, transitive edge inference, stale node pruning
+- **Encoding**: Optional server-side LLM pipeline (OpenAI, Ollama, Azure, etc.)
+- **Transport**: stdio (standard for IDE integrations)
+
+## License
+
+MIT

package/dist/constants.d.ts

@@ -0,0 +1,34 @@
+/** Maximum response size in characters to prevent overwhelming the agent */
+export declare const CHARACTER_LIMIT = 25000;
+/** Default number of results in paginated responses */
+export declare const DEFAULT_PAGE_SIZE = 20;
+/** Maximum page size for list operations */
+export declare const MAX_PAGE_SIZE = 100;
+/** Default number of hops for graph neighborhood traversal */
+export declare const DEFAULT_TRAVERSAL_DEPTH = 2;
+/** Default number of results for semantic search */
+export declare const DEFAULT_TOP_K = 10;
+/** Similarity threshold for duplicate detection during consolidation */
+export declare const DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+/** Minimum edge weight to keep during pruning */
+export declare const MIN_EDGE_WEIGHT = 0.1;
+/** Maximum age (days) for stale node pruning — nodes not accessed in this period */
+export declare const STALE_NODE_AGE_DAYS = 90;
+/** Default storage file path */
+export declare const DEFAULT_MEMORY_STORE_PATH = "./memory.json";
+/** Server name for MCP registration */
+export declare const SERVER_NAME = "open-memory-mcp-server";
+/** Server version */
+export declare const SERVER_VERSION = "1.0.0";
+export declare const ENV_KEYS: {
+    readonly STORAGE_BACKEND: "STORAGE_BACKEND";
+    readonly MEMORY_STORE_PATH: "MEMORY_STORE_PATH";
+    readonly NEO4J_URI: "NEO4J_URI";
+    readonly NEO4J_USER: "NEO4J_USER";
+    readonly NEO4J_PASSWORD: "NEO4J_PASSWORD";
+    readonly LLM_API_KEY: "LLM_API_KEY";
+    readonly LLM_BASE_URL: "LLM_BASE_URL";
+    readonly LLM_CHAT_MODEL: "LLM_CHAT_MODEL";
+    readonly LLM_EMBEDDING_MODEL: "LLM_EMBEDDING_MODEL";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAIA,4EAA4E;AAC5E,eAAO,MAAM,eAAe,QAAS,CAAC;AAEtC,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,4CAA4C;AAC5C,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,oDAAoD;AACpD,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,wEAAwE;AACxE,eAAO,MAAM,8BAA8B,OAAO,CAAC;AAEnD,iDAAiD;AACjD,eAAO,MAAM,eAAe,MAAM,CAAC;AAEnC,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,gCAAgC;AAChC,eAAO,MAAM,yBAAyB,kBAAkB,CAAC;AAEzD,uCAAuC;AACvC,eAAO,MAAM,WAAW,2BAA2B,CAAC;AAEpD,qBAAqB;AACrB,eAAO,MAAM,cAAc,UAAU,CAAC;AAMtC,eAAO,MAAM,QAAQ;;;;;;;;;;CAUX,CAAC"}

package/dist/constants.js

@@ -0,0 +1,40 @@
+// =============================================================================
+// Open-Memory MCP Server — Constants & Configuration
+// =============================================================================
+/** Maximum response size in characters to prevent overwhelming the agent */
+export const CHARACTER_LIMIT = 25_000;
+/** Default number of results in paginated responses */
+export const DEFAULT_PAGE_SIZE = 20;
+/** Maximum page size for list operations */
+export const MAX_PAGE_SIZE = 100;
+/** Default number of hops for graph neighborhood traversal */
+export const DEFAULT_TRAVERSAL_DEPTH = 2;
+/** Default number of results for semantic search */
+export const DEFAULT_TOP_K = 10;
+/** Similarity threshold for duplicate detection during consolidation */
+export const DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+/** Minimum edge weight to keep during pruning */
+export const MIN_EDGE_WEIGHT = 0.1;
+/** Maximum age (days) for stale node pruning — nodes not accessed in this period */
+export const STALE_NODE_AGE_DAYS = 90;
+/** Default storage file path */
+export const DEFAULT_MEMORY_STORE_PATH = "./memory.json";
+/** Server name for MCP registration */
+export const SERVER_NAME = "open-memory-mcp-server";
+/** Server version */
+export const SERVER_VERSION = "1.0.0";
+// -----------------------------------------------------------------------------
+// Environment variable keys
+// -----------------------------------------------------------------------------
+export const ENV_KEYS = {
+    STORAGE_BACKEND: "STORAGE_BACKEND",
+    MEMORY_STORE_PATH: "MEMORY_STORE_PATH",
+    NEO4J_URI: "NEO4J_URI",
+    NEO4J_USER: "NEO4J_USER",
+    NEO4J_PASSWORD: "NEO4J_PASSWORD",
+    LLM_API_KEY: "LLM_API_KEY",
+    LLM_BASE_URL: "LLM_BASE_URL",
+    LLM_CHAT_MODEL: "LLM_CHAT_MODEL",
+    LLM_EMBEDDING_MODEL: "LLM_EMBEDDING_MODEL",
+};
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,qDAAqD;AACrD,gFAAgF;AAEhF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC;AAEtC,uDAAuD;AACvD,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAEpC,4CAA4C;AAC5C,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,CAAC;AAEjC,8DAA8D;AAC9D,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC;AAEzC,oDAAoD;AACpD,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAEhC,wEAAwE;AACxE,MAAM,CAAC,MAAM,8BAA8B,GAAG,IAAI,CAAC;AAEnD,iDAAiD;AACjD,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAC;AAEnC,oFAAoF;AACpF,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAEtC,gCAAgC;AAChC,MAAM,CAAC,MAAM,yBAAyB,GAAG,eAAe,CAAC;AAEzD,uCAAuC;AACvC,MAAM,CAAC,MAAM,WAAW,GAAG,wBAAwB,CAAC;AAEpD,qBAAqB;AACrB,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAEtC,gFAAgF;AAChF,4BAA4B;AAC5B,gFAAgF;AAEhF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,eAAe,EAAE,iBAAiB;IAClC,iBAAiB,EAAE,mBAAmB;IACtC,SAAS,EAAE,WAAW;IACtB,UAAU,EAAE,YAAY;IACxB,cAAc,EAAE,gBAAgB;IAChC,WAAW,EAAE,aAAa;IAC1B,YAAY,EAAE,cAAc;IAC5B,cAAc,EAAE,gBAAgB;IAChC,mBAAmB,EAAE,qBAAqB;CAClC,CAAC"}

package/dist/encoding/embedder.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generate a lightweight embedding from text using character n-gram hashing.
+ * This is a simple, deterministic approach that works offline without any API.
+ * Quality is lower than neural embeddings but sufficient for basic similarity.
+ */
+export declare function generateLocalEmbedding(text: string): number[];
+/**
+ * Compute cosine similarity between two vectors.
+ * Returns a value between -1 and 1 (1 = identical, 0 = orthogonal).
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+//# sourceMappingURL=embedder.d.ts.map

package/dist/encoding/embedder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedder.d.ts","sourceRoot":"","sources":["../../src/encoding/embedder.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAgC7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAiBjE"}