memty 0.1.0__tar.gz

memty-0.1.0/LICENSE

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

memty-0.1.0/PKG-INFO

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: memty
+Version: 0.1.0
+Summary: Memty: portable memory, smart model routing, and multi-provider chat
+Project-URL: Repository, https://github.com/RohanNK86/memty
+Project-URL: Documentation, https://github.com/RohanNK86/memty/tree/main/memty
+Keywords: memty,portable-memory,vector-memory,model-routing,linucb,mcp,openai-compatible
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+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: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.9
+Provides-Extra: mongodb
+Requires-Dist: pymongo>=4.6; extra == "mongodb"
+Provides-Extra: crypto
+Requires-Dist: cryptography>=43.0; extra == "crypto"
+Provides-Extra: mcp
+Provides-Extra: server
+Requires-Dist: fastapi>=0.115; extra == "server"
+Requires-Dist: uvicorn>=0.30; extra == "server"
+Dynamic: license-file
+
+# Memty
+
+Memty is the public product and Python distribution for smart model routing, multi-provider chat, and a user-owned portable memory vault. Its CLI supports both model tasks and the atomic vault. The deterministic context compiler uses canonical slots, logical constraints, capped summaries, and an explicit raw drill-down archive.
+
+Week 1 is the storage and retrieval engine. It is standard-library only, local-first, and makes no model or network calls.
+
+## What Week 1 ships
+
+| Requirement | Implementation |
+| --- | --- |
+| Atomic facts, one value per slot | `atomic_facts` with `UNIQUE(user_id, namespace, slot)` |
+| Logical constraints per namespace | `logical_constraints` with replaceable `rule_id`, condition, and constraint |
+| No contradictory memories | Superseding increments `version`, writes the old value to `atomic_fact_audit`, then overwrites the active slot |
+| Facts capped at 40 tokens | `record()` rejects anything longer |
+| Delete is durable | `forget()` tombstones the slot and purges its plaintext/audit history |
+| Automatic extraction cannot resurrect deleted memory | `record(..., verification_state="EXTRACTED")` raises `TombstonedSlot` |
+| User can restore a deleted slot | `verification_state="USER_CONFIRMED"` (or `SPEC_LOCKED`) |
+| Rolling namespace summaries | `rolling_summaries`, capped at 150 tokens, optional float32 embedding |
+| Raw text is never injected | `raw_drilldown` is only returned by an explicit `drill_down()` call |
+| Deterministic context under 600 tokens | Three-section compiler: slots ≤250, summary ≤200, semantic ≤150 |
+| FTS5 keyword retrieval with SQL fallback | `atomic_facts_fts` and `rolling_summaries_fts`, created when SQLite supports FTS5 |
+| SECRET facts cannot leave the device | `LocalRoutingRequired` forces the caller to switch to local `ollama` |
+| CONFIDENTIAL facts can be masked | `<MEMTY_REDACTED_SLOT_N>` placeholders plus `rehydrate()` in the response path |
+| Provider allow/block lists | Per-fact `allowed_providers` / `blocked_providers` |
+
+The four functional tables are `atomic_facts`, `logical_constraints`, `rolling_summaries`, and `raw_drilldown`. A small `atomic_fact_audit` table preserves superseded values and is purged on forget.
+
+## Install
+
+```shell
+python -m pip install memty
+# MCP support is included
+```
+
+The vault lives at `~/.memty/ledger.sqlite3` by default. Override it with `MEMTY_VAULT_PATH` or `--db`.
+
+## Quick start: CLI
+
+After installing the package, the following commands create a complete local namespace:
+
+```powershell
+python -m pip install -e .
+memty remember project.api cache_engine "DragonflyDB" --verification USER_CONFIRMED
+memty remember project.api rate_limiter "Token Bucket via Lua, 500 req/min" --verification SPEC_LOCKED
+memty rule project.api database_queries "writing database queries" "always use async Motor and project only needed fields"
+memty summary project.api --set "FastAPI backend with JWT auth and MongoDB Atlas sync."
+memty recall "Which cache and rate limiter should I use?" --provider claude --namespace project.api
+memty stats
+```
+
+Use `memty list`, `memty rules`, `memty history`, `memty forget`, `memty raw-add`, and `memty raw-get` to inspect and manage the vault. The default database is `~/.memty/ledger.sqlite3`; use `--db` or `MEMTY_VAULT_PATH` for another location.
+
+## Model routing and chat SDK
+
+The same package provides prompt-aware routing, provider adapters, and a local chat client. Generate a model catalog, set provider credentials in your environment, and use:
+
+```shell
+memty init
+memty models
+memty route "Review this Python function"
+memty chat --interactive --chat-id work
+```
+
+```python
+from memty import Memty, ModelConfig, load_client
+
+client = load_client()  # reads ~/.memty/models.json
+answer = client.chat("Review this Python function", chat_id="code-review")
+print(answer.model_id, answer.text)
+```
+
+`Memty` supports configured OpenAI-compatible providers, Anthropic, Gemini Interactions, local Ollama, and custom adapters. Routing can use task rules, cost, latency, or adaptive feedback. The catalog uses operator-supplied capability, context, cost, and latency metadata; it does not fetch provider catalogs. Chat transcripts remain in process memory by default. Existing temporal-vault files are reused when found; the atomic CLI vault and web account memory keep their established storage boundaries.
+
+The distribution metadata is named `memty`. Once a release is published on PyPI, install it with `python -m pip install memty`; until then, install the project checkout or use the GitHub installer linked in the root guide. PyPI publishing still needs to be completed.
+
+`memty recall` prints a deterministic `<memty_state>` capsule. It never includes archived raw source text. A matching `SECRET` fact exits with status 2 and reports that the request must use a local provider.
+
+## Python API
+
+```python
+from memty import open_ledger
+
+vault = open_ledger()  # ~/.memty/ledger.sqlite3, user "local"
+
+vault.record("work.preferences", "editor", "VS Code", verification_state="USER_CONFIRMED")
+vault.record("repo.memty", "primary_db", "Postgres 16", verification_state="USER_CONFIRMED")
+vault.set_summary("repo.memty", "Memty uses Postgres and a local context compiler.")
+vault.set_constraint("repo.memty", "database_queries",
+                     "writing database queries",
+                     "always use async Motor and project only needed fields")
+
+compiled = vault.context("Which editor and database do I use?", provider="claude", token_budget=600)
+print(compiled["text"])
+print(compiled["approx_tokens"], compiled["sections"])
+```
+
+Typical output:
+
+```xml
+<memty_state v="1" provider="claude">
+<slots>
+repo.memty.primary_db="Postgres 16"
+work.preferences.editor="VS Code"
+</slots>
+<summary ns="repo.memty">Memty uses Postgres and a local context compiler.</summary>
+<semantic>
+repo.memty.primary_db="Postgres 16"
+</semantic>
+</memty_state>
+```
+
+The compiler returns `citations`, `redactions`, `approx_tokens`, `eligible_count`, `injected_count`, and per-section counts. The final text is checked against the budget with a conservative token estimator and trimmed if necessary.
+
+## Privacy gate
+
+```python
+from memty import LocalRoutingRequired
+
+vault.record("user.vault", "api_key", "...", sensitivity="SECRET",
+             verification_state="USER_CONFIRMED")
+
+try:
+    vault.context("api key", provider="claude")
+except LocalRoutingRequired as exc:
+    print(exc.as_dict())  # suggests ollama; no secret value is included
+
+# CONFIDENTIAL facts are masked for untrusted providers.
+vault.record("repo.memty", "internal_host", "db.internal.example",
+             sensitivity="CONFIDENTIAL", verification_state="USER_CONFIRMED")
+compiled = vault.context("internal host", provider="claude")
+answer = vault.rehydrate(model_output, compiled["redactions"])
+# For streamed output, use vault.rehydrate_stream(chunks, compiled["redactions"]).
+```
+
+A provider is trusted when it is local (`local`, `ollama`, `local_ollama`, `memty_local`), was passed to `MemtyLedger(..., trusted_providers=[...])`, or is named in that fact's `allowed_providers`.
+
+## Raw drill-down
+
+```python
+fact = vault.record("repo.memty", "deployment_host", "db.internal.example",
+                    verification_state="USER_CONFIRMED",
+                    source_raw="full transcript or log excerpt ...")
+
+vault.context("deployment host", provider="local")   # raw text is absent
+vault.drill_down(fact_id=fact["id"])                 # explicit fetch only
+```
+
+## CLI
+
+```shell
+memty --db ~/.memty/ledger.sqlite3 remember work.preferences editor "VS Code"
+memty recall "Which editor do I use?" --provider claude --tokens 600
+memty list
+memty history work.preferences editor
+memty summary repo.memty --set "Memty uses Postgres and a local context compiler."
+memty forget work.preferences editor --purge-raw
+memty stats
+memty rule repo.memty database_queries "writing database queries" "always use async Motor and project only needed fields"
+memty rules --namespace repo.memty
+memty rule-delete repo.memty database_queries
+memty migrate ~/.memty/memory.sqlite3
+```
+
+`memty recall` exits with status 2 and prints a `local_routing_required` payload when a SECRET fact matches a cloud provider.
+
+## MCP bridge and client setup
+
+Install Memty with `pip install memty`, then run `memty connect`. It detects existing Claude Desktop, Claude Code, Cursor, and Windsurf configuration locations and adds a `memty` server while preserving other settings. Restart the clients after connecting. Invalid JSON is reported without being overwritten. Clients that are not detected are skipped; launch them once and rerun the command.
+
+The clients start `memty mcp` over stdio. The server exposes `memty_sync` (`recall`, `remember`, or `forget`) and the resource template `memty://capsule/{namespace}`. The compiled capsule is limited to 120 estimated tokens. MCP results are treated as an external provider by default, so the ledger's sensitivity rules apply. `MEMTY_PROVIDER` can select another provider identity; choose a local identity only when the receiving model is actually local. Database path and user overrides are `MEMTY_VAULT_PATH` (or `MEMTY_DB`) and `MEMTY_USER`.
+
+The MCP servers and atomic-vault CLI automatically start and share one `memtyd` process for each database path. The daemon serializes their ledger operations and holds a SQLite connection. It uses authenticated loopback connections; its endpoint and secret are stored beside the database, so keep that directory private. The SDK and other applications may still access SQLite directly. WAL and a 5-second busy timeout reduce contention with those external connections, but a lock held longer than the timeout can still cause an error.
+
+```shell
+memtyd status
+memtyd start
+memtyd stop
+# For a non-default database, add --db PATH to each command.
+# Equivalent: memty daemon status
+```
+
+The daemon persists until stopped or the computer exits. It restarts automatically when a client next needs it. Run `memtyd serve` in the foreground to diagnose startup failures.
+
+## Guarantees and verification
+
+The Week 1 acceptance suite covers the schema, logical constraints, 40-token enforcement, versioning/audit, tombstones, raw isolation, budgets, semantic snippets, summaries, allow/block lists, SECRET routing, and CONFIDENTIAL rehydration:
+
+```shell
+python -m pytest tests/test_memty_week1.py -q
+python scripts/test_memty_week1.py
+```
+
+The performance test builds 200 facts and asserts a warm compiler median below 6 ms on the local machine; the measured median on the development machine is about 3.2 ms (p95 ~4.8 ms) with a 600-token budget and 300 facts. The compiler also enforces a hard `estimate_tokens(text) <= token_budget` check, so larger inputs cannot silently exceed the ceiling.
+
+## Migration from an earlier Memty vault
+
+The SDK can continue reading its previous temporal-vault database format. To copy its latest active facts into the atomic vault:
+
+```shell
+memty migrate ~/.memty/memory.sqlite3
+```
+
+Only the newest event for each `(namespace, slot)` is considered, so superseded values are not re-imported and deleted slots stay deleted. Facts longer than 40 tokens are skipped and reported rather than truncated.
+
+## Scope of the atomic vault release
+
+The atomic vault CLI and compiler are dependency-free and local-first. Model routing, multi-provider chat, the optional HTTP and MCP bridges, MongoDB support, and encrypted exports are provided through the same Memty distribution as separate integrations and optional extras.

