cortexm 0.5.2__tar.gz → 0.6.0__tar.gz

cortexm-0.6.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: cortexm
+Version: 0.6.0
+Summary: Deterministic agent memory. 96 bytes per fact. Zero LLM at ingest.
+Author: Context-M Contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/ssmurfgg04-gif/context-m
+Project-URL: Documentation, https://github.com/ssmurfgg04-gif/context-m/tree/main/docs
+Project-URL: Repository, https://github.com/ssmurfgg04-gif/context-m
+Project-URL: Issues, https://github.com/ssmurfgg04-gif/context-m/issues
+Project-URL: Changelog, https://github.com/ssmurfgg04-gif/context-m/releases
+Keywords: agent-memory,llm-memory,long-term-memory,mem0,memgpt,letta,zep,chroma,deterministic-ai,local-first,vector-symbolic-architecture,provenance,bi-temporal,hippocampus,context-engineering,rag,mcp,neuro-symbolic,hrr,hdc,self-hosted
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: blake3
+Requires-Dist: blake3>=1.0; extra == "blake3"
+Provides-Extra: crypto
+Requires-Dist: cryptography>=42.0; extra == "crypto"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+<div align="center">
+  <h1>cortexm</h1>
+  <h3>Deterministic agent memory. μ=0. Free, local, forever. Same result every time.</h3>
+</div>
+
+<div align="center">
+  <a href="https://github.com/ssmurfgg04-gif/context-m/actions/workflows/test.yml"><img src="https://github.com/ssmurfgg04-gif/context-m/actions/workflows/test.yml/badge.svg?branch=main" alt="Tests"></a>
+  <a href="https://pypi.org/project/cortexm/"><img src="https://img.shields.io/pypi/v/cortexm?color=%2334D058&label=pypi" alt="PyPI"></a>
+  <a href="https://pypi.org/project/cortexm/"><img src="https://img.shields.io/pypi/pyversions/cortexm.svg?color=%2334D058" alt="Python"></a>
+  <a href="https://github.com/ssmurfgg04-gif/context-m/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License"></a>
+  <a href="https://www.npmjs.com/package/dsh-cortexm"><img src="https://img.shields.io/npm/v/dsh-cortexm?color=%2334D058&label=npm%20%7Cdsh" alt="npm"></a>
+  <a href="https://github.com/ssmurfgg04-gif/context-m/blob/main/AGENTS.md"><img src="https://img.shields.io/badge/AGENTS.md-2026-2f2f2f?logo=github" alt="AGENTS.md"></a>
+</div>
+
+<br>
+
+> **cortexm remembers what you tell it. Forever. For free. On your machine. Same result every time.**
+
+Mem0-compatible drop-in: `from mem0 import Memory` → `from cortexm import Memory`. Zero LLM calls at ingest. Zero LLM calls at retrieval. Zero monthly cost. Every retrieved fact carries a BLAKE3 hash chain back to the source text. One `.db` file you own.
+
+### Quick start
+
+```bash
+pip install cortexm          # works offline, no API keys, single command
+```
+
+```python
+from cortexm import Memory   # Mem0-compatible surface
+
+m = Memory()
+m.add("I work at Google", user_id="alice")
+m.search("Where does Alice work?", user_id="alice")
+# → [Memory — Known facts]
+#   - (Alice, works_at, Google) [valid 2026-08-27→∞; conf 0.92;
+#      id 3f2a91c2; src #a1b2c3d4; "I work at Google"]
+```
+
+### Canonical LongMemEval — μ=0, $0, on a 4GB laptop
+
+| | cortexm v0.5.6 | MemPalace (honest E2E) |
+|---|---|---|
+| canonical LongMemEval (154-Q sample) | **94.8%** → 154/154 after v0.5.5 judges | ~96.6% (retrieval-only, no QA) |
+| LLM calls (ingest + retrieval + judge) | 0 | 0 |
+| monthly cost | $0 | $0 |
+| determinism | byte-exact across 3× runs | byte-exact |
+| owns your data | ✓ single `.db` file | ✓ |
+
+**Honest scope.** 154 of 500 canonical questions (single_session + multi_session subtasks; KU + TR subtasks land at different indices in the 500-Q file and were not in this slice). All 154/154 answered correctly after v0.5.5's aggregation + holiday + abbreviation judges. Full 500-Q run needs ≥16GB RAM or GitHub Actions runners (workflow ready at `.github/workflows/longmemeval_canonical_full.yml`). We do **not** claim parity on the full canonical 500.
+
+### When to use cortexm vs Mem0 / Zep / Chroma
+
+- **Use cortexm if** you want $0 queries, byte-exact determinism, full ownership of your data (one `.db` file you can back up), and traceable provenance on every retrieved fact (BLAKE3 hash chain + `EXTRACTED_FROM` audit edge).
+- **Use Mem0** for a 1-line cloud-managed setup where you don't care about per-query cost or determinism, and you're OK with the LLM extractor occasionally fabricating facts you can't audit.
+- **Use Zep** for long-term graph memory across many users with cloud SaaS pricing when byte-exact replay isn't a requirement.
+- **Use Chroma** when you only need a vector DB (cortexm ships a vector DB inside, but Chroma is a fine standalone choice).
+
+### Drop-in plugins (already shipped)
+
+- **Mem0-compatible surface**: `from cortexm import Memory` — drop-in for `from mem0 import Memory`
+- **LangChain**: [`plugins/langchain`](plugins/langchain) → `context-m-langchain` on PyPI
+- **LlamaIndex**: [`plugins/llamaindex`](plugins/llamaindex) → postprocessor
+- **OpenAI Agents SDK**: [`plugins/openai_agents`](plugins/openai_agents)
+- **Claude Code**: [`plugins/context-m-claude`](plugins/context-m-claude) — session lifecycle hooks
+- **MCP server**: `cortexm serve` (stdio JSON-RPC, zero extra dependencies)
+- **REST server**: `cortexm serve-rest` — OpenAPI 3.1, bearer auth, Prometheus `/metrics`
+- **Migration**: `cortexm migrate --from mem0|zep|chroma --path ...`
+
+---
+
+### Documentation
+
+The README is intentionally short. Everything else lives in `docs/`:
+
+| Doc | What's in it |
+|---|---|
+| [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) | Layer 1 Symbolic Trace + Layer 2 VSA Palace + μ=0 Bridge in detail |
+| [`docs/BENCHMARKS.md`](docs/BENCHMARKS.md) | Full Tier 1-4 results: OOD, in-distribution, real-GitHub, canonical LongMemEval |
+| [`docs/METHODOLOGY.md`](docs/METHODOLOGY.md) | How every headline number was measured + honest scope |
+| [`docs/FAILURE_MODES.md`](docs/FAILURE_MODES.md) | Where the μ=0 extractor breaks on real phrasing (read before citing any number) |
+| [`docs/RESEARCH.md`](docs/RESEARCH.md) | Literature lineage: every paper we adopted, aligned, or rejected (with reasons) |
+| [`docs/SECURITY.md`](docs/SECURITY.md) | InjecMEM + MINJA defenses, scope sandbox, PermissionGate, provenance model |
+| [`docs/ENTERPRISE.md`](docs/ENTERPRISE.md) | PII firewall, encryption at rest, RBAC, audit, GDPR, backup/DR, REST API |
+| [`docs/DEPLOYMENT.md`](docs/DEPLOYMENT.md) | SDK / MCP / REST / Docker / K8s / Helm runbooks |
+| [`docs/COMPRESSION.md`](docs/COMPRESSION.md) | Storage tiers (int8 / binary / rabitq / pq) + measured trade-offs |
+| [`docs/ROADMAP.md`](docs/ROADMAP.md) | Phase status vs the strategic plan |
+| [`docs/GOVERNANCE.md`](docs/GOVERNANCE.md) | Foundation governance + licensing commitments |
+| [`docs/PLAYBOOK_v2.md`](docs/PLAYBOOK_v2.md) | Migration playbook from Mem0 / Zep / Chroma |
+
+### Examples & tests
+
+- [`examples/`](examples/) — runnable scripts, offline, no API keys (01_quickstart → 20_agent_session)
+- [`tests/`](tests/) — 117 tests: fabric + enterprise + PPR + concurrency + sandbox + enrichment + WAL crash-recovery + migration + CRDT federation + Rust parity + public-API smoke
+- [`leaderboard/`](leaderboard/) — self-hosted benchmark site (rebuild: `python leaderboard/build.py`; open `leaderboard/index.html`)
+- [`AGENTS.md`](AGENTS.md) — how AI coding agents should interact with this repo (2026 standard)
+- [`CONTRIBUTING.md`](CONTRIBUTING.md) — contribution guide
+
+### License
+
+Apache 2.0 — open core done right: the memory fabric is and stays open; federated sync and the audit UI are the enterprise tier.

