yomemoai-mcp 0.1.0__tar.gz → 0.1.3__tar.gz

yomemoai_mcp-0.1.3/CURSOR_RULES.md

@@ -0,0 +1,40 @@
+# Cursor best practice: proactive Yomemo long-term memory
+
+After configuring the Yomemo MCP in Cursor, add the rule below to **Rules for AI**. The AI will then **proactively** call `save_memory` when it detects important information—no need to say "remember this" every time.
+
+---
+
+## Option 1: Cursor global / project Rules for AI
+
+Open Cursor settings → **Rules for AI**, add a new rule, and paste the following:
+
+```
+You are equipped with Yomemo.ai MCP.
+
+## When to use `save_memory`:
+- **Tech Stack**: When we decide on a specific library or version.
+- **Business Logic**: When I explain a complex internal rule.
+- **Preferences**: If I tell you "I prefer using early returns in Go".
+
+## When to use `load_memories`:
+- At the start of a new feature implementation, check if there's relevant context in the 'coding' or 'project-name' handle.
+
+## Feedback:
+- After saving, just add a ✓ in your response. No need for a long confirmation.
+```
+
+---
+
+## Option 2: Project-level rule file (.cursor/rules)
+
+Create `.cursor/rules/` in your project root and add a file such as `yomemo-memory.mdc` with the same content above. The rule will then apply only in that project.
+
+---
+
+## What you get
+
+- The AI will call `save_memory` when it recognizes **preferences, decisions, or reusable logic**.
+- After saving, it will add a ✓ in its reply—smooth and low-friction.
+- At the start of new chats or features, it will call `load_memories` when it needs historical context.
+
+Use this together with your [yomemoai-mcp](https://github.com/yomemoai/python-yomemo-mcp) MCP setup.

{yomemoai_mcp-0.1.0 → yomemoai_mcp-0.1.3}/PKG-INFO

@@ -1,8 +1,12 @@
 Metadata-Version: 2.4
 Name: yomemoai-mcp
-Version: 0.1.0
+Version: 0.1.3
 Summary: Model Context Protocol (MCP) server for YoMemoAI - enables AI assistants to save and retrieve encrypted memories
-Author-email: lvxiangxiang <lvxiangxiang@shopline.com>
+Project-URL: Homepage, https://github.com/yomemoai/python-yomemo-mcp
+Project-URL: Documentation, https://github.com/yomemoai/python-yomemo-mcp#readme
+Project-URL: Repository, https://github.com/yomemoai/python-yomemo-mcp
+Project-URL: Issues, https://github.com/yomemoai/python-yomemo-mcp/issues
+Author-email: xxlv <lvxiang119@gmail.com>
 License: MIT
 License-File: LICENSE
 Keywords: ai,claude,cursor,mcp,mcp-server,memory,yomemoai
@@ -44,8 +48,8 @@ A Model Context Protocol (MCP) server for YoMemoAI, enabling AI assistants to sa
 1. Clone the repository:
 
 ```bash
-git clone <repository-url>
-cd yomemoai-mcp
+git clone https://github.com/yomemoai/python-yomemo-mcp.git
+cd python-yomemo-mcp
 ```
 
 2. Install dependencies using uv:
@@ -99,6 +103,11 @@ After configuration, you can run the MCP server using:
 uv run memo-mcp
 ```
 
+### Cursor best practice (recommended)
+
+Want the AI to **proactively** save memories when it detects preferences or decisions (not only when you say "remember")?  
+Add one rule in Cursor's Rules for AI—see **[CURSOR_RULES.md](./CURSOR_RULES.md)**.
+
 ### Integration with Cursor/Claude Desktop
 
 Add the following configuration to your MCP settings file:
@@ -225,9 +234,6 @@ yomemoai-mcp/
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-## Contributing
-
-[Add contribution guidelines here]
 
 ## Support
 

{yomemoai_mcp-0.1.0 → yomemoai_mcp-0.1.3}/PUBLISHING.md

@@ -8,6 +8,19 @@ This document describes how to publish `yomemoai-mcp` to PyPI so that users can
 2. **TestPyPI Account** (recommended for testing): Create an account at [TestPyPI](https://test.pypi.org/)
 3. **API Token**: You'll need an API token to publish packages
 
+### Important: TestPyPI vs PyPI Accounts
+
+**TestPyPI and PyPI are separate systems**, but you can use the **same username and password** for both:
+
+- **Same credentials work**: If you register on TestPyPI, you can use the same username and password to register on PyPI
+- **Separate accounts**: They are technically separate accounts, but sharing credentials is common and recommended
+- **Email conflicts**: If you get an "email already in use" error on PyPI:
+  - You may have already registered on PyPI before (check your email for activation links)
+  - Or someone else is using that email (unlikely but possible)
+  - **Solution**: Try password reset on PyPI using the same email, or use a different email
+
+**Recommended approach**: Register on both TestPyPI and PyPI using the same username and password for consistency.
+
 ## Step 1: Create API Token
 
 1. Log in to [PyPI](https://pypi.org/)
@@ -41,6 +54,7 @@ uv build
 ```
 
 This will create a `dist/` directory containing:
+
 - `yomemoai_mcp-0.1.0-py3-none-any.whl` (wheel distribution)
 - `yomemoai-mcp-0.1.0.tar.gz` (source distribution)
 
@@ -67,17 +81,21 @@ uv publish --publish-url https://test.pypi.org/legacy/
 
 Test that the package can be installed and run:
 
+**Important**: TestPyPI may not have all dependencies. Use `--extra-index-url` to fetch dependencies from PyPI while getting the package from TestPyPI:
+
 ```bash
-# Test installation from TestPyPI
-uvx --index-url https://test.pypi.org/simple/ yomemoai-mcp --help
+# Test installation from TestPyPI (dependencies from PyPI)
+uvx --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ yomemoai-mcp --help
 
 # Or test in a clean environment
 uv venv test-env
 source test-env/bin/activate  # On Windows: test-env\Scripts\activate
-pip install --index-url https://test.pypi.org/simple/ yomemoai-mcp
+pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ yomemoai-mcp
 yomemoai-mcp --help
 ```
 
+**Note**: The `--extra-index-url` flag tells the package manager to also check PyPI for dependencies that might not be available on TestPyPI.
+
 ## Step 5: Publish to PyPI
 
 Once testing is successful, publish to the real PyPI:
@@ -130,6 +148,7 @@ curl https://pypi.org/pypi/yomemoai-mcp/json | jq
 When you need to publish a new version:
 
 1. **Update version** in `pyproject.toml`:
+
    ```toml
    version = "0.1.1"  # or 0.2.0, 1.0.0, etc.
    ```
@@ -145,6 +164,7 @@ When you need to publish a new version:
 ## Version Numbering
 
 Follow [Semantic Versioning](https://semver.org/):
+
 - **MAJOR** (1.0.0): Breaking changes
 - **MINOR** (0.1.0): New features, backward compatible
 - **PATCH** (0.1.1): Bug fixes, backward compatible

{yomemoai_mcp-0.1.0 → yomemoai_mcp-0.1.3}/README.md

@@ -21,8 +21,8 @@ A Model Context Protocol (MCP) server for YoMemoAI, enabling AI assistants to sa
 1. Clone the repository:
 
 ```bash
-git clone <repository-url>
-cd yomemoai-mcp
+git clone https://github.com/yomemoai/python-yomemo-mcp.git
+cd python-yomemo-mcp
 ```
 
 2. Install dependencies using uv:
@@ -76,6 +76,11 @@ After configuration, you can run the MCP server using:
 uv run memo-mcp
 ```
 
+### Cursor best practice (recommended)
+
+Want the AI to **proactively** save memories when it detects preferences or decisions (not only when you say "remember")?  
+Add one rule in Cursor's Rules for AI—see **[CURSOR_RULES.md](./CURSOR_RULES.md)**.
+
 ### Integration with Cursor/Claude Desktop
 
 Add the following configuration to your MCP settings file:
@@ -202,9 +207,6 @@ yomemoai-mcp/
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-## Contributing
-
-[Add contribution guidelines here]
 
 ## Support
 

yomemoai_mcp-0.1.3/llm.md

@@ -0,0 +1,27 @@
+# Project Description for GitHub/PyPI
+
+**yomemoai-mcp** is a Model Context Protocol (MCP) server that enables AI assistants like Claude and Cursor to seamlessly save and retrieve encrypted memories through YoMemoAI's secure storage platform.
+
+## Key Features
+
+- **End-to-End Encryption**: All memories are encrypted client-side using RSA-OAEP and AES-GCM before being stored, ensuring your data remains private even from the service provider
+- **Persistent Memory**: AI assistants can remember important information, user preferences, and conversation context across sessions
+- **Organized Storage**: Memories can be categorized using handles (tags/categories) for easy retrieval and organization
+- **MCP Integration**: Built on the Model Context Protocol standard, making it compatible with any MCP-enabled AI assistant
+- **Easy Installation**: Available on PyPI and can be installed with a single command: `uvx yomemoai-mcp`
+
+## Use Cases
+
+- Save important user preferences and context that AI assistants should remember
+- Store conversation history and key information for future reference
+- Organize memories by topics, projects, or categories using handles
+- Enable AI assistants to maintain long-term memory across multiple sessions
+
+## Technical Highlights
+
+- Hybrid encryption architecture (RSA + AES-GCM) for secure data storage
+- FastMCP framework for efficient MCP server implementation
+- Type-safe Python implementation with full type hints
+- Simple configuration via environment variables
+
+Perfect for developers and users who want to give their AI assistants persistent, encrypted memory capabilities.

{yomemoai_mcp-0.1.0 → yomemoai_mcp-0.1.3}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "yomemoai-mcp"
-version = "0.1.0"
+version = "0.1.3"
 description = "Model Context Protocol (MCP) server for YoMemoAI - enables AI assistants to save and retrieve encrypted memories"
 readme = "README.md"
 license = { text = "MIT" }
 authors = [
-    { name = "lvxiangxiang", email = "lvxiangxiang@shopline.com" }
+    { name = "xxlv", email = "lvxiang119@gmail.com" }
 ]
 requires-python = ">=3.12"
 keywords = ["mcp", "mcp-server", "yomemoai", "memory", "ai", "claude", "cursor"]
@@ -26,9 +26,14 @@ dependencies = [
     "requests>=2.32.5",
 ]
 
+[project.urls]
+Homepage = "https://github.com/yomemoai/python-yomemo-mcp"
+Documentation = "https://github.com/yomemoai/python-yomemo-mcp#readme"
+Repository = "https://github.com/yomemoai/python-yomemo-mcp"
+Issues = "https://github.com/yomemoai/python-yomemo-mcp/issues"
+
 [project.scripts]
 yomemoai-mcp = "yomemoai_mcp.server:mcp.run"
-yomemo = "yomemoai_mcp.server:mcp.run"
 memo-mcp = "yomemoai_mcp.server:mcp.run"
 
 [build-system]

yomemoai_mcp-0.1.3/src/yomemoai_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""YoMemoAI MCP Server - Model Context Protocol server for YoMemoAI."""
+
+__version__ = "0.1.0"

{yomemoai_mcp-0.1.0 → yomemoai_mcp-0.1.3}/src/yomemoai_mcp/client.py

@@ -1,5 +1,6 @@
 import base64
 import json
+import logging
 import time
 import requests
 from typing import Dict, List, Optional, Tuple
@@ -9,6 +10,24 @@ from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from cryptography.hazmat.backends import default_backend
 import os
 
+logger = logging.getLogger(__name__)
+
+
+class MemoRequestError(Exception):
+    def __init__(
+        self,
+        message: str,
+        url: str,
+        payload: Dict,
+        status_code: Optional[int] = None,
+        response_text: Optional[str] = None,
+    ):
+        super().__init__(message)
+        self.url = url
+        self.payload = payload
+        self.status_code = status_code
+        self.response_text = response_text
+
 
 class MemoClient:
     """
@@ -98,9 +117,20 @@ class MemoClient:
             )
 
     def add_memory(self, content: str, handle: str = "", description: str = "", metadata: Dict = None):
+        # Ensure handle is not empty (API requires it)
+        if not handle or not handle.strip():
+            handle = "general"
+
+        # Remove spaces from handle (API doesn't allow spaces)
+        handle = handle.replace(" ", "-").lower()
+
         token_size = len(content)
+        logger.debug(
+            f"Adding memory: handle={handle}, content_length={token_size}, description={description}")
 
         packed = self.pack_data(content.encode('utf-8'))
+        logger.debug(f"Packed data length: {len(packed)}")
+
         payload = {
             "ciphertext": packed,
             "description": description,
@@ -110,10 +140,42 @@ class MemoClient:
                 "from": "yomemoai-mcp",
             }
         }
-        resp = self.session.post(
-            f"{self.base_url}/api/v1/memory", json=payload)
-        resp.raise_for_status()
-        return resp.json()
+
+        url = f"{self.base_url}/api/v1/memory"
+        logger.debug(f"POST {url}")
+
+        try:
+            resp = self.session.post(url, json=payload)
+            logger.debug(f"Response status: {resp.status_code}")
+
+            # Provide better error messages
+            if not resp.ok:
+                try:
+                    error_detail = resp.json().get("error", resp.text)
+                except Exception:
+                    error_detail = resp.text
+                logger.error(f"API error {resp.status_code}: {error_detail}")
+                raise MemoRequestError(
+                    f"API error {resp.status_code}: {error_detail}",
+                    url=url,
+                    payload=payload,
+                    status_code=resp.status_code,
+                    response_text=resp.text,
+                )
+
+            result = resp.json()
+            logger.debug(f"Success response: {result}")
+            return result
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request failed: {type(e).__name__}: {str(e)}")
+            raise MemoRequestError(
+                f"Request failed: {type(e).__name__}: {str(e)}",
+                url=url,
+                payload=payload,
+            ) from e
+        except Exception as e:
+            logger.error(f"Unexpected error: {type(e).__name__}: {str(e)}")
+            raise
 
     def get_memories(self, handle: Optional[str] = None) -> List[Dict]:
         url = f"{self.base_url}/api/v1/memory"

yomemoai_mcp-0.1.3/src/yomemoai_mcp/server.py

@@ -0,0 +1,143 @@
+import asyncio
+import json
+import logging
+import os
+import sys
+from mcp.server.fastmcp import FastMCP
+from .client import MemoClient, MemoRequestError
+
+if "--version" in sys.argv or "-version" in sys.argv:
+    from importlib.metadata import version
+    print(version("yomemoai-mcp"))
+    sys.exit(0)
+
+from dotenv import load_dotenv
+load_dotenv()
+
+# Configure logging
+DEBUG = os.getenv("DEBUG", "false").lower() == "true"
+LOG_LEVEL = logging.DEBUG if DEBUG else logging.INFO
+
+logging.basicConfig(
+    level=LOG_LEVEL,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    stream=sys.stderr
+)
+logger = logging.getLogger(__name__)
+
+mcp = FastMCP("yomemoai")
+
+API_KEY = os.getenv("MEMO_API_KEY", "")
+PRIV_KEY_PATH = os.getenv("MEMO_PRIVATE_KEY_PATH", "private.pem")
+BASE_URL = os.getenv("MEMO_BASE_URL", "https://api.yomemo.ai")
+
+if not API_KEY:
+    raise ValueError("MEMO_API_KEY environment variable is required")
+
+if not os.path.exists(PRIV_KEY_PATH):
+    raise FileNotFoundError(
+        f"Private key file not found: {PRIV_KEY_PATH}. "
+        f"Please set MEMO_PRIVATE_KEY_PATH environment variable or place your private key at {PRIV_KEY_PATH}"
+    )
+
+try:
+    with open(PRIV_KEY_PATH, "r") as f:
+        private_pem = f.read()
+except Exception as e:
+    raise IOError(f"Failed to read private key from {PRIV_KEY_PATH}: {e}")
+
+if not private_pem.strip():
+    raise ValueError(f"Private key file {PRIV_KEY_PATH} is empty")
+
+client = MemoClient(API_KEY, private_pem, BASE_URL)
+
+
+def _format_payload(payload: dict) -> dict:
+    if not payload:
+        return {}
+    return dict(payload)
+
+
+@mcp.tool()
+async def save_memory(content: str, handle: str = "general", description: str = "") -> str:
+    """
+    Store important information as a permanent memory. You should call this proactively when you
+    detect user preferences, important decisions, reusable logic, or context worth recalling later—
+    not only when the user explicitly says "remember" or "save". After saving successfully, reply with ✓.
+
+    :param content: The actual text/information to be remembered. Be concise but maintain context.
+    :param handle: A short, unique category or tag (e.g., 'work', 'personal', 'project-x'). Defaults to 'general'.
+    :param description: A brief, non-sensitive summary or tag for this memory (helps future identification and search).
+    """
+    logger.debug(
+        f"save_memory called: handle={handle}, description={description}, content_length={len(content)}")
+    try:
+        result = client.add_memory(
+            content, handle=handle, description=description)
+        logger.debug(f"add_memory response: {result}")
+
+        if "memory_id" not in result:
+            return f"Failed to save memory for handle: {handle}"
+
+        memory_id = result.get('memory_id')
+
+        return f"Successfully archived in memory. ID: {memory_id}"
+    except MemoRequestError as e:
+        logger.error(
+            f"Error saving memory: {type(e).__name__}: {str(e)}", exc_info=DEBUG)
+        request_info = {
+            "url": e.url,
+            "status_code": e.status_code,
+            "response_text": e.response_text,
+            "payload": _format_payload(e.payload),
+            "handle": handle,
+            "description": description,
+            "content_length": len(content),
+        }
+        # only debug mode return the request_info
+        if DEBUG:
+            return json.dumps(request_info, ensure_ascii=False)
+        return f"Failed to save your memory: {str(e)}"
+    except Exception as e:
+        logger.error(
+            f"Error saving memory: {type(e).__name__}: {str(e)}", exc_info=DEBUG)
+        return (
+            f"Failed to save your memory: {str(e)},"
+            f"handle: {handle},description: {description},content: {content}"
+        )
+
+
+@mcp.tool()
+async def load_memories(handle: str = None) -> str:
+    """
+    Retrieve previously stored memories. Call this when the user asks what you remember, or when you
+    need historical context (preferences, past decisions, project details) to answer accurately.
+
+    :param handle: Optional filter. If the user specifies a category (e.g., 'work', 'project-x'),
+                   use the relevant handle; otherwise omit to load across handles.
+    """
+    logger.debug(f"load_memories called: handle={handle}")
+    try:
+        memories = client.get_memories(handle=handle)
+        logger.debug(f"Retrieved {len(memories)} memories")
+
+        if not memories:
+            logger.info(
+                f"No memories found for handle: {handle if handle else 'all'}")
+            return f"No memories found under the handle: {handle if handle else 'all'}."
+
+        output = ["### Retrieved Memories:"]
+        for m in memories:
+            timestamp = m.get('created_at', 'N/A')
+            output.append(
+                f"Handle: [{m.get('handle')}]\nContent: {m.get('content')}\n---"
+            )
+        logger.info(f"Successfully loaded {len(memories)} memories")
+        return "\n".join(output)
+    except Exception as e:
+        logger.error(
+            f"Error retrieving memories: {type(e).__name__}: {str(e)}", exc_info=DEBUG)
+        return f"Error retrieving memories: {str(e)}"
+
+if __name__ == "__main__":
+    mcp.run()

{yomemoai_mcp-0.1.0 → yomemoai_mcp-0.1.3}/uv.lock

@@ -1018,27 +1018,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548 },
 ]
 
-[[package]]
-name = "python-memo-mcp"
-version = "0.1.0"
-source = { editable = "." }
-dependencies = [
-    { name = "cryptography" },
-    { name = "fastmcp" },
-    { name = "mcp" },
-    { name = "python-dotenv" },
-    { name = "requests" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "cryptography", specifier = ">=46.0.3" },
-    { name = "fastmcp", specifier = ">=0.1.0" },
-    { name = "mcp", specifier = ">=1.25.0" },
-    { name = "python-dotenv", specifier = ">=1.2.1" },
-    { name = "requests", specifier = ">=2.32.5" },
-]
-
 [[package]]
 name = "python-multipart"
 version = "0.0.21"
@@ -1297,28 +1276,28 @@ wheels = [
 
 [[package]]
 name = "sse-starlette"
-version = "3.1.2"
+version = "3.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "starlette" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/34/f5df66cb383efdbf4f2db23cabb27f51b1dcb737efaf8a558f6f1d195134/sse_starlette-3.1.2.tar.gz", hash = "sha256:55eff034207a83a0eb86de9a68099bd0157838f0b8b999a1b742005c71e33618", size = 26303 }
+sdist = { url = "https://files.pythonhosted.org/packages/8b/8d/00d280c03ffd39aaee0e86ec81e2d3b9253036a0f93f51d10503adef0e65/sse_starlette-3.2.0.tar.gz", hash = "sha256:8127594edfb51abe44eac9c49e59b0b01f1039d0c7461c6fd91d4e03b70da422", size = 27253 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/95/8c4b76eec9ae574474e5d2997557cebf764bcd3586458956c30631ae08f4/sse_starlette-3.1.2-py3-none-any.whl", hash = "sha256:cd800dd349f4521b317b9391d3796fa97b71748a4da9b9e00aafab32dda375c8", size = 12484 },
+    { url = "https://files.pythonhosted.org/packages/96/7f/832f015020844a8b8f7a9cbc103dd76ba8e3875004c41e08440ea3a2b41a/sse_starlette-3.2.0-py3-none-any.whl", hash = "sha256:5876954bd51920fc2cd51baee47a080eb88a37b5b784e615abb0b283f801cdbf", size = 12763 },
 ]
 
 [[package]]
 name = "starlette"
-version = "0.51.0"
+version = "0.52.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/65/5a1fadcc40c5fdc7df421a7506b79633af8f5d5e3a95c3e72acacec644b9/starlette-0.51.0.tar.gz", hash = "sha256:4c4fda9b1bc67f84037d3d14a5112e523509c369d9d47b111b2f984b0cc5ba6c", size = 2647658 }
+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/c4/09985a03dba389d4fe16a9014147a7b02fa76ef3519bf5846462a485876d/starlette-0.51.0-py3-none-any.whl", hash = "sha256:fb460a3d6fd3c958d729fdd96aee297f89a51b0181f16401fe8fd4cb6129165d", size = 74133 },
+    { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272 },
 ]
 
 [[package]]
@@ -1473,6 +1452,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591 },
 ]
 
+[[package]]
+name = "yomemoai-mcp"
+version = "0.1.1"
+source = { editable = "." }
+dependencies = [
+    { name = "cryptography" },
+    { name = "fastmcp" },
+    { name = "mcp" },
+    { name = "python-dotenv" },
+    { name = "requests" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "cryptography", specifier = ">=46.0.3" },
+    { name = "fastmcp", specifier = ">=0.1.0" },
+    { name = "mcp", specifier = ">=1.25.0" },
+    { name = "python-dotenv", specifier = ">=1.2.1" },
+    { name = "requests", specifier = ">=2.32.5" },
+]
+
 [[package]]
 name = "zipp"
 version = "3.23.0"

yomemoai_mcp-0.1.0/src/yomemoai_mcp/__init__.py

@@ -1,2 +0,0 @@
-def hello() -> str:
-    return "Hello from yomemoai-mcp!"

yomemoai_mcp-0.1.0/src/yomemoai_mcp/server.py

@@ -1,80 +0,0 @@
-import asyncio
-from mcp.server.fastmcp import FastMCP
-from .client import MemoClient
-import os
-
-from dotenv import load_dotenv
-load_dotenv()
-
-mcp = FastMCP("yomemoai")
-
-API_KEY = os.getenv("MEMO_API_KEY", "")
-PRIV_KEY_PATH = os.getenv("MEMO_PRIVATE_KEY_PATH", "private.pem")
-BASE_URL = os.getenv("MEMO_BASE_URL", "https://api.yomemo.ai")
-
-if not API_KEY:
-    raise ValueError("MEMO_API_KEY environment variable is required")
-
-if not os.path.exists(PRIV_KEY_PATH):
-    raise FileNotFoundError(
-        f"Private key file not found: {PRIV_KEY_PATH}. "
-        f"Please set MEMO_PRIVATE_KEY_PATH environment variable or place your private key at {PRIV_KEY_PATH}"
-    )
-
-try:
-    with open(PRIV_KEY_PATH, "r") as f:
-        private_pem = f.read()
-except Exception as e:
-    raise IOError(f"Failed to read private key from {PRIV_KEY_PATH}: {e}")
-
-if not private_pem.strip():
-    raise ValueError(f"Private key file {PRIV_KEY_PATH} is empty")
-
-client = MemoClient(API_KEY, private_pem, BASE_URL)
-
-
-@mcp.tool()
-async def save_memory(content: str, handle: str = "general", description: str = "") -> str:
-    """
-    Store important information, user preferences, or conversation context as a permanent memory.
-    Use this tool when the user explicitly asks to 'remember', 'save', or 'keep track of' something.
-
-    :param content: The actual text/information to be remembered. Be concise but maintain context.
-    :param handle: A short, unique category or tag (e.g., 'work', 'personal', 'project-x'). Defaults to 'general'.
-    :param description: A brief summary of what this memory is about to help with future identification. don't include any sensitive information.
-    """
-    try:
-        result = client.add_memory(
-            content, handle=handle, description=description)
-        return f"Successfully archived in memory. ID: {result.get('memory_id')}"
-    except Exception as e:
-        return f"Failed to save memory: {str(e)}"
-
-
-@mcp.tool()
-async def load_memories(handle: str = None) -> str:
-    """
-    Retrieve previously stored memories or context. 
-    Use this tool when the user asks 'what do you remember about...', 'check my notes on...', or when 
-    you need historical context to answer a question accurately.
-
-    :param handle: Optional filter. If the user specifies a category (e.g., 'about my job'), 
-                   extract and provide the relevant handle.
-    """
-    try:
-        memories = client.get_memories(handle=handle)
-        if not memories:
-            return f"No memories found under the handle: {handle if handle else 'all'}."
-
-        output = ["### Retrieved Memories:"]
-        for m in memories:
-            timestamp = m.get('created_at', 'N/A')
-            output.append(
-                f"Handle: [{m.get('handle')}]\nContent: {m.get('content')}\n---"
-            )
-        return "\n".join(output)
-    except Exception as e:
-        return f"Error retrieving memories: {str(e)}"
-
-if __name__ == "__main__":
-    mcp.run()