n1mem-mcp 0.1.0__tar.gz

n1mem_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: n1mem-mcp
+Version: 0.1.0
+Summary: N1Mem MCP server (BYOK, zero dependencies) — let Claude / Cursor / OpenClaw talk to N1Mem long-term memory via MCP
+Author: N1Mem (powered by T1Mem engine)
+License: Proprietary
+Project-URL: Homepage, https://www.n1mem.com
+Keywords: mcp,memory,llm,agent,n1mem,t1mem,claude,cursor,openclaw
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# n1mem-mcp · N1Mem 记忆 MCP Server
+
+> powered by T1Mem engine · BYOK（自带 Key）· 零依赖（仅标准库）
+
+让 Claude / Cursor / OpenClaw 之类支持 MCP 的客户端，直接获得 N1Mem 的**长期记忆**能力。
+
+- `memory_write`：写入一段记忆（持久化 + 建向量，写入即可召回）
+- `memory_recall`：按自然语言问题召回记忆；返回的 `answer` 已基于命中记忆接地，`retrieved` 给出命中的明文记忆
+- `memory_health`：查看服务健康与 provider 可用性
+
+本 Server 是**薄层透传**：不含任何记忆逻辑，只把工具调用转发到 N1Mem C-2 API（`https://api.n1mem.com`）。因此零依赖、可塞进任意环境。
+
+## 安装
+
+```bash
+pip install n1mem-mcp
+```
+
+## 获取 Key
+
+试用 Key 当前由 N1Mem 团队发放（自助注册 / 定价页在路上）。拿到形如 `tk_xxx` 的 Key。
+
+## 配置（Cursor / Claude / OpenClaw）
+
+把下面片段加进你的 MCP 配置（`~/.cursor/mcp.json`、Claude 的 `claude_desktop_config.json`、或 OpenClaw 的 MCP 配置）：
+
+```json
+{
+  "mcpServers": {
+    "n1mem": {
+      "command": "n1mem-mcp",
+      "env": { "N1MEM_API_KEY": "tk_xxx" }
+    }
+  }
+}
+```
+
+或用模块方式启动（无需 `pip install` 也可，只要能 import）：
+
+```json
+{
+  "mcpServers": {
+    "n1mem": {
+      "command": "python",
+      "args": ["-m", "n1mem_mcp"],
+      "env": { "N1MEM_API_KEY": "tk_xxx" }
+    }
+  }
+}
+```
+
+## 环境变量
+
+| 变量 | 说明 | 默认 |
+|---|---|---|
+| `N1MEM_API_KEY` | 你的试用 Key（必填） | 空 |
+| `N1MEM_BASE_URL` | C-2 API 地址 | `https://api.n1mem.com` |
+| `N1MEM_MCP_TIMEOUT` | 单条调用超时（秒） | `90` |
+
+## 已知限制（诚实告知）
+
+- 暂无 `delete` / `update` 工具（服务端未就绪，故不暴露）；需要删记忆请联系团队。
+- `health()` 可能返回 `status: degraded`：这是设计使然（部分上游 provider 未配置），核心记忆链路（存储 / 嵌入 / 写入 / 召回）正常。
+
+## 与 `n1mem` 的区别
+
+| 包 | 形态 | 用途 |
+|---|---|---|
+| `n1mem` | Python SDK（函数调用） | 代码里直接 `m.ingest() / m.recall()` |
+| `n1mem-mcp` | MCP Server（stdio） | 让 MCP 客户端（Claude/Cursor/OpenClaw）以工具方式调用记忆 |

n1mem_mcp-0.1.0/README.md