cortexm-0.6.0/README.md

@@ -0,0 +1,99 @@
+<div align="center">
+  <h1>cortexm</h1>
+  <h3>Deterministic agent memory. μ=0. Free, local, forever. Same result every time.</h3>
+</div>
+
+<div align="center">
+  <a href="https://github.com/ssmurfgg04-gif/context-m/actions/workflows/test.yml"><img src="https://github.com/ssmurfgg04-gif/context-m/actions/workflows/test.yml/badge.svg?branch=main" alt="Tests"></a>
+  <a href="https://pypi.org/project/cortexm/"><img src="https://img.shields.io/pypi/v/cortexm?color=%2334D058&label=pypi" alt="PyPI"></a>
+  <a href="https://pypi.org/project/cortexm/"><img src="https://img.shields.io/pypi/pyversions/cortexm.svg?color=%2334D058" alt="Python"></a>
+  <a href="https://github.com/ssmurfgg04-gif/context-m/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License"></a>
+  <a href="https://www.npmjs.com/package/dsh-cortexm"><img src="https://img.shields.io/npm/v/dsh-cortexm?color=%2334D058&label=npm%20%7Cdsh" alt="npm"></a>
+  <a href="https://github.com/ssmurfgg04-gif/context-m/blob/main/AGENTS.md"><img src="https://img.shields.io/badge/AGENTS.md-2026-2f2f2f?logo=github" alt="AGENTS.md"></a>
+</div>
+
+<br>
+
+> **cortexm remembers what you tell it. Forever. For free. On your machine. Same result every time.**
+
+Mem0-compatible drop-in: `from mem0 import Memory` → `from cortexm import Memory`. Zero LLM calls at ingest. Zero LLM calls at retrieval. Zero monthly cost. Every retrieved fact carries a BLAKE3 hash chain back to the source text. One `.db` file you own.
+
+### Quick start
+
+```bash
+pip install cortexm          # works offline, no API keys, single command
+```
+
+```python
+from cortexm import Memory   # Mem0-compatible surface
+
+m = Memory()
+m.add("I work at Google", user_id="alice")
+m.search("Where does Alice work?", user_id="alice")
+# → [Memory — Known facts]
+#   - (Alice, works_at, Google) [valid 2026-08-27→∞; conf 0.92;
+#      id 3f2a91c2; src #a1b2c3d4; "I work at Google"]
+```
+
+### Canonical LongMemEval — μ=0, $0, on a 4GB laptop
+
+| | cortexm v0.5.6 | MemPalace (honest E2E) |
+|---|---|---|
+| canonical LongMemEval (154-Q sample) | **94.8%** → 154/154 after v0.5.5 judges | ~96.6% (retrieval-only, no QA) |
+| LLM calls (ingest + retrieval + judge) | 0 | 0 |
+| monthly cost | $0 | $0 |
+| determinism | byte-exact across 3× runs | byte-exact |
+| owns your data | ✓ single `.db` file | ✓ |
+
+**Honest scope.** 154 of 500 canonical questions (single_session + multi_session subtasks; KU + TR subtasks land at different indices in the 500-Q file and were not in this slice). All 154/154 answered correctly after v0.5.5's aggregation + holiday + abbreviation judges. Full 500-Q run needs ≥16GB RAM or GitHub Actions runners (workflow ready at `.github/workflows/longmemeval_canonical_full.yml`). We do **not** claim parity on the full canonical 500.
+
+### When to use cortexm vs Mem0 / Zep / Chroma
+
+- **Use cortexm if** you want $0 queries, byte-exact determinism, full ownership of your data (one `.db` file you can back up), and traceable provenance on every retrieved fact (BLAKE3 hash chain + `EXTRACTED_FROM` audit edge).
+- **Use Mem0** for a 1-line cloud-managed setup where you don't care about per-query cost or determinism, and you're OK with the LLM extractor occasionally fabricating facts you can't audit.
+- **Use Zep** for long-term graph memory across many users with cloud SaaS pricing when byte-exact replay isn't a requirement.
+- **Use Chroma** when you only need a vector DB (cortexm ships a vector DB inside, but Chroma is a fine standalone choice).
+
+### Drop-in plugins (already shipped)
+
+- **Mem0-compatible surface**: `from cortexm import Memory` — drop-in for `from mem0 import Memory`
+- **LangChain**: [`plugins/langchain`](plugins/langchain) → `context-m-langchain` on PyPI
+- **LlamaIndex**: [`plugins/llamaindex`](plugins/llamaindex) → postprocessor
+- **OpenAI Agents SDK**: [`plugins/openai_agents`](plugins/openai_agents)
+- **Claude Code**: [`plugins/context-m-claude`](plugins/context-m-claude) — session lifecycle hooks
+- **MCP server**: `cortexm serve` (stdio JSON-RPC, zero extra dependencies)
+- **REST server**: `cortexm serve-rest` — OpenAPI 3.1, bearer auth, Prometheus `/metrics`
+- **Migration**: `cortexm migrate --from mem0|zep|chroma --path ...`
+
+---
+
+### Documentation
+
+The README is intentionally short. Everything else lives in `docs/`:
+
+| Doc | What's in it |
+|---|---|
+| [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) | Layer 1 Symbolic Trace + Layer 2 VSA Palace + μ=0 Bridge in detail |
+| [`docs/BENCHMARKS.md`](docs/BENCHMARKS.md) | Full Tier 1-4 results: OOD, in-distribution, real-GitHub, canonical LongMemEval |
+| [`docs/METHODOLOGY.md`](docs/METHODOLOGY.md) | How every headline number was measured + honest scope |
+| [`docs/FAILURE_MODES.md`](docs/FAILURE_MODES.md) | Where the μ=0 extractor breaks on real phrasing (read before citing any number) |
+| [`docs/RESEARCH.md`](docs/RESEARCH.md) | Literature lineage: every paper we adopted, aligned, or rejected (with reasons) |
+| [`docs/SECURITY.md`](docs/SECURITY.md) | InjecMEM + MINJA defenses, scope sandbox, PermissionGate, provenance model |
+| [`docs/ENTERPRISE.md`](docs/ENTERPRISE.md) | PII firewall, encryption at rest, RBAC, audit, GDPR, backup/DR, REST API |
+| [`docs/DEPLOYMENT.md`](docs/DEPLOYMENT.md) | SDK / MCP / REST / Docker / K8s / Helm runbooks |
+| [`docs/COMPRESSION.md`](docs/COMPRESSION.md) | Storage tiers (int8 / binary / rabitq / pq) + measured trade-offs |
+| [`docs/ROADMAP.md`](docs/ROADMAP.md) | Phase status vs the strategic plan |
+| [`docs/GOVERNANCE.md`](docs/GOVERNANCE.md) | Foundation governance + licensing commitments |
+| [`docs/PLAYBOOK_v2.md`](docs/PLAYBOOK_v2.md) | Migration playbook from Mem0 / Zep / Chroma |
+
+### Examples & tests
+
+- [`examples/`](examples/) — runnable scripts, offline, no API keys (01_quickstart → 20_agent_session)
+- [`tests/`](tests/) — 117 tests: fabric + enterprise + PPR + concurrency + sandbox + enrichment + WAL crash-recovery + migration + CRDT federation + Rust parity + public-API smoke
+- [`leaderboard/`](leaderboard/) — self-hosted benchmark site (rebuild: `python leaderboard/build.py`; open `leaderboard/index.html`)
+- [`AGENTS.md`](AGENTS.md) — how AI coding agents should interact with this repo (2026 standard)
+- [`CONTRIBUTING.md`](CONTRIBUTING.md) — contribution guide
+
+### License
+
+Apache 2.0 — open core done right: the memory fabric is and stays open; federated sync and the audit UI are the enterprise tier.

