pgmnemo-mcp 0.5.2__py3-none-any.whl

pgmnemo_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""pgmnemo-mcp — MCP server exposing pgmnemo ingest and recall tools."""
+
+__version__ = "0.5.0"
+
+from .server import mcp, ingest, recall, main
+
+__all__ = ["mcp", "ingest", "recall", "main", "__version__"]

pgmnemo_mcp/__main__.py

@@ -0,0 +1,56 @@
+"""python -m pgmnemo_mcp — CLI entry point with --smoke flag."""
+
+import argparse
+import sys
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="pgmnemo-mcp")
+    parser.add_argument(
+        "--smoke",
+        action="store_true",
+        help="Run a connectivity smoke test: connect to DB and call recall_lessons().",
+    )
+    args = parser.parse_args()
+
+    if args.smoke:
+        _run_smoke()
+    else:
+        from .server import run
+        run()
+
+
+def _run_smoke() -> None:
+    from .config import DATABASE_URL, get_pool
+
+    print(f"pgmnemo-mcp smoke: connecting to {_redact(DATABASE_URL)} …")
+    try:
+        pool = get_pool()
+        conn = pool.getconn()
+        try:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "SELECT count(*) FROM pgmnemo.recall_lessons("
+                    "NULL::vector(1024), 5, NULL, NULL, 'test')"
+                )
+                row = cur.fetchone()
+            pool.putconn(conn)
+        except Exception:
+            pool.putconn(conn)
+            raise
+    except Exception as exc:
+        print(f"pgmnemo-mcp smoke: FAIL — {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"pgmnemo-mcp smoke: OK (recall_lessons returned {row[0]} rows)")
+    sys.exit(0)
+
+
+def _redact(url: str) -> str:
+    """Hide password in DATABASE_URL for safe printing."""
+    import re
+    return re.sub(r"://([^:@]+):([^@]+)@", r"://\1:***@", url)
+
+
+if __name__ == "__main__":
+    main()

pgmnemo_mcp/config.py

@@ -0,0 +1,16 @@
+import os
+from psycopg2 import pool
+
+__all__ = ["DATABASE_URL", "MCP_PORT", "get_pool"]
+
+DATABASE_URL: str = os.environ.get("DATABASE_URL", "postgresql://localhost/pgmnemo")
+MCP_PORT: int = int(os.environ.get("MCP_PORT", "8765"))
+
+_pool: pool.SimpleConnectionPool | None = None
+
+
+def get_pool() -> pool.SimpleConnectionPool:
+    global _pool
+    if _pool is None:
+        _pool = pool.SimpleConnectionPool(1, 5, dsn=DATABASE_URL)
+    return _pool

pgmnemo_mcp/server.py

@@ -0,0 +1,109 @@
+"""pgmnemo MCP server — exposes ingest and recall as MCP tools.
+
+Transport note (BUG-3 resolution):
+    FastMCP uses MCP protocol transport (stdio by default, SSE/streamable-http
+    optionally). It does NOT expose REST endpoints at /ingest or /recall.
+    Clients must use the MCP JSON-RPC protocol (stdio pipe or SSE at /sse).
+    The --smoke command in __main__.py exercises the DB layer directly
+    without going through the MCP transport.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from .config import get_pool
+
+mcp = FastMCP("pgmnemo", port=8765)
+
+
+@mcp.tool(name="pgmnemo.ingest", description="Ingest a lesson into pgmnemo agent memory.")
+def ingest(
+    text: str,
+    role: str = "mcp_agent",
+    topic: str = "general",
+    importance: int = 3,
+    project_id: int = 1,
+    commit_sha: str | None = None,
+    artifact_hash: str | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Store a lesson via pgmnemo.ingest() SP and return its id.
+
+    Uses the pgmnemo.ingest() stored procedure instead of raw INSERT so that:
+    - Gate enforcement (provenance checks) runs inside the SP.
+    - verified_at is stamped automatically when commit_sha/artifact_hash are present.
+    - Embedding dimension validation fires before the INSERT.
+    """
+    p = get_pool()
+    conn = p.getconn()
+    try:
+        with conn.cursor() as cur:
+            cur.execute(
+                """
+                SELECT pgmnemo.ingest(
+                    %s, %s, %s, %s, %s::smallint,
+                    NULL::vector(1024), %s, %s, %s::jsonb
+                )
+                """,
+                (
+                    role,
+                    project_id,
+                    topic,
+                    text,
+                    importance,
+                    commit_sha,
+                    artifact_hash,
+                    json.dumps(metadata) if metadata is not None else "{}",
+                ),
+            )
+            new_id = cur.fetchone()[0]
+            conn.commit()
+        return {"id": new_id}
+    finally:
+        p.putconn(conn)
+
+
+@mcp.tool(name="pgmnemo.recall", description="Recall lessons from pgmnemo agent memory.")
+def recall(query: str, top_k: int = 5) -> list[dict[str, Any]]:
+    """Return up to top_k lessons whose text matches query via pgmnemo.recall_lessons.
+
+    recall_lessons() RETURNS TABLE (lesson_id bigint, score, role, ...) — the output
+    column is 'lesson_id' (an alias), not 'id' (the physical table column).
+    """
+    p = get_pool()
+    conn = p.getconn()
+    try:
+        with conn.cursor() as cur:
+            # recall_lessons(query_vec, top_k, role_filter, project_id_filter, query_text)
+            # Pass NULL vector — rely on query_text for BM25/hybrid keyword match.
+            cur.execute(
+                """
+                SELECT lesson_id, role, topic, lesson_text, importance, created_at
+                FROM pgmnemo.recall_lessons(
+                    NULL::vector(1024), %s, NULL, NULL, %s
+                )
+                """,
+                (top_k, query),
+            )
+            cols = [d[0] for d in cur.description]
+            return [dict(zip(cols, row)) for row in cur.fetchall()]
+    finally:
+        p.putconn(conn)
+
+
+def run() -> None:
+    """Entry point for `python -m pgmnemo_mcp.server`."""
+    mcp.run()
+
+
+def main() -> None:
+    """Console script entry point (pgmnemo-mcp = pgmnemo_mcp.server:main)."""
+    run()
+
+
+if __name__ == "__main__":
+    main()

pgmnemo_mcp-0.5.2.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: pgmnemo-mcp
+Version: 0.5.2
+Summary: MCP server wrapping pgmnemo ingest and recall for AI agent memory
+License: Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0
+Requires-Dist: psycopg2-binary>=2.9
+Requires-Dist: pydantic>=2.0

pgmnemo_mcp-0.5.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+pgmnemo_mcp/__init__.py,sha256=fdbWQ7cWSPFZWnGHZcgsPsID8_6jrLzwDiMq9eSrar8,207
+pgmnemo_mcp/__main__.py,sha256=C70Hy0oI3NAOWlp2KImAvqZ1WkU6NHkSZjtv5J56s5I,1478
+pgmnemo_mcp/config.py,sha256=W-oonbahlggYdvrTW9HxY6KWxovANy2wSAdOLg7CAVE,447
+pgmnemo_mcp/server.py,sha256=1CJ-8OfrocRPKFfqWa_KQRm3oiOER-13pYpYv9OhDMc,3537
+pgmnemo_mcp-0.5.2.dist-info/METADATA,sha256=z6Y6xV6LvbbcO0hIWOzjvv2p3SCTB95mYG3qnXyHzvg,303
+pgmnemo_mcp-0.5.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pgmnemo_mcp-0.5.2.dist-info/entry_points.txt,sha256=Pit6nwvR6ZCXd6yu9MYiycaQIKcXYzq80GbESAD8vIc,55
+pgmnemo_mcp-0.5.2.dist-info/top_level.txt,sha256=dzfHsNhBFdEcp1eCqIdY6kpX_PCevAQsS2Kz3lBcADc,12
+pgmnemo_mcp-0.5.2.dist-info/RECORD,,

pgmnemo_mcp-0.5.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pgmnemo_mcp-0.5.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pgmnemo-mcp = pgmnemo_mcp.server:run

pgmnemo_mcp-0.5.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pgmnemo_mcp