@@ -0,0 +1,70 @@
+# n1mem-mcp · N1Mem 记忆 MCP Server
+
+> powered by T1Mem engine · BYOK（自带 Key）· 零依赖（仅标准库）
+
+让 Claude / Cursor / OpenClaw 之类支持 MCP 的客户端，直接获得 N1Mem 的**长期记忆**能力。
+
+- `memory_write`：写入一段记忆（持久化 + 建向量，写入即可召回）
+- `memory_recall`：按自然语言问题召回记忆；返回的 `answer` 已基于命中记忆接地，`retrieved` 给出命中的明文记忆
+- `memory_health`：查看服务健康与 provider 可用性
+
+本 Server 是**薄层透传**：不含任何记忆逻辑，只把工具调用转发到 N1Mem C-2 API（`https://api.n1mem.com`）。因此零依赖、可塞进任意环境。
+
+## 安装
+
+```bash
+pip install n1mem-mcp
+```
+
+## 获取 Key
+
+试用 Key 当前由 N1Mem 团队发放（自助注册 / 定价页在路上）。拿到形如 `tk_xxx` 的 Key。
+
+## 配置（Cursor / Claude / OpenClaw）
+
+把下面片段加进你的 MCP 配置（`~/.cursor/mcp.json`、Claude 的 `claude_desktop_config.json`、或 OpenClaw 的 MCP 配置）：
+
+```json
+{
+  "mcpServers": {
+    "n1mem": {
+      "command": "n1mem-mcp",
+      "env": { "N1MEM_API_KEY": "tk_xxx" }
+    }
+  }
+}
+```
+
+或用模块方式启动（无需 `pip install` 也可，只要能 import）：
+
+```json
+{
+  "mcpServers": {
+    "n1mem": {
+      "command": "python",
+      "args": ["-m", "n1mem_mcp"],
+      "env": { "N1MEM_API_KEY": "tk_xxx" }
+    }
+  }
+}
+```
+
+## 环境变量
+
+| 变量 | 说明 | 默认 |
+|---|---|---|
+| `N1MEM_API_KEY` | 你的试用 Key（必填） | 空 |
+| `N1MEM_BASE_URL` | C-2 API 地址 | `https://api.n1mem.com` |
+| `N1MEM_MCP_TIMEOUT` | 单条调用超时（秒） | `90` |
+
+## 已知限制（诚实告知）
+
+- 暂无 `delete` / `update` 工具（服务端未就绪，故不暴露）；需要删记忆请联系团队。
+- `health()` 可能返回 `status: degraded`：这是设计使然（部分上游 provider 未配置），核心记忆链路（存储 / 嵌入 / 写入 / 召回）正常。
+
+## 与 `n1mem` 的区别
+
+| 包 | 形态 | 用途 |
+|---|---|---|
+| `n1mem` | Python SDK（函数调用） | 代码里直接 `m.ingest() / m.recall()` |
+| `n1mem-mcp` | MCP Server（stdio） | 让 MCP 客户端（Claude/Cursor/OpenClaw）以工具方式调用记忆 |

n1mem_mcp-0.1.0/n1mem_mcp/__init__.py

@@ -0,0 +1,9 @@
+"""N1Mem MCP Server —— 让 Claude / Cursor / OpenClaw 通过 MCP 直连 N1Mem 记忆能力。
+
+零依赖：仅用标准库实现最小 JSON-RPC 2.0 over stdio，薄层转发到 C-2 API。
+"""
+
+from .server import SERVER_NAME, SERVER_VERSION, handle, serve_stdio
+
+__version__ = SERVER_VERSION
+__all__ = ["SERVER_NAME", "SERVER_VERSION", "__version__", "serve_stdio", "handle"]

n1mem_mcp-0.1.0/n1mem_mcp/__main__.py

@@ -0,0 +1,14 @@
+"""Entry point for `python -m n1mem_mcp` and the `n1mem-mcp` console command.
+
+无第三方依赖：仅用标准库做最小 JSON-RPC 2.0 over stdio。
+"""
+
+from .server import serve_stdio
+
+
+def main() -> None:
+    serve_stdio()
+
+
+if __name__ == "__main__":
+    main()

n1mem_mcp-0.1.0/n1mem_mcp/server.py