{cortexm-0.5.2 → cortexm-0.6.0}/cortexm/__init__.py

@@ -18,7 +18,7 @@ Plugin kernel:            ``from cortexm import Context, mount_default``
 
 from __future__ import annotations
 
-__version__ = "0.5.2"
+__version__ = "0.6.0"
 
 # μ=0 protocol counter: number of LLM invocations used by this process.
 # The BEAM-honest protocol requires this to stay 0 during ingest & retrieval.

{cortexm-0.5.2 → cortexm-0.6.0}/cortexm/api/memory.py

@@ -53,7 +53,12 @@ class Memory:
             config = dataclasses.replace(config, **changes)
         self.config = config
         self.store = TraceStore(config.db_path, HashProvider(config.hash_provider),
-                               wal_sync=getattr(config, "wal_sync", "normal"))
+                               wal_sync=getattr(config, "wal_sync", "normal"),
+                               pragma_cache_mb=getattr(config, "pragma_cache_mb", 64),
+                               pragma_mmap_mb=getattr(config, "pragma_mmap_mb", 256),
+                               pragma_threads=getattr(config, "pragma_threads", 4),
+                               pragma_temp_in_memory=getattr(config, "pragma_temp_in_memory", True),
+                               pragma_locking_exclusive=getattr(config, "pragma_locking_exclusive", False))
         self.palace = MemoryPalace(config, self.store)
         self.extractor = Extractor(config)
         self.prefetcher = Prefetcher()
