wontopos 2.0.0__tar.gz

wontopos-2.0.0/LICENSE

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

wontopos-2.0.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: wontopos
+Version: 2.0.0
+Summary: Wontopos — long-term memory for AI agents. Pure semantic retrieval, identical recall in every language, ~100× lower LLM bill.
+Author: Wontopos
+License: MIT
+Project-URL: Homepage, https://wontopos.com
+Project-URL: Documentation, https://wontopos.com/why
+Project-URL: Repository, https://github.com/Irina1920/Wos_API
+Project-URL: Issues, https://github.com/Irina1920/Wos_API/issues
+Keywords: memory,ai,agent,llm,vector,embedding,semantic,rag,context
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# Wontopos — long-term memory for AI agents
+
+```bash
+pip install wontopos
+```
+
+```python
+from wontopos import Client
+
+mem = Client(api_key="wos-...")
+mem.add("she prefers tea over coffee", user_id="alice")
+
+# one call → short-term + long-term + context, ready for your LLM prompt
+ctx = mem.recall("what does alice drink?", user_id="alice")
+```
+
+## Why
+
+- **Pure semantic retrieval** — no keyword/BM25. Identical recall in every language (한국어 · 日本語 · 中文 · English).
+- **No LLM in the loop** — `store` / `search` / `recall` never call a language model. You pay embeddings, not generation.
+- **Bounded retrieval** — `recall()` returns a small, fixed-size slice (~1,200 tokens) regardless of how much you've stored. Your LLM bill stops growing with history.
+
+## Methods
+
+| Method | Purpose |
+|---|---|
+| `add(content, user_id, **metadata)` | Store one memory |
+| `add_turn(user_id, user_msg, assistant_msg)` | Store a conversation exchange |
+| `add_bulk(content, user_id, category=, timestamp=)` | Backfill a long history |
+| `update(user_id, old_memory_id, new_content)` | Supersede an old fact |
+| `search(query, user_id, limit=10, **opts)` | Semantic search |
+| `recall(query, user_id)` | One-call context (short + long + surrounding) |
+| `history(user_id)` | Recent turns (short-term) |
+| `stats(user_id)` | Counts |
+| `delete(user_id, memory_id)` | Delete one memory |
+| `delete_all(user_id)` | GDPR erase (delete every memory for the user) |
+
+All methods take a `user_id` — memories are isolated per user, then per account (your API key).
+
+## Errors
+
+Any non-2xx response raises `WosError(status, message)`:
+
+```python
+from wontopos import Client, WosError
+
+try:
+    mem.search("...", user_id="alice")
+except WosError as e:
+    if e.status == 401:
+        print("API key invalid or revoked")
+    elif e.status == 429:
+        print("Rate limited — back off")
+    else:
+        print(e.status, e.message)
+```
+
+## Self-host
+
+Point at your own engine:
+
+```python
+mem = Client(api_key="...", base_url="https://wos.your-host.com")
+```
+
+## Links
+
+- Homepage: <https://wontopos.com>
+- API reference: <https://wontopos.com/why> (Developers tab)
+- Repo: <https://github.com/Irina1920/Wos_API>
+
+License: MIT.

wontopos-2.0.0/README.md

@@ -0,0 +1,72 @@
+# Wontopos — long-term memory for AI agents
+
+```bash
+pip install wontopos
+```
+
+```python
+from wontopos import Client
+
+mem = Client(api_key="wos-...")
+mem.add("she prefers tea over coffee", user_id="alice")
+
+# one call → short-term + long-term + context, ready for your LLM prompt
+ctx = mem.recall("what does alice drink?", user_id="alice")
+```
+
+## Why
+
+- **Pure semantic retrieval** — no keyword/BM25. Identical recall in every language (한국어 · 日本語 · 中文 · English).
+- **No LLM in the loop** — `store` / `search` / `recall` never call a language model. You pay embeddings, not generation.
+- **Bounded retrieval** — `recall()` returns a small, fixed-size slice (~1,200 tokens) regardless of how much you've stored. Your LLM bill stops growing with history.
+
+## Methods
+
+| Method | Purpose |
+|---|---|
+| `add(content, user_id, **metadata)` | Store one memory |
+| `add_turn(user_id, user_msg, assistant_msg)` | Store a conversation exchange |
+| `add_bulk(content, user_id, category=, timestamp=)` | Backfill a long history |
+| `update(user_id, old_memory_id, new_content)` | Supersede an old fact |
+| `search(query, user_id, limit=10, **opts)` | Semantic search |
+| `recall(query, user_id)` | One-call context (short + long + surrounding) |
+| `history(user_id)` | Recent turns (short-term) |
+| `stats(user_id)` | Counts |
+| `delete(user_id, memory_id)` | Delete one memory |
+| `delete_all(user_id)` | GDPR erase (delete every memory for the user) |
+
+All methods take a `user_id` — memories are isolated per user, then per account (your API key).
+
+## Errors
+
+Any non-2xx response raises `WosError(status, message)`:
+
+```python
+from wontopos import Client, WosError
+
+try:
+    mem.search("...", user_id="alice")
+except WosError as e:
+    if e.status == 401:
+        print("API key invalid or revoked")
+    elif e.status == 429:
+        print("Rate limited — back off")
+    else:
+        print(e.status, e.message)
+```
+
+## Self-host
+
+Point at your own engine:
+
+```python
+mem = Client(api_key="...", base_url="https://wos.your-host.com")
+```
+
+## Links
+
+- Homepage: <https://wontopos.com>
+- API reference: <https://wontopos.com/why> (Developers tab)
+- Repo: <https://github.com/Irina1920/Wos_API>
+
+License: MIT.

