agent-memory-mcp-server 0.1.0__tar.gz

agent_memory_mcp_server-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+dist/
+build/
+.env
+keys.env
+.mcp.json
+memory.db

agent_memory_mcp_server-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: agent-memory-mcp-server
+Version: 0.1.0
+Summary: Persistent memory for AI agents — store, retrieve and search knowledge across sessions
+Project-URL: Homepage, https://github.com/AiAgentKarl/agent-memory-mcp-server
+Project-URL: Repository, https://github.com/AiAgentKarl/agent-memory-mcp-server
+Author: AiAgentKarl
+License: MIT
+Keywords: ai-agents,knowledge-base,mcp,memory,persistence,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# Agent Memory MCP Server 🧠
+
+Persistent memory for AI agents — store, retrieve and search knowledge across sessions. No more forgetting between conversations.
+
+## The Problem
+
+AI agents lose all context when a session ends. This MCP server gives agents a **persistent knowledge store** that survives across sessions, tools, and even different agent frameworks.
+
+## Features
+
+- **Store & Retrieve** — Key-value storage with full persistence
+- **Namespaces** — Separate memories by project, user, or context
+- **Tags** — Categorize memories for easy filtering
+- **Full-Text Search** — Search across all stored knowledge
+- **Access Tracking** — See which memories are accessed most
+- **Statistics** — Dashboard showing memory usage
+
+## Installation
+
+```bash
+pip install agent-memory-mcp-server
+```
+
+## Usage with Claude Code
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "uvx",
+      "args": ["agent-memory-mcp-server"]
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `memory_store` | Store a key-value pair persistently |
+| `memory_retrieve` | Retrieve stored knowledge by key |
+| `memory_search` | Full-text search across all memories |
+| `memory_list` | List all memories in a namespace |
+| `memory_delete` | Remove a memory |
+| `memory_namespaces` | List all namespaces |
+| `memory_stats` | Usage statistics |
+
+## Examples
+
+```
+"Remember that the user prefers dark mode"
+"What do you know about Project Alpha?"
+"Store this API response for later"
+"What were the key decisions from last session?"
+```
+
+## How It Works
+
+Uses SQLite for zero-configuration persistent storage. Data is stored locally — no cloud, no API keys, no costs. The database file (`memory.db`) is created automatically in the server directory.
+
+## License
+
+MIT

agent_memory_mcp_server-0.1.0/README.md

@@ -0,0 +1,64 @@
+# Agent Memory MCP Server 🧠
+
+Persistent memory for AI agents — store, retrieve and search knowledge across sessions. No more forgetting between conversations.
+
+## The Problem
+
+AI agents lose all context when a session ends. This MCP server gives agents a **persistent knowledge store** that survives across sessions, tools, and even different agent frameworks.
+
+## Features
+
+- **Store & Retrieve** — Key-value storage with full persistence
+- **Namespaces** — Separate memories by project, user, or context
+- **Tags** — Categorize memories for easy filtering
+- **Full-Text Search** — Search across all stored knowledge
+- **Access Tracking** — See which memories are accessed most
+- **Statistics** — Dashboard showing memory usage
+
+## Installation
+
+```bash
+pip install agent-memory-mcp-server
+```
+
+## Usage with Claude Code
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "uvx",
+      "args": ["agent-memory-mcp-server"]
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `memory_store` | Store a key-value pair persistently |
+| `memory_retrieve` | Retrieve stored knowledge by key |
+| `memory_search` | Full-text search across all memories |
+| `memory_list` | List all memories in a namespace |
+| `memory_delete` | Remove a memory |
+| `memory_namespaces` | List all namespaces |
+| `memory_stats` | Usage statistics |
+
+## Examples
+
+```
+"Remember that the user prefers dark mode"
+"What do you know about Project Alpha?"
+"Store this API response for later"
+"What were the key decisions from last session?"
+```
+
+## How It Works
+
+Uses SQLite for zero-configuration persistent storage. Data is stored locally — no cloud, no API keys, no costs. The database file (`memory.db`) is created automatically in the server directory.
+
+## License
+
+MIT

agent_memory_mcp_server-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agent-memory-mcp-server"
+version = "0.1.0"
+description = "Persistent memory for AI agents — store, retrieve and search knowledge across sessions"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{name = "AiAgentKarl"}]
+keywords = ["mcp", "memory", "ai-agents", "persistence", "knowledge-base", "rag"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AiAgentKarl/agent-memory-mcp-server"
+Repository = "https://github.com/AiAgentKarl/agent-memory-mcp-server"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]

agent_memory_mcp_server-0.1.0/src/db.py

