easy-agent-mem 0.3.0__tar.gz

easy_agent_mem-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atharva
+
+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.

easy_agent_mem-0.3.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: easy-agent-mem
+Version: 0.3.0
+Summary: Persistent memory layer for AI coding agents (Cursor / VS Code). Auto-summarizes sessions to Markdown / Obsidian.
+Author-email: Atharva <atharva.v.deo@gmail.com>
+License: MIT
+Keywords: ai,agent,memory,obsidian,claude,cursor,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12
+Provides-Extra: mcp
+Requires-Dist: mcp>=0.3; extra == "mcp"
+Dynamic: license-file
+
+# agent-mem
+
+**Persistent memory layer for AI coding agents** (Cursor, VS Code + Claude Code, etc.)
+
+Tired of repeating context every time you start a new chat?
+`agent-mem` automatically maintains a clean project memory file so your agent always knows what happened before - without bloating the context window.
+
+## Features
+
+- Simple local fallback: `.agent-memory/memory.md`
+- Optional Obsidian vault support (with full graph view, backlinks, Canvas)
+- Auto-generates strong agent instruction rules
+- Zero extra models or API keys needed
+- Works with any MCP-compatible IDE (Cursor, VS Code, etc.)
+- Extremely lightweight
+
+## Installation
+
+```bash
+pip install easy-agent-mem
+```
+
+## Quick Start
+
+```bash
+# 1. One-time setup
+agent-mem init
+
+# 2. (Recommended) Add the generated rules to your IDE
+#    - Cursor: Settings -> Custom Instructions
+#    - VS Code: Create CLAUDE.md or .claude/instructions.md in project root
+```
+
+During `init` you can:
+
+- Provide an Obsidian vault path (optional)
+- Or just press Enter to use the simple local `.agent-memory/memory.md` fallback
+
+## How It Works
+
+1. `agent-mem init` creates:
+   - `AGENT-MEM-RULES.md` (strong instructions for the agent)
+   - `.agent-memory/memory.md` (or Obsidian notes)
+
+2. Add the rules from `AGENT-MEM-RULES.md` to your IDE's custom instructions.
+
+3. From then on, your agent will:
+   - Read memory first in every new chat
+   - Summarize sessions when context gets long
+   - Keep a clean, persistent project history
+
+## Example Usage in Chat
+
+Tell your agent:
+> "Summarize this session for memory"
+
+It will create a clean summary and append it to memory. Then start a fresh chat - the agent will automatically load the latest memory.
+
+## Commands
+
+```bash
+agent-mem init          # Setup (Obsidian optional)
+agent-mem status        # Show current config
+agent-mem --help        # Full help
+```
+
+## Project Links
+
+- PyPI: [https://pypi.org/project/easy-agent-mem/](https://pypi.org/project/easy-agent-mem/)
+- Source: [https://github.com/atharvavdeo/agent-mem](https://github.com/atharvavdeo/agent-mem)
+
+## License
+
+MIT

easy_agent_mem-0.3.0/README.md

@@ -0,0 +1,74 @@
+# agent-mem
+
+**Persistent memory layer for AI coding agents** (Cursor, VS Code + Claude Code, etc.)
+
+Tired of repeating context every time you start a new chat?
+`agent-mem` automatically maintains a clean project memory file so your agent always knows what happened before - without bloating the context window.
+
+## Features
+
+- Simple local fallback: `.agent-memory/memory.md`
+- Optional Obsidian vault support (with full graph view, backlinks, Canvas)
+- Auto-generates strong agent instruction rules
+- Zero extra models or API keys needed
+- Works with any MCP-compatible IDE (Cursor, VS Code, etc.)
+- Extremely lightweight
+
+## Installation
+
+```bash
+pip install easy-agent-mem
+```
+
+## Quick Start
+
+```bash
+# 1. One-time setup
+agent-mem init
+
+# 2. (Recommended) Add the generated rules to your IDE
+#    - Cursor: Settings -> Custom Instructions
+#    - VS Code: Create CLAUDE.md or .claude/instructions.md in project root
+```
+
+During `init` you can:
+
+- Provide an Obsidian vault path (optional)
+- Or just press Enter to use the simple local `.agent-memory/memory.md` fallback
+
+## How It Works
+
+1. `agent-mem init` creates:
+   - `AGENT-MEM-RULES.md` (strong instructions for the agent)
+   - `.agent-memory/memory.md` (or Obsidian notes)
+
+2. Add the rules from `AGENT-MEM-RULES.md` to your IDE's custom instructions.
+
+3. From then on, your agent will:
+   - Read memory first in every new chat
+   - Summarize sessions when context gets long
+   - Keep a clean, persistent project history
+
+## Example Usage in Chat
+
+Tell your agent:
+> "Summarize this session for memory"
+
+It will create a clean summary and append it to memory. Then start a fresh chat - the agent will automatically load the latest memory.
+
+## Commands
+
+```bash
+agent-mem init          # Setup (Obsidian optional)
+agent-mem status        # Show current config
+agent-mem --help        # Full help
+```
+
+## Project Links
+
+- PyPI: [https://pypi.org/project/easy-agent-mem/](https://pypi.org/project/easy-agent-mem/)
+- Source: [https://github.com/atharvavdeo/agent-mem](https://github.com/atharvavdeo/agent-mem)
+
+## License
+
+MIT

easy_agent_mem-0.3.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "easy-agent-mem"
+version = "0.3.0"
+description = "Persistent memory layer for AI coding agents (Cursor / VS Code). Auto-summarizes sessions to Markdown / Obsidian."
+authors = [{ name = "Atharva", email = "atharva.v.deo@gmail.com" }]
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["ai", "agent", "memory", "obsidian", "claude", "cursor", "mcp"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "typer>=0.12",
+]
+
+[project.optional-dependencies]
+mcp = ["mcp>=0.3"]
+
+[project.scripts]
+agent-mem = "agent_mem.cli:app"
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

easy_agent_mem-0.3.0/setup.cfg

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

easy_agent_mem-0.3.0/src/agent_mem/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

easy_agent_mem-0.3.0/src/agent_mem/cli.py

@@ -0,0 +1,414 @@
+import typer
+from .config import CONFIG_FILE, get_config, save_config
+from pathlib import Path
+import json
+import shutil
+import sys
+from typing import Dict, List
+
+from .memory import get_fallback_memory_file
+
+app = typer.Typer()
+
+
+def _project_name_from_root(project_root: Path) -> str:
+    return project_root.resolve().name
+
+
+def _rules_body(project_name: str) -> str:
+    return f"""# Agent-Mem Rules
+
+You have persistent project memory via agent-mem.
+
+## Objective
+
+- Keep durable project context across chats.
+- Prefer stored memory over long chat history.
+
+## Memory Source Of Truth
+
+- Primary (default): .agent-memory/memory.md
+- Optional: [vault_path]/Memory/Agent-Mem/ when Obsidian mode is configured
+
+## Mandatory Start-Of-Session Workflow
+
+1. Resolve project root and project name (root folder name).
+2. Load latest memory before planning or coding.
+3. If memory exists, treat it as authoritative project context.
+4. If memory does not exist, continue normally and create or update it after meaningful progress.
+
+## Mandatory Summarization Triggers
+
+- Context pressure (roughly 15-20 turns)
+- Major milestone completed
+- Before ending session when important decisions were made
+
+## Required Summary Structure
+
+Use concise Markdown with these sections in order:
+
+- Goal
+- Outcome
+- Key decisions (with rationale)
+- Files changed (path + reason)
+- Open tasks or blockers
+- Next prioritized steps
+
+## Memory Write Rules
+
+- Append new information; do not delete prior history unless it is clearly obsolete and corrected.
+- Be factual and specific; never invent decisions or changes.
+- Never write secrets (tokens, API keys, passwords, private credentials).
+
+## MCP Compatibility (Optional)
+
+- If MCP tools are available: use query_memory, summarize_to_obsidian, list_recent_sessions.
+- If MCP tools are unavailable: read and update .agent-memory/memory.md directly with the same structure.
+
+## Project Name Rule
+
+- Always use the repository root folder name as project_name.
+
+Project name for this workspace: {project_name}
+"""
+
+
+def _cursor_rule_content(project_name: str) -> str:
+    return f"""---
+description: Enforce agent-mem persistent memory workflow
+alwaysApply: true
+---
+
+Follow AGENT-MEM-RULES.md in the repository root.
+
+Critical reminders:
+
+- Resolve project_name as: {project_name}
+- Read .agent-memory/memory.md before planning or coding.
+- On long sessions or milestones, write a structured summary with decisions and changed files.
+- Use MCP tools when available; otherwise update memory.md directly.
+"""
+
+
+def _claude_instructions_content(project_name: str) -> str:
+    return f"""# Agent Memory Instructions
+
+Use AGENT-MEM-RULES.md as the source of truth.
+
+Project name: {project_name}
+
+Mandatory behavior:
+
+- Resolve project name from repository root and keep it consistent.
+- Read memory before planning or coding.
+- Summarize at milestones/context pressure and persist outcomes.
+- Prefer memory content over old chat history.
+- Never hallucinate historical decisions.
+- Never store secrets in memory files.
+"""
+
+
+def _simple_wrapper_content(path_hint: str) -> str:
+    return (
+        "Use AGENT-MEM-RULES.md in the repository root as the authoritative instruction set for memory workflow.\n"
+        f"Wrapper target: {path_hint}\n"
+    )
+
+
+def _write_file(path: Path, content: str) -> bool:
+    if path.exists():
+        return False
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    return True
+
+
+def _create_instruction_files(project_root: Path) -> Dict[str, List[str]]:
+    project_name = _project_name_from_root(project_root)
+
+    files_to_write = {
+        project_root / "AGENT-MEM-RULES.md": _rules_body(project_name),
+        project_root / ".cursor" / "rules" / "agent-mem.mdc": _cursor_rule_content(project_name),
+        project_root / ".claude" / "instructions.md": _claude_instructions_content(project_name),
+        project_root / "CLAUDE.md": _claude_instructions_content(project_name),
+        project_root / ".antigravity" / "rules.md": _simple_wrapper_content("antigravity"),
+        project_root / ".opencode" / "instructions.md": _simple_wrapper_content("opencode"),
+    }
+
+    created: List[str] = []
+    skipped: List[str] = []
+    for path, content in files_to_write.items():
+        if _write_file(path, content):
+            created.append(str(path.relative_to(project_root)))
+        else:
+            skipped.append(str(path.relative_to(project_root)))
+
+    return {"created": created, "skipped": skipped}
+
+
+def _upsert_mcp_config(config_path: Path) -> str:
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if config_path.exists():
+        try:
+            config = json.loads(config_path.read_text(encoding="utf-8"))
+            if not isinstance(config, dict):
+                config = {}
+        except json.JSONDecodeError:
+            config = {}
+    else:
+        config = {}
+
+    servers = config.get("mcpServers")
+    if not isinstance(servers, dict):
+        servers = {}
+
+    resolved_command = shutil.which("agent-mem") or "agent-mem"
+    servers["agent-mem"] = {
+        "command": resolved_command,
+        "args": ["serve"],
+    }
+    config["mcpServers"] = servers
+
+    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+    return str(config_path)
+
+
+def _create_local_mcp_configs(project_root: Path) -> List[str]:
+    return [
+        _upsert_mcp_config(project_root / ".vscode" / "mcp.json"),
+        _upsert_mcp_config(project_root / ".cursor" / "mcp.json"),
+    ]
+
+
+def _upsert_vscode_mcp_with_python(config_path: Path, python_executable: str) -> str:
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if config_path.exists():
+        try:
+            config = json.loads(config_path.read_text(encoding="utf-8"))
+            if not isinstance(config, dict):
+                config = {}
+        except json.JSONDecodeError:
+            config = {}
+    else:
+        config = {}
+
+    servers = config.get("mcpServers")
+    if not isinstance(servers, dict):
+        servers = {}
+
+    servers["agent-mem"] = {
+        "command": python_executable,
+        "args": ["-m", "agent_mem.cli", "serve"],
+    }
+    config["mcpServers"] = servers
+
+    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+    return str(config_path)
+
+
+def _detect_preferred_python(project_root: Path) -> str:
+    # Prefer repo-local virtual env for predictable MCP startup.
+    local_venv_python = project_root / ".venv" / "bin" / "python"
+    if local_venv_python.exists():
+        return str(local_venv_python)
+
+    virtual_env = Path(sys.prefix)
+    if (virtual_env / "bin" / "python").exists():
+        return str(virtual_env / "bin" / "python")
+
+    return sys.executable
+
+
+def _resolve_python_for_mcp(project_root: Path, python_option: str) -> str:
+    if python_option.strip():
+        explicit_python = Path(python_option.strip()).expanduser().resolve()
+        if not explicit_python.exists():
+            typer.echo(f"❌ Python path not found: {explicit_python}", err=True)
+            raise typer.Exit(1)
+        return str(explicit_python)
+
+    return _detect_preferred_python(project_root)
+
+
+def _build_mcp_json_with_python(python_executable: str) -> dict:
+    return {
+        "mcpServers": {
+            "agent-mem": {
+                "command": python_executable,
+                "args": ["-m", "agent_mem.cli", "serve"],
+            }
+        }
+    }
+
+
+def _ensure_local_memory_initialized(project_root: Path):
+    fallback_file = get_fallback_memory_file(project_root)
+    if fallback_file.exists():
+        return
+    fallback_file.parent.mkdir(parents=True, exist_ok=True)
+    fallback_file.write_text("# Agent Memory\n\n", encoding="utf-8")
+
+
+@app.command()
+def init():
+    """One-time setup - Obsidian is optional, local memory.md fallback is supported."""
+    typer.echo("agent-mem setup (Obsidian path is optional)")
+    vault = typer.prompt(
+        "Full path to your Obsidian vault (press Enter to skip and use local memory.md)",
+        default="",
+    )
+
+    config = {"use_obsidian": False, "obsidian_vault": None}
+    if vault.strip():
+        vault_path = Path(vault).expanduser().resolve()
+        if vault_path.exists():
+            config = {"use_obsidian": True, "obsidian_vault": str(vault_path)}
+            typer.echo(f"✅ Using Obsidian vault: {vault_path}")
+        else:
+            typer.echo("⚠️ Path does not exist. Falling back to local memory.md", err=True)
+    else:
+        typer.echo("✅ Using simple local memory.md fallback in project folder")
+        _ensure_local_memory_initialized(Path.cwd().resolve())
+
+    save_config(config)
+    typer.echo(f"✅ Config saved to {CONFIG_FILE}")
+
+    project_root = Path.cwd().resolve()
+    typer.echo(f"Project root for setup: {project_root}")
+
+    if typer.confirm(
+        "Create automatic instruction files for Cursor/Claude/Antigravity/OpenCode? (recommended)",
+        default=True,
+    ):
+        result = _create_instruction_files(project_root)
+        if result["created"]:
+            typer.echo("✅ Created instruction files:")
+            for relative_path in result["created"]:
+                typer.echo(f"  - {relative_path}")
+        if result["skipped"]:
+            typer.echo("ℹ️ Existing files kept unchanged:")
+            for relative_path in result["skipped"]:
+                typer.echo(f"  - {relative_path}")
+        typer.echo("Restart your IDE chat (or reload rules) to apply instruction changes.")
+
+    if typer.confirm(
+        "Create/update local MCP config files (.vscode/mcp.json and .cursor/mcp.json)? (optional)",
+        default=False,
+    ):
+        written_paths = _create_local_mcp_configs(project_root)
+        typer.echo("✅ MCP config updated:")
+        for config_path in written_paths:
+            typer.echo(f"  - {config_path}")
+
+    typer.echo("\nSetup complete!")
+    typer.echo("Next: add AGENT-MEM-RULES.md to your IDE custom instructions.")
+    typer.echo('Optional MCP mode: pip install "easy-agent-mem[mcp]" && agent-mem serve')
+
+
+@app.command()
+def setup():
+    """Set up instruction files + MCP configs for the current project."""
+    project_root = Path.cwd().resolve()
+
+    result = _create_instruction_files(project_root)
+    written_paths = _create_local_mcp_configs(project_root)
+
+    typer.echo(f"Project root: {project_root}")
+    if result["created"]:
+        typer.echo("✅ Created instruction files:")
+        for relative_path in result["created"]:
+            typer.echo(f"  - {relative_path}")
+    if result["skipped"]:
+        typer.echo("ℹ️ Existing files kept unchanged:")
+        for relative_path in result["skipped"]:
+            typer.echo(f"  - {relative_path}")
+
+    typer.echo("✅ MCP config updated:")
+    for config_path in written_paths:
+        typer.echo(f"  - {config_path}")
+
+
+@app.command("setup-vscode")
+def setup_vscode(
+    python: str = typer.Option(
+        "",
+        "--python",
+        help="Explicit Python executable path for MCP command",
+    ),
+):
+    """Write .vscode/mcp.json using the currently active Python interpreter."""
+    project_root = Path.cwd().resolve()
+    config_path = project_root / ".vscode" / "mcp.json"
+    selected_python = _resolve_python_for_mcp(project_root, python)
+
+    written = _upsert_vscode_mcp_with_python(config_path, selected_python)
+
+    typer.echo("✅ VS Code MCP config written")
+    typer.echo(f"Path: {written}")
+    typer.echo("Server command uses:")
+    typer.echo(f"  {selected_python} -m agent_mem.cli serve")
+
+
+@app.command("print-mcp-json")
+def print_mcp_json(
+    python: str = typer.Option(
+        "",
+        "--python",
+        help="Explicit Python executable path for MCP command",
+    ),
+):
+    """Print a ready-to-paste MCP JSON block without writing any files."""
+    project_root = Path.cwd().resolve()
+    selected_python = _resolve_python_for_mcp(project_root, python)
+    block = _build_mcp_json_with_python(selected_python)
+
+    typer.echo(json.dumps(block, indent=2))
+
+
+@app.command()
+def serve():
+    """Start the optional MCP server (stdio transport)."""
+    try:
+        from .mcp_server import mcp
+    except ImportError:
+        typer.echo(
+            '❌ MCP dependencies are not installed. Install with: pip install "easy-agent-mem[mcp]"',
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    config = get_config()
+    if config.get("use_obsidian") and not config.get("obsidian_vault"):
+        typer.echo("❌ Obsidian mode selected but no vault path found. Re-run agent-mem init.", err=True)
+        raise typer.Exit(1)
+
+    typer.echo("agent-mem MCP server started (stdio transport)")
+    typer.echo("Tip: run 'agent-mem print-mcp-json' if you need a config block.")
+    mcp.run()
+
+
+@app.command()
+def status():
+    """Show the configured vault and stored session count."""
+    config = get_config()
+    project_root = Path.cwd().resolve()
+    vault = config.get("obsidian_vault")
+
+    if config.get("use_obsidian") and vault:
+        memory_dir = Path(vault) / "Memory" / "Agent-Mem"
+        count = len(list(memory_dir.glob("*.md"))) if memory_dir.exists() else 0
+        typer.echo("Storage mode   : Obsidian")
+        typer.echo(f"Obsidian vault : {vault}")
+        typer.echo(f"Memory notes   : {count} sessions stored")
+        return
+
+    fallback_file = project_root / ".agent-memory" / "memory.md"
+    typer.echo("Storage mode   : Local fallback")
+    typer.echo(f"Memory file    : {fallback_file}")
+    typer.echo(f"Memory exists  : {'yes' if fallback_file.exists() else 'no'}")
+
+
+if __name__ == "__main__":
+    app()

easy_agent_mem-0.3.0/src/agent_mem/config.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    tomllib = importlib.import_module("tomllib")
+else:  # pragma: no cover
+    tomllib = importlib.import_module("tomli")
+
+CONFIG_DIR = Path.home() / ".config" / "agent-mem"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+DEFAULT_CONFIG = {"use_obsidian": False, "obsidian_vault": None}
+
+
+def _normalize_config(config: dict) -> dict:
+    normalized = dict(DEFAULT_CONFIG)
+    normalized.update(config)
+
+    use_obsidian = normalized.get("use_obsidian")
+    if isinstance(use_obsidian, str):
+        normalized["use_obsidian"] = use_obsidian.lower() in {"1", "true", "yes", "y"}
+
+    vault = normalized.get("obsidian_vault")
+    if isinstance(vault, str) and not vault.strip():
+        normalized["obsidian_vault"] = None
+
+    if not normalized.get("obsidian_vault"):
+        normalized["use_obsidian"] = False
+
+    return normalized
+
+
+def _serialize_toml(config: dict) -> str:
+    lines = []
+    for key, value in config.items():
+        if value is None:
+            value_repr = '""'
+        elif isinstance(value, bool):
+            value_repr = "true" if value else "false"
+        elif isinstance(value, (int, float)):
+            value_repr = str(value)
+        else:
+            escaped = str(value).replace("\\", "\\\\").replace('"', '\\"')
+            value_repr = f'"{escaped}"'
+        lines.append(f"{key} = {value_repr}")
+    return "\n".join(lines) + "\n"
+
+
+def get_config() -> dict:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    if not CONFIG_FILE.exists():
+        return dict(DEFAULT_CONFIG)
+
+    with open(CONFIG_FILE, "rb") as file:
+        loaded = tomllib.load(file)
+    return _normalize_config(loaded)
+
+def save_config(config: dict):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(_serialize_toml(_normalize_config(config)), encoding="utf-8")

easy_agent_mem-0.3.0/src/agent_mem/mcp_server.py

@@ -0,0 +1,107 @@
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError:  # pragma: no cover - fallback for older installs
+    from fastmcp import FastMCP
+
+from pathlib import Path
+
+from .memory import (
+    get_fallback_memory_file,
+    is_obsidian_enabled,
+    list_recent_session_files,
+    write_session_summary,
+)
+
+mcp = FastMCP("agent-mem")
+
+
+def _score_line(line: str, query: str) -> int:
+    line_lower = line.lower()
+    query_lower = query.lower().strip()
+    if not query_lower:
+        return 0
+
+    score = 0
+    for word in query_lower.split():
+        if word and word in line_lower:
+            score += 2
+    if query_lower in line_lower:
+        score += 5
+    return score
+
+
+def _scored_excerpt(content: str, query: str, limit: int = 12) -> list[str]:
+    lines = [line.strip() for line in content.splitlines() if line.strip()]
+    scored = sorted(
+        ((line, _score_line(line, query)) for line in lines),
+        key=lambda item: item[1],
+        reverse=True,
+    )
+    matches = [line for line, score in scored if score > 0][:limit]
+    if matches:
+        return matches
+    return [content[:800].strip()] if content.strip() else []
+
+@mcp.tool()
+def query_memory(project_name: str, query: str) -> str:
+    """MUST be called at the start of every new session.
+
+    Use the project root folder name for project_name and a short goal-focused query.
+    Works in both modes:
+    - Obsidian mode: reads recent notes from <vault>/Memory/Agent-Mem
+    - Fallback mode: reads local .agent-memory/memory.md
+    """
+    project_root = Path.cwd().resolve()
+    files = list_recent_session_files(project_name, count=5, project_root=project_root)
+
+    if not files:
+        return "No memory yet for this project. Start by chatting, then save a session summary."
+
+    mode = "Obsidian" if is_obsidian_enabled() else "Local memory.md"
+    result = [f"## Latest Memory ({mode})"]
+    for file_path in files:
+        content = file_path.read_text(encoding="utf-8")
+        matches = _scored_excerpt(content, query, limit=12)
+
+        result.append(f"### {file_path.name}")
+        if matches:
+            result.extend(matches)
+        result.append("")
+
+    return "\n".join(result)[:6000]
+
+@mcp.tool()
+def summarize_to_obsidian(project_name: str, summary: str) -> str:
+    """Call when context is getting long (about 15-20 turns).
+
+    Provide a structured markdown summary with decisions, file changes, open tasks,
+    blockers, and next steps. After saving, suggest starting a fresh chat.
+
+    This tool writes to Obsidian when configured, otherwise to local .agent-memory/memory.md.
+    """
+    project_root = Path.cwd().resolve()
+    filepath = write_session_summary(project_name, summary, project_root=project_root)
+    target = "Obsidian" if is_obsidian_enabled() else "local memory file"
+
+    return (
+        f"✅ Session summarized and saved to {target}: {filepath}\n"
+        "You can now start a fresh chat. Future chats will use query_memory first."
+    )
+
+
+@mcp.tool()
+def list_recent_sessions(project_name: str, count: int = 3) -> str:
+    """List recent memory notes for quick historical overviews.
+
+    Useful when users ask about prior work before requesting deep details.
+    In fallback mode, returns the local memory.md file when available.
+    """
+    project_root = Path.cwd().resolve()
+    files = list_recent_session_files(project_name, count=count, project_root=project_root)
+    if not files:
+        return "No sessions yet"
+    if is_obsidian_enabled():
+        return "\n".join(file_path.name for file_path in files)
+
+    fallback = get_fallback_memory_file(project_root)
+    return str(fallback.relative_to(project_root)) if fallback.exists() else "No sessions yet"

easy_agent_mem-0.3.0/src/agent_mem/memory.py

@@ -0,0 +1,88 @@
+from datetime import datetime
+from pathlib import Path
+
+from .config import get_config
+
+
+FALLBACK_DIR_NAME = ".agent-memory"
+FALLBACK_FILE_NAME = "memory.md"
+
+
+def is_obsidian_enabled() -> bool:
+    config = get_config()
+    return bool(config.get("use_obsidian") and config.get("obsidian_vault"))
+
+
+def get_memory_dir(project_root: Path | None = None) -> Path:
+    resolved_project_root = (project_root or Path.cwd()).resolve()
+    if is_obsidian_enabled():
+        vault = Path(get_config()["obsidian_vault"])
+        memory_dir = vault / "Memory" / "Agent-Mem"
+    else:
+        memory_dir = resolved_project_root / FALLBACK_DIR_NAME
+
+    memory_dir.mkdir(parents=True, exist_ok=True)
+    return memory_dir
+
+
+def get_fallback_memory_file(project_root: Path | None = None) -> Path:
+    return get_memory_dir(project_root) / FALLBACK_FILE_NAME
+
+
+def _session_block(project_name: str, summary: str) -> str:
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+    return f"""## Session Summary - {timestamp}
+
+Project: {project_name}
+
+{summary}
+
+---
+**Auto-generated by agent-mem**
+"""
+
+
+def write_session_summary(project_name: str, summary: str, project_root: Path | None = None) -> str:
+    resolved_project_root = (project_root or Path.cwd()).resolve()
+    memory_dir = get_memory_dir(resolved_project_root)
+    date_str = datetime.now().strftime("%Y-%m-%d_%H-%M")
+
+    if is_obsidian_enabled():
+        filepath = memory_dir / f"{project_name}-{date_str}-session.md"
+        content = f"""# Session Summary - {datetime.now().strftime("%Y-%m-%d %H:%M")}
+
+{summary}
+
+---
+**Auto-generated by agent-mem • Obsidian mode**
+"""
+        filepath.write_text(content, encoding="utf-8")
+        vault = Path(get_config()["obsidian_vault"])
+        return str(filepath.relative_to(vault))
+
+    filepath = get_fallback_memory_file(resolved_project_root)
+    entry = _session_block(project_name, summary).strip() + "\n"
+    if filepath.exists():
+        filepath.write_text(filepath.read_text(encoding="utf-8") + "\n" + entry, encoding="utf-8")
+    else:
+        filepath.write_text("# Agent Memory\n\n" + entry, encoding="utf-8")
+    return str(filepath.relative_to(resolved_project_root))
+
+
+def list_recent_session_files(
+    project_name: str,
+    count: int = 3,
+    project_root: Path | None = None,
+) -> list[Path]:
+    resolved_project_root = (project_root or Path.cwd()).resolve()
+    if is_obsidian_enabled():
+        memory_dir = get_memory_dir(resolved_project_root)
+        files = sorted(
+            memory_dir.glob(f"{project_name}*.md"),
+            key=lambda path: path.stat().st_mtime,
+            reverse=True,
+        )
+        return files[:count]
+
+    fallback_file = get_fallback_memory_file(resolved_project_root)
+    return [fallback_file] if fallback_file.exists() else []

easy_agent_mem-0.3.0/src/easy_agent_mem.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: easy-agent-mem
+Version: 0.3.0
+Summary: Persistent memory layer for AI coding agents (Cursor / VS Code). Auto-summarizes sessions to Markdown / Obsidian.
+Author-email: Atharva <atharva.v.deo@gmail.com>
+License: MIT
+Keywords: ai,agent,memory,obsidian,claude,cursor,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12
+Provides-Extra: mcp
+Requires-Dist: mcp>=0.3; extra == "mcp"
+Dynamic: license-file
+
+# agent-mem
+
+**Persistent memory layer for AI coding agents** (Cursor, VS Code + Claude Code, etc.)
+
+Tired of repeating context every time you start a new chat?
+`agent-mem` automatically maintains a clean project memory file so your agent always knows what happened before - without bloating the context window.
+
+## Features
+
+- Simple local fallback: `.agent-memory/memory.md`
+- Optional Obsidian vault support (with full graph view, backlinks, Canvas)
+- Auto-generates strong agent instruction rules
+- Zero extra models or API keys needed
+- Works with any MCP-compatible IDE (Cursor, VS Code, etc.)
+- Extremely lightweight
+
+## Installation
+
+```bash
+pip install easy-agent-mem
+```
+
+## Quick Start
+
+```bash
+# 1. One-time setup
+agent-mem init
+
+# 2. (Recommended) Add the generated rules to your IDE
+#    - Cursor: Settings -> Custom Instructions
+#    - VS Code: Create CLAUDE.md or .claude/instructions.md in project root
+```
+
+During `init` you can:
+
+- Provide an Obsidian vault path (optional)
+- Or just press Enter to use the simple local `.agent-memory/memory.md` fallback
+
+## How It Works
+
+1. `agent-mem init` creates:
+   - `AGENT-MEM-RULES.md` (strong instructions for the agent)
+   - `.agent-memory/memory.md` (or Obsidian notes)
+
+2. Add the rules from `AGENT-MEM-RULES.md` to your IDE's custom instructions.
+
+3. From then on, your agent will:
+   - Read memory first in every new chat
+   - Summarize sessions when context gets long
+   - Keep a clean, persistent project history
+
+## Example Usage in Chat
+
+Tell your agent:
+> "Summarize this session for memory"
+
+It will create a clean summary and append it to memory. Then start a fresh chat - the agent will automatically load the latest memory.
+
+## Commands
+
+```bash
+agent-mem init          # Setup (Obsidian optional)
+agent-mem status        # Show current config
+agent-mem --help        # Full help
+```
+
+## Project Links
+
+- PyPI: [https://pypi.org/project/easy-agent-mem/](https://pypi.org/project/easy-agent-mem/)
+- Source: [https://github.com/atharvavdeo/agent-mem](https://github.com/atharvavdeo/agent-mem)
+
+## License
+
+MIT

easy_agent_mem-0.3.0/src/easy_agent_mem.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/agent_mem/__init__.py
+src/agent_mem/cli.py
+src/agent_mem/config.py
+src/agent_mem/mcp_server.py
+src/agent_mem/memory.py
+src/easy_agent_mem.egg-info/PKG-INFO
+src/easy_agent_mem.egg-info/SOURCES.txt
+src/easy_agent_mem.egg-info/dependency_links.txt
+src/easy_agent_mem.egg-info/entry_points.txt
+src/easy_agent_mem.egg-info/requires.txt
+src/easy_agent_mem.egg-info/top_level.txt

easy_agent_mem-0.3.0/src/easy_agent_mem.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

easy_agent_mem-0.3.0/src/easy_agent_mem.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-mem = agent_mem.cli:app

easy_agent_mem-0.3.0/src/easy_agent_mem.egg-info/requires.txt

@@ -0,0 +1,4 @@
+typer>=0.12
+
+[mcp]
+mcp>=0.3

easy_agent_mem-0.3.0/src/easy_agent_mem.egg-info/top_level.txt

@@ -0,0 +1 @@
+agent_mem