cortexlayer 0.1.0__py3-none-any.whl

cortexlayer-0.1.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.4
+Name: cortexlayer
+Version: 0.1.0
+Summary: Cortex: a memory layer for AI agents (linked pages + link-expansion retrieval) — hosted client and embedded engine.
+License-Expression: Apache-2.0
+Keywords: memory,agents,llm,mcp,rag,cortex
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: httpx>=0.27
+Provides-Extra: local
+Requires-Dist: chromadb>=1.0; extra == "local"
+Requires-Dist: spacy>=3.7; extra == "local"
+Provides-Extra: dev
+Requires-Dist: cortexlayer[local]; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Dynamic: license-file
+
+# cortexlayer
+
+Python library for **Cortex**, a memory layer for AI agents. Cortex stores memories as linked
+pages and retrieves with vector search **plus link-expansion**, so multi-hop facts come back
+without over-fetching a large top-k.
+
+Two ways to use it, with the same method names and result types:
+
+| | What it is | Install |
+|---|---|---|
+| **`Memory`** | The engine, embedded in your process. No server; data stays on your machine. | `pip install "cortexlayer[local]"` |
+| **`CortexClient`** | A client for a running Cortex server (hosted or self-hosted). | `pip install cortexlayer` |
+
+Python 3.10+. The client needs only `httpx`; the embedded engine adds Chroma and spaCy.
+
+> **Status: 0.1 (alpha), not yet on PyPI.** Local `Memory` has two engines: `raw` (default, no LLM)
+> and `facts` (Mem0-style LLM fact extraction; see below). The Cortex server runs on this same library:
+> its `facts` backend is `Memory(backend="facts")`, and it no longer depends on the `mem0ai` package.
+
+## Quickstart: embedded (`Memory`)
+
+```bash
+pip install "cortexlayer[local]"
+python -m spacy download en_core_web_sm     # recommended: better entity extraction
+```
+
+```python
+from cortexlayer import Memory
+
+m = Memory()                                 # ~/.cortexlayer, or Memory("path/to/dir")
+
+m.add("Christopher Nolan directed Inception.", user_id="alice")
+m.add("Christopher Nolan was born in London in 1970.", user_id="alice")
+m.relink(user_id="alice")                    # batch linking pass: run after adding several
+
+m.search("Who directed Inception?", user_id="alice", limit=1)
+# [SearchResult(title='Christopher Nolan directed Inception.', via='direct', …),
+#  SearchResult(title='Christopher Nolan was born in London in 1970.',
+#               via='link', linked_from='…')]   <- pulled in through the shared entity
+```
+
+- **One store, many users:** every call takes an optional `user_id`; each user gets an isolated
+  collection, so users can never see each other's pages. Omit it and the default user is used.
+- **Linking is a batch pass**, never per insert: call `relink()` after adding memories (or pass
+  `auto_relink=True` to relink after every `add`, which costs a scan of all pages).
+- **Local and private:** memories live in an embedded Chroma store under `data_dir`. Nothing leaves
+  your machine (Chroma's anonymous telemetry is switched off). Two one-time downloads: Chroma's small
+  ONNX embedding model on first use (~80 MB), and the spaCy model if you install it.
+- **No model? It still runs.** With `entity_extractor="auto"` (the default) `Memory` falls back to a
+  simpler regex extractor, with a one-time warning, if spaCy or its model is missing. Entities drive
+  linking, so the fallback finds fewer links. Force a choice with `"spacy"` or `"regex"`, or pass your
+  own object with `entities(text)` and `sentences(text)` methods.
+- **Short answers (optional):** `m.answer("Where did Alice move?")` retrieves and has an LLM distil a
+  direct answer plus the supporting page ids. It uses a local Ollama by default
+  (`$OLLAMA_HOST`); pass `chat=fn(prompt, model) -> str` to use any model.
+
+| `Memory` method | Returns |
+|---|---|
+| `add(text, user_id=, timestamp=)` | `AddResult` (long text is chunked into several pages) |
+| `search(query, user_id=, limit=4, expand_links=True)` | `list[SearchResult]` |
+| `get(id)` / `get_all(query=, limit=, offset=)` | `Page` / `PageList` |
+| `update(id, text)` / `delete(id)` / `delete_all(user_id=)` | `None` / `None` / count removed |
+| `relink()` / `count()` | `{"pages", "links_written"}` / `int` |
+| `answer(query, limit=, model=, chat=)` | `Answer(answer, source_page_ids)` |
+
+`Memory.from_config({...})` builds one from a dict (`data_dir`, `entity_extractor`, `spacy_model`,
+`default_user_id`, `auto_relink`, `backend`, `llm`, `embedder`, `custom_instructions`,
+`observation_date_from_timestamp`, `keyword_scoring`).
+
+### Fact memory: `Memory(backend="facts")`
+
+The default `raw` engine stores your text as small pages and never calls an LLM. `facts` works like
+Mem0: each `add` asks an LLM to distil the text into self-contained facts (resolving dates and pronouns),
+stores those, and boosts search results by the entities they share with your query.
+
+```python
+m = Memory(
+    backend="facts",
+    llm={"model": "qwen3.5:9b"},                                   # Ollama at $OLLAMA_HOST by default
+    embedder={"provider": "ollama", "model": "qwen3-embedding:8b"},  # default: Chroma's built-in ONNX model
+)
+m.add("[8 May, 2023] Caroline: I moved to Lisbon last week and adopted a dog named Max.", user_id="alice")
+m.search("What is Caroline's dog called?", user_id="alice")   # -> "Caroline adopted a dog named Max ..."
+```
+
+- **Same API** as the raw engine, including `relink()` and link-expansion (links are entity overlap over the
+  extracted facts).
+- **Bring your own model:** `llm` can be a dict, a callable `fn(system, user) -> str`, or any object with
+  `generate()`; `embedder` any object with `embed_batch(texts, action)` and a `name`. A store records which
+  embedder made its vectors and refuses to open with a different one.
+- **Failure is loud:** an unreachable LLM or embedder raises `LLMError` (nothing is stored). "The model found
+  nothing worth remembering" is a normal empty result.
+- **It costs an LLM call per `add`** (plus embeddings). The `raw` engine costs none.
+- **Relative dates:** like Mem0, the extractor resolves "yesterday" against *today* unless told the
+  conversation's date. `observation_date_from_timestamp=True` passes your `add(timestamp=...)` as that date.
+- **Exact words:** embedding scores are often compressed into a narrow band, so a fact that literally contains
+  a query word can rank below generic ones. Search fuses a BM25 keyword score by default (`keyword_scoring=False`
+  gives plain semantic + entity scoring, identical to Mem0 on Chroma; on a small LOCOMO subset it lifted F1 from 0.37 to 0.47 at the same token cost — not yet a
+  statistical result).
+- **Facts are ordinary pages:** each fact is stored as a page in the user's Chroma collection, so links are
+  persisted and `get` / `get_all` / `update` / `delete` work on facts exactly as on raw pages.
+- **Origin:** the extraction prompt and pipeline are adapted from [Mem0](https://github.com/mem0ai/mem0)
+  (Apache-2.0); cortexlayer does not depend on the `mem0ai` package. See `NOTICE`. The larger
+  multi-conversation comparison against Mem0 is still open.
+
+## Quickstart: hosted (`CortexClient`)
+
+```bash
+pip install cortexlayer
+```
+
+```python
+from cortexlayer import CortexClient
+
+client = CortexClient(api_key="...")        # or set CORTEX_API_KEY
+
+client.search("Where does Alice live?", limit=5)
+# [SearchResult(id='…', title='Alice moved to Lisbon in March.', via='direct', …),
+#  SearchResult(id='…', title='…', via='link', linked_from='…'), …]
+
+client.get_all(limit=50)                    # browse pages
+client.get(page_id)                         # one page + its links
+```
+
+Create a key in the Cortex web app (**Keys**). Point at a self-hosted server with
+`base_url="http://localhost:8000"` (or `CORTEX_BASE_URL`).
+
+Writes:
+
+```python
+client.add("I moved to Lisbon in March.")   # long text is chunked into several pages
+client.update(page_id, "…")
+client.delete(page_id)
+client.relink()                             # re-run the batch linking pass after adding several
+```
+
+> **Writes need a server with REST write endpoints** (added in Cortex server task 0073; the hosted
+> server has them). Against an older self-hosted server these four raise `WritesNotSupportedError`;
+> reads, search, graph and usage work on every version.
+
+### Async
+
+```python
+from cortexlayer import AsyncCortexClient
+
+async with AsyncCortexClient(api_key="...") as client:
+    hits = await client.search("Where does Alice live?")
+```
+
+Same methods, awaited.
+
+## Results
+
+Plain frozen dataclasses (no pydantic). Unknown fields from a newer server are ignored.
+
+| Call | Returns |
+|---|---|
+| `search(query, limit=4, expand_links=True)` | `list[SearchResult]` — `id, title, snippet, score, via, linked_from` |
+| `get(id)` | `Page` — `id, title, content, links, linked_from, degree, created_at` |
+| `get_all(query=None, limit=50, offset=0)` | `PageList` — `pages, total, limit, offset` |
+| `add(text, timestamp=None)` | `AddResult` — `page_ids` |
+| `me()` | `Account` — `user_id, account_name` |
+| `usage(group_by="day", since=None, until=None)` | `Usage` — your own API usage, by `day` / `key` / `operation` |
+| `graph(limit=None)`, `neighbors(id, depth=1)` | `Graph` — `nodes, edges, truncated, stale` |
+
+`via` is `"direct"` for a vector hit and `"link"` for a page pulled in by link-expansion
+(`linked_from` is the page that led to it). `score` semantics depend on the backend: on `raw` it is a
+distance (lower is closer); on `facts` it is the fused semantic + keyword + entity score (higher is
+closer). Compare within one store or server, not across.
+
+## Errors
+
+Every failure is a `CortexError`:
+
+| Exception | When |
+|---|---|
+| `InvalidRequestError` (also a `ValueError`) | bad arguments (caught before any request) or a server 400 |
+| `AuthenticationError` | 401 — key missing, wrong or revoked |
+| `PermissionDeniedError` | 403 — `.code` is the server's reason (`session_required`, …) |
+| `NotFoundError` | 404 — unknown page (another user's page looks the same) |
+| `ConflictError` | 409 |
+| `RateLimitError` | 429 — `.retry_after` seconds if sent |
+| `ServerError` | 5xx or an unreadable reply |
+| `ConnectionError` | no response (DNS, refused, timeout) |
+| `WritesNotSupportedError` | the server is too old to have REST write endpoints |
+| `CortexConfigError` | bad client configuration (e.g. no API key) |
+
+Reads and search are retried (default 2×, with backoff) on connection errors and 502/503/504.
+**Writes are never retried**, so an `add` can't be applied twice.
+
+```python
+from cortexlayer import CortexClient, NotFoundError
+
+try:
+    client.get("does-not-exist")
+except NotFoundError:
+    ...
+```
+
+## Configuration
+
+```python
+CortexClient(
+    api_key=None,          # or CORTEX_API_KEY
+    base_url=None,         # or CORTEX_BASE_URL; default https://api.cortexlayer.net
+    timeout=30.0,
+    max_retries=2,
+    http_client=None,      # bring your own httpx.Client (proxies, transports, tests)
+)
+```
+
+The key is never included in `repr()`. Use the client as a context manager (or `.close()`) to
+release connections; a client you pass in is never closed for you.
+
+## Coming from Mem0
+
+| Mem0 | cortexlayer |
+|---|---|
+| `Memory()` (embedded) | `Memory()` |
+| `MemoryClient(api_key=...)` (hosted) | `CortexClient(api_key=...)` |
+| `m.add(messages, user_id=...)` | `m.add(text, user_id=...)` |
+| `m.search(query, user_id=...)` | `m.search(query, user_id=...)` — results add `via` / `linked_from` provenance |
+| `m.get_all(...)` / `m.get(id)` | `m.get_all()` / `m.get(id)` |
+| `m.update(id, data)` / `m.delete(id)` / `m.delete_all(...)` | `m.update(id, text)` / `m.delete(id)` / `m.delete_all(user_id=)` |
+| — | `m.relink()` — Cortex links pages in a batch pass, never per insert |
+
+Differences worth knowing: Cortex takes plain text, not chat-message lists. The default `raw` engine
+stores your text as small pages and links them by shared entities, so **adding never needs an LLM**;
+`Memory(backend="facts")` is the Mem0-style engine that extracts facts with an LLM. On `CortexClient`
+there is no `user_id` argument: each API key belongs to exactly one user.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/python -m pytest
+```
+
+## Licence
+
+[Apache-2.0](LICENSE).

cortexlayer-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+cortexlayer/__init__.py,sha256=zKPO5mhHm6qmBdrgtlstJaMMR3tmOLv3NbJ1SrcnECc,1821
+cortexlayer/_validate.py,sha256=ppbcYz4v_Obv9x4TnNtiY16qMBch0R-0UicSPgtWkqo,825
+cortexlayer/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+cortexlayer/client.py,sha256=V8hOg-s5M-tnOmUDyCNGWZzqwWVkJOJ6qOIrJ2SJlnM,18888
+cortexlayer/errors.py,sha256=DLrhks7x0ddtcudtvvnDeKoQDOzLEN18jLpadjG1dFI,3382
+cortexlayer/memory.py,sha256=fh84P_CkMPqMLUyoOyrMFpzPU3QRhw5G5bRj0FzfFPM,16243
+cortexlayer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cortexlayer/types.py,sha256=vPkP6ZjVEPuhu-H5KcYP-lv9AdOELZ2g5e-FxuuVFYM,5826
+cortexlayer/_engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cortexlayer/_engine/compression.py,sha256=OfKvs-oeqvyerQbshuNJPOH7dovJYEYeQ0CztlhSuKo,3456
+cortexlayer/_engine/ingestion.py,sha256=QyxDzLJ2XgCw66FoI5XG6iVhx0CUIuTsdkNEMJWQJ-0,2653
+cortexlayer/_engine/linking.py,sha256=XkoMb9pYVcvuZbyR1d2KT-GUC7f6uuJJiliPwqYsGFo,2477
+cortexlayer/_engine/nlp.py,sha256=9cYqbhw3jP5SuvbXZDUndQRFLiAXNj0Tx0rD53e_GjA,6215
+cortexlayer/_engine/retrieval.py,sha256=ibcW3CJvV8GIm6j7HXQimgDQ-RIyrX6IG0HeGA3BkWY,2258
+cortexlayer/_engine/shaping.py,sha256=bP_UoqndLzZomhew-wykUEID9F_voor6kMn4QY1oSjk,2944
+cortexlayer/_engine/storage.py,sha256=XctWES1gNk5ezESPSozqj9EPnK_6KaQrujnizWD90kA,10261
+cortexlayer/_engine/facts/__init__.py,sha256=1xoTpWLTSW8FaMk70NVzjw7N5fQVwtz7fDMZm9e1s5s,86
+cortexlayer/_engine/facts/additive_extraction_prompt.txt,sha256=rRkYejeBPvd-4VbnFMBlDm7HSeAmS9wH1Jm8myQRUVU,33831
+cortexlayer/_engine/facts/backends.py,sha256=uxYYSbCsFY7taw6pGaG73-MjFD71oAzMsLqz9xVSK9s,7027
+cortexlayer/_engine/facts/engine.py,sha256=fikYhK2T_kCXW09ACNqr_TPWZAcy0mqdZmYo8bAarV8,24208
+cortexlayer/_engine/facts/entities.py,sha256=EL8Jj49FTy4XGGRnKAYdrYTCkrvVoqFAgDHZWjo3fmI,22440
+cortexlayer/_engine/facts/prompts.py,sha256=LvsdmhQNz4yP9J54nOaahZ6Y4NzaGjbuptAnv-h4Vfo,3733
+cortexlayer/_engine/facts/scoring.py,sha256=ma4FEtxamrEi0cEQBhTb2jrCtP_-RFPdNIJZSfqq_AI,5737
+cortexlayer-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+cortexlayer-0.1.0.dist-info/licenses/NOTICE,sha256=xaDRyokng60bCPC6WacrWz2r6e_v_2sGl4QYPonsKxI,1928
+cortexlayer-0.1.0.dist-info/METADATA,sha256=W7zGeM74kusZy4sEVkQR5ZBTatij5_D3n8Qi7A18fUc,12542
+cortexlayer-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cortexlayer-0.1.0.dist-info/top_level.txt,sha256=FKvfKZDu082td37gHcA3GQBlfdfp0SWdxyKpeVhhbo8,12
+cortexlayer-0.1.0.dist-info/RECORD,,

cortexlayer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cortexlayer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

cortexlayer-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,40 @@
+cortexlayer
+Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+This product includes software derived from Mem0:
+
+  Mem0 — https://github.com/mem0ai/mem0 (PyPI: mem0ai 2.1.0)
+  Author: Mem0 <support@mem0.ai>
+  Licensed under the Apache License, Version 2.0.
+
+The following files reproduce or adapt Mem0 source code or prompt text. Each
+carries a notice in its header describing what was changed, as required by the
+Apache License, Version 2.0, section 4.
+
+  src/cortexlayer/_engine/facts/additive_extraction_prompt.txt
+      Mem0's additive extraction system prompt (ADDITIVE_EXTRACTION_PROMPT from
+      mem0/configs/prompts.py). Copied unchanged.
+
+  src/cortexlayer/_engine/facts/prompts.py
+      Adapted from the user-prompt builder in mem0/configs/prompts.py
+      (generate_additive_extraction_prompt and helpers). Re-typed with type
+      hints; behavior unchanged.
+
+  src/cortexlayer/_engine/facts/entities.py
+      Adapted from mem0/utils/entity_extraction.py. The extraction heuristics are
+      unchanged; the two public entry points accept an optional spaCy pipeline and
+      no longer import mem0's model loader (which downloads a model at runtime).
+
+  src/cortexlayer/_engine/facts/scoring.py
+      Adapted from mem0/utils/scoring.py and Memory._compute_entity_boosts in
+      mem0/memory/main.py. Mem0's BM25 term never runs with its Chroma vector
+      store, so it is off by default; an optional keyword term uses our own
+      dependency-free BM25 (not Mem0's lemmatizer/normalisation) fused with the
+      same (semantic + keyword + entity) / max_possible formula.
+
+  src/cortexlayer/_engine/facts/engine.py
+      Implements the algorithm of Mem0's add/search pipeline (mem0/memory/main.py,
+      "V3 phased batch pipeline") on cortexlayer's own storage. See the module
+      docstring for the deliberate differences.
+
+cortexlayer does not depend on, import, or redistribute the mem0ai package.

cortexlayer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cortexlayer