wontopos-2.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wontopos"
+version = "2.0.0"
+description = "Wontopos — long-term memory for AI agents. Pure semantic retrieval, identical recall in every language, ~100× lower LLM bill."
+readme = "README.md"
+authors = [{ name = "Wontopos" }]
+license = { text = "MIT" }
+requires-python = ">=3.9"
+keywords = ["memory", "ai", "agent", "llm", "vector", "embedding", "semantic", "rag", "context"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = ["requests>=2.28"]
+
+[project.urls]
+Homepage = "https://wontopos.com"
+Documentation = "https://wontopos.com/why"
+Repository = "https://github.com/Irina1920/Wos_API"
+Issues = "https://github.com/Irina1920/Wos_API/issues"
+
+[tool.setuptools.packages.find]
+include = ["wontopos*"]

wontopos-2.0.0/setup.cfg

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

wontopos-2.0.0/wontopos/__init__.py

@@ -0,0 +1,247 @@
+"""Wontopos — long-term memory for AI, in three lines.
+
+    pip install wontopos
+
+    from wontopos import Client
+    mem = Client(api_key="wos-...")
+    mem.add("I love hiking in Yosemite", user_id="alice")
+    print(mem.search("what does she like?", user_id="alice"))
+
+Pure semantic retrieval — no keyword/BM25 matching, so it works the SAME in every
+language (Korean, Japanese, Chinese, English, ...). Storing and searching call no LLM;
+you only pay for embeddings.
+
+For BYOK chat/persona (bring your own LLM key), see the advanced `Wos` client at the
+bottom of this module.
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import requests
+
+__version__ = "2.0.0"
+DEFAULT_BASE_URL = "https://api.wontopos.com"
+
+
+class WosError(RuntimeError):
+    """Raised when the Wontopos API returns a non-2xx response (or the network fails)."""
+
+    def __init__(self, status: int, message: str):
+        self.status = status
+        self.message = message
+        super().__init__(f"[{status}] {message}")
+
+
+class Client:
+    """Wontopos memory client.
+
+    Store and recall memories, isolated per ``user_id``.
+
+        mem = Client(api_key="wos-...")
+        mem.add("she prefers tea over coffee", user_id="alice")
+        hits = mem.search("what does alice drink?", user_id="alice")
+
+    Args:
+        api_key:  your Wontopos API key (sent as ``X-API-Key``).
+        base_url: API base URL (defaults to the hosted service).
+        timeout:  per-request timeout in seconds.
+    """
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL, timeout: float = 30.0):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self._base = base_url.rstrip("/")
+        self._timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({"X-API-Key": api_key, "Content-Type": "application/json"})
+
+    # ----- write -----
+
+    def add(self, content: str, user_id: str, **metadata: Any) -> dict:
+        """Store one memory. Extra keyword args become metadata.
+
+            mem.add("moved to Berlin", user_id="alice", event_date="2026-03-01")
+        """
+        return self._post(
+            "/api/v1/memory/store",
+            {"user_id": user_id, "content": content, "metadata": metadata},
+        )
+
+    store = add  # alias (back-compat / preference)
+
+    def add_turn(self, user_id: str, user_msg: str, assistant_msg: str) -> dict:
+        """Store a conversation turn (user + assistant) into short-term + long-term memory."""
+        return self._post(
+            "/api/v1/memory/store-turn",
+            {"user_id": user_id, "user_msg": user_msg, "assistant_msg": assistant_msg},
+        )
+
+    def add_bulk(
+        self, content: str, user_id: str, category: str = "general",
+        timestamp: Optional[str] = None,
+    ) -> dict:
+        """Bulk-ingest a large blob of text (chunked + embedded server-side).
+
+        Use this to backfill long histories in one call. ``timestamp`` is an RFC3339 string.
+        """
+        body: dict[str, Any] = {"user_id": user_id, "content": content, "category": category}
+        if timestamp:
+            body["timestamp"] = timestamp
+        return self._post("/api/v1/memory/bulk-store", body)
+
+    def update(self, user_id: str, old_memory_id: str, new_content: str) -> dict:
+        """Supersede an old memory with new content (e.g. a fact that changed)."""
+        return self._post(
+            "/api/v1/memory/supersede",
+            {"user_id": user_id, "old_memory_id": old_memory_id, "new_content": new_content},
+        )
+
+    # ----- read -----
+
+    def search(self, query: str, user_id: str, limit: int = 10, **opts: Any) -> list[dict]:
+        """Semantic search over a user's memories. Returns memories, most relevant first."""
+        body = {"user_id": user_id, "query": query, "max_results": limit, **opts}
+        return self._post("/api/v1/memory/search", body).get("memories", [])
+
+    def recall(self, query: str, user_id: str) -> dict:
+        """One-call context for an LLM: short-term turns + long-term matches + surrounding context.
+
+        Returns ``{"short_term": ..., "long_term": ..., "context": ...}``. No extra round-trips.
+        """
+        return self._post("/api/v1/memory/recall", {"user_id": user_id, "query": query})
+
+    def history(self, user_id: str) -> list[dict]:
+        """Recent conversation turns (short-term memory)."""
+        return self._post("/api/v1/memory/history", {"user_id": user_id}).get("turns", [])
+
+    def stats(self, user_id: str) -> dict:
+        """Memory counts for a user: ``{total_memories, short_term_turns}``."""
+        return self._post("/api/v1/memory/stats", {"user_id": user_id})
+
+    # ----- delete -----
+
+    def delete(self, user_id: str, memory_id: str) -> dict:
+        """Delete a single memory by id."""
+        return self._post("/api/v1/memory/forget", {"user_id": user_id, "memory_id": memory_id})
+
+    def delete_all(self, user_id: str) -> dict:
+        """Delete ALL memories for a user (GDPR erase)."""
+        return self._post("/api/v1/memory/forget", {"user_id": user_id})
+
+    # ----- internal -----
+
+    def _post(self, path: str, body: dict) -> dict:
+        try:
+            r = self._session.post(f"{self._base}{path}", json=body, timeout=self._timeout)
+        except requests.RequestException as e:
+            raise WosError(0, f"network error: {e}") from e
+        if not r.ok:
+            # Server may return either:
+            #   Anthropic-style envelope: {"type":"error","error":{"type":...,"message":...,"request_id":...}}
+            #   Spec simple:             {"error":"reason string"}
+            # Fall back to raw text.
+            msg = r.text
+            try:
+                data = r.json()
+                if isinstance(data, dict):
+                    err = data.get("error")
+                    if isinstance(err, dict):
+                        msg = err.get("message") or err.get("type") or msg
+                    elif isinstance(err, str):
+                        msg = err
+                    elif "message" in data:
+                        msg = data["message"]
+            except Exception:
+                pass
+            raise WosError(r.status_code, msg)
+        return r.json()
+
+
+# Back-compat alias: older code used `WME`.
+WME = Client
+
+
+# ---------------------------------------------------------------------------
+# Advanced: BYOK chat (WPE + WME). Most users only need `Client` above.
+# The customer brings their own LLM API key; Wos never stores it (sent per request).
+# ---------------------------------------------------------------------------
+
+import json as _json  # noqa: E402
+from typing import Iterator  # noqa: E402
+
+
+class Wos:
+    """Full chat client (persona + memory). Bring your own LLM API key.
+
+    Model slots (named after neurotransmitters by function):
+        glu  (Glutamate)     : MAIN  — LLM1 (fast reply / deficit) + LLM3 (synthesis).
+        sero (Serotonin)     : SUB   — LLM2 engram router.
+        ach  (Acetylcholine) : MIDDLE — optional, future use.
+    """
+
+    def __init__(
+        self,
+        llm_api_key: str,
+        glu: str,
+        sero: str,
+        persona: str = "",
+        ach: Optional[str] = None,
+        llm_base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+    ):
+        self._url = base_url.rstrip("/")
+        self._llm_key = llm_api_key
+        self._glu = glu
+        self._sero = sero
+        self._ach = ach
+        self._persona = persona
+        self._llm_base = llm_base_url
+        self._svc_key = api_key
+
+    def _headers(self, stream: bool = False) -> dict:
+        h = {
+            "Content-Type": "application/json",
+            "X-LLM-Key": self._llm_key,
+            "X-LLM-Glu": self._glu,
+            "X-LLM-Sero": self._sero,
+        }
+        if self._ach:
+            h["X-LLM-Ach"] = self._ach
+        if self._llm_base:
+            h["X-LLM-Base-Url"] = self._llm_base
+        if self._svc_key:
+            h["X-API-Key"] = self._svc_key
+        if stream:
+            h["Accept"] = "text/event-stream"
+        return h
+
+    def create_character(self, name: str, **extra) -> str:
+        body = {"name": name, "persona": self._persona, **extra}
+        r = requests.post(f"{self._url}/api/v1/character/create", json=body, headers=self._headers(), timeout=30)
+        r.raise_for_status()
+        return r.json()["id"]
+
+    def chat(self, character_id: str, message: str) -> Iterator[str]:
+        """Stream a chat response token by token."""
+        body = {"message": message, "persona": self._persona}
+        with requests.post(
+            f"{self._url}/api/v1/character/{character_id}/chat",
+            json=body, headers=self._headers(stream=True), stream=True, timeout=180,
+        ) as r:
+            r.raise_for_status()
+            for line in r.iter_lines(decode_unicode=True):
+                if not line or not line.startswith("data:"):
+                    continue
+                payload = line[5:].strip()
+                if not payload:
+                    continue
+                try:
+                    evt = _json.loads(payload)
+                except _json.JSONDecodeError:
+                    continue
+                if "delta" in evt:
+                    yield evt["delta"]
+                elif "error" in evt:
+                    raise RuntimeError(evt["error"])

wontopos-2.0.0/wontopos.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: wontopos
+Version: 2.0.0
+Summary: Wontopos — long-term memory for AI agents. Pure semantic retrieval, identical recall in every language, ~100× lower LLM bill.
+Author: Wontopos
+License: MIT
+Project-URL: Homepage, https://wontopos.com
+Project-URL: Documentation, https://wontopos.com/why
+Project-URL: Repository, https://github.com/Irina1920/Wos_API
+Project-URL: Issues, https://github.com/Irina1920/Wos_API/issues
+Keywords: memory,ai,agent,llm,vector,embedding,semantic,rag,context
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# Wontopos — long-term memory for AI agents
+
+```bash
+pip install wontopos
+```
+
+```python
+from wontopos import Client
+
+mem = Client(api_key="wos-...")
+mem.add("she prefers tea over coffee", user_id="alice")
+
+# one call → short-term + long-term + context, ready for your LLM prompt
+ctx = mem.recall("what does alice drink?", user_id="alice")
+```
+
+## Why
+
+- **Pure semantic retrieval** — no keyword/BM25. Identical recall in every language (한국어 · 日本語 · 中文 · English).
+- **No LLM in the loop** — `store` / `search` / `recall` never call a language model. You pay embeddings, not generation.
+- **Bounded retrieval** — `recall()` returns a small, fixed-size slice (~1,200 tokens) regardless of how much you've stored. Your LLM bill stops growing with history.
+
+## Methods
+
+| Method | Purpose |
+|---|---|
+| `add(content, user_id, **metadata)` | Store one memory |
+| `add_turn(user_id, user_msg, assistant_msg)` | Store a conversation exchange |
+| `add_bulk(content, user_id, category=, timestamp=)` | Backfill a long history |
+| `update(user_id, old_memory_id, new_content)` | Supersede an old fact |
+| `search(query, user_id, limit=10, **opts)` | Semantic search |
+| `recall(query, user_id)` | One-call context (short + long + surrounding) |
+| `history(user_id)` | Recent turns (short-term) |
+| `stats(user_id)` | Counts |
+| `delete(user_id, memory_id)` | Delete one memory |
+| `delete_all(user_id)` | GDPR erase (delete every memory for the user) |
+
+All methods take a `user_id` — memories are isolated per user, then per account (your API key).
+
+## Errors
+
+Any non-2xx response raises `WosError(status, message)`:
+
+```python
+from wontopos import Client, WosError
+
+try:
+    mem.search("...", user_id="alice")
+except WosError as e:
+    if e.status == 401:
+        print("API key invalid or revoked")
+    elif e.status == 429:
+        print("Rate limited — back off")
+    else:
+        print(e.status, e.message)
+```
+
+## Self-host
+
+Point at your own engine:
+
+```python
+mem = Client(api_key="...", base_url="https://wos.your-host.com")
+```
+
+## Links
+
+- Homepage: <https://wontopos.com>
+- API reference: <https://wontopos.com/why> (Developers tab)
+- Repo: <https://github.com/Irina1920/Wos_API>
+
+License: MIT.

wontopos-2.0.0/wontopos.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+wontopos/__init__.py
+wontopos.egg-info/PKG-INFO
+wontopos.egg-info/SOURCES.txt
+wontopos.egg-info/dependency_links.txt
+wontopos.egg-info/requires.txt
+wontopos.egg-info/top_level.txt

wontopos-2.0.0/wontopos.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wontopos-2.0.0/wontopos.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28

wontopos-2.0.0/wontopos.egg-info/top_level.txt

@@ -0,0 +1 @@
+wontopos