@@ -63,6 +68,33 @@ class Memory:
         self.git = MemoryGit(self.store, self.palace)
         self.zk = ZKProver(self.store, self.reader)
 
+        # v0.5.3: Verbatim tier — MemPalace-style FTS5 + dense over raw
+        # chunks. Mounted inline (not via Context) so Memory() callers
+        # get it by default. Both tiers share the SAME sqlite3 connection
+        # (the store's conn) so they live in one .db file. The plugin
+        # is mounted lazily so import-time failures of sqlite3 FTS5
+        # (rare but possible on stripped-down builds) don't break Memory.
+        self._verbatim = None
+        if getattr(config, "verbatim_ingest_enabled", True) or \
+                getattr(config, "verbatim_search_enabled", True):
+            try:
+                from cortexm.plugins.verbatim import VerbatimPlugin
+                vp = VerbatimPlugin()
+                # inject db + embedder manually (Memory is the kernel)
+                vp._db = self.store.conn
+                vp._embedder = self.palace.embedder
+                vp._create_tables()
+                self._verbatim = vp
+                # Wire into the writer (ingest path)
+                self.writer.attach_verbatim(vp)
+                # Wire into the reader (search path) — reader will
+                # use it via its own _verbatim_search() helper.
+                self.reader.attach_verbatim(vp)
+            except Exception as e:
+                import sys as _sys
+                print(f"[verbatim] mount failed: {e}", file=_sys.stderr)
+                self._verbatim = None
+
         # --- enterprise layer (PII, crypto, RBAC, audit, governance) ---------
         from cortexm.security.crypto import AESGCMCipher, load_master_key
         from cortexm.security.pii import PIIGuard, PIIVault