@@ -0,0 +1,176 @@
+"""Datenbank — SQLite-basierter persistenter Speicher für Agent-Memories."""
+
+import sqlite3
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+_DB_PATH = os.getenv("MEMORY_DB_PATH", str(Path(__file__).resolve().parent.parent / "memory.db"))
+
+
+def _connect() -> sqlite3.Connection:
+    """DB-Verbindung herstellen und Schema anlegen."""
+    conn = sqlite3.connect(_DB_PATH)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")  # Bessere Performance
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS memories (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            namespace TEXT NOT NULL DEFAULT 'default',
+            key TEXT NOT NULL,
+            value TEXT NOT NULL,
+            tags TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            access_count INTEGER DEFAULT 0,
+            UNIQUE(namespace, key)
+        )
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_namespace ON memories(namespace)
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_tags ON memories(tags)
+    """)
+    conn.commit()
+    return conn
+
+
+def store(namespace: str, key: str, value: str, tags: list[str] = None) -> dict:
+    """Memory speichern oder aktualisieren."""
+    conn = _connect()
+    now = datetime.now(timezone.utc).isoformat()
+    tags_str = json.dumps(tags) if tags else None
+
+    conn.execute(
+        """INSERT INTO memories (namespace, key, value, tags, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(namespace, key) DO UPDATE SET
+               value=excluded.value,
+               tags=excluded.tags,
+               updated_at=excluded.updated_at""",
+        (namespace, key, value, tags_str, now, now),
+    )
+    conn.commit()
+    conn.close()
+    return {"namespace": namespace, "key": key, "stored": True, "updated_at": now}
+
+
+def retrieve(namespace: str, key: str) -> dict | None:
+    """Memory abrufen und Zugriffszähler erhöhen."""
+    conn = _connect()
+    row = conn.execute(
+        "SELECT * FROM memories WHERE namespace=? AND key=?",
+        (namespace, key),
+    ).fetchone()
+
+    if row:
+        conn.execute(
+            "UPDATE memories SET access_count = access_count + 1 WHERE id=?",
+            (row["id"],),
+        )
+        conn.commit()
+        result = dict(row)
+        result["tags"] = json.loads(result["tags"]) if result["tags"] else []
+        conn.close()
+        return result
+
+    conn.close()
+    return None
+
+
+def search(query: str, namespace: str = None, tags: list[str] = None, limit: int = 20) -> list:
+    """Memories durchsuchen (Key und Value)."""
+    conn = _connect()
+    sql = "SELECT * FROM memories WHERE (key LIKE ? OR value LIKE ?)"
+    params = [f"%{query}%", f"%{query}%"]
+
+    if namespace:
+        sql += " AND namespace=?"
+        params.append(namespace)
+
+    if tags:
+        for tag in tags:
+            sql += " AND tags LIKE ?"
+            params.append(f"%{tag}%")
+
+    sql += " ORDER BY updated_at DESC LIMIT ?"
+    params.append(limit)
+
+    rows = conn.execute(sql, params).fetchall()
+    conn.close()
+
+    results = []
+    for r in rows:
+        d = dict(r)
+        d["tags"] = json.loads(d["tags"]) if d["tags"] else []
+        results.append(d)
+    return results
+
+
+def list_memories(namespace: str = None, limit: int = 50) -> list:
+    """Alle Memories auflisten."""
+    conn = _connect()
+    if namespace:
+        rows = conn.execute(
+            "SELECT * FROM memories WHERE namespace=? ORDER BY updated_at DESC LIMIT ?",
+            (namespace, limit),
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM memories ORDER BY updated_at DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    conn.close()
+
+    results = []
+    for r in rows:
+        d = dict(r)
+        d["tags"] = json.loads(d["tags"]) if d["tags"] else []
+        results.append(d)
+    return results
+
+
+def delete(namespace: str, key: str) -> dict:
+    """Memory löschen."""
+    conn = _connect()
+    cursor = conn.execute(
+        "DELETE FROM memories WHERE namespace=? AND key=?",
+        (namespace, key),
+    )
+    conn.commit()
+    conn.close()
+    return {"deleted": cursor.rowcount > 0, "namespace": namespace, "key": key}
+
+
+def list_namespaces() -> list:
+    """Alle Namespaces auflisten mit Anzahl Memories."""
+    conn = _connect()
+    rows = conn.execute(
+        "SELECT namespace, COUNT(*) as count FROM memories GROUP BY namespace ORDER BY count DESC"
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def get_stats() -> dict:
+    """Statistiken über den Speicher."""
+    conn = _connect()
+    total = conn.execute("SELECT COUNT(*) as c FROM memories").fetchone()["c"]
+    namespaces = conn.execute("SELECT COUNT(DISTINCT namespace) as c FROM memories").fetchone()["c"]
+    most_accessed = conn.execute(
+        "SELECT namespace, key, access_count FROM memories ORDER BY access_count DESC LIMIT 5"
+    ).fetchall()
+    recent = conn.execute(
+        "SELECT namespace, key, updated_at FROM memories ORDER BY updated_at DESC LIMIT 5"
+    ).fetchall()
+    conn.close()
+
+    return {
+        "total_memories": total,
+        "total_namespaces": namespaces,
+        "most_accessed": [dict(r) for r in most_accessed],
+        "recently_updated": [dict(r) for r in recent],
+    }

agent_memory_mcp_server-0.1.0/src/server.py

@@ -0,0 +1,25 @@
+"""Agent Memory MCP Server — Persistenter Speicher für AI-Agents."""
+
+from mcp.server.fastmcp import FastMCP
+
+from src.tools.memory import register_memory_tools
+
+mcp = FastMCP(
+    "Agent Memory Server",
+    instructions=(
+        "Provides persistent memory for AI agents across sessions. "
+        "Store facts, preferences, context and knowledge that survives "
+        "session boundaries. Supports namespaces, tags and full-text search."
+    ),
+)
+
+register_memory_tools(mcp)
+
+
+def main():
+    """Server starten."""
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

agent_memory_mcp_server-0.1.0/src/tools/memory.py

@@ -0,0 +1,112 @@
+"""Memory-Tools — Persistenter Speicher für AI-Agents."""
+
+from mcp.server.fastmcp import FastMCP
+
+from src import db
+
+
+def register_memory_tools(mcp: FastMCP):
+    """Memory-bezogene MCP-Tools registrieren."""
+
+    @mcp.tool()
+    async def memory_store(
+        key: str,
+        value: str,
+        namespace: str = "default",
+        tags: list[str] = None,
+    ) -> dict:
+        """Wissen persistent speichern.
+
+        Speichert einen Key-Value-Eintrag der über Sessions hinweg
+        erhalten bleibt. Ideal für Fakten, Präferenzen, Kontext.
+
+        Args:
+            key: Eindeutiger Schlüssel (z.B. "user_preference_language")
+            value: Der zu speichernde Inhalt (Text, JSON, etc.)
+            namespace: Namespace zur Trennung (z.B. "project_x", "user_123")
+            tags: Optionale Tags zum Kategorisieren (z.B. ["preference", "important"])
+        """
+        return db.store(namespace, key, value, tags)
+
+    @mcp.tool()
+    async def memory_retrieve(key: str, namespace: str = "default") -> dict:
+        """Gespeichertes Wissen abrufen.
+
+        Args:
+            key: Schlüssel des gesuchten Eintrags
+            namespace: Namespace (Standard: "default")
+        """
+        result = db.retrieve(namespace, key)
+        if result:
+            return result
+        return {"found": False, "key": key, "namespace": namespace}
+
+    @mcp.tool()
+    async def memory_search(
+        query: str,
+        namespace: str = None,
+        tags: list[str] = None,
+        limit: int = 10,
+    ) -> dict:
+        """Memories durchsuchen.
+
+        Sucht in Keys und Values nach dem Suchbegriff.
+        Optional filterbar nach Namespace und Tags.
+
+        Args:
+            query: Suchbegriff
+            namespace: Optional — nur in diesem Namespace suchen
+            tags: Optional — nur Memories mit diesen Tags
+            limit: Maximale Ergebnisse (Standard: 10)
+        """
+        results = db.search(query, namespace, tags, limit)
+        return {
+            "query": query,
+            "results_count": len(results),
+            "results": results,
+        }
+
+    @mcp.tool()
+    async def memory_list(namespace: str = None, limit: int = 20) -> dict:
+        """Alle Memories auflisten.
+
+        Args:
+            namespace: Optional — nur diesen Namespace zeigen
+            limit: Maximale Anzahl (Standard: 20)
+        """
+        results = db.list_memories(namespace, limit)
+        return {
+            "total": len(results),
+            "memories": results,
+        }
+
+    @mcp.tool()
+    async def memory_delete(key: str, namespace: str = "default") -> dict:
+        """Ein Memory löschen.
+
+        Args:
+            key: Schlüssel des zu löschenden Eintrags
+            namespace: Namespace (Standard: "default")
+        """
+        return db.delete(namespace, key)
+
+    @mcp.tool()
+    async def memory_namespaces() -> dict:
+        """Alle Namespaces mit Anzahl Memories auflisten.
+
+        Zeigt eine Übersicht aller verwendeten Namespaces.
+        """
+        namespaces = db.list_namespaces()
+        return {
+            "total_namespaces": len(namespaces),
+            "namespaces": namespaces,
+        }
+
+    @mcp.tool()
+    async def memory_stats() -> dict:
+        """Speicher-Statistiken abrufen.
+
+        Zeigt: Gesamtzahl Memories, Namespaces, meistgenutzte
+        und zuletzt aktualisierte Einträge.
+        """
+        return db.get_stats()