rewind-memory 0.1.0__tar.gz

rewind_memory-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 SARAI Defence Ltd
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

rewind_memory-0.1.0/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: rewind-memory
+Version: 0.1.0
+Summary: Bio-inspired persistent memory for AI agents. 5-layer architecture with FTS5, vector search, knowledge graph, and HybridRAG fusion.
+Author-email: SARAI Defence <vova@saraidefence.com>
+License: Apache-2.0
+Project-URL: Homepage, https://saraidefence.com
+Project-URL: Documentation, https://saraidefence.com/docs
+Project-URL: Repository, https://github.com/saraidefence/rewind-memory
+Keywords: memory,ai,agents,rag,bio-inspired,knowledge-graph
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: httpx>=0.24
+Provides-Extra: vector
+Requires-Dist: sqlite-vec>=0.0.1; extra == "vector"
+Provides-Extra: mcp
+Requires-Dist: httpx>=0.24; extra == "mcp"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# 🧠 Rewind
+
+**7-layer bio-inspired memory architecture for AI agents.**
+
+Rewind gives AI agents persistent, structured memory that works like biological memory — with sensory buffers, short-term recall, knowledge graphs, semantic search, and natural forgetting curves.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                    L2 Orchestrator                   │
+│          (fusion · ranking · entity extraction)      │
+├─────────┬─────────┬─────────┬─────────┬─────┬───────┤
+│   L0    │   L1    │   L3    │   L4    │ L5  │  L6   │
+│Sensory  │  STM    │ Graph   │Workspace│Comms│ Docs  │
+│ Buffer  │(Vector) │         │ (Files) │     │       │
+│         │         │         │         │     │       │
+│ FTS5/   │sqlite-  │SQLite/  │sqlite-  │sqlite│ FTS  │
+│ BM25    │ vec     │ Neo4j   │ vec     │/Qdrant│     │
+└─────────┴─────────┴─────────┴─────────┴─────┴───────┘
+                         +
+              Bio Layer (Pro/MOS only)
+        (decay · consolidation · Hebbian · pruning)
+```
+
+## Layers
+
+| Layer | Name | Bio Analogy | Backend | Purpose |
+|-------|------|-------------|---------|---------|
+| **L0** | Sensory Buffer | Sensory cortex | SQLite FTS5 | Fast keyword search, BM25 ranking |
+| **L1** | Short-Term Memory | Hippocampus | sqlite-vec | Vector similarity, recent context |
+| **L2** | Orchestrator | Prefrontal cortex | In-process | Fusion, dedup, adaptive scoring |
+| **L3** | Graph Memory | Association cortex | SQLite / Neo4j | Entity relationships, spreading activation |
+| **L4** | Workspace | Working memory | sqlite-vec | Project files, semantic search |
+| **L5** | Communications | Social memory | sqlite-vec / Qdrant | Chat history, email, contacts |
+| **L6** | Documents | Declarative memory | SQLite FTS5 | PDFs, docs, arena-based retrieval |
+
+## Quick Start
+
+```bash
+pip install rewind-memory
+
+# Minimal — zero external dependencies
+python -c "
+from rewind.client import RewindClient
+client = RewindClient()
+results = client.search('what is Hebbian learning')
+for r in results:
+    print(f'{r.score:.2f} [{r.layer}] {r.text[:80]}')
+"
+```
+
+### With production backends
+
+```bash
+pip install rewind-memory[all]  # includes neo4j, qdrant-client, etc.
+```
+
+## Configuration Tiers
+
+```python
+from rewind.config import default_config
+
+# Core (Free) — local SQLite only, zero external deps
+config = default_config("free")
+
+# Pro — all layers, optional Neo4j/Qdrant migration
+config = default_config("pro")
+
+# MOS (Enterprise) — full stack + bio lifecycle
+config = default_config("enterprise")
+```
+
+| Feature | Core (Free) | Pro ($9/mo) | MOS (Custom) |
+|---------|-------------|-------------|--------------|
+| L0 Full-text search (FTS5) | ✅ | ✅ | ✅ |
+| L1 System memory (sqlite-vec) | ✅ | ✅ | ✅ |
+| L2 HybridRAG fusion | basic | full | full |
+| L3 Knowledge graph | ✅ SQLite | ✅ SQLite or Neo4j | ✅ Neo4j |
+| L4 Semantic vector search | ✅ sqlite-vec | ✅ sqlite-vec or Qdrant | ✅ Qdrant |
+| L5 Communications memory | ❌ | ✅ | ✅ |
+| L6 Document store | ❌ | ✅ | ✅ |
+| Query orchestrator | ❌ | ✅ | ✅ |
+| Retrieval feedback learning | ❌ | ✅ | ✅ |
+| Cloud GPU embeddings | ❌ | ✅ 100K/mo | Custom |
+| Migration assist (SQLite → Neo4j/Qdrant) | — | ✅ | — |
+| Bio lifecycle (decay, consolidation, pruning) | ❌ | ❌ | ✅ |
+| Air-gapped deployment | ❌ | ❌ | ✅ |
+| Custom graph schemas | ❌ | ❌ | ✅ |
+| Dedicated engineer + SLA | ❌ | ❌ | ✅ |
+| API Server | ✅ | ✅ | ✅ |
+
+### Backend Flexibility (Pro)
+
+Pro users can keep running on SQLite (zero-dependency) or upgrade to production backends locally:
+
+```bash
+# Migrate graph from SQLite to Neo4j
+rewind migrate --backend neo4j --uri bolt://localhost:7687
+
+# Migrate vectors from sqlite-vec to Qdrant
+rewind migrate --backend qdrant --url http://localhost:6333
+
+# Both migrations preserve all data and validate counts
+```
+
+## API Server
+
+```bash
+# Start the server
+python -m rewind.api.server --tier pro --port 8080
+
+# Search
+curl -X POST http://localhost:8080/v1/search \
+  -H "Content-Type: application/json" \
+  -d '{"query": "memory consolidation", "limit": 10}'
+
+# Convenience GET
+curl "http://localhost:8080/search?q=memory+consolidation&limit=10"
+
+# Health check
+curl http://localhost:8080/health
+
+# Stats
+curl http://localhost:8080/stats
+```
+
+### Authentication
+
+Set `REWIND_API_KEY` environment variable or pass keys programmatically:
+
+```bash
+REWIND_API_KEY=sk-your-key python -m rewind.api.server
+```
+
+```bash
+curl http://localhost:8080/v1/search \
+  -H "X-API-Key: sk-your-key" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "test"}'
+```
+
+## Docker Deployment
+
+```bash
+cd docker
+
+# Full stack (Neo4j + Qdrant + Rewind API)
+docker compose up -d
+
+# Just the API
+docker build -f Dockerfile -t rewind ..
+docker run -p 8080:8080 rewind
+```
+
+## Bio-Inspired Features
+
+> Available on MOS (Enterprise) tier only.
+
+### Hebbian Learning
+*"Neurons that fire together wire together."*
+
+When a search result is accessed, its connections to co-occurring results strengthen. Frequently co-retrieved memories form stronger associations over time, just like synaptic potentiation.
+
+### Spreading Activation
+Queries activate not just direct matches but related concepts through the graph layer (L3). Activating "memory" spreads to "hippocampus", "consolidation", "encoding" — mimicking how biological neural networks propagate signals.
+
+### Decay (Ebbinghaus Forgetting Curve)
+Memories lose confidence over time following an exponential decay curve: `C(t) = C₀ · e^(-λt)`. Frequently accessed memories decay slower (reduced λ), mirroring spaced repetition effects. A minimum confidence floor prevents complete forgetting.
+
+### Consolidation
+Periodically, high-value short-term memories (L1) are consolidated into long-term graph storage (L3), similar to how sleep consolidates hippocampal memories into neocortical storage.
+
+### Pruning
+Low-confidence memories below a threshold are pruned to prevent unbounded growth — analogous to synaptic pruning during development.
+
+## Development
+
+```bash
+git clone https://github.com/sarai-defence/rewind-memory.git
+cd rewind
+pip install -e ".[dev]"
+pytest tests/
+```
+
+## License
+
+Elastic License 2.0

rewind_memory-0.1.0/README.md

@@ -0,0 +1,188 @@
+# 🧠 Rewind
+
+**7-layer bio-inspired memory architecture for AI agents.**
+
+Rewind gives AI agents persistent, structured memory that works like biological memory — with sensory buffers, short-term recall, knowledge graphs, semantic search, and natural forgetting curves.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                    L2 Orchestrator                   │
+│          (fusion · ranking · entity extraction)      │
+├─────────┬─────────┬─────────┬─────────┬─────┬───────┤
+│   L0    │   L1    │   L3    │   L4    │ L5  │  L6   │
+│Sensory  │  STM    │ Graph   │Workspace│Comms│ Docs  │
+│ Buffer  │(Vector) │         │ (Files) │     │       │
+│         │         │         │         │     │       │
+│ FTS5/   │sqlite-  │SQLite/  │sqlite-  │sqlite│ FTS  │
+│ BM25    │ vec     │ Neo4j   │ vec     │/Qdrant│     │
+└─────────┴─────────┴─────────┴─────────┴─────┴───────┘
+                         +
+              Bio Layer (Pro/MOS only)
+        (decay · consolidation · Hebbian · pruning)
+```
+
+## Layers
+
+| Layer | Name | Bio Analogy | Backend | Purpose |
+|-------|------|-------------|---------|---------|
+| **L0** | Sensory Buffer | Sensory cortex | SQLite FTS5 | Fast keyword search, BM25 ranking |
+| **L1** | Short-Term Memory | Hippocampus | sqlite-vec | Vector similarity, recent context |
+| **L2** | Orchestrator | Prefrontal cortex | In-process | Fusion, dedup, adaptive scoring |
+| **L3** | Graph Memory | Association cortex | SQLite / Neo4j | Entity relationships, spreading activation |
+| **L4** | Workspace | Working memory | sqlite-vec | Project files, semantic search |
+| **L5** | Communications | Social memory | sqlite-vec / Qdrant | Chat history, email, contacts |
+| **L6** | Documents | Declarative memory | SQLite FTS5 | PDFs, docs, arena-based retrieval |
+
+## Quick Start
+
+```bash
+pip install rewind-memory
+
+# Minimal — zero external dependencies
+python -c "
+from rewind.client import RewindClient
+client = RewindClient()
+results = client.search('what is Hebbian learning')
+for r in results:
+    print(f'{r.score:.2f} [{r.layer}] {r.text[:80]}')
+"
+```
+
+### With production backends
+
+```bash
+pip install rewind-memory[all]  # includes neo4j, qdrant-client, etc.
+```
+
+## Configuration Tiers
+
+```python
+from rewind.config import default_config
+
+# Core (Free) — local SQLite only, zero external deps
+config = default_config("free")
+
+# Pro — all layers, optional Neo4j/Qdrant migration
+config = default_config("pro")
+
+# MOS (Enterprise) — full stack + bio lifecycle
+config = default_config("enterprise")
+```
+
+| Feature | Core (Free) | Pro ($9/mo) | MOS (Custom) |
+|---------|-------------|-------------|--------------|
+| L0 Full-text search (FTS5) | ✅ | ✅ | ✅ |
+| L1 System memory (sqlite-vec) | ✅ | ✅ | ✅ |
+| L2 HybridRAG fusion | basic | full | full |
+| L3 Knowledge graph | ✅ SQLite | ✅ SQLite or Neo4j | ✅ Neo4j |
+| L4 Semantic vector search | ✅ sqlite-vec | ✅ sqlite-vec or Qdrant | ✅ Qdrant |
+| L5 Communications memory | ❌ | ✅ | ✅ |
+| L6 Document store | ❌ | ✅ | ✅ |
+| Query orchestrator | ❌ | ✅ | ✅ |
+| Retrieval feedback learning | ❌ | ✅ | ✅ |
+| Cloud GPU embeddings | ❌ | ✅ 100K/mo | Custom |
+| Migration assist (SQLite → Neo4j/Qdrant) | — | ✅ | — |
+| Bio lifecycle (decay, consolidation, pruning) | ❌ | ❌ | ✅ |
+| Air-gapped deployment | ❌ | ❌ | ✅ |
+| Custom graph schemas | ❌ | ❌ | ✅ |
+| Dedicated engineer + SLA | ❌ | ❌ | ✅ |
+| API Server | ✅ | ✅ | ✅ |
+
+### Backend Flexibility (Pro)
+
+Pro users can keep running on SQLite (zero-dependency) or upgrade to production backends locally:
+
+```bash
+# Migrate graph from SQLite to Neo4j
+rewind migrate --backend neo4j --uri bolt://localhost:7687
+
+# Migrate vectors from sqlite-vec to Qdrant
+rewind migrate --backend qdrant --url http://localhost:6333
+
+# Both migrations preserve all data and validate counts
+```
+
+## API Server
+
+```bash
+# Start the server
+python -m rewind.api.server --tier pro --port 8080
+
+# Search
+curl -X POST http://localhost:8080/v1/search \
+  -H "Content-Type: application/json" \
+  -d '{"query": "memory consolidation", "limit": 10}'
+
+# Convenience GET
+curl "http://localhost:8080/search?q=memory+consolidation&limit=10"
+
+# Health check
+curl http://localhost:8080/health
+
+# Stats
+curl http://localhost:8080/stats
+```
+
+### Authentication
+
+Set `REWIND_API_KEY` environment variable or pass keys programmatically:
+
+```bash
+REWIND_API_KEY=sk-your-key python -m rewind.api.server
+```
+
+```bash
+curl http://localhost:8080/v1/search \
+  -H "X-API-Key: sk-your-key" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "test"}'
+```
+
+## Docker Deployment
+
+```bash
+cd docker
+
+# Full stack (Neo4j + Qdrant + Rewind API)
+docker compose up -d
+
+# Just the API
+docker build -f Dockerfile -t rewind ..
+docker run -p 8080:8080 rewind
+```
+
+## Bio-Inspired Features
+
+> Available on MOS (Enterprise) tier only.
+
+### Hebbian Learning
+*"Neurons that fire together wire together."*
+
+When a search result is accessed, its connections to co-occurring results strengthen. Frequently co-retrieved memories form stronger associations over time, just like synaptic potentiation.
+
+### Spreading Activation
+Queries activate not just direct matches but related concepts through the graph layer (L3). Activating "memory" spreads to "hippocampus", "consolidation", "encoding" — mimicking how biological neural networks propagate signals.
+
+### Decay (Ebbinghaus Forgetting Curve)
+Memories lose confidence over time following an exponential decay curve: `C(t) = C₀ · e^(-λt)`. Frequently accessed memories decay slower (reduced λ), mirroring spaced repetition effects. A minimum confidence floor prevents complete forgetting.
+
+### Consolidation
+Periodically, high-value short-term memories (L1) are consolidated into long-term graph storage (L3), similar to how sleep consolidates hippocampal memories into neocortical storage.
+
+### Pruning
+Low-confidence memories below a threshold are pruned to prevent unbounded growth — analogous to synaptic pruning during development.
+
+## Development
+
+```bash
+git clone https://github.com/sarai-defence/rewind-memory.git
+cd rewind
+pip install -e ".[dev]"
+pytest tests/
+```
+
+## License
+
+Elastic License 2.0