memty-0.1.0/README.md

@@ -0,0 +1,214 @@
+<div align="center">
+
+<img src="assets/memty_logo.png" alt="Memty logo" width="180" />
+
+# Memty
+
+### One workspace for multiple AI models, conversations, and portable memory.
+
+[Explore the code](#project-map) · [Run locally](#get-started) · [Understand the architecture](#how-it-fits-together) · [Find a guide](#choose-your-path)
+
+</div>
+
+Memty is a multi-provider AI workspace and portable-memory toolkit built with **Next.js**, an **Express** account service, **MongoDB**, and a local Python SDK. One `memty` package provides the model-routing SDK, atomic memory vault, CLI, and optional HTTP and MCP integrations. The web workspace keeps signed-in account data in MongoDB; the local SDK and CLI keep their vault data on the user's device.
+
+This project is licensed under the [MIT License](LICENSE).
+
+> **Project status:** provider access depends on your own credentials. Some production features are still planned; see [current limitations](#current-limitations) before deploying publicly.
+
+## ✨ What you can do
+
+| Chat across providers | Own memory from the CLI | Keep useful context |
+| --- | --- | --- |
+| Select a configured model, use fallbacks, or compare responses. | Store, inspect, recall, constrain, and delete facts with the `memty` command. | Compile deterministic, provider-filtered context without sending the whole vault to an assistant. |
+
+The workspace also includes a responsive chat UI, model availability metadata, a memory dashboard, privacy and terms pages, and a first-party API reference. The atomic vault is standard-library-only: it stores facts, logical constraints, rolling summaries, and raw drill-down records in `~/.memty/ledger.sqlite3`. Smart model routing and multi-provider chat are available from the same Python package.
+
+<a id="how-it-fits-together"></a>
+## 🧭 How it fits together
+
+![Memty system architecture: browser, Next.js, model providers, Express API, MongoDB, and optional local memory services](docs/architecture.svg)
+
+The browser talks to the Next.js app. Its chat route calls the selected model adapter and uses a private proxy to reach the Express service for account sessions and saved data. MongoDB stores account and web-workspace memory. Memty is intentionally separate and local: the CLI owns `~/.memty/ledger.sqlite3`, and assistants consume only the compact context capsule that the user chooses to share.
+
+### A chat request, at a glance
+
+```mermaid
+flowchart LR
+    U[Your message] --> C[Next.js chat route]
+    C --> M[Context and memory lookup]
+    M --> R[Selected provider adapter]
+    R --> A[Assistant response]
+    A --> P[Persist conversation and usage]
+```
+
+<a id="get-started"></a>
+## 🚀 Get started
+
+### Requirements
+
+- Node.js 20.9 or later and npm
+- MongoDB for sign-in, saved conversations, and server-side memory
+- Provider credentials for the models you want to use
+- Python 3.10+ for the Memty CLI
+
+Install the frontend and backend dependencies:
+
+```powershell
+npm install
+cd backend
+npm install
+cd ..
+```
+
+Create local environment files and add the MongoDB URI and any provider keys you want to use:
+
+```powershell
+Copy-Item .env.example .env
+Copy-Item backend/.env.example backend/.env
+```
+
+Keep populated environment files private. Open two terminals from the repository root:
+
+```powershell
+# Terminal 1: Next.js app
+npm run dev
+```
+
+```powershell
+# Terminal 2: Express API
+cd backend
+npm run dev
+```
+
+Open [http://localhost:3001](http://localhost:3001). The API listens on port `3002` by default. Sign-in and server-backed memory features need a reachable MongoDB instance. Without provider credentials, those models are shown as unavailable.
+
+### Use the Memty CLI
+
+Install the local package from the repository root:
+
+```powershell
+python -m pip install -e .
+```
+
+Once the first PyPI release is published, users can install the distribution with `python -m pip install memty`. Until then, an account with repository access can install the renamed GitHub repository directly:
+
+```powershell
+python -m pip install "memty @ git+https://github.com/RohanNK86/memty.git@main"
+```
+
+Create and inspect a user-owned vault without starting the web application:
+
+```powershell
+memty stats
+memty remember project.api cache_engine "DragonflyDB" --verification USER_CONFIRMED
+memty rule project.api database_queries "writing database queries" "use async Motor and project only needed fields"
+memty summary project.api --set "FastAPI backend with JWT auth and MongoDB Atlas sync."
+memty recall "Which cache engine should I use?" --provider claude
+memty rules --namespace project.api
+```
+
+The default database is `~/.memty/ledger.sqlite3`. Use `--db C:\path\to\ledger.sqlite3` or set `MEMTY_VAULT_PATH` to select another file. `memty forget` tombstones a fact, while `memty raw-get` is the only command that reads archived raw source text.
+
+### Use Memty's model SDK
+
+The same install provides prompt-aware routing, provider adapters, and a local chat client:
+
+```powershell
+memty init
+# Edit ~/.memty/models.json and set each configured provider's API key in your environment.
+memty models
+memty route "Review this Python function"
+memty chat --interactive --chat-id work
+```
+
+```python
+from memty import Memty, ModelConfig, load_client
+
+client = load_client()  # reads ~/.memty/models.json
+answer = client.chat("Review this Python function", chat_id="code-review")
+print(answer.model_id, answer.text)
+```
+
+The SDK's historical temporal ledger remains available during migration; its existing data files are reused when found. The atomic CLI vault and web account memory keep their established storage and access boundaries.
+
+### Start with Docker Compose
+
+Compose starts the frontend, backend, and optional Memty HTTP vault service. MongoDB remains external. The Memty CLI can also use its local SQLite vault independently. Create the environment files as above, set a reachable `MONGO_URI` and stable `SESSION_SECRET` in `backend/.env`, and replace the example `MEMORY_VAULT_API_TOKEN` with a random secret of at least 32 characters in `.env`.
+
+```powershell
+docker compose up --build
+```
+
+The Memty HTTP vault stays on Compose's private network. Open [http://localhost:3001](http://localhost:3001); stop the stack with `Ctrl+C` or `docker compose down`. Compose does not migrate existing MongoDB memories into the local Memty vault.
+
+<a id="project-map"></a>
+## 🗺️ Project map
+
+| Path | What lives here | Start here |
+| --- | --- | --- |
+| [`app/`](app/README.md) | Next.js pages, API routes, chat orchestration, and UI styles | [`app/api/chat/route.ts`](app/api/chat/route.ts) |
+| [`backend/`](backend/README.md) | Express routes, authentication, MongoDB models, and memory services | [`backend/server.js`](backend/server.js) |
+| [`providers/`](providers/README.md) | Model registry, provider adapters, and fallbacks | [`providers/index.js`](providers/index.js) |
+| [`memty/`](memty/README.md) | Public Python API, smart-routing SDK, CLI, atomic vault, context compiler, and MCP entry points | [`memty/__init__.py`](memty/__init__.py) |
+| [`memoryport/`](memoryport/README.md) | Internal compatibility implementations retained for existing vaults and integrations | [`memoryport/README.md`](memoryport/README.md) |
+| [`GitPage/`](GitPage/index.html) | Memty product site, quick starts, architecture, and integration guides | [`GitPage/index.html`](GitPage/index.html) |
+| [`components/`](components/legacy-page.tsx) · [`lib/`](lib/legacy-markup.ts) · [`public/`](public/) | Shared wrapper, legacy page markup, and browser assets/scripts | [`components/legacy-page.tsx`](components/legacy-page.tsx) |
+| [`templates/`](templates/) · [`static/`](static/) | Legacy HTML templates and static assets | — |
+| [`assets/`](assets/) | Project and provider artwork used by the UI and documentation | — |
+| [`compose.yaml`](compose.yaml) · [`Dockerfile`](Dockerfile) · [`Dockerfile.vault`](Dockerfile.vault) | Local multi-service deployment and container builds | [Compose setup](#start-with-docker-compose) |
+| [`.env.example`](.env.example) · [`backend/.env.example`](backend/.env.example) | Frontend/provider and backend configuration templates | [Configuration](#configuration-at-a-glance) |
+
+<a id="choose-your-path"></a>
+### Choose your path
+
+- **Frontend contributor:** [routes, UI, and responsive styles](app/README.md)
+- **API or data contributor:** [backend routes, sessions, and MongoDB](backend/README.md)
+- **Model contributor:** [provider adapters and fallbacks](providers/README.md)
+- **Memory contributor:** [Memty CLI and atomic vault](memty/README.md)
+- **Python SDK contributor:** [Memty SDK and vault guide](memty/README.md)
+- **Memory feature reader:** [memory lifecycle and storage guide](app/memory/README.md)
+
+<a id="configuration-at-a-glance"></a>
+## ⚙️ Configuration at a glance
+
+The root `.env` configures Next.js and model providers. `backend/.env` configures MongoDB and the Express service; the backend loads the root environment first, then lets backend values override it.
+
+| Setting | Service | Purpose |
+| --- | --- | --- |
+| `GEMINI_API_KEY`, `CLAUDE_API_KEY`, `GROK_API_KEY`, `KIMI_API_KEY` | Frontend and/or backend | Enable the corresponding model features. |
+| `OPEN_ROUTER_OPEN_API_KEYS`, `OPEN_ROUTER_API_KEY` | Frontend | Enable OpenRouter-backed models. |
+| `MONGO_URI`, `MONGO_DATABASE`, `MEMORY_DATABASE` | Backend | Connect to account and memory databases. |
+| `SESSION_SECRET` | Backend | Sign account sessions; use a stable high-entropy value in production. |
+| `PROXY_TARGET` | Frontend | Backend URL; defaults to `http://localhost:3002`. |
+| `MEMORY_VAULT_API_URL`, `MEMORY_VAULT_API_TOKEN` | Backend and Vault | Connect the trusted backend to the optional Vault API. |
+
+See [`.env.example`](.env.example) and [`backend/.env.example`](backend/.env.example) for all options. Never commit real credentials or paste them into issues.
+
+For semantic memory retrieval, create the Atlas Search vector index on `Memory.user_memories` using [`backend/memory-vector-index.json`](backend/memory-vector-index.json). The configured index expects 768-dimensional cosine vectors and filters for `userId` and `status`. Without the index or an embedding service, retrieval can use lexical and recency scoring.
+
+<a id="current-limitations"></a>
+## ⚠️ Current limitations
+
+- Chat responses are not streamed.
+- The frontend request limit is in-memory per frontend process, not a shared account quota.
+- Public launch needs an account deletion and retention process, shared abuse controls, monitoring, backups, and deployment-specific security review.
+- Model availability, IDs, prices, and provider behavior depend on external providers and your configuration.
+- Cost figures are estimates only when operators configure per-model rates; they are not billing records.
+- Memty's working SQLite database is plaintext on disk. Week 1 does not provide encryption or remote synchronization.
+
+Review the [Privacy Notice](app/privacy/page.tsx) and [Terms](app/terms/page.tsx) against your deployment and applicable provider agreements before release.
+
+## 📚 More documentation
+
+- [Frontend and mobile layout](app/README.md)
+- [Backend, routes, and MongoDB](backend/README.md)
+- [Memory layers, retrieval, and storage](app/memory/README.md)
+- [Provider adapters and costs](providers/README.md)
+- [Memty CLI and atomic vault](memty/README.md)
+- [Memty Python SDK and CLI](memty/README.md)
+- [Frontend scripts](package.json) · [Backend scripts](backend/package.json) · [Python package configuration](pyproject.toml)
+
+## 🤝 Contributing
+
+Start with the [contributor guide](CONTRIBUTING.md), choose the guide for the area you are changing, and pick a focused issue. Keep credentials and personal data out of commits and issue attachments.

memty-0.1.0/memoryport/__init__.py

@@ -0,0 +1,20 @@
+"""Internal implementation modules for the Memty SDK."""
+
+from .memory import MongoSyncedMemoryStore, PortableMemoryStore
+from .router import ModelSpec, RouteDecision, SmartRouter
+from .ledger import MemoryLedger
+from .evaluation import evaluate_cases
+from .vault import export_nxvault, import_nxvault
+from .mongo_ledger import MongoMemoryLedger
+from .extractor import MemoryExtractor
+from .sdk import ChatResponse, Memty, RouteResult, ModelConfig, load_client
+NexorAI = Memty  # Keep the former Python name as a compatibility alias.
+from .embeddings import (EmbeddingAdapter, EmbeddingConfig, EmbeddingError,
+                         GeminiEmbeddingAdapter, OpenAICompatibleEmbeddingAdapter)
+
+__all__ = ["ChatResponse", "EmbeddingAdapter", "EmbeddingConfig", "EmbeddingError", "GeminiEmbeddingAdapter",
+           "MemoryExtractor", "OpenAICompatibleEmbeddingAdapter",
+           "MemoryLedger", "ModelConfig", "ModelSpec", "MongoMemoryLedger",
+           "MongoSyncedMemoryStore", "Memty", "NexorAI", "PortableMemoryStore", "RouteDecision", "RouteResult",
+           "SmartRouter", "evaluate_cases", "export_nxvault", "import_nxvault", "load_client"]
+