fidelis-memory 0.0.93__tar.gz

fidelis_memory-0.0.93/.cogito.example.json

@@ -0,0 +1,25 @@
+{
+  "_comment": "Copy to .cogito.json and edit. All fields optional — env vars override everything.",
+
+  "port": 19420,
+  "user_id": "agent",
+
+  "store_path": "~/.cogito/store",
+  "collection": "cogito_memory",
+
+  "ollama_url": "http://localhost:11434",
+  "llm_model": "mistral:7b",
+  "embed_model": "nomic-embed-text",
+
+  "filter_endpoint": "http://127.0.0.1:19051",
+  "filter_token": "your-gateway-or-api-token",
+  "filter_model": "anthropic/claude-haiku-4-5",
+  "filter_timeout_ms": 12000,
+
+  "recall_limit": 50,
+  "recall_threshold": 400.0,
+  "query_threshold": 250.0,
+
+  "_note_filter": "filter_endpoint accepts any OpenAI-compatible URL. Set ANTHROPIC_API_KEY instead to call Anthropic directly.",
+  "_note_extraction": "Add custom_fact_extraction_prompt here to override mem0's default extraction prompt (recommended for technical domains — see zer0lint)."
+}

fidelis_memory-0.0.93/.github/workflows/ci.yml

@@ -0,0 +1,105 @@
+name: CI
+
+# Hermetic CI for the current Fidelis Memory release: runs on fresh Ubuntu and macOS runners. Proves the
+# fidelis package installs cleanly from source on a box that has never seen it
+# before — the equivalent of a beta tester installing the tagged source. Tests
+# that require a live Ollama or LLM endpoint are excluded by directory; the
+# rest (~370) must pass on every commit.
+#
+# What this catches:
+#   - missing dependencies (e.g. the `ollama` python lib that crashed our
+#     fresh-venv smoke test before we added it to pyproject)
+#   - macOS-only or Linux-only path bugs
+#   - Python-version regressions across 3.10 through 3.14
+#   - lint regressions
+#   - silent test-collection failures
+#
+# What this does NOT catch (intentionally — handled by manual smoke):
+#   - live Ollama embedding behaviour (tests/scaffold/test_e2e_store_query.py)
+#   - LLM backend portability (tests/scaffold/test_backend_portability.py)
+#   - Anthropic / OpenAI streaming wire format
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: pytest ${{ matrix.os }} / py${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install fidelis (proves clean install)
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Verify console scripts are wired
+        run: |
+          fidelis --help
+
+      - name: Ruff lint
+        run: ruff check src/ tests/
+
+      - name: Pytest (CI-runnable suite)
+        env:
+          FIDELIS_QUEUE_DIR: ${{ runner.temp }}/fidelis-ci-queue
+        run: |
+          pytest tests/ \
+            --ignore=tests/scaffold/test_e2e_store_query.py \
+            --ignore=tests/scaffold/test_backend_portability.py \
+            --ignore=tests/scaffold/test_anthropic_cache_wire.py \
+            --ignore=tests/scaffold/test_openai_format_compatibility.py \
+            --ignore=tests/scaffold/test_streaming_marker_integrity.py \
+            -q --no-header --tb=line
+
+      - name: Smoke — package metadata sanity
+        run: |
+          python -c "import fidelis; assert fidelis.__version__, 'no version'; print('version:', fidelis.__version__)"
+          python -c "from fidelis import degrade, server, init_cmd, watch_cmd, mcp_server; print('imports OK')"
+
+      - name: Smoke — plist contents test (macOS-only behaviour)
+        if: runner.os == 'macOS'
+        run: |
+          pytest tests/test_init_plist_contents.py -v --no-header
+
+  build:
+    name: build sdist + wheel
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build distributions
+        run: |
+          pip install --upgrade pip build
+          python -m build
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fidelis-dist
+          path: dist/
+          retention-days: 14

fidelis_memory-0.0.93/.github/workflows/release.yml

@@ -0,0 +1,102 @@
+name: Release
+
+# Manual, tag-driven PyPI release for the `fidelis-memory` distribution
+# (import name and CLI commands stay `fidelis`; only the PyPI listing name
+# differs, because the plain `fidelis` name is squatted by an unrelated
+# project). Triggered by hand via `workflow_dispatch` against an existing
+# `vX.Y.Z` tag — never runs automatically on push, so a release always
+# requires a deliberate dispatch.
+#
+# Flow: checkout the given tag -> verify the tag matches
+# `[project].version` in pyproject.toml -> lint + test (same gate as CI) ->
+# build sdist/wheel -> twine check -> publish to PyPI via Trusted
+# Publishing (OIDC, no stored API token).
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Git tag to release (e.g. v0.0.92) — must already exist and match pyproject.toml's version"
+        required: true
+        type: string
+
+jobs:
+  build-and-test:
+    name: verify + build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout tag
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.tag }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Verify tag matches package version
+        run: |
+          PKG_VERSION=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          TAG="${{ inputs.tag }}"
+          TAG_VERSION="${TAG#v}"
+          echo "pyproject.toml version: $PKG_VERSION"
+          echo "tag version:            $TAG_VERSION"
+          if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
+            echo "::error::Tag $TAG does not match pyproject.toml version $PKG_VERSION"
+            exit 1
+          fi
+
+      - name: Install fidelis (dev extras — pinned ruff)
+        run: |
+          python -m pip install --upgrade pip
+          pip install ".[dev]"
+
+      - name: Ruff lint
+        run: ruff check src/ tests/
+
+      - name: Pytest (CI-runnable suite)
+        env:
+          FIDELIS_QUEUE_DIR: ${{ runner.temp }}/fidelis-release-queue
+        run: |
+          pytest tests/ \
+            --ignore=tests/scaffold/test_e2e_store_query.py \
+            --ignore=tests/scaffold/test_backend_portability.py \
+            --ignore=tests/scaffold/test_anthropic_cache_wire.py \
+            --ignore=tests/scaffold/test_openai_format_compatibility.py \
+            --ignore=tests/scaffold/test_streaming_marker_integrity.py \
+            -q --no-header --tb=line
+
+      - name: Build sdist + wheel
+        run: |
+          pip install --upgrade build twine
+          python -m build
+
+      - name: Twine check
+        run: twine check dist/*
+
+      - name: Upload dist artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: fidelis-memory-dist
+          path: dist/
+
+  publish-pypi:
+    name: publish to PyPI
+    runs-on: ubuntu-latest
+    needs: build-and-test
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: fidelis-memory-dist
+          path: dist/
+
+      - name: Publish to PyPI (Trusted Publishing / OIDC)
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

fidelis_memory-0.0.93/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.py[cod]
+*.pyc
+*.egg-info/
+dist/
+build/
+.eggs/
+.venv/
+venv/
+node_modules/
+.env
+.cogito.json
+snapshot.md
+*.sqlite3
+*.chroma/
+.cogito/store/
+.pytest_cache/
+PENDING-PAPER*.md
+TODO.md
+
+# Benchmark run-log artifacts (outputs, not source)
+*.log
+bench/runs/

fidelis_memory-0.0.93/.zenodo.json

@@ -0,0 +1,25 @@
+{
+  "title": "fidelis: zero-LLM agent memory for Claude Code and AI agents",
+  "description": "fidelis is zero-LLM agent memory for Claude Code and AI agents: a local-first memory layer whose default retrieval path uses BM25, dense vectors, and reciprocal rank fusion with no LLM call. It returns your original passages verbatim instead of paraphrasing and runs fully local. Benchmarked on LongMemEval-S.",
+  "upload_type": "software",
+  "access_right": "open",
+  "license": "MIT",
+  "creators": [
+    {
+      "name": "Bosch, Rolando",
+      "orcid": "0009-0005-4896-1112",
+      "affiliation": "Hermes Labs"
+    }
+  ],
+  "keywords": [
+    "agent memory",
+    "retrieval-augmented generation",
+    "BM25",
+    "reciprocal rank fusion",
+    "LLM agents",
+    "Claude Code",
+    "local-first",
+    "zero-LLM",
+    "LongMemEval"
+  ]
+}

fidelis_memory-0.0.93/CHANGELOG.md

@@ -0,0 +1,143 @@
+# Changelog
+
+# Unreleased
+
+## v0.0.93 — 2026-08-05
+
+- Publish the Hermes Labs distribution to PyPI as `fidelis-memory`.
+- Make **Fidelis Memory** the user-facing product name across package metadata
+  and primary documentation, while preserving the `fidelis` repository, import,
+  and CLI names for compatibility.
+- Replace the GitHub-source install path in primary documentation with the
+  version-pinned PyPI installation command.
+
+## v0.0.92 — 2026-08-04
+
+- Preserve `/add` input verbatim when the extraction model returns no facts,
+  expose the degraded fallback through HTTP and CLI, and apply the same
+  no-silent-loss rule during queued-write replay.
+- Correct every current install surface to use tagged GitHub source; the PyPI
+  project named `fidelis` is unrelated to Hermes Labs Fidelis.
+- Align public package status with v0.0.91 and remove a dead benchmark link.
+- Narrow local-data and compliance wording to the demonstrated boundary.
+- Default mem0 telemetry off for direct server launches so SIGTERM completes
+  cleanly, while preserving explicit opt-in; document the remaining Chroma
+  settings and extend CI coverage through Python 3.14.
+- Remove cross-project proof language from current Fidelis presentation.
+- Add a regression test for the public installation contract.
+
+# fidelis era
+## v0.0.91 — 2026-06-18 (public release)
+- Public open-source release on GitHub + Zenodo DOI.
+- Repo hygiene only: relativized benchmark paths, removed run-log artifacts, refreshed module naming, added Zenodo metadata. No API changes vs v0.0.9.
+
+
+## v0.0.5 — 2026-04-24 (first release as `fidelis`, renamed from `cogito-ergo`)
+
+**Package rename: `cogito-ergo` → `fidelis`.** Version reset for the new
+PyPI package. The old `cogito-ergo` PyPI entries (0.0.8 and 0.3.0) remain
+published but are now deprecated pointers to this package. Note: a prior
+`cogito-ergo` v0.0.5 also exists in the changelog below — these are
+**different packages**; the version numbers do not collide on PyPI.
+
+**Headline: zero-LLM is the default retrieval tier.** The repositioning
+reflects what the benchmark numbers actually show — the zero-LLM path is
+the production moat (83.2% R@1 at $0, fully local); the LLM tiers are
+benchmark-tuned and held as experimental until calibration is fixed.
+
+### Rename details
+
+- PyPI package: `cogito-ergo` → `fidelis`
+- Import name: `from cogito` → `from fidelis`
+- CLI: `cogito ...` → `fidelis ...`, `cogito-server` → `fidelis-server`
+- Data paths kept as `~/.cogito/` for backward-compat with existing deployments
+- Env vars kept as `COGITO_*` for backward-compat
+- ChromaDB collection names kept as `cogito_memory` to avoid data loss
+
+### Default change (breaking for callers relying on default tier)
+
+- `recall_hybrid()` default tier flipped from `filter` to `zero_llm`.
+  Callers that relied on the filter default must pass `tier="filter"`
+  explicitly. Affects: `fidelis recall-hybrid` CLI, `POST /recall_hybrid`,
+  `recall_hybrid(...)` Python API.
+
+### Features
+
+- New `since` parameter on `/recall` and `fidelis recall --since` —
+  ISO-8601 timestamp filter applied after Stage 2.
+
+### Observability & reliability
+
+- New `fidelis.telemetry` module: escalation-rate log + `rate()` summariser.
+  Makes the 80%-vs-10% calibration miss measurable at runtime. Crash-safe.
+- `degrade.replay_queue` corrupt-file branch now covered by tests.
+
+### Tests
+
+- `tests/test_zero_llm_regression.py` — 4 tests pin zero-LLM default:
+  no filter/flagship invocation, works without LLM config, matches
+  explicit-tier output, handles empty corpus.
+- `tests/test_telemetry.py` — 5 tests for the new observability module.
+- `tests/test_verify_guard.py` — regression pin for the documented
+  verify-guard-inactive bug; xfail until fixed.
+- `tests/test_graceful_degrade_corruption.py` — replay_queue corruption.
+- Test baseline: 61 → 72 passing + 2 defensive skips.
+
+### Benchmarks (for reference, not default-path claims)
+
+- `recall_hybrid` at `tier="flagship"` hits 96.4% R@1 on LongMemEval_S
+  (470 questions, runP-v35, 2026-04-18). Escalates on ~80% of queries
+  under current calibration vs 10% intended — known limitation
+  documented in STATUS.md and `docs/RELEASE-SCOPE.md`. Do not use the
+  96.4% number as a cost-model baseline.
+- Zero-LLM per-category R@1 (now the default): single-session-assistant
+  100%, knowledge-update 96%, single-session-user 95%, multi-session 83%,
+  single-session-preference 67%, temporal-reasoning 66%.
+
+### Docs
+
+- README repositioned: zero-LLM leads, LLM tiers labeled experimental,
+  per-category table published.
+- `docs/THRESHOLD-AUDIT.md` — pins prod vs bench escalation constants.
+- `docs/RELEASE-SCOPE.md` — in-scope / held-for-later with unlock criteria.
+
+---
+
+# cogito-ergo era (predecessor package, retained for history)
+
+## v0.3.0 — 2026-04-16
+
+- New `recall_hybrid` path: BM25 + dense + RRF with tiered LLM escalation.
+  Port of the architecture that reached **93.4% R@1 on LongMemEval_S** (up
+  from the 56% mem0 baseline). Superseded by v0.3.1 (96.4%).
+- New `POST /recall_hybrid` HTTP endpoint and `fidelis recall-hybrid` CLI.
+- New tiers: `zero_llm` (no LLM, fastest), `filter` (cheap rerank, default),
+  `flagship` (stronger model, 4x larger snippets).
+- New env vars: `COGITO_FLAGSHIP_ENDPOINT`, `COGITO_FLAGSHIP_TOKEN`,
+  `COGITO_FLAGSHIP_MODEL`, `COGITO_FLAGSHIP_TIMEOUT_MS`,
+  `COGITO_HYBRID_COSINE_WEIGHT`. Optional `[hybrid]` extra for `bm25s`.
+- Existing `/recall` and `/recall_b` behavior is unchanged. The hybrid path
+  is strictly opt-in.
+
+## v0.2.0 — 2026-03-28
+
+- Dual-pipeline recall: zero-LLM `recall_b` (RRF multi-query) feeds `recall` (integer-pointer LLM filter)
+- Snapshot layer for high-fidelity context injection
+- Combined eval harness (`bench/`)
+- Technical extraction prompt baked into default config (no external prompt file needed)
+- Qwen3/qwen3.5 support via native Ollama `/api/chat` with `think:false`
+
+## v0.0.5 — 2026-03-28
+
+- Fixed benchmark attribution: qwen3.5:2b filter model (not claude-haiku-4-5)
+- Added Hermes Labs PyPI metadata (author, homepage, keywords)
+- Added agents.md for AI agent discoverability
+- Updated llms.txt with full API shapes and integration notes
+- Added "Built by Hermes Labs" ecosystem section to README
+
+## v0.1.0 — 2026-03
+
+- Initial two-stage integer-pointer recall pipeline
+- mem0 + ChromaDB vector store backend
+- HTTP server with `/recall`, `/add`, `/snapshot` endpoints
+- `fidelis calibrate` for vocab map generation

fidelis_memory-0.0.93/CODE_OF_CONDUCT.md

@@ -0,0 +1,11 @@
+# Code of Conduct
+
+This project follows the [Contributor Covenant v2.1](https://www.contributor-covenant.org/version/2/1/code_of_conduct/).
+
+All participants in this project are expected to abide by its terms.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the project maintainer at roli@hermes-labs.ai.
+
+All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances.

fidelis_memory-0.0.93/COMPLIANCE-DRAFT.md

@@ -0,0 +1,95 @@
+# COMPLIANCE-DRAFT.md — cogito-ergo
+
+**Status:** DRAFT. Internal self-audit artifact generated 2026-04-17 by
+`hermes_deliverable`. Not a conformity declaration; not a legal attestation.
+Review and sign off before distribution.
+
+**System:** cogito-ergo — semantic memory retrieval for AI agents. Retrieves
+prior conversations via integer-pointer filter (LLM returns only integers,
+structurally cannot corrupt returned content). Hybrid R@1 = 96.4% on
+LongMemEval_S.
+
+**Risk classification under EU AI Act:** Not a high-risk AI system per Annex III
+on its own. Becomes high-risk when used as a retrieval layer inside a
+high-risk downstream system (clinical decision, hiring, credit, law enforcement,
+emergency triage). Compliance posture below assumes the downstream context may
+be high-risk — compliance documentation written to meet the strictest case.
+
+---
+
+## Article 9 — Risk management & data provenance
+
+**Data sources used by cogito-ergo:**
+
+- Caller-provided conversation logs (not owned or stored by the library itself
+  beyond the session the caller passes in).
+- No training data. cogito-ergo is a retrieval library, not a trained model.
+- Embedding model: `nomic-embed-text` via Ollama (local, open-weights).
+- Filter LLM: caller-supplied. Default recommendation: small local model
+  (qwen3.5:2b / 4b). See `README.md` for the full calibration.
+
+**Risk identified:**
+1. Retrieval may miss critical context (false negative). R@1 = 96.4%; 3.6%
+   failure mode is a missed retrieval.
+2. Retrieval may surface stale or contradicted content (staleness). Mitigation:
+   caller must version memories or pass a freshness filter.
+3. Embedding model drift if Ollama updates the nomic-embed-text pointer.
+   Mitigation: pin model version in caller deployment.
+
+**Residual risk:** acceptable for non-safety-critical uses. NOT acceptable as
+sole source of truth for high-risk decisions; always combine with authoritative
+retrieval.
+
+## Article 10 — Data governance
+
+- No PII stored by the library.
+- Caller is responsible for the lawful basis of the memories they pass in.
+- No bias metrics computed by cogito-ergo itself (retrieval is content-agnostic).
+- Bias in retrieved content is a function of bias in the caller's memory store;
+  cogito-ergo does not filter for bias.
+
+## Article 14 — Human oversight & override
+
+- **Override mechanism:** caller controls all inputs and outputs. cogito-ergo
+  does not act; it returns ranked memory pointers. The caller's agent is where
+  oversight is enforced.
+- **Kill-switch:** library is a Python function call. Stopping it is `raise`.
+- **Audit trail:** caller is responsible for logging retrieval events. See
+  `examples/audit_logging.py` (TODO, not yet implemented — flagged as gap).
+
+## Article 15 — Accuracy, robustness, cybersecurity
+
+- **Accuracy:** benchmarked at R@1 = 96.4% on LongMemEval_S (runP-v35, 2026-04-18). Measurement
+  methodology in `bench/`.
+- **Robustness:** TODO — adversarial inputs (prompt injection in memory content)
+  have not been systematically fuzzed. Flagged as gap. See `little-canary` tool
+  for integration candidate.
+- **Cybersecurity:** the integer-pointer filter is a structural mitigation —
+  the filter LLM cannot hallucinate content; it can only pick or mis-pick an
+  index. Worst case is mis-retrieval, not fabricated content.
+
+## Article 86 — Right to explanation
+
+For any retrieved memory, the caller receives:
+- The integer index chosen by the filter LLM
+- The similarity score of each candidate
+- The full candidate list considered
+
+This is enough for a downstream system to explain *why this memory and not
+others*. cogito-ergo itself does not produce natural-language explanations.
+
+## Known limitations (disclosure)
+
+1. No bias testing (no test suite; flagged).
+2. No behavioral robustness harness against memory-content injection (flagged).
+3. No model registry; depends on caller pinning their embedding and filter
+   model versions.
+4. No incident-response runbook; failures are exceptions the caller must handle.
+5. English-optimized; performance on non-English queries not measured.
+
+## Remediation plan (next 90 days)
+
+- Add adversarial memory-injection test suite (sprint 1)
+- Add example audit-logging integration (sprint 1)
+- Add calibration bench for non-English queries (sprint 2)
+- Publish incident-response runbook for common failure modes (sprint 2)

fidelis_memory-0.0.93/CONTRIBUTING.md

@@ -0,0 +1,53 @@
+# Contributing
+
+## Running tests
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests/ -v
+```
+
+Tests in `tests/` are server-free — no Ollama or ChromaDB required. Mark any test that needs a live server with `pytest.mark.skip(reason="requires server")`.
+
+## Adding bench cases
+
+Bench cases live in `bench/`. Each case is a JSON file with `query`, `expected_ids`, and optional `notes`. Run the combined eval with:
+
+```bash
+python bench/eval.py
+```
+
+Add cases that cover real retrieval failures or regressions. Include the memory seed data in `bench/seeds/` if needed.
+
+## Code style
+
+- Line length: 100
+- Formatter/linter: `ruff` (`pip install ruff`, then `ruff check .` and `ruff format .`)
+- Target: Python 3.10+
+
+## `top_score` input contract
+
+`wrap_system_prompt(qtype, top_score=...)` accepts any numeric value for `top_score`:
+
+| Input | Behaviour |
+|---|---|
+| `None` | Treated as unknown → `[retrieval-quality: unknown]` |
+| `float` in `[0, 1]` | Used as-is for confidence band selection |
+| `float` outside `[0, 1]` (e.g. `-0.5`, `1.5`) | **Clamped** silently to `[0, 1]` — no exception raised |
+| `nan` / `inf` / `-inf` | Treated as `None` → `[retrieval-quality: unknown]` |
+| `int` `0` / `1` | Coerced to `float 0.0` / `1.0` |
+| `bool` `True` / `False` | Coerced to `1.0` / `0.0` (Python bool subclasses int) |
+
+Rationale: retrieval backends may return cosine values fractionally outside `[0, 1]` due to float
+arithmetic, or `nan`/`inf` on degenerate inputs. The scaffold uses `top_score` only for a
+cosmetic confidence label, so clamping is the principle-of-least-surprise choice — it never
+raises and never breaks the caller's pipeline.
+
+See `tests/scaffold/test_top_score_contract.py` for the full contract test suite.
+
+## Pull requests
+
+1. Fork and branch from `main`.
+2. Keep changes focused — one feature or fix per PR.
+3. Add a test if the change touches retrieval logic.
+4. Update `CHANGELOG.md` under an `Unreleased` section.

fidelis_memory-0.0.93/Dockerfile

@@ -0,0 +1,43 @@
+# Fidelis Dockerfile — runs fidelis-server in a container.
+# Build: docker build -t fidelis:0.1.0 .
+# Run:   docker run -p 19420:19420 -v fidelis-data:/data fidelis:0.1.0
+#
+# This image runs the fidelis-server only. For embedding/Ollama you point at
+# a separate ollama container (see docker-compose.yml) or your host's Ollama.
+
+FROM python:3.12-slim
+
+LABEL org.opencontainers.image.title="fidelis"
+LABEL org.opencontainers.image.description="Agent memory with zero-LLM retrieval and a $0-incremental QA scaffold"
+LABEL org.opencontainers.image.source="https://github.com/hermes-labs-ai/fidelis"
+LABEL org.opencontainers.image.licenses="MIT"
+LABEL org.opencontainers.image.version="0.1.0"
+
+# System deps for chromadb + sqlite
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+       curl \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install fidelis from source (alternative: COPY pyproject.toml + pip install .)
+COPY pyproject.toml README.md LICENSE ./
+COPY src/ ./src/
+RUN pip install --no-cache-dir -e .
+
+# Persist memory store outside the container
+VOLUME ["/data"]
+ENV FIDELIS_HOME=/data
+ENV FIDELIS_PORT=19420
+
+# Default Ollama URL points at host (override via env)
+ENV OLLAMA_URL=http://host.docker.internal:11434
+
+EXPOSE 19420
+
+# Health check: GET /health
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD curl -fs http://localhost:19420/health || exit 1
+
+CMD ["fidelis-server"]

fidelis_memory-0.0.93/Formula/fidelis.rb

@@ -0,0 +1,48 @@
+# Homebrew formula for fidelis.
+#
+# Tap install (after the formula is in a tap):
+#   brew tap hermes-labs-ai/tap
+#   brew install fidelis
+#
+# Local install (testing):
+#   brew install --build-from-source ./Formula/fidelis.rb
+#
+# This formula installs fidelis as a standalone Python tool via uv (or pip),
+# wraps the entry points, and registers a launchd service via `brew services`.
+
+class Fidelis < Formula
+  include Language::Python::Virtualenv
+
+  desc "Agent memory with zero-LLM retrieval and a $0-incremental QA scaffold"
+  homepage "https://github.com/hermes-labs-ai/fidelis"
+  url "https://github.com/hermes-labs-ai/fidelis/archive/refs/tags/v0.1.0.tar.gz"
+  # SHA256 placeholder — populated when the v0.1.0 tag tarball is published.
+  # `brew create` and `brew bump-formula-pr` will fill this in automatically
+  # once the GitHub release tarball is available.
+  sha256 "TBD-fill-when-v0.1.0-tag-tarball-is-published"
+  license "MIT"
+  version "0.1.0"
+
+  depends_on "python@3.12"
+
+  # Resource declarations are managed by `brew update-python-resources Formula/fidelis.rb`
+  # once mem0ai and chromadb pin a stable version line.
+
+  def install
+    virtualenv_install_with_resources
+  end
+
+  service do
+    run [opt_bin/"fidelis-server"]
+    keep_alive true
+    log_path var/"log/fidelis-server.log"
+    error_log_path var/"log/fidelis-server.log"
+    working_dir HOMEBREW_PREFIX
+  end
+
+  test do
+    # Confirm the entry points install and respond to --help
+    system bin/"fidelis", "--help"
+    system bin/"fidelis-server", "--help"
+  end
+end