rewind_memory-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rewind-memory"
+version = "0.1.0"
+description = "Bio-inspired persistent memory for AI agents. 5-layer architecture with FTS5, vector search, knowledge graph, and HybridRAG fusion."
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.10"
+authors = [{name = "SARAI Defence", email = "vova@saraidefence.com"}]
+keywords = ["memory", "ai", "agents", "rag", "bio-inspired", "knowledge-graph"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "pyyaml>=6.0",
+    "httpx>=0.24",
+]
+
+[project.optional-dependencies]
+vector = ["sqlite-vec>=0.0.1"]
+mcp = ["httpx>=0.24"]
+dev = ["pytest>=7.0", "ruff>=0.1"]
+
+[project.scripts]
+rewind = "rewind.__main__:main"
+rewind-mcp = "rewind.integrations.mcp_server:main"
+rewind-openclaw = "rewind.integrations.openclaw:main"
+
+[project.urls]
+Homepage = "https://saraidefence.com"
+Documentation = "https://saraidefence.com/docs"
+Repository = "https://github.com/saraidefence/rewind-memory"
+
+[tool.setuptools.packages.find]
+include = ["rewind*"]

rewind_memory-0.1.0/rewind/__init__.py

@@ -0,0 +1,7 @@
+"""Rewind — 7-layer bio-inspired memory architecture for AI agents."""
+
+__version__ = "0.1.0"
+
+from rewind.client import RewindClient
+
+__all__ = ["RewindClient", "__version__"]

rewind_memory-0.1.0/rewind/__main__.py

@@ -0,0 +1,213 @@
+"""Rewind CLI — memory stack for AI agents.
+
+Usage:
+    rewind ingest <path> [--tier free|pro|enterprise] [--db ./data/vector.db]
+    rewind search <query> [--tier free|pro|enterprise] [--limit 10]
+    rewind health [--tier free|pro|enterprise]
+    rewind stats
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+
+
+def cmd_ingest(args: argparse.Namespace) -> None:
+    """Ingest files into the memory stack."""
+    from rewind.config import default_config
+    from rewind.ingest import IngestPipeline
+    from pathlib import Path
+
+    cfg = default_config(args.tier)
+    if args.db:
+        cfg.vector_db_path = args.db
+
+    pipeline = IngestPipeline(cfg)
+
+    path = Path(args.path)
+    if path.is_dir():
+        stats = pipeline.ingest_directory(str(path))
+    elif path.is_file():
+        stats = pipeline.ingest_file(str(path))
+    else:
+        print(f"Error: {args.path} not found", file=sys.stderr)
+        sys.exit(1)
+
+    pipeline.close()
+
+    # Print summary
+    print(f"Files:    {stats.get('files', 1)}")
+    print(f"Chunks:   {stats.get('chunks', 0)}")
+    print(f"Vectors:  {stats.get('vectors', 0)}")
+    print(f"Entities: {stats.get('entities', 0)}")
+    if "elapsed_seconds" in stats:
+        print(f"Time:     {stats['elapsed_seconds']}s")
+    if stats.get("errors"):
+        print(f"Errors:   {stats['errors']}")
+
+
+def cmd_search(args: argparse.Namespace) -> None:
+    """Search the memory stack."""
+    from rewind.client import RewindClient
+    from rewind.config import default_config
+
+    cfg = default_config(args.tier)
+    if args.db:
+        cfg.vector_db_path = args.db
+
+    client = RewindClient(cfg)
+    results = client.search(args.query, limit=args.limit)
+    client.close()
+
+    if not results:
+        print("No results found.")
+        return
+
+    if args.json:
+        print(json.dumps([{
+            "score": r.score, "layer": r.layer,
+            "path": r.path, "text": r.text[:200],
+        } for r in results], indent=2))
+    else:
+        for i, r in enumerate(results, 1):
+            print(f"\n{'─' * 60}")
+            print(f"  #{i}  score={r.score:.3f}  layer={r.layer}")
+            if r.path:
+                print(f"  path: {r.path}")
+            print(f"  {r.text[:200]}")
+
+
+def cmd_health(args: argparse.Namespace) -> None:
+    """Health check."""
+    from rewind.client import RewindClient
+    from rewind.config import default_config
+
+    cfg = default_config(args.tier)
+    if args.db:
+        cfg.vector_db_path = args.db
+
+    client = RewindClient(cfg)
+    health = client.health()
+    client.close()
+
+    print(f"Tier:         {health['tier']}")
+    print(f"Orchestrator: {'✅' if health['orchestrator'] else '❌'}")
+    print(f"Bio:          {'✅' if health['bio'] else '❌'}")
+    print(f"Healthy:      {'✅' if health['healthy'] else '❌'}")
+    print()
+    for name, status in health.get("layers", {}).items():
+        s = status.get("status", "unknown")
+        icon = "✅" if s == "ok" else "❌" if s == "error" else "⚠️"
+        extra = ""
+        if "nodes" in status:
+            extra = f" ({status['nodes']} nodes, {status.get('edges', 0)} edges)"
+        elif "total_chunks" in status:
+            extra = f" ({status['total_chunks']} chunks)"
+        elif "backend" in status:
+            extra = f" ({status['backend']})"
+        print(f"  {icon} {name}: {s}{extra}")
+
+
+def cmd_migrate(args: argparse.Namespace) -> None:
+    """Migrate SQLite backends to Neo4j/Qdrant."""
+    from rewind.migrate import Migrator
+
+    db = args.db or "./data/vector.db"
+    migrator = Migrator(sqlite_db=db)
+
+    if args.subcmd == "status":
+        import json
+        print(json.dumps(migrator.status(), indent=2))
+        return
+
+    if args.subcmd == "graph":
+        result = migrator.migrate_graph_to_neo4j(
+            uri=args.uri or "bolt://localhost:7687",
+            user=args.user or "neo4j",
+            password=args.password or "",
+            dry_run=args.dry_run,
+        )
+    elif args.subcmd == "vectors":
+        result = migrator.migrate_vectors_to_qdrant(
+            qdrant_url=args.uri or "http://localhost:6333",
+            collection=args.collection or "rewind_chunks",
+            dry_run=args.dry_run,
+        )
+    else:
+        print("Usage: rewind migrate {status|graph|vectors}", file=sys.stderr)
+        sys.exit(1)
+
+    if "error" in result:
+        print(f"Error: {result['error']}", file=sys.stderr)
+        sys.exit(1)
+
+    import json
+    print(json.dumps(result, indent=2))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="rewind",
+        description="Rewind — bio-inspired memory stack for AI agents",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true",
+        help="Enable debug logging",
+    )
+
+    sub = parser.add_subparsers(dest="command")
+
+    # ingest
+    p_ingest = sub.add_parser("ingest", help="Ingest files into memory")
+    p_ingest.add_argument("path", help="File or directory to ingest")
+    p_ingest.add_argument("--tier", default="free", choices=["free", "pro", "enterprise"])
+    p_ingest.add_argument("--db", default=None, help="Path to vector DB")
+
+    # search
+    p_search = sub.add_parser("search", help="Search memory")
+    p_search.add_argument("query", help="Search query")
+    p_search.add_argument("--tier", default="free", choices=["free", "pro", "enterprise"])
+    p_search.add_argument("--db", default=None, help="Path to vector DB")
+    p_search.add_argument("--limit", type=int, default=10)
+    p_search.add_argument("--json", action="store_true", help="Output JSON")
+
+    # health
+    p_health = sub.add_parser("health", help="Health check")
+    p_health.add_argument("--tier", default="free", choices=["free", "pro", "enterprise"])
+    p_health.add_argument("--db", default=None, help="Path to vector DB")
+
+    # migrate
+    p_migrate = sub.add_parser("migrate", help="Migrate backends (Pro)")
+    p_migrate.add_argument("subcmd", choices=["status", "graph", "vectors"],
+                           help="Migration target")
+    p_migrate.add_argument("--db", default=None, help="Path to SQLite DB")
+    p_migrate.add_argument("--uri", default=None, help="Target URI (bolt:// or http://)")
+    p_migrate.add_argument("--user", default="neo4j", help="Neo4j username")
+    p_migrate.add_argument("--password", default="", help="Neo4j password")
+    p_migrate.add_argument("--collection", default="rewind_chunks", help="Qdrant collection")
+    p_migrate.add_argument("--dry-run", action="store_true", help="Report only, don't write")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        logging.basicConfig(level=logging.DEBUG, format="%(levelname)s %(name)s: %(message)s")
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    if args.command == "ingest":
+        cmd_ingest(args)
+    elif args.command == "search":
+        cmd_search(args)
+    elif args.command == "health":
+        cmd_health(args)
+    elif args.command == "migrate":
+        cmd_migrate(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()