mag-memory 0.1.0__tar.gz

mag_memory-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+/target
+.cargo-cache/
+
+.env
+.env.local
+# Local provenance / legal notes (not published)
+PROVENANCE.local.md
+
+# Claude Code worktrees (agent isolation)
+.claude/worktrees/
+
+# Local MCP config (machine-specific paths)
+.mcp.json
+
+# Benchmark datasets (large, downloaded separately)
+data/*
+# But track the local benchmark definition
+!data/local_benchmark.json

mag_memory-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: mag-memory
+Version: 0.1.0
+Summary: PyPI wrapper for the mag MCP memory server (Rust binary)
+Project-URL: Homepage, https://github.com/George-RD/mag
+Project-URL: Repository, https://github.com/George-RD/mag
+Project-URL: Issues, https://github.com/George-RD/mag/issues
+Author: George-RD
+License-Expression: MIT
+Keywords: ai,llm,mcp,memory,semantic-search,sqlite
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# mag-memory
+
+PyPI wrapper for [mag](https://github.com/George-RD/mag), a Rust-based MCP memory server.
+
+mag stores memories in SQLite with ONNX embeddings for semantic search, exposing 16 MCP tools via stdio protocol. No external services required.
+
+## Installation
+
+```bash
+pip install mag-memory
+```
+
+## Usage
+
+```bash
+# Start the MCP server
+mag serve
+
+# The native binary is downloaded automatically on first run.
+# All CLI arguments are passed through to the Rust binary.
+```
+
+## How it works
+
+This package does not bundle the native binary. On first run, it detects your platform (Linux/macOS/Windows, x86_64/ARM64), downloads the correct prebuilt binary from [GitHub Releases](https://github.com/George-RD/mag/releases), and caches it locally. Subsequent runs use the cached binary with zero overhead (Unix `exec`).
+
+## Supported platforms
+
+| OS      | Architecture |
+|---------|-------------|
+| Linux   | x86_64, aarch64 |
+| macOS   | x86_64, Apple Silicon (aarch64) |
+| Windows | x86_64 |
+
+## License
+
+MIT

mag_memory-0.1.0/README.md

@@ -0,0 +1,37 @@
+# mag-memory
+
+PyPI wrapper for [mag](https://github.com/George-RD/mag), a Rust-based MCP memory server.
+
+mag stores memories in SQLite with ONNX embeddings for semantic search, exposing 16 MCP tools via stdio protocol. No external services required.
+
+## Installation
+
+```bash
+pip install mag-memory
+```
+
+## Usage
+
+```bash
+# Start the MCP server
+mag serve
+
+# The native binary is downloaded automatically on first run.
+# All CLI arguments are passed through to the Rust binary.
+```
+
+## How it works
+
+This package does not bundle the native binary. On first run, it detects your platform (Linux/macOS/Windows, x86_64/ARM64), downloads the correct prebuilt binary from [GitHub Releases](https://github.com/George-RD/mag/releases), and caches it locally. Subsequent runs use the cached binary with zero overhead (Unix `exec`).
+
+## Supported platforms
+
+| OS      | Architecture |
+|---------|-------------|
+| Linux   | x86_64, aarch64 |
+| macOS   | x86_64, Apple Silicon (aarch64) |
+| Windows | x86_64 |
+
+## License
+
+MIT

mag_memory-0.1.0/mag_memory/__init__.py

@@ -0,0 +1,75 @@
+"""
+mag-memory: PyPI wrapper for the mag MCP memory server.
+
+On first run, the native binary is downloaded from GitHub Releases
+for the current platform. Subsequent runs use the cached binary.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+
+
+__version__ = "0.1.0"
+
+# Version of the Rust binary to download (kept in sync with __version__)
+_BINARY_VERSION = "0.1.0"
+
+
+def _binary_dir():
+    # type: () -> str
+    """Return the directory where the mag binary is stored."""
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bin")
+
+
+def _binary_name():
+    # type: () -> str
+    """Return the platform-appropriate binary filename."""
+    if sys.platform == "win32":
+        return "mag.exe"
+    return "mag"
+
+
+def _find_binary():
+    # type: () -> str | None
+    """Locate the mag binary: package dir first, then PATH."""
+    # 1. Check package bin directory
+    packaged = os.path.join(_binary_dir(), _binary_name())
+    if os.path.isfile(packaged) and os.access(packaged, os.X_OK):
+        return packaged
+
+    # 2. Fall back to PATH
+    found = shutil.which("mag")
+    return found
+
+
+def main():
+    # type: () -> None
+    """Entry point: find (or download) the mag binary and exec it."""
+    binary = _find_binary()
+
+    if binary is None:
+        # Download on first run
+        sys.stderr.write("mag: binary not found, downloading for this platform...\n")
+        try:
+            from mag_memory._download import download_binary
+
+            binary = download_binary(_BINARY_VERSION)
+        except Exception as exc:
+            sys.stderr.write("mag: failed to download binary: {}\n".format(exc))
+            sys.stderr.write(
+                "mag: install manually from "
+                "https://github.com/George-RD/mag/releases\n"
+            )
+            sys.exit(1)
+
+    # Replace this process with the binary (Unix) or subprocess (Windows)
+    args = [binary] + sys.argv[1:]
+
+    if sys.platform != "win32":
+        os.execvp(binary, args)
+    else:
+        # os.execvp is unreliable on Windows; use subprocess instead
+        result = subprocess.run(args)
+        sys.exit(result.returncode)

mag_memory-0.1.0/mag_memory/_download.py

@@ -0,0 +1,186 @@
+"""
+Download the correct mag binary for the current platform from GitHub Releases.
+"""
+
+import io
+import os
+import platform
+import stat
+import sys
+import tarfile
+import zipfile
+
+try:
+    from urllib.request import urlopen, Request
+    from urllib.error import URLError, HTTPError
+except ImportError:
+    # Python 2 fallback (shouldn't happen with >=3.8, but defensive)
+    from urllib2 import urlopen, Request, URLError, HTTPError  # type: ignore[no-redef]
+
+
+_GITHUB_RELEASE_URL = (
+    "https://github.com/George-RD/mag/releases/download/"
+    "v{version}/mag-{target}.{ext}"
+)
+
+# Mapping: (sys.platform, platform.machine()) -> Rust target triple
+_TARGET_MAP = {
+    ("linux", "x86_64"): "x86_64-unknown-linux-gnu",
+    ("linux", "aarch64"): "aarch64-unknown-linux-gnu",
+    ("linux", "arm64"): "aarch64-unknown-linux-gnu",
+    ("darwin", "x86_64"): "x86_64-apple-darwin",
+    ("darwin", "arm64"): "aarch64-apple-darwin",
+    ("darwin", "aarch64"): "aarch64-apple-darwin",
+    ("win32", "AMD64"): "x86_64-pc-windows-msvc",
+    ("win32", "x86_64"): "x86_64-pc-windows-msvc",
+}
+
+
+def _detect_target():
+    # type: () -> tuple[str, str]
+    """Detect the Rust target triple and archive extension for this platform.
+
+    Returns:
+        (target_triple, archive_extension)
+    """
+    plat = sys.platform
+    # Normalize platform string
+    if plat.startswith("linux"):
+        plat = "linux"
+
+    machine = platform.machine()
+
+    key = (plat, machine)
+    target = _TARGET_MAP.get(key)
+    if target is None:
+        raise RuntimeError(
+            "Unsupported platform: {} / {} (machine={})".format(
+                sys.platform, platform.system(), machine
+            )
+        )
+
+    ext = "zip" if plat == "win32" else "tar.gz"
+    return target, ext
+
+
+def _download_url(url):
+    # type: (str) -> bytes
+    """Download a URL and return its content as bytes."""
+    req = Request(url, headers={"User-Agent": "mag-memory-pypi-installer"})
+    try:
+        resp = urlopen(req, timeout=120)
+        return resp.read()
+    except HTTPError as exc:
+        raise RuntimeError(
+            "HTTP {} downloading {}: {}".format(exc.code, url, exc.reason)
+        )
+    except URLError as exc:
+        raise RuntimeError("Failed to download {}: {}".format(url, exc.reason))
+
+
+def _extract_tar_gz(data, dest_dir):
+    # type: (bytes, str) -> str
+    """Extract a .tar.gz archive, find the mag binary, place it in dest_dir."""
+    binary_name = "mag"
+    with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as tar:
+        # Find the mag binary in the archive
+        members = tar.getnames()
+        binary_member = None
+        for name in members:
+            basename = os.path.basename(name)
+            if basename == binary_name:
+                binary_member = name
+                break
+
+        if binary_member is None:
+            raise RuntimeError(
+                "Could not find '{}' in archive. Contents: {}".format(
+                    binary_name, members
+                )
+            )
+
+        # Extract just the binary
+        member = tar.getmember(binary_member)
+        fileobj = tar.extractfile(member)
+        if fileobj is None:
+            raise RuntimeError("Could not extract '{}'".format(binary_member))
+
+        dest_path = os.path.join(dest_dir, binary_name)
+        with open(dest_path, "wb") as f:
+            f.write(fileobj.read())
+
+    return dest_path
+
+
+def _extract_zip(data, dest_dir):
+    # type: (bytes, str) -> str
+    """Extract a .zip archive, find the mag binary, place it in dest_dir."""
+    binary_name = "mag.exe"
+    with zipfile.ZipFile(io.BytesIO(data)) as zf:
+        names = zf.namelist()
+        binary_member = None
+        for name in names:
+            basename = os.path.basename(name)
+            if basename == binary_name:
+                binary_member = name
+                break
+
+        if binary_member is None:
+            raise RuntimeError(
+                "Could not find '{}' in archive. Contents: {}".format(
+                    binary_name, names
+                )
+            )
+
+        dest_path = os.path.join(dest_dir, binary_name)
+        with open(dest_path, "wb") as f:
+            f.write(zf.read(binary_member))
+
+    return dest_path
+
+
+def download_binary(version):
+    # type: (str) -> str
+    """Download the mag binary for this platform and return its path.
+
+    Args:
+        version: The version string (e.g. "0.1.0")
+
+    Returns:
+        Absolute path to the downloaded binary.
+    """
+    target, ext = _detect_target()
+    url = _GITHUB_RELEASE_URL.format(version=version, target=target, ext=ext)
+
+    sys.stderr.write("mag: downloading {} ...\n".format(url))
+    data = _download_url(url)
+    sys.stderr.write(
+        "mag: downloaded {:.1f} MB\n".format(len(data) / (1024.0 * 1024.0))
+    )
+
+    # Ensure destination directory exists
+    from mag_memory import _binary_dir
+
+    dest_dir = _binary_dir()
+    os.makedirs(dest_dir, exist_ok=True)
+
+    # Extract
+    if ext == "zip":
+        binary_path = _extract_zip(data, dest_dir)
+    else:
+        binary_path = _extract_tar_gz(data, dest_dir)
+
+    # Make executable (Unix)
+    if sys.platform != "win32":
+        st = os.stat(binary_path)
+        os.chmod(binary_path, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    sys.stderr.write("mag: installed to {}\n".format(binary_path))
+    return binary_path
+
+
+if __name__ == "__main__":
+    # Allow running directly: python -m mag_memory._download [version]
+    ver = sys.argv[1] if len(sys.argv) > 1 else "0.1.0"
+    path = download_binary(ver)
+    print("Downloaded: {}".format(path))

mag_memory-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mag-memory"
+version = "0.1.0"
+description = "PyPI wrapper for the mag MCP memory server (Rust binary)"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [{ name = "George-RD" }]
+keywords = ["mcp", "memory", "ai", "llm", "semantic-search", "sqlite"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Rust",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://github.com/George-RD/mag"
+Repository = "https://github.com/George-RD/mag"
+Issues = "https://github.com/George-RD/mag/issues"
+
+[project.scripts]
+mag = "mag_memory:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["mag_memory"]