memory-hive-mcp 0.1.0__tar.gz

memory_hive_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Memory Hive
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

memory_hive_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: memory-hive-mcp
+Version: 0.1.0
+Summary: Local-first personal memory for your AI agents — an MCP stdio bridge to the Hive running on your own machine.
+Author: Memory Hive
+License-Expression: MIT
+Project-URL: Homepage, https://apps.apple.com/app/id6806992983
+Project-URL: Repository, https://github.com/330899935/memory-hive-ios
+Project-URL: Source, https://github.com/330899935/memory-hive-ios
+Keywords: mcp,model-context-protocol,memory,local-first,privacy,ai-agents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# memory-hive-mcp
+
+**Local-first personal memory for your AI agents — an MCP stdio bridge to the Hive running on your own machine.**
+
+`memory-hive-mcp` is a thin [Model Context Protocol](https://modelcontextprotocol.io) bridge.
+It lets any MCP-capable host (Claude Desktop, Cursor, and friends) read and write
+*your* memory — stored on *your* computer, by *your* Hive, and never uploaded anywhere.
+
+> **This package contains no memory engine.** It only relays MCP protocol traffic to the
+> Hive app already running on your machine (`127.0.0.1:8768`). Your data never passes
+> through this bridge as stored state, and nothing leaves your computer.
+
+## Install
+
+```bash
+pip install memory-hive-mcp
+```
+
+Requires Python 3.8+. No third-party dependencies.
+
+This installs the command **`memory-hive-mcp`**.
+(Note: an unrelated project also owns the plain `hive-mcp` name on PyPI — that is not us.)
+
+## Prerequisite: a running Hive
+
+`memory-hive-mcp` talks to the Hive on your own machine. Get it from the Mac App Store:
+
+**https://apps.apple.com/app/id6806992983**
+
+Then register an agent inside the Hive (`POST /api/agent/register`) to obtain an
+`agent_id` and `access_token`.
+
+## Configure your MCP host
+
+Add the server to your host's MCP config. For Claude Desktop
+(`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "hive-memory": {
+      "command": "memory-hive-mcp",
+      "env": {
+        "HIVE_AGENT_ID": "your-agent-id",
+        "HIVE_AGENT_TOKEN": "your-access-token"
+      }
+    }
+  }
+}
+```
+
+### Environment variables
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `HIVE_AGENT_ID` | yes | Agent id issued by your own Hive. |
+| `HIVE_AGENT_TOKEN` | yes | Access token issued when the agent was registered. Keep it secret. |
+| `HIVE_MCP_URL` | no | Hive MCP endpoint. Defaults to `http://127.0.0.1:8768/mcp`. |
+
+## Why a bridge, not a bundle
+
+Your memory should have exactly one writer: the Hive on your machine. This bridge
+therefore speaks protocol and nothing else — no data files are opened, no state is
+cached, no engine is duplicated. That keeps your memory single-sourced, local, and
+under your control.
+
+## License
+
+MIT

memory_hive_mcp-0.1.0/README.md

@@ -0,0 +1,69 @@
+# memory-hive-mcp
+
+**Local-first personal memory for your AI agents — an MCP stdio bridge to the Hive running on your own machine.**
+
+`memory-hive-mcp` is a thin [Model Context Protocol](https://modelcontextprotocol.io) bridge.
+It lets any MCP-capable host (Claude Desktop, Cursor, and friends) read and write
+*your* memory — stored on *your* computer, by *your* Hive, and never uploaded anywhere.
+
+> **This package contains no memory engine.** It only relays MCP protocol traffic to the
+> Hive app already running on your machine (`127.0.0.1:8768`). Your data never passes
+> through this bridge as stored state, and nothing leaves your computer.
+
+## Install
+
+```bash
+pip install memory-hive-mcp
+```
+
+Requires Python 3.8+. No third-party dependencies.
+
+This installs the command **`memory-hive-mcp`**.
+(Note: an unrelated project also owns the plain `hive-mcp` name on PyPI — that is not us.)
+
+## Prerequisite: a running Hive
+
+`memory-hive-mcp` talks to the Hive on your own machine. Get it from the Mac App Store:
+
+**https://apps.apple.com/app/id6806992983**
+
+Then register an agent inside the Hive (`POST /api/agent/register`) to obtain an
+`agent_id` and `access_token`.
+
+## Configure your MCP host
+
+Add the server to your host's MCP config. For Claude Desktop
+(`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "hive-memory": {
+      "command": "memory-hive-mcp",
+      "env": {
+        "HIVE_AGENT_ID": "your-agent-id",
+        "HIVE_AGENT_TOKEN": "your-access-token"
+      }
+    }
+  }
+}
+```
+
+### Environment variables
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `HIVE_AGENT_ID` | yes | Agent id issued by your own Hive. |
+| `HIVE_AGENT_TOKEN` | yes | Access token issued when the agent was registered. Keep it secret. |
+| `HIVE_MCP_URL` | no | Hive MCP endpoint. Defaults to `http://127.0.0.1:8768/mcp`. |
+
+## Why a bridge, not a bundle
+
+Your memory should have exactly one writer: the Hive on your machine. This bridge
+therefore speaks protocol and nothing else — no data files are opened, no state is
+cached, no engine is duplicated. That keeps your memory single-sourced, local, and
+under your control.
+
+## License
+
+MIT

memory_hive_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "memory-hive-mcp"
+version = "0.1.0"
+description = "Local-first personal memory for your AI agents — an MCP stdio bridge to the Hive running on your own machine."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [{ name = "Memory Hive" }]
+keywords = ["mcp", "model-context-protocol", "memory", "local-first", "privacy", "ai-agents"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://apps.apple.com/app/id6806992983"
+Repository = "https://github.com/330899935/memory-hive-ios"
+Source = "https://github.com/330899935/memory-hive-ios"
+
+[project.scripts]
+memory-hive-mcp = "hive_mcp.stdio:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

memory_hive_mcp-0.1.0/setup.cfg

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

memory_hive_mcp-0.1.0/src/hive_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""hive_mcp — MCP stdio bridge for Memory Hive (local-first personal memory)."""
+
+from .stdio import __version__, forward, main
+
+__all__ = ["__version__", "forward", "main"]

memory_hive_mcp-0.1.0/src/hive_mcp/stdio.py

@@ -0,0 +1,92 @@
+"""hive_mcp — stdio bridge to a Hive running on your own machine.
+
+Reads MCP JSON-RPC messages line-by-line from stdin, forwards each to the local
+Hive service's HTTP ``/mcp`` endpoint, and writes the response back to stdout.
+
+This is a *thin bridge*. It does not read or write your data files, and it does
+not embed a memory engine. The Hive app on your machine is the single writer;
+this package only relays protocol traffic to it, so there is no cross-process
+write contention and no working-directory dependency.
+
+Credentials are injected via environment variables:
+
+* ``HIVE_AGENT_ID``     — agent id issued by your own Hive
+* ``HIVE_AGENT_TOKEN``  — access token issued by your own Hive
+* ``HIVE_MCP_URL``      — Hive MCP endpoint (default http://127.0.0.1:8768/mcp)
+
+Zero dependencies: standard library only.
+"""
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+__version__ = "0.1.0"
+
+AGENT_ID = os.environ.get("HIVE_AGENT_ID", "")
+AGENT_TOKEN = os.environ.get("HIVE_AGENT_TOKEN", "")
+MCP_URL = os.environ.get("HIVE_MCP_URL", "http://127.0.0.1:8768/mcp")
+
+
+def forward(payload):
+    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    req = urllib.request.Request(MCP_URL, data=body, method="POST")
+    req.add_header("Content-Type", "application/json")
+    if AGENT_ID:
+        req.add_header("X-Hive-Agent", AGENT_ID)
+    if AGENT_TOKEN:
+        req.add_header("X-Hive-Token", AGENT_TOKEN)
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            if resp.status == 202:
+                return None  # notification: backend accepted, no response needed
+            raw = resp.read().decode("utf-8")
+            if not raw.strip():
+                return None  # empty body: stay silent rather than emit a false error
+            return json.loads(raw)
+    except urllib.error.HTTPError as e:
+        if e.code == 202:
+            return None
+        try:
+            return json.loads(e.read().decode("utf-8"))
+        except Exception:
+            return {
+                "jsonrpc": "2.0",
+                "id": payload.get("id"),
+                "error": {"code": -32603, "message": f"HTTP {e.code}"},
+            }
+    except Exception as e:
+        return {
+            "jsonrpc": "2.0",
+            "id": payload.get("id"),
+            "error": {"code": -32603, "message": f"forward failed: {e}"},
+        }
+
+
+def main():
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            payload = json.loads(line)
+        except Exception:
+            err = {
+                "jsonrpc": "2.0",
+                "id": None,
+                "error": {"code": -32700, "message": "Parse error"},
+            }
+            sys.stdout.write(json.dumps(err) + "\n")
+            sys.stdout.flush()
+            continue
+        resp = forward(payload)
+        if resp is None:
+            continue  # nothing to send back for notifications
+        sys.stdout.write(json.dumps(resp, ensure_ascii=False) + "\n")
+        sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

memory_hive_mcp-0.1.0/src/memory_hive_mcp.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: memory-hive-mcp
+Version: 0.1.0
+Summary: Local-first personal memory for your AI agents — an MCP stdio bridge to the Hive running on your own machine.
+Author: Memory Hive
+License-Expression: MIT
+Project-URL: Homepage, https://apps.apple.com/app/id6806992983
+Project-URL: Repository, https://github.com/330899935/memory-hive-ios
+Project-URL: Source, https://github.com/330899935/memory-hive-ios
+Keywords: mcp,model-context-protocol,memory,local-first,privacy,ai-agents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# memory-hive-mcp
+
+**Local-first personal memory for your AI agents — an MCP stdio bridge to the Hive running on your own machine.**
+
+`memory-hive-mcp` is a thin [Model Context Protocol](https://modelcontextprotocol.io) bridge.
+It lets any MCP-capable host (Claude Desktop, Cursor, and friends) read and write
+*your* memory — stored on *your* computer, by *your* Hive, and never uploaded anywhere.
+
+> **This package contains no memory engine.** It only relays MCP protocol traffic to the
+> Hive app already running on your machine (`127.0.0.1:8768`). Your data never passes
+> through this bridge as stored state, and nothing leaves your computer.
+
+## Install
+
+```bash
+pip install memory-hive-mcp
+```
+
+Requires Python 3.8+. No third-party dependencies.
+
+This installs the command **`memory-hive-mcp`**.
+(Note: an unrelated project also owns the plain `hive-mcp` name on PyPI — that is not us.)
+
+## Prerequisite: a running Hive
+
+`memory-hive-mcp` talks to the Hive on your own machine. Get it from the Mac App Store:
+
+**https://apps.apple.com/app/id6806992983**
+
+Then register an agent inside the Hive (`POST /api/agent/register`) to obtain an
+`agent_id` and `access_token`.
+
+## Configure your MCP host
+
+Add the server to your host's MCP config. For Claude Desktop
+(`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "hive-memory": {
+      "command": "memory-hive-mcp",
+      "env": {
+        "HIVE_AGENT_ID": "your-agent-id",
+        "HIVE_AGENT_TOKEN": "your-access-token"
+      }
+    }
+  }
+}
+```
+
+### Environment variables
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `HIVE_AGENT_ID` | yes | Agent id issued by your own Hive. |
+| `HIVE_AGENT_TOKEN` | yes | Access token issued when the agent was registered. Keep it secret. |
+| `HIVE_MCP_URL` | no | Hive MCP endpoint. Defaults to `http://127.0.0.1:8768/mcp`. |
+
+## Why a bridge, not a bundle
+
+Your memory should have exactly one writer: the Hive on your machine. This bridge
+therefore speaks protocol and nothing else — no data files are opened, no state is
+cached, no engine is duplicated. That keeps your memory single-sourced, local, and
+under your control.
+
+## License
+
+MIT

memory_hive_mcp-0.1.0/src/memory_hive_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/hive_mcp/__init__.py
+src/hive_mcp/stdio.py
+src/memory_hive_mcp.egg-info/PKG-INFO
+src/memory_hive_mcp.egg-info/SOURCES.txt
+src/memory_hive_mcp.egg-info/dependency_links.txt
+src/memory_hive_mcp.egg-info/entry_points.txt
+src/memory_hive_mcp.egg-info/top_level.txt

memory_hive_mcp-0.1.0/src/memory_hive_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

memory_hive_mcp-0.1.0/src/memory_hive_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+memory-hive-mcp = hive_mcp.stdio:main

memory_hive_mcp-0.1.0/src/memory_hive_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+hive_mcp