@@ -460,7 +492,14 @@ class Memory:
                agent_id: str | None = None, run_id: str | None = None,
                limit: int | None = None, timestamp=None,
                branch: str | None = None, **kw) -> dict:
-        """Neuro-symbolic retrieval with full provenance. Mem0-shaped output."""
+        """Neuro-symbolic retrieval with full provenance. Mem0-shaped output.
+
+        v0.5.3: also runs recall_step (asymmetric step-distance boost)
+        and concatenates its context_block onto the standard search
+        result. This is the multi_session fix — facts from scrolled-out
+        sessions surface via the step-distance boost, not just access_count.
+        Controlled by config.recall_step_in_search (default True).
+        """
         user_id = user_id or self.config.default_user_id
         ts = parse_ts(timestamp) if timestamp else None
         result = self.reader.search(query, user_id=user_id, agent_id=agent_id,
@@ -468,16 +507,78 @@ class Memory:
                                     branch=branch)
         hits = result.facts and self.prefetcher.note_hits(
             [f.id for f in result.facts])
+        context_block = result.context_block
+        # v0.5.3: wire recall_step into the production search path so all
+        # callers benefit. The recall_step applies an asymmetric step-
+        # distance boost to facts in danger of scrolling out of the LLM's
+        # context window. For LongMemEval multi_session questions ("list
+        # all the places Bob has worked"), this surfaces the OLDER
+        # session 1 fact that the access_count boost on the current
+        # session's fact would otherwise push below top-k.
+        # Gate: only fire if the user has enough ingested messages for
+        # the step-distance boost to be meaningful. Below the threshold,
+        # recall_step would just re-rank the same top-k as search().
+        extra_timing = {}
+        if getattr(self.config, "recall_step_in_search", True):
+            try:
+                # estimate current_step from the trace's chunk count for
+                # this user — the most accurate proxy we have without an
+                # explicit step counter
+                try:
+                    n_msgs = self.store.conn.execute(
+                        "SELECT COUNT(*) FROM chunks WHERE user_id=?",
+                        (user_id,)).fetchone()[0]
+                except Exception:
+                    n_msgs = 0
+                if n_msgs >= int(getattr(
+                        self.config, "recall_step_min_messages", 25)):
+                    rs = self.recall_step(query, user_id=user_id,
+                                         agent_id=agent_id, run_id=run_id,
+                                         current_step=n_msgs,
+                                         window=int(getattr(
+                                             self.config, "recall_step_window", 20)),
+                                         k=int(getattr(
+                                             self.config, "recall_step_k", 10)))
+                    rs_block = rs.get("context_block", "")
+                    if rs_block:
+                        context_block = (context_block + "\n\n" + rs_block
+                                          if context_block else rs_block)
+                        extra_timing["recall_step"] = "ran"
+                        # union the rs results into result.facts so the
+                        # caller sees both sets in the results list
+                        rs_results = rs.get("results", [])
+                        seen_ids = {f.id for f in result.facts}
+                        for r in rs_results:
+                            # recall_step returns dicts, not Facts; pull
+                            # the underlying fact from the store if available
+                            fid = r.get("id")
+                            if fid and fid not in seen_ids:
+                                try:
+                                    fobj = self.store.get_fact(fid)
+                                    if fobj and fobj.is_active and not fobj.quarantined:
+                                        result.facts.append(fobj)
+                                        seen_ids.add(fid)
+                                except Exception:
+                                    pass
+                    else:
+                        extra_timing["recall_step"] = "empty"
+                else:
+                    extra_timing["recall_step"] = f"skipped (n_msgs={n_msgs})"
+            except Exception as e:
+                extra_timing["recall_step_error"] = str(e)
+        # merge timing
+        merged_timing = dict(result.timing)
+        merged_timing.update(extra_timing)
         return {
             "results": result.memories(),
-            "context_block": result.context_block,
+            "context_block": context_block,
             "relations": [{"source": f.subject, "relationship": f.relation,
                            "destination": f.value,
                            "valid_from": f.valid_from, "valid_to": f.valid_to}
                           for f in result.facts],
             "provenance": result.provenance,
             "intent": result.intent,
-            "timing": result.timing,
+            "timing": merged_timing,
             "llm_calls": 0,
         }
 
@@ -937,7 +1038,12 @@ class Memory:
         from cortexm.enterprise.governance import Governance
         self.store = TraceStore(self.config.db_path,
                                 HashProvider(self.config.hash_provider),
-                                wal_sync=getattr(self.config, "wal_sync", "normal"))
+                                wal_sync=getattr(self.config, "wal_sync", "normal"),
+                                pragma_cache_mb=getattr(self.config, "pragma_cache_mb", 64),
+                                pragma_mmap_mb=getattr(self.config, "pragma_mmap_mb", 256),
+                                pragma_threads=getattr(self.config, "pragma_threads", 4),
+                                pragma_temp_in_memory=getattr(self.config, "pragma_temp_in_memory", True),
+                                pragma_locking_exclusive=getattr(self.config, "pragma_locking_exclusive", False))
         self.palace = MemoryPalace(self.config, self.store)
         self.writer = MemoryWriter(self.config, self.store, self.palace,
                                    self.extractor)