@@ -0,0 +1,227 @@
+"""N1Mem MCP Server —— 让 Claude / Cursor / OpenClaw 通过 MCP 直连记忆能力。
+
+设计取舍（写在最前面，避免后来人重复踩）：
+  * **不引第三方 MCP SDK**：用最小 JSON-RPC 2.0 over stdio 实现，零依赖。
+    原因：本模块要能塞进 FC 代码包，且 MCP 协议在
+    initialize / tools/list / tools/call 三个方法上非常稳定，自己实现可控性更高。
+  * **薄层透传**：本模块不含任何记忆逻辑，只把工具调用转发到 C-2 API。
+    记忆能力在 T1Mem 引擎与 C-2 服务里，避免逻辑分叉、避免泄露引擎实现。
+  * **错误诚实**：上游 401 / 429 原样转成 MCP 工具错误；未就绪能力（delete/update）
+    **不暴露成工具**，避免客户端以为支持。
+
+✅ 写入即持久化（D7 存储 + C-10 语义召回）：memory_write 写入即可被召回。
+✅ recall 已接地（P0 修复，2026-09-09）：memory_recall 返回的 `answer` 是基于
+   召回记忆生成的，不再是「我没有你的记忆」这类拒答；`retrieved` 同时给出命中的
+   明文记忆，便于审计。
+⚠ 已知限制（如实告知调用方）：暂无 delete / update 工具（未就绪故不暴露）。
+
+用法（Cursor / Claude / OpenClaw 配置片段）::
+
+    {
+      "mcpServers": {
+        "n1mem": {
+          "command": "n1mem-mcp",
+          "env": { "N1MEM_API_KEY": "tk_xxx" }
+        }
+      }
+    }
+
+或等价地用模块方式启动（无需安装命令）：:
+
+    {
+      "mcpServers": {
+        "n1mem": {
+          "command": "python",
+          "args": ["-m", "n1mem_mcp"],
+          "env": { "N1MEM_API_KEY": "tk_xxx" }
+        }
+      }
+    }
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from typing import Any
+
+SERVER_NAME = "n1mem"
+SERVER_VERSION = "0.1.0"
+PROTOCOL_VERSION = "2024-11-05"
+
+DEFAULT_BASE_URL = os.environ.get("N1MEM_BASE_URL", "https://api.n1mem.com")
+
+# ---------------------------------------------------------------- 工具定义
+
+TOOLS: list[dict] = [
+    {
+        "name": "memory_write",
+        "description": (
+            "把一段内容写入 N1Mem 长期记忆（持久化 + 生成向量，写入即可被召回）。"
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "text": {"type": "string", "description": "要记住的内容"},
+            },
+            "required": ["text"],
+        },
+    },
+    {
+        "name": "memory_recall",
+        "description": (
+            "按问题从 N1Mem 记忆中召回相关内容（关键词 + 语义融合，支持改写问法）。"
+            "返回体含 retrieved（召回的明文记忆）与 answer（已基于记忆接地的回答）。"
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "prompt": {"type": "string", "description": "要问的问题 / 检索提示"},
+                "purpose": {"type": "string", "description": "用途标签，默认 recall",
+                            "default": "recall"},
+            },
+            "required": ["prompt"],
+        },
+    },
+    {
+        "name": "memory_health",
+        "description": "查看 N1Mem 服务健康状态与各 provider 可用性。",
+        "inputSchema": {"type": "object", "properties": {}},
+    },
+]
+
+
+# ---------------------------------------------------------------- 上游调用
+
+class UpstreamError(Exception):
+    def __init__(self, status: int, detail: str):
+        super().__init__(f"[{status}] {detail}")
+        self.status = status
+        self.detail = detail
+
+
+def _call_api(path: str, body: dict | None = None, timeout: float | None = None) -> Any:
+    """转发到 C-2 API。BYOK：key 只从环境变量取，绝不内联。
+
+    超时说明：C-2 的 ingest/recall 内部含一次上游 LLM 生成，默认 90s
+    （实测首调含冷启动可能 20-50s）。可用 N1MEM_MCP_TIMEOUT 覆盖。
+    """
+    timeout = timeout or float(os.environ.get("N1MEM_MCP_TIMEOUT", "90"))
+    api_key = os.environ.get("N1MEM_API_KEY", "")
+    headers = {"Accept": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
+    if data:
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(DEFAULT_BASE_URL + path, data=data,
+                                 headers=headers, method="POST" if data else "GET")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            raw = r.read().decode("utf-8", "replace")
+            return json.loads(raw) if raw else {}
+    except urllib.error.HTTPError as e:
+        detail = ""
+        try:
+            detail = e.read().decode("utf-8", "replace")
+        except Exception:
+            pass
+        raise UpstreamError(e.code, detail or e.reason) from e
+    except urllib.error.URLError as e:
+        raise UpstreamError(0, f"connection error: {e.reason}") from e
+
+
+def _dispatch(name: str, args: dict) -> dict:
+    """执行工具，返回 MCP content 结构。"""
+    if name == "memory_write":
+        text = (args or {}).get("text", "")
+        if not text:
+            raise ValueError("text 不能为空")
+        out = _call_api("/v1/ingest", {"text": text, "purpose": "recall"})
+        return {"ok": True, "endpoint": "/v1/ingest", "result": out}
+    if name == "memory_recall":
+        prompt = (args or {}).get("prompt", "")
+        if not prompt:
+            raise ValueError("prompt 不能为空")
+        out = _call_api("/v1/recall", {"prompt": prompt,
+                                       "purpose": (args or {}).get("purpose", "recall")})
+        return {"ok": True, "endpoint": "/v1/recall", "result": out}
+    if name == "memory_health":
+        return {"ok": True, "endpoint": "/health", "result": _call_api("/health")}
+    raise ValueError(f"unknown tool: {name}")
+
+
+# ---------------------------------------------------------------- JSON-RPC
+
+def _ok(id_: Any, result: dict) -> dict:
+    return {"jsonrpc": "2.0", "id": id_, "result": result}
+
+
+def _err(id_: Any, code: int, msg: str) -> dict:
+    return {"jsonrpc": "2.0", "id": id_, "error": {"code": code, "message": msg}}
+
+
+def handle(msg: dict) -> dict | None:
+    """处理一条 JSON-RPC 消息；notification 返回 None（不回包）。"""
+    id_ = msg.get("id")
+    method = msg.get("method", "")
+
+    if method == "initialize":
+        return _ok(id_, {
+            "protocolVersion": PROTOCOL_VERSION,
+            "capabilities": {"tools": {}},
+            "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
+        })
+    if method == "tools/list":
+        return _ok(id_, {"tools": TOOLS})
+    if method == "tools/call":
+        params = msg.get("params") or {}
+        name = params.get("name", "")
+        try:
+            payload = _dispatch(name, params.get("arguments") or {})
+            return _ok(id_, {
+                "content": [{"type": "text",
+                             "text": json.dumps(payload, ensure_ascii=False, indent=2)}],
+                "isError": False,
+            })
+        except UpstreamError as e:
+            # 上游 401/429 等原样透传，便于客户端区分是鉴权问题还是配额问题
+            return _ok(id_, {
+                "content": [{"type": "text",
+                             "text": f"upstream error {e.status}: {e.detail}"}],
+                "isError": True,
+            })
+        except Exception as e:  # noqa: BLE001
+            return _ok(id_, {
+                "content": [{"type": "text", "text": f"tool error: {e}"}],
+                "isError": True,
+            })
+    if method.startswith("notifications/") or id_ is None:
+        return None
+    return _err(id_, -32601, f"method not found: {method}")
+
+
+def serve_stdio(stream_in=None, stream_out=None) -> None:
+    """stdio 传输：一问一答，每行一条 JSON-RPC。"""
+    sin = stream_in or sys.stdin
+    sout = stream_out or sys.stdout
+    for line in sin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            msg = json.loads(line)
+        except json.JSONDecodeError:
+            sout.write(json.dumps(_err(None, -32700, "parse error")) + "\n")
+            sout.flush()
+            continue
+        resp = handle(msg)
+        if resp is not None:
+            sout.write(json.dumps(resp, ensure_ascii=False) + "\n")
+            sout.flush()
+
+
+if __name__ == "__main__":
+    serve_stdio()

n1mem_mcp-0.1.0/n1mem_mcp.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: n1mem-mcp
+Version: 0.1.0
+Summary: N1Mem MCP server (BYOK, zero dependencies) — let Claude / Cursor / OpenClaw talk to N1Mem long-term memory via MCP
+Author: N1Mem (powered by T1Mem engine)
+License: Proprietary
+Project-URL: Homepage, https://www.n1mem.com
+Keywords: mcp,memory,llm,agent,n1mem,t1mem,claude,cursor,openclaw
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# n1mem-mcp · N1Mem 记忆 MCP Server
+
+> powered by T1Mem engine · BYOK（自带 Key）· 零依赖（仅标准库）
+
+让 Claude / Cursor / OpenClaw 之类支持 MCP 的客户端，直接获得 N1Mem 的**长期记忆**能力。
+
+- `memory_write`：写入一段记忆（持久化 + 建向量，写入即可召回）
+- `memory_recall`：按自然语言问题召回记忆；返回的 `answer` 已基于命中记忆接地，`retrieved` 给出命中的明文记忆
+- `memory_health`：查看服务健康与 provider 可用性
+
+本 Server 是**薄层透传**：不含任何记忆逻辑，只把工具调用转发到 N1Mem C-2 API（`https://api.n1mem.com`）。因此零依赖、可塞进任意环境。
+
+## 安装
+
+```bash
+pip install n1mem-mcp
+```
+
+## 获取 Key
+
+试用 Key 当前由 N1Mem 团队发放（自助注册 / 定价页在路上）。拿到形如 `tk_xxx` 的 Key。
+
+## 配置（Cursor / Claude / OpenClaw）
+
+把下面片段加进你的 MCP 配置（`~/.cursor/mcp.json`、Claude 的 `claude_desktop_config.json`、或 OpenClaw 的 MCP 配置）：
+
+```json
+{
+  "mcpServers": {
+    "n1mem": {
+      "command": "n1mem-mcp",
+      "env": { "N1MEM_API_KEY": "tk_xxx" }
+    }
+  }
+}
+```
+
+或用模块方式启动（无需 `pip install` 也可，只要能 import）：
+
+```json
+{
+  "mcpServers": {
+    "n1mem": {
+      "command": "python",
+      "args": ["-m", "n1mem_mcp"],
+      "env": { "N1MEM_API_KEY": "tk_xxx" }
+    }
+  }
+}
+```
+
+## 环境变量
+
+| 变量 | 说明 | 默认 |
+|---|---|---|
+| `N1MEM_API_KEY` | 你的试用 Key（必填） | 空 |
+| `N1MEM_BASE_URL` | C-2 API 地址 | `https://api.n1mem.com` |
+| `N1MEM_MCP_TIMEOUT` | 单条调用超时（秒） | `90` |
+
+## 已知限制（诚实告知）
+
+- 暂无 `delete` / `update` 工具（服务端未就绪，故不暴露）；需要删记忆请联系团队。
+- `health()` 可能返回 `status: degraded`：这是设计使然（部分上游 provider 未配置），核心记忆链路（存储 / 嵌入 / 写入 / 召回）正常。
+
+## 与 `n1mem` 的区别
+
+| 包 | 形态 | 用途 |
+|---|---|---|
+| `n1mem` | Python SDK（函数调用） | 代码里直接 `m.ingest() / m.recall()` |
+| `n1mem-mcp` | MCP Server（stdio） | 让 MCP 客户端（Claude/Cursor/OpenClaw）以工具方式调用记忆 |

n1mem_mcp-0.1.0/n1mem_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+n1mem_mcp/__init__.py
+n1mem_mcp/__main__.py
+n1mem_mcp/server.py
+n1mem_mcp.egg-info/PKG-INFO
+n1mem_mcp.egg-info/SOURCES.txt
+n1mem_mcp.egg-info/dependency_links.txt
+n1mem_mcp.egg-info/entry_points.txt
+n1mem_mcp.egg-info/top_level.txt

n1mem_mcp-0.1.0/n1mem_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

n1mem_mcp-0.1.0/n1mem_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+n1mem-mcp = n1mem_mcp.__main__:main

n1mem_mcp-0.1.0/n1mem_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+n1mem_mcp

n1mem_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "n1mem-mcp"
+version = "0.1.0"
+description = "N1Mem MCP server (BYOK, zero dependencies) — let Claude / Cursor / OpenClaw talk to N1Mem long-term memory via MCP"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Proprietary" }
+authors = [{ name = "N1Mem (powered by T1Mem engine)" }]
+keywords = ["mcp", "memory", "llm", "agent", "n1mem", "t1mem", "claude", "cursor", "openclaw"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.scripts]
+n1mem-mcp = "n1mem_mcp.__main__:main"
+
+[project.urls]
+Homepage = "https://www.n1mem.com"
+
+[tool.setuptools.packages.find]
+include = ["n1mem_mcp*"]

n1mem_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+