nexor-mneme 0.1.0__tar.gz

nexor_mneme-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+.venv/
+.ruff_cache/
+.pytest_cache/
+.mypy_cache/
+dist/
+build/
+*.egg-info/
+.codegraph-nightly.log

nexor_mneme-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: nexor-mneme
+Version: 0.1.0
+Summary: Open memory engine + code intelligence for AI agents
+Project-URL: Homepage, https://github.com/nexorhq/nexor-mneme
+Project-URL: Repository, https://github.com/nexorhq/nexor-mneme
+Author: Giovanni Consiglio
+License-Expression: MIT
+Keywords: ai-agents,code-intelligence,knowledge-graph,memory,nexor,rag,scip
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.12
+Requires-Dist: asyncpg>=0.29
+Requires-Dist: httpx>=0.27
+Requires-Dist: nexor-core>=0.1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: qdrant-client>=1.7
+Requires-Dist: redis>=5.0
+Provides-Extra: codegraph
+Requires-Dist: tree-sitter-languages>=1.10; extra == 'codegraph'
+Requires-Dist: tree-sitter<0.22,>=0.21; extra == 'codegraph'
+Provides-Extra: hybrid
+Requires-Dist: flagembedding>=1.2; extra == 'hybrid'
+Provides-Extra: mcp
+Requires-Dist: httpx>=0.27; extra == 'mcp'
+Requires-Dist: mcp>=1.2; extra == 'mcp'
+Provides-Extra: scip
+Requires-Dist: protobuf>=5; extra == 'scip'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110; extra == 'server'
+Requires-Dist: uvicorn>=0.30; extra == 'server'
+Description-Content-Type: text/markdown
+
+# nexor-mneme
+
+> Persistent memory + code-intelligence for AI agents — a knowledge layer you self-host.
+
+`nexor-mneme` is the open memory engine of the [Nexor](https://github.com/nexorhq) project
+(*mneme*, μνήμη — "memory"). It gives agents long-term semantic memory **and** a queryable
+structural map of your codebase, so they answer *"what did we decide"* and *"what calls this
+function / what's the blast radius"* without re-reading everything.
+
+Dependency-light core; heavier capabilities are optional extras. Run it standalone — **no
+dependency on anyone's personal orchestrator or daemon**.
+
+## What's inside
+
+- **Semantic memory** — hybrid (dense+sparse) retrieval over Qdrant, cross-encoder reranking,
+  forgetting, contradiction & entity resolution, auto-profile.
+- **Progressive layering (L0→L3)** — a semantic pyramid with provenance + deterministic
+  drill-down from an abstraction to its evidence.
+- **Code structure graph** — multi-language (Python via stdlib `ast`; JS/TS/Go via tree-sitter),
+  precise resolution via **SCIP** ingest, blast-radius queries, PageRank repo-map, community
+  detection, incremental cache — landed in Apache AGE.
+- **Symbolic task memory** — Mermaid task canvases with offload-by-reference.
+- **Obsidian export** — a human-browsable, interlinked vault of the whole graph.
+- **Standalone service** — a FastAPI server + docker-compose (`server` extra).
+
+## Install
+
+```bash
+pip install nexor-mneme                 # core memory + code graph (Python)
+pip install "nexor-mneme[codegraph]"    # + tree-sitter (JS/TS/Go)
+pip install "nexor-mneme[scip]"         # + SCIP precise resolution
+pip install "nexor-mneme[server]"       # + FastAPI standalone service
+```
+
+## Run your own instance
+
+```bash
+git clone https://github.com/nexorhq/nexor-mneme && cd nexor-mneme/deploy
+docker compose up -d                    # API on http://localhost:8200
+curl http://localhost:8200/health
+```
+
+See the [deploy guide](https://github.com/nexorhq/nexor-mneme/blob/main/deploy/README.md).
+
+## License
+
+MIT — see [LICENSE](https://github.com/nexorhq/nexor-mneme/blob/main/LICENSE).

nexor_mneme-0.1.0/README.md

@@ -0,0 +1,47 @@
+# nexor-mneme
+
+> Persistent memory + code-intelligence for AI agents — a knowledge layer you self-host.
+
+`nexor-mneme` is the open memory engine of the [Nexor](https://github.com/nexorhq) project
+(*mneme*, μνήμη — "memory"). It gives agents long-term semantic memory **and** a queryable
+structural map of your codebase, so they answer *"what did we decide"* and *"what calls this
+function / what's the blast radius"* without re-reading everything.
+
+Dependency-light core; heavier capabilities are optional extras. Run it standalone — **no
+dependency on anyone's personal orchestrator or daemon**.
+
+## What's inside
+
+- **Semantic memory** — hybrid (dense+sparse) retrieval over Qdrant, cross-encoder reranking,
+  forgetting, contradiction & entity resolution, auto-profile.
+- **Progressive layering (L0→L3)** — a semantic pyramid with provenance + deterministic
+  drill-down from an abstraction to its evidence.
+- **Code structure graph** — multi-language (Python via stdlib `ast`; JS/TS/Go via tree-sitter),
+  precise resolution via **SCIP** ingest, blast-radius queries, PageRank repo-map, community
+  detection, incremental cache — landed in Apache AGE.
+- **Symbolic task memory** — Mermaid task canvases with offload-by-reference.
+- **Obsidian export** — a human-browsable, interlinked vault of the whole graph.
+- **Standalone service** — a FastAPI server + docker-compose (`server` extra).
+
+## Install
+
+```bash
+pip install nexor-mneme                 # core memory + code graph (Python)
+pip install "nexor-mneme[codegraph]"    # + tree-sitter (JS/TS/Go)
+pip install "nexor-mneme[scip]"         # + SCIP precise resolution
+pip install "nexor-mneme[server]"       # + FastAPI standalone service
+```
+
+## Run your own instance
+
+```bash
+git clone https://github.com/nexorhq/nexor-mneme && cd nexor-mneme/deploy
+docker compose up -d                    # API on http://localhost:8200
+curl http://localhost:8200/health
+```
+
+See the [deploy guide](https://github.com/nexorhq/nexor-mneme/blob/main/deploy/README.md).
+
+## License
+
+MIT — see [LICENSE](https://github.com/nexorhq/nexor-mneme/blob/main/LICENSE).

nexor_mneme-0.1.0/pyproject.toml

@@ -0,0 +1,61 @@
+[project]
+name = "nexor-mneme"
+version = "0.1.0"
+description = "Open memory engine + code intelligence for AI agents"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [{ name = "Giovanni Consiglio" }]
+keywords = [
+    "nexor",
+    "ai-agents",
+    "memory",
+    "code-intelligence",
+    "knowledge-graph",
+    "rag",
+    "scip",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "nexor-core>=0.1.0",
+    "redis>=5.0",
+    "asyncpg>=0.29",
+    "qdrant-client>=1.7",
+    "httpx>=0.27",
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+hybrid = ["FlagEmbedding>=1.2"]
+# Multi-language code structure graph (tree-sitter). Optional: the Python
+# extractor uses the stdlib ast and needs none of this.
+codegraph = ["tree-sitter-languages>=1.10", "tree-sitter>=0.21,<0.22"]
+# Precise resolution by ingesting SCIP indexes (scip-typescript/python/…).
+scip = ["protobuf>=5"]
+# Standalone deployable service (FastAPI) — run your own nexor-mneme instance.
+server = ["fastapi>=0.110", "uvicorn>=0.30"]
+# MCP server: expose a running nexor-mneme instance to Claude Code / any agent.
+mcp = ["mcp>=1.2", "httpx>=0.27"]
+
+[project.scripts]
+nexor-mneme-mcp = "nexor_memory.mcp_server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project.urls]
+Homepage = "https://github.com/nexorhq/nexor-mneme"
+Repository = "https://github.com/nexorhq/nexor-mneme"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/nexor_memory"]
+
+[tool.uv.sources]
+nexor-core = { workspace = true }

nexor_mneme-0.1.0/src/nexor_memory/__init__.py

@@ -0,0 +1,310 @@
+"""Nexor Memory — Memory layer (short-term, episodic, semantic).
+
+Sprint 2 additions: contradiction resolution, temporal extraction,
+entity resolution, cross-encoder reranking.
+
+Sprint 3 additions: category extraction, auto-profile generation,
+AST-aware code chunking.
+
+Sprint 5 additions: memory quality benchmark, semantic auto-forgetting.
+
+Sprint 6 additions: hybrid search (dense+sparse), HybridEmbedding,
+BGEM3HybridProvider, RRF fusion in Qdrant, migration script.
+"""
+
+__version__ = "0.6.0"
+
+from nexor_memory.auto_profile import (
+    AutoProfileGenerator,
+    UserProfile,
+    export_profile_markdown,
+)
+from nexor_memory.benchmark import (
+    ABComparison,
+    BenchmarkCategory,
+    BenchmarkQuestion,
+    BenchmarkRun,
+    MemoryBenchmarkRunner,
+    QuestionResult,
+    aggregate_results,
+    compare_runs,
+    evaluate_question,
+    format_ab_comparison,
+    format_benchmark_run,
+    load_default_test_set,
+)
+from nexor_memory.category_extractor import (
+    CategoryExtractor,
+    CategoryResult,
+    MemoryCategory,
+)
+from nexor_memory.code_chunker import (
+    CodeChunk,
+    chunk_code,
+    chunk_diff,
+    detect_language,
+)
+from nexor_memory.code_communities import (
+    Community,
+    communities,
+    detect_communities,
+)
+from nexor_memory.code_graph import (
+    SUPPORTED_EXTENSIONS,
+    CodeEdge,
+    CodeGraph,
+    CodeGraphBuilder,
+    CodeNode,
+    PythonAstExtractor,
+    TreeSitterExtractor,
+    build_code_graph,
+)
+from nexor_memory.code_graph_age import CodeGraphStore
+from nexor_memory.code_graph_cache import (
+    FileGraphCache,
+    file_sha256,
+)
+from nexor_memory.code_graph_sync import (
+    CodeGraphSync,
+    SourceSpec,
+    SyncResult,
+    build_for_spec,
+    load_sources,
+)
+from nexor_memory.code_repomap import (
+    rank_nodes,
+    ranked_symbols,
+    repo_map,
+)
+from nexor_memory.contradiction import (
+    ContradictionCheck,
+    ContradictionResolver,
+    ContradictionResult,
+    ResolutionStrategy,
+)
+from nexor_memory.embeddings import (
+    BaseEmbeddingProvider,
+    BGEM3HybridProvider,
+    FakeEmbeddingProvider,
+    HybridEmbedding,
+    OllamaEmbeddingProvider,
+)
+from nexor_memory.entity_resolution import (
+    EntityCatalog,
+    EntityResolver,
+    ResolvedEntity,
+    fuzzy_similarity,
+    levenshtein_distance,
+)
+from nexor_memory.episodic import (
+    BaseEpisodicMemory,
+    InMemoryEpisodicMemory,
+    PostgresEpisodicMemory,
+)
+from nexor_memory.forgetting import (
+    DEFAULT_ARCHIVE_THRESHOLD,
+    FORGETTABLE_COLLECTIONS,
+    PROTECTED_COLLECTIONS,
+    ForgettingResult,
+    RelevanceScore,
+    SemanticForgettingEngine,
+    compute_access_score,
+    compute_importance_score,
+    compute_recency_score,
+    format_forgetting_result,
+    score_memory,
+)
+from nexor_memory.layering import (
+    DEFAULT_TIER,
+    TIER_BY_COLLECTION,
+    LayeredMemory,
+    MemoryTier,
+    ProvenanceRef,
+)
+from nexor_memory.lifecycle import (
+    cleanup_old_events,
+    generate_daily_summary,
+    generate_weekly_summary,
+)
+from nexor_memory.observation import (
+    Observation,
+    ObservationCompressor,
+    RawToolEvent,
+    should_compress,
+)
+from nexor_memory.obsidian_export import (
+    MemoryRecord,
+    ObsidianVaultWriter,
+    VaultNote,
+    code_graph_to_notes,
+    memories_to_notes,
+    slugify,
+)
+from nexor_memory.offload import (
+    DEFAULT_OFFLOAD_THRESHOLD,
+    OFFLOAD_COLLECTION,
+    LogOffloader,
+    OffloadResult,
+)
+from nexor_memory.reranker import (
+    CrossEncoderReranker,
+    RerankResult,
+    rerank_with_cross_encoder,
+)
+from nexor_memory.result_factory import result_from_tool_result
+from nexor_memory.scip_import import (
+    ScipDocument,
+    ScipOccurrence,
+    load_scip_index,
+    parse_scip_symbol,
+    scip_to_code_graph,
+)
+from nexor_memory.semantic import (
+    BaseSemanticMemory,
+    InMemorySemanticMemory,
+    QdrantSemanticMemory,
+)
+from nexor_memory.short_term import (
+    BaseShortTermMemory,
+    InMemoryShortTermMemory,
+    RedisShortTermMemory,
+)
+from nexor_memory.symbolic import (
+    SymbolicEdge,
+    SymbolicNode,
+    SymbolicTaskMemory,
+    TaskCanvas,
+)
+from nexor_memory.temporal import (
+    DateExtractor,
+    TemporalMetadata,
+    build_temporal_filter,
+    compute_temporal_boost,
+    filter_by_temporal_range,
+)
+from nexor_memory.warmup import WarmupSchedule
+
+__all__ = [
+    # Sprint 5 — Forgetting
+    "DEFAULT_ARCHIVE_THRESHOLD",
+    "DEFAULT_OFFLOAD_THRESHOLD",
+    "DEFAULT_TIER",
+    "FORGETTABLE_COLLECTIONS",
+    "OFFLOAD_COLLECTION",
+    "PROTECTED_COLLECTIONS",
+    "SUPPORTED_EXTENSIONS",
+    "TIER_BY_COLLECTION",
+    # Sprint 5 — Benchmark
+    "ABComparison",
+    # Existing
+    "AutoProfileGenerator",
+    "BGEM3HybridProvider",
+    "BaseEmbeddingProvider",
+    "BaseEpisodicMemory",
+    "BaseSemanticMemory",
+    "BaseShortTermMemory",
+    "BenchmarkCategory",
+    "BenchmarkQuestion",
+    "BenchmarkRun",
+    "CategoryExtractor",
+    "CategoryResult",
+    "CodeChunk",
+    "CodeEdge",
+    "CodeGraph",
+    "CodeGraphBuilder",
+    "CodeGraphStore",
+    "CodeGraphSync",
+    "CodeNode",
+    "Community",
+    "ContradictionCheck",
+    "ContradictionResolver",
+    "ContradictionResult",
+    "CrossEncoderReranker",
+    "DateExtractor",
+    "EntityCatalog",
+    "EntityResolver",
+    "FakeEmbeddingProvider",
+    "FileGraphCache",
+    "ForgettingResult",
+    "HybridEmbedding",
+    "InMemoryEpisodicMemory",
+    "InMemorySemanticMemory",
+    "InMemoryShortTermMemory",
+    "LayeredMemory",
+    "LogOffloader",
+    "MemoryBenchmarkRunner",
+    "MemoryCategory",
+    "MemoryRecord",
+    "MemoryTier",
+    "Observation",
+    "ObservationCompressor",
+    "ObsidianVaultWriter",
+    "OffloadResult",
+    "OllamaEmbeddingProvider",
+    "PostgresEpisodicMemory",
+    "ProvenanceRef",
+    "PythonAstExtractor",
+    "QdrantSemanticMemory",
+    "QuestionResult",
+    "RawToolEvent",
+    "RedisShortTermMemory",
+    "RelevanceScore",
+    "RerankResult",
+    "ResolutionStrategy",
+    "ResolvedEntity",
+    "ScipDocument",
+    "ScipOccurrence",
+    "SemanticForgettingEngine",
+    "SourceSpec",
+    "SymbolicEdge",
+    "SymbolicNode",
+    "SymbolicTaskMemory",
+    "SyncResult",
+    "TaskCanvas",
+    "TemporalMetadata",
+    "TreeSitterExtractor",
+    "UserProfile",
+    "VaultNote",
+    "WarmupSchedule",
+    "aggregate_results",
+    "build_code_graph",
+    "build_for_spec",
+    "build_temporal_filter",
+    "chunk_code",
+    "chunk_diff",
+    "cleanup_old_events",
+    "code_graph_to_notes",
+    "communities",
+    "compare_runs",
+    "compute_access_score",
+    "compute_importance_score",
+    "compute_recency_score",
+    "compute_temporal_boost",
+    "detect_communities",
+    "detect_language",
+    "evaluate_question",
+    "export_profile_markdown",
+    "file_sha256",
+    "filter_by_temporal_range",
+    "format_ab_comparison",
+    "format_benchmark_run",
+    "format_forgetting_result",
+    "fuzzy_similarity",
+    "generate_daily_summary",
+    "generate_weekly_summary",
+    "levenshtein_distance",
+    "load_default_test_set",
+    "load_scip_index",
+    "load_sources",
+    "memories_to_notes",
+    "parse_scip_symbol",
+    "rank_nodes",
+    "ranked_symbols",
+    "repo_map",
+    "rerank_with_cross_encoder",
+    "result_from_tool_result",
+    "scip_to_code_graph",
+    "score_memory",
+    "should_compress",
+    "slugify",
+]

nexor_mneme-0.1.0/src/nexor_memory/_scip/NOTICE.md

@@ -0,0 +1,13 @@
+# Vendored SCIP schema
+
+`scip.proto` is vendored from [sourcegraph/scip](https://github.com/sourcegraph/scip)
+(SCIP Code Intelligence Protocol), licensed **Apache-2.0**.
+
+`scip_pb2.py` is generated from it via `grpc_tools.protoc` and committed so that
+runtime only needs `protobuf` (the `scip` optional extra), not a protoc toolchain.
+
+To regenerate after updating `scip.proto`:
+
+```bash
+python -m grpc_tools.protoc -I. --python_out=. scip.proto
+```