memos-ai 0.1.0__tar.gz

memos_ai-0.1.0/LICENSE

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

memos_ai-0.1.0/MANIFEST.in

@@ -0,0 +1,19 @@
+include README.md
+include LICENSE
+include pyproject.toml
+
+global-exclude .env
+global-exclude node_modules
+global-exclude node_modules/*
+global-exclude venv
+global-exclude venv/*
+global-exclude dist
+global-exclude dist/*
+global-exclude __pycache__
+global-exclude __pycache__/*
+global-exclude .pytest_cache
+global-exclude .pytest_cache/*
+global-exclude coverage
+global-exclude coverage/*
+global-exclude *.log
+global-exclude *.sqlite

memos_ai-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: memos-ai
+Version: 0.1.0
+Summary: Python SDK for memos — persistent brain framework for AI agents
+License-Expression: MIT
+Project-URL: Homepage, https://memos.io
+Project-URL: Repository, https://github.com/memos/memos-py
+Project-URL: Documentation, https://docs.memos.io
+Requires-Python: <4.0,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-mock>=3.0; extra == "test"
+Dynamic: license-file
+
+# MEMOS Python SDK
+
+Python SDK for [MEMOS](https://memos.io) — persistent brain framework for AI agents.
+
+## Installation
+```bash
+pip install memos-ai
+```
+
+## Publish Verification
+```bash
+python3 -m venv verify
+source verify/bin/activate
+pip install memos-ai
+python3
+```
+
+```python
+from memos import MemosClient
+
+print(MemosClient)
+```
+
+Expected output:
+```text
+<class 'memos.client.MemosClient'>
+```
+
+## Quick Start
+```python
+from memos import MemosClient
+
+client = MemosClient(
+    api_key="your_api_key",
+    agent_id="your_agent_id"
+)
+
+# Store a memory
+memory = client.store_memory(
+    content="User prefers Python over JavaScript",
+    type="semantic",
+    importance=4
+)
+
+# Search memories
+results = client.search("language preferences")
+for r in results:
+    print(f"{r.score:.2f} — {r.content}")
+
+# Ask with memory context
+response = client.query("What language does this user prefer?")
+print(response.answer)
+
+# Trigger dream consolidation
+dream = client.trigger_dream()
+print(f"Created {dream.new_memories_created} new memories")
+```
+
+## Authentication
+Get your API key and agent ID from https://memos.io/dashboard
+
+## Methods Reference
+
+| Method | Parameters | Returns | Description |
+|---|---|---|---|
+| `store_memory` | `content` (str), `type` (str="episodic"), `importance` (int=3), `tags` (list[str]=None) | `Memory` | Store a new memory for the agent |
+| `list_memories` | None | `list[Memory]` | List all memories for the agent |
+| `delete_memory` | `memory_id` (str) | `bool` | Delete a specific memory by ID |
+| `search` | `query` (str), `search_type` (str="keyword"), `limit` (int=10) | `list[SearchResult]` | Search agent memories |
+| `query` | `question` (str), `include_sources` (bool=True), `conversation_history` (list[dict]=None) | `RAGResponse` | Ask a question using RAG |
+| `trigger_dream` | None | `DreamResult` | Trigger a dream consolidation cycle |
+| `list_skills` | None | `list[Skill]` | List all available skills in the marketplace |
+| `execute_skill` | `skill_id` (str), `input` (str) | `SkillResult` | Execute a skill |
+| `run_pipeline` | `steps` (list[dict]), `input` (str) | `dict` | Run a multi-step pipeline |
+| `get_identity` | None | `dict` | Get the agent's identity and reputation |
+
+## Error Handling
+```python
+from memos import MemosError, AuthError, RateLimitError
+
+try:
+    client.store_memory("...")
+except AuthError:
+    print("Check your API key at memos.io/profile")
+except RateLimitError:
+    print("Rate limit hit — slow down requests")
+except MemosError as e:
+    print(f"API error {e.status_code}: {e.message}")
+```
+
+## Context Manager
+```python
+with MemosClient(api_key="...", agent_id="...") as client:
+    client.store_memory("...")
+# HTTP connection closed automatically
+```
+
+## Requirements
+Python 3.8+
+No additional dependencies beyond `httpx`.
+
+## License
+MIT

memos_ai-0.1.0/README.md

@@ -0,0 +1,103 @@
+# MEMOS Python SDK
+
+Python SDK for [MEMOS](https://memos.io) — persistent brain framework for AI agents.
+
+## Installation
+```bash
+pip install memos-ai
+```
+
+## Publish Verification
+```bash
+python3 -m venv verify
+source verify/bin/activate
+pip install memos-ai
+python3
+```
+
+```python
+from memos import MemosClient
+
+print(MemosClient)
+```
+
+Expected output:
+```text
+<class 'memos.client.MemosClient'>
+```
+
+## Quick Start
+```python
+from memos import MemosClient
+
+client = MemosClient(
+    api_key="your_api_key",
+    agent_id="your_agent_id"
+)
+
+# Store a memory
+memory = client.store_memory(
+    content="User prefers Python over JavaScript",
+    type="semantic",
+    importance=4
+)
+
+# Search memories
+results = client.search("language preferences")
+for r in results:
+    print(f"{r.score:.2f} — {r.content}")
+
+# Ask with memory context
+response = client.query("What language does this user prefer?")
+print(response.answer)
+
+# Trigger dream consolidation
+dream = client.trigger_dream()
+print(f"Created {dream.new_memories_created} new memories")
+```
+
+## Authentication
+Get your API key and agent ID from https://memos.io/dashboard
+
+## Methods Reference
+
+| Method | Parameters | Returns | Description |
+|---|---|---|---|
+| `store_memory` | `content` (str), `type` (str="episodic"), `importance` (int=3), `tags` (list[str]=None) | `Memory` | Store a new memory for the agent |
+| `list_memories` | None | `list[Memory]` | List all memories for the agent |
+| `delete_memory` | `memory_id` (str) | `bool` | Delete a specific memory by ID |
+| `search` | `query` (str), `search_type` (str="keyword"), `limit` (int=10) | `list[SearchResult]` | Search agent memories |
+| `query` | `question` (str), `include_sources` (bool=True), `conversation_history` (list[dict]=None) | `RAGResponse` | Ask a question using RAG |
+| `trigger_dream` | None | `DreamResult` | Trigger a dream consolidation cycle |
+| `list_skills` | None | `list[Skill]` | List all available skills in the marketplace |
+| `execute_skill` | `skill_id` (str), `input` (str) | `SkillResult` | Execute a skill |
+| `run_pipeline` | `steps` (list[dict]), `input` (str) | `dict` | Run a multi-step pipeline |
+| `get_identity` | None | `dict` | Get the agent's identity and reputation |
+
+## Error Handling
+```python
+from memos import MemosError, AuthError, RateLimitError
+
+try:
+    client.store_memory("...")
+except AuthError:
+    print("Check your API key at memos.io/profile")
+except RateLimitError:
+    print("Rate limit hit — slow down requests")
+except MemosError as e:
+    print(f"API error {e.status_code}: {e.message}")
+```
+
+## Context Manager
+```python
+with MemosClient(api_key="...", agent_id="...") as client:
+    client.store_memory("...")
+# HTTP connection closed automatically
+```
+
+## Requirements
+Python 3.8+
+No additional dependencies beyond `httpx`.
+
+## License
+MIT

memos_ai-0.1.0/memos/__init__.py

@@ -0,0 +1,22 @@
+"""memos-py — Python SDK for memos."""
+from __future__ import annotations
+
+from .client import MemosClient
+from .exceptions import AuthError, MemosError, NotFoundError, RateLimitError, ServerError
+from .models import DreamResult, Memory, RAGResponse, SearchResult, Skill, SkillResult
+
+__version__ = "0.1.0"
+__all__ = [
+    "MemosClient",
+    "Memory",
+    "SearchResult",
+    "RAGResponse",
+    "Skill",
+    "SkillResult",
+    "DreamResult",
+    "MemosError",
+    "AuthError",
+    "RateLimitError",
+    "NotFoundError",
+    "ServerError",
+]

memos_ai-0.1.0/memos/client.py

@@ -0,0 +1,337 @@
+"""Synchronous HTTP client for the memos API."""
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+import httpx
+
+from .exceptions import AuthError, MemosError, NotFoundError, RateLimitError, ServerError
+from .models import DreamResult, Memory, RAGResponse, SearchResult, Skill, SkillResult
+
+
+class MemosClient:
+    """Python client for the memos API.
+
+    Usage::
+
+        from memos import MemosClient
+
+        client = MemosClient(
+            api_key="mk0s_your_key",
+            agent_id="your_agent_id",
+            base_url="https://memos.io"
+        )
+
+        with MemosClient(api_key=..., agent_id=...) as client:
+            client.store_memory("...")
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        agent_id: str,
+        base_url: str = "https://memos.io",
+        timeout: float = 30.0,
+    ) -> None:
+        if not api_key or not api_key.strip():
+            raise AuthError("api_key is required", status_code=None)
+        if not agent_id or not agent_id.strip():
+            raise MemosError("agent_id is required", status_code=None)
+
+        self.api_key = api_key
+        self.agent_id = agent_id
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            timeout=timeout,
+            headers={
+                "Authorization": "Bearer {0}".format(api_key),
+                "Content-Type": "application/json",
+                "User-Agent": "memos-py/0.1.0",
+            },
+        )
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _handle_response(self, response: httpx.Response) -> Dict:  # type: ignore[type-arg]
+        """Parse response and raise typed exceptions on errors."""
+        if response.status_code == 401:
+            raise AuthError("Invalid or missing API key", 401)
+        if response.status_code == 429:
+            raise RateLimitError("Rate limit exceeded", 429)
+        if response.status_code == 404:
+            raise NotFoundError("Resource not found", 404)
+        if response.status_code >= 500:
+            raise ServerError("Server error: {0}".format(response.text), response.status_code)
+        if not response.is_success:
+            raise MemosError("Request failed: {0}".format(response.text), response.status_code)
+        return response.json()  # type: ignore[no-any-return]
+
+    @staticmethod
+    def _build_memory(data: Dict) -> Memory:  # type: ignore[type-arg]
+        """Safely build a Memory from a response dict, ignoring unknown keys."""
+        known = Memory.__dataclass_fields__
+        filtered = {k: v for k, v in data.items() if k in known}
+        # Map camelCase keys from API
+        if "agentId" in data and "agent_id" not in filtered:
+            filtered["agent_id"] = data["agentId"]
+        if "createdAt" in data and "created_at" not in filtered:
+            filtered["created_at"] = data["createdAt"]
+        if "accessCount" in data and "access_count" not in filtered:
+            filtered["access_count"] = data["accessCount"]
+        if "decayScore" in data and "decay_score" not in filtered:
+            filtered["decay_score"] = data["decayScore"]
+        return Memory(**filtered)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def store_memory(
+        self,
+        content: str,
+        type: str = "episodic",
+        importance: int = 3,
+        tags: Optional[List[str]] = None,
+    ) -> Memory:
+        """Store a new memory for the agent.
+
+        Args:
+            content: The text content to store.
+            type: Memory type — "episodic", "semantic", or "procedural".
+            importance: Importance score from 1 to 5.
+            tags: Optional list of string tags.
+
+        Returns:
+            The created Memory object.
+        """
+        response = self._client.post(
+            "/api/memory",
+            json={
+                "agentId": self.agent_id,
+                "content": content,
+                "type": type,
+                "importance": importance,
+                "tags": tags or [],
+            },
+        )
+        data = self._handle_response(response)
+        memory_data = data.get("memory", data)
+        return self._build_memory(memory_data)
+
+    def list_memories(self) -> List[Memory]:
+        """List all memories for the agent.
+
+        Returns:
+            A list of Memory objects.
+        """
+        response = self._client.get(
+            "/api/memory",
+            params={"agentId": self.agent_id},
+        )
+        data = self._handle_response(response)
+        items = data.get("memories", data) if isinstance(data, dict) else data
+        if not isinstance(items, list):
+            items = []
+        return [self._build_memory(m) for m in items]
+
+    def delete_memory(self, memory_id: str) -> bool:
+        """Delete a specific memory by ID.
+
+        Args:
+            memory_id: The ID of the memory to delete.
+
+        Returns:
+            True if deletion was successful.
+        """
+        response = self._client.delete("/api/memory/{0}".format(memory_id))
+        self._handle_response(response)
+        return True
+
+    def search(
+        self,
+        query: str,
+        search_type: str = "keyword",
+        limit: int = 10,
+    ) -> List[SearchResult]:
+        """Search agent memories.
+
+        Args:
+            query: The search query string.
+            search_type: "keyword" or "semantic".
+            limit: Maximum number of results.
+
+        Returns:
+            A list of SearchResult objects.
+        """
+        response = self._client.post(
+            "/api/search",
+            json={
+                "agentId": self.agent_id,
+                "query": query,
+                "searchType": search_type,
+                "limit": limit,
+            },
+        )
+        data = self._handle_response(response)
+        items = data.get("results", data) if isinstance(data, dict) else data
+        if not isinstance(items, list):
+            items = []
+        return [
+            SearchResult(
+                id=r.get("id", ""),
+                content=r.get("content", ""),
+                type=r.get("type", ""),
+                importance=r.get("importance", 0),
+                score=r.get("score", 0.0),
+                tags=r.get("tags", []),
+            )
+            for r in items
+        ]
+
+    def query(
+        self,
+        question: str,
+        include_sources: bool = True,
+        conversation_history: Optional[List[dict]] = None,  # type: ignore[type-arg]
+    ) -> RAGResponse:
+        """Ask a question using RAG (retrieval-augmented generation).
+
+        Args:
+            question: The question to ask.
+            include_sources: Whether to include source memories.
+            conversation_history: Optional prior conversation turns.
+
+        Returns:
+            A RAGResponse with answer, sources, and confidence.
+        """
+        response = self._client.post(
+            "/api/rag",
+            json={
+                "agentId": self.agent_id,
+                "query": question,
+                "conversationHistory": conversation_history or [],
+            },
+        )
+        data = self._handle_response(response)
+        return RAGResponse(
+            answer=data.get("answer", ""),
+            sources=data.get("sources", []),
+            confidence=data.get("confidence", 0.0),
+        )
+
+    def trigger_dream(self) -> DreamResult:
+        """Trigger a dream consolidation cycle for the agent.
+
+        Returns:
+            A DreamResult with consolidation details.
+        """
+        response = self._client.post(
+            "/api/agent/{0}/dreams".format(self.agent_id),
+            json={},
+        )
+        data = self._handle_response(response)
+        return DreamResult(
+            memories_analyzed=data.get("memoriesAnalyzed", 0),
+            patterns_found=data.get("patternsFound", 0),
+            new_memories_created=data.get("newMemoriesCreated", 0),
+            dream_summary=data.get("dreamSummary", ""),
+            new_memories=data.get("newMemories", []),
+            duration=data.get("duration", 0),
+        )
+
+    def list_skills(self) -> List[Skill]:
+        """List all available skills in the marketplace.
+
+        Returns:
+            A list of Skill objects.
+        """
+        response = self._client.get("/api/skills")
+        data = self._handle_response(response)
+        items = data.get("skills", data) if isinstance(data, dict) else data
+        if not isinstance(items, list):
+            items = []
+        return [
+            Skill(
+                id=s.get("id", ""),
+                name=s.get("name", ""),
+                description=s.get("description", ""),
+                category=s.get("category", ""),
+                price=s.get("price", 0.0),
+                publisher=s.get("publisher", ""),
+            )
+            for s in items
+        ]
+
+    def execute_skill(self, skill_id: str, input: str) -> SkillResult:
+        """Execute a skill.
+
+        Args:
+            skill_id: The ID of the skill to execute.
+            input: The input string for the skill.
+
+        Returns:
+            A SkillResult with execution details.
+        """
+        response = self._client.post(
+            "/api/execute",
+            json={
+                "agentId": self.agent_id,
+                "skillId": skill_id,
+                "input": input,
+            },
+        )
+        data = self._handle_response(response)
+        return SkillResult(
+            skill_id=data.get("skillId", skill_id),
+            result=data.get("result", ""),
+            tokens_used=data.get("tokensUsed", 0),
+            duration=data.get("duration", 0),
+        )
+
+    def run_pipeline(self, steps: List[dict], input: str) -> dict:  # type: ignore[type-arg]
+        """Run a multi-step pipeline.
+
+        Args:
+            steps: List of step dicts, each with at least a "skillId" key.
+            input: The initial input string.
+
+        Returns:
+            Raw response dict (pipeline responses are complex).
+        """
+        response = self._client.post(
+            "/api/pipeline",
+            json={
+                "agentId": self.agent_id,
+                "steps": steps,
+                "input": input,
+            },
+        )
+        return self._handle_response(response)
+
+    def get_identity(self) -> dict:  # type: ignore[type-arg]
+        """Get the agent's identity and reputation.
+
+        Returns:
+            Raw response dict with reputation data.
+        """
+        response = self._client.get(
+            "/api/agent/{0}/reputation".format(self.agent_id),
+        )
+        return self._handle_response(response)
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection."""
+        self._client.close()
+
+    def __enter__(self) -> "MemosClient":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

memos_ai-0.1.0/memos/exceptions.py

@@ -0,0 +1,27 @@
+"""memos-py exception hierarchy."""
+from __future__ import annotations
+
+
+class MemosError(Exception):
+    """Base exception for all memos SDK errors."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        self.message = message
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class AuthError(MemosError):
+    """Raised when authentication fails (HTTP 401)."""
+
+
+class RateLimitError(MemosError):
+    """Raised when rate limit is exceeded (HTTP 429)."""
+
+
+class NotFoundError(MemosError):
+    """Raised when a resource is not found (HTTP 404)."""
+
+
+class ServerError(MemosError):
+    """Raised when the server returns a 5xx error."""

memos_ai-0.1.0/memos/models.py

@@ -0,0 +1,75 @@
+"""memos-py data models using Python dataclasses."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass
+class Memory:
+    """Represents a stored memory."""
+
+    id: str
+    agent_id: str
+    content: str
+    type: str
+    importance: int
+    tags: List[str] = field(default_factory=list)
+    created_at: Optional[str] = None
+    access_count: int = 0
+    decay_score: float = 1.0
+
+
+@dataclass
+class SearchResult:
+    """A single search result."""
+
+    id: str
+    content: str
+    type: str
+    importance: int
+    score: float
+    tags: List[str] = field(default_factory=list)
+
+
+@dataclass
+class RAGResponse:
+    """Response from a RAG (retrieval-augmented generation) query."""
+
+    answer: str
+    sources: List[dict]  # type: ignore[type-arg]
+    confidence: float
+
+
+@dataclass
+class Skill:
+    """A skill available in the marketplace."""
+
+    id: str
+    name: str
+    description: str
+    category: str
+    price: float
+    publisher: str
+
+
+@dataclass
+class SkillResult:
+    """Result of executing a skill."""
+
+    skill_id: str
+    result: str
+    tokens_used: int
+    duration: int
+
+
+@dataclass
+class DreamResult:
+    """Result of a dream consolidation cycle."""
+
+    memories_analyzed: int
+    patterns_found: int
+    new_memories_created: int
+    dream_summary: str
+    new_memories: List[dict]  # type: ignore[type-arg]
+    duration: int

memos_ai-0.1.0/memos_ai.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: memos-ai
+Version: 0.1.0
+Summary: Python SDK for memos — persistent brain framework for AI agents
+License-Expression: MIT
+Project-URL: Homepage, https://memos.io
+Project-URL: Repository, https://github.com/memos/memos-py
+Project-URL: Documentation, https://docs.memos.io
+Requires-Python: <4.0,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-mock>=3.0; extra == "test"
+Dynamic: license-file
+
+# MEMOS Python SDK
+
+Python SDK for [MEMOS](https://memos.io) — persistent brain framework for AI agents.
+
+## Installation
+```bash
+pip install memos-ai
+```
+
+## Publish Verification
+```bash
+python3 -m venv verify
+source verify/bin/activate
+pip install memos-ai
+python3
+```
+
+```python
+from memos import MemosClient
+
+print(MemosClient)
+```
+
+Expected output:
+```text
+<class 'memos.client.MemosClient'>
+```
+
+## Quick Start
+```python
+from memos import MemosClient
+
+client = MemosClient(
+    api_key="your_api_key",
+    agent_id="your_agent_id"
+)
+
+# Store a memory
+memory = client.store_memory(
+    content="User prefers Python over JavaScript",
+    type="semantic",
+    importance=4
+)
+
+# Search memories
+results = client.search("language preferences")
+for r in results:
+    print(f"{r.score:.2f} — {r.content}")
+
+# Ask with memory context
+response = client.query("What language does this user prefer?")
+print(response.answer)
+
+# Trigger dream consolidation
+dream = client.trigger_dream()
+print(f"Created {dream.new_memories_created} new memories")
+```
+
+## Authentication
+Get your API key and agent ID from https://memos.io/dashboard
+
+## Methods Reference
+
+| Method | Parameters | Returns | Description |
+|---|---|---|---|
+| `store_memory` | `content` (str), `type` (str="episodic"), `importance` (int=3), `tags` (list[str]=None) | `Memory` | Store a new memory for the agent |
+| `list_memories` | None | `list[Memory]` | List all memories for the agent |
+| `delete_memory` | `memory_id` (str) | `bool` | Delete a specific memory by ID |
+| `search` | `query` (str), `search_type` (str="keyword"), `limit` (int=10) | `list[SearchResult]` | Search agent memories |
+| `query` | `question` (str), `include_sources` (bool=True), `conversation_history` (list[dict]=None) | `RAGResponse` | Ask a question using RAG |
+| `trigger_dream` | None | `DreamResult` | Trigger a dream consolidation cycle |
+| `list_skills` | None | `list[Skill]` | List all available skills in the marketplace |
+| `execute_skill` | `skill_id` (str), `input` (str) | `SkillResult` | Execute a skill |
+| `run_pipeline` | `steps` (list[dict]), `input` (str) | `dict` | Run a multi-step pipeline |
+| `get_identity` | None | `dict` | Get the agent's identity and reputation |
+
+## Error Handling
+```python
+from memos import MemosError, AuthError, RateLimitError
+
+try:
+    client.store_memory("...")
+except AuthError:
+    print("Check your API key at memos.io/profile")
+except RateLimitError:
+    print("Rate limit hit — slow down requests")
+except MemosError as e:
+    print(f"API error {e.status_code}: {e.message}")
+```
+
+## Context Manager
+```python
+with MemosClient(api_key="...", agent_id="...") as client:
+    client.store_memory("...")
+# HTTP connection closed automatically
+```
+
+## Requirements
+Python 3.8+
+No additional dependencies beyond `httpx`.
+
+## License
+MIT

memos_ai-0.1.0/memos_ai.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+memos/__init__.py
+memos/client.py
+memos/exceptions.py
+memos/models.py
+memos_ai.egg-info/PKG-INFO
+memos_ai.egg-info/SOURCES.txt
+memos_ai.egg-info/dependency_links.txt
+memos_ai.egg-info/requires.txt
+memos_ai.egg-info/top_level.txt
+tests/test_client.py

memos_ai-0.1.0/memos_ai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

memos_ai-0.1.0/memos_ai.egg-info/requires.txt

@@ -0,0 +1,5 @@
+httpx>=0.24.0
+
+[test]
+pytest>=7.0
+pytest-mock>=3.0

memos_ai-0.1.0/memos_ai.egg-info/top_level.txt

@@ -0,0 +1 @@
+memos

memos_ai-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "memos-ai"
+version = "0.1.0"
+description = "Python SDK for memos — persistent brain framework for AI agents"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11,<4.0"
+dependencies = [
+    "httpx>=0.24.0"
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7.0", "pytest-mock>=3.0"]
+
+[project.urls]
+Homepage = "https://memos.io"
+Repository = "https://github.com/memos/memos-py"
+Documentation = "https://docs.memos.io"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["memos*"]

memos_ai-0.1.0/setup.cfg

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

memos_ai-0.1.0/tests/test_client.py

@@ -0,0 +1,127 @@
+import pytest
+from unittest.mock import MagicMock, patch
+
+from memos import MemosClient, AuthError, RateLimitError, ServerError, MemosError
+from memos.models import Memory, SearchResult, RAGResponse, DreamResult
+
+def make_mock_response(status_code: int, json_data: dict):
+    mock = MagicMock()
+    mock.status_code = status_code
+    mock.is_success = 200 <= status_code < 300
+    mock.json.return_value = json_data
+    mock.text = str(json_data)
+    return mock
+
+def test_init_requires_api_key():
+    with pytest.raises(AuthError):
+        MemosClient(api_key="", agent_id="agent_123")
+
+def test_init_requires_agent_id():
+    with pytest.raises(MemosError):
+        MemosClient(api_key="mk0s_key", agent_id="")
+
+@patch("httpx.Client.post")
+def test_store_memory_success(mock_post):
+    mock_post.return_value = make_mock_response(200, {
+        "memory": {
+            "id": "mem_1",
+            "agent_id": "agent_123",
+            "content": "test content",
+            "type": "episodic",
+            "importance": 3
+        }
+    })
+    client = MemosClient(api_key="key", agent_id="agent")
+    result = client.store_memory("test content")
+    assert isinstance(result, Memory)
+    assert result.content == "test content"
+
+@patch("httpx.Client.post")
+def test_store_memory_401(mock_post):
+    mock_post.return_value = make_mock_response(401, {"error": "Unauthorized"})
+    client = MemosClient(api_key="key", agent_id="agent")
+    with pytest.raises(AuthError):
+        client.store_memory("test")
+
+@patch("httpx.Client.post")
+def test_store_memory_429(mock_post):
+    mock_post.return_value = make_mock_response(429, {"error": "Rate limit"})
+    client = MemosClient(api_key="key", agent_id="agent")
+    with pytest.raises(RateLimitError):
+        client.store_memory("test")
+
+@patch("httpx.Client.post")
+def test_store_memory_500(mock_post):
+    mock_post.return_value = make_mock_response(500, {"error": "Server error"})
+    client = MemosClient(api_key="key", agent_id="agent")
+    with pytest.raises(ServerError):
+        client.store_memory("test")
+
+@patch("httpx.Client.get")
+def test_list_memories_returns_list(mock_get):
+    mock_get.return_value = make_mock_response(200, {
+        "memories": [
+            {
+                "id": "mem_1",
+                "agent_id": "agent",
+                "content": "c1",
+                "type": "episodic",
+                "importance": 3
+            }
+        ]
+    })
+    client = MemosClient(api_key="key", agent_id="agent")
+    result = client.list_memories()
+    assert isinstance(result, list)
+    assert all(isinstance(m, Memory) for m in result)
+
+@patch("httpx.Client.post")
+def test_search_returns_results(mock_post):
+    mock_post.return_value = make_mock_response(200, {
+        "results": [
+            {
+                "id": "mem_1",
+                "content": "test result",
+                "type": "episodic",
+                "importance": 3,
+                "score": 0.95
+            }
+        ]
+    })
+    client = MemosClient(api_key="key", agent_id="agent")
+    result = client.search("test query")
+    assert isinstance(result, list)
+    assert all(isinstance(r, SearchResult) for r in result)
+
+@patch("httpx.Client.post")
+def test_query_returns_rag_response(mock_post):
+    mock_post.return_value = make_mock_response(200, {
+        "answer": "this is the answer",
+        "sources": [],
+        "confidence": 0.9
+    })
+    client = MemosClient(api_key="key", agent_id="agent")
+    result = client.query("what do I prefer?")
+    assert isinstance(result, RAGResponse)
+    assert result.answer == "this is the answer"
+
+@patch("httpx.Client.post")
+def test_trigger_dream_returns_dream_result(mock_post):
+    mock_post.return_value = make_mock_response(200, {
+        "memoriesAnalyzed": 10,
+        "patternsFound": 2,
+        "newMemoriesCreated": 1,
+        "dreamSummary": "summary",
+        "newMemories": [],
+        "duration": 500
+    })
+    client = MemosClient(api_key="key", agent_id="agent")
+    result = client.trigger_dream()
+    assert isinstance(result, DreamResult)
+    assert result.memories_analyzed == 10
+
+def test_context_manager_closes_client():
+    with patch.object(MemosClient, 'close') as mock_close:
+        with MemosClient(api_key="key", agent_id="agent"):
+            pass
+        mock_close.assert_called_once()