AmplifierSkills and tools for thoughtful work

Library

Amplifier Data

Keep the evidence. Change the view.

An independent Python storage library for tools that need exact source bytes, durable history and room to evolve. Memory is one consumer; your own capability can be another.

Use Amplifier DataWatch the 63-second filmWalk through an example
What you getFictional illustration
source = store.write_cell(b"Fictional parser check remains unverified.")
action = store.write_cell(b"Fictional next step: run the parser check.")
store.relate(action, source, "derived_from")

Original bytes retained.
Consumer views replaceable.
Models owned by the caller.

This fictional illustration shows the API shape. The doctor runs a separate temporary two-consumer and durable-restart check.

Keep a dependable source

Content-addressed Cells and an append-only log retain the original bytes behind a result.

Give each tool its own view

Scopes, relations and query lenses let multiple capabilities work over a shared substrate without importing each other.

Rebuild what you derive

Regenerate complete Cells from the log and replace derived views as your application changes.

The film

Three copies. No original.

In 63 seconds, one true sentence goes into three tools and comes out as three versions. Amplifier Data keeps the original once, as exact bytes on a log that only moves forward. Each tool builds its own view that points back home, and after the lights go out the original comes back byte for byte. It is a library for builders: it keeps evidence honest and does not promise smarter answers. Captions are on the player; a transcript is below.

Download the film 15-second cut Captions
Read the transcript

One true sentence goes into three tools.

And the copier does what copiers do.

Now there are three versions, and no original.

Amplifier Data keeps the original once.

Exact bytes, on a log that only moves forward.

Each tool builds its own view, and every view points home.

Lights out. Lights on.

The original comes back, byte for byte.

It’s a library for builders. It keeps evidence honest; it doesn’t promise smarter answers.

On screen: Keep the evidence once.

Amplifier Data. Keep the evidence. Change the view.

The sentence, the tools and the copier are a fictional example, shared with the Memory film. The film shows how the library behaves; it does not report results.

See the work take shape.

This fictional illustration shows the API shape. The doctor runs a separate temporary two-consumer and durable-restart check.

Write the source

Store a fictional parser-check note as bytes. The returned content reference identifies the source your application can cite.

Fictional example

One source note, two useful views

The brief A fictional project stores a parser-check note and the next action derived from it.

Before

The evidence tool and artifact tool keep disconnected copies with no shared source reference.

After applying the method

Each consumer owns its scope; a derived_from relation connects the next action to the exact source note in one append-only log.

Consumers can change their views without changing the retained source bytes.

A clear job.
A useful stopping point.

Several capabilities need exact retained bytes, provenance and their own replaceable views over the same log.

Use it when

  • Your application needs exact retained evidence plus derived summaries or indexes.
  • Multiple capabilities need the same storage substrate while keeping independent schemas and models.
  • You want a local native log you can close, replay and inspect.

Choose another route when

  • You need a turnkey end-user memory app or hosted database service.
  • Your retention policy requires immediate physical deletion from an append-only file.
  • You need validated production support or Windows native acceptance today.

Retain

Evidence or an artifact must keep its original bytes.

A content reference that can be regenerated from the log.

Derive

A consumer needs its own scope, relations or query lens.

A replaceable view over the same retained evidence.

Reopen

A process ends and another needs the same record.

Durable replay through the native Rust kernel.

Read the canonical method

Store exact bytes as content-addressed Cells in an append-only log. Derive scopes, relations and query lenses over that log. Keep models, interpretation and consumer schemas outside the storage library. Preserve the source log for replay and regeneration.

Limits and prerequisites
  • Alpha library. Durable paths require the native Rust kernel; the Python source fallback is in-memory only.
  • One writer owns a durable file; multi-process access uses the companion server/RemoteStore seam.
  • Invalidation does not erase bytes from an append-only log. Keep original logs and review retention separately.
  • The supplied binary wheel is macOS Apple silicon only. Source-built native acceptance also passes on Ubuntu 24.04/Python 3.12; other platform/toolchain combinations remain unverified.

Your first useful run.

Install in a fresh environment, run the doctor on its temporary test store, then adapt one small example to your own consumer.

This is a native tool or library. Install its package in an isolated environment, then use the documented command or protocol.

Source on GitHub

Start from the public source

git clone https://github.com/michaeljabbour/amplifier-tool-data.git
cd amplifier-tool-data
python3 -m venv .venv
.venv/bin/python -m pip install .
.venv/bin/amplifier-data-doctor --self-test

Use the native package and command interface described in the installation guide. This capability does not require a portable skill.

  • Python 3.11+, Rust (cargo/rustc) and a native compiler are required for source installation.
  • A reviewed macOS Apple silicon wheel and source distribution are linked from the public release guide.
  • Package name: amplifier-data. Python import: amplifier_data. No model or runtime Python dependency is owned by this library.
  • The shown commands use macOS/Linux virtual-environment paths. Windows uses .venv\Scripts executables; Windows native acceptance remains unverified.

Keep the guide nearby

Read the guide · License · Changes · Release metadata · PUBLIC RELEASE · CONSTRAINTS · SPEC · ARCHITECTURE · THIRD_PARTY_NOTICES

Know what you can rely on.

The reviewed source and native artifacts resolve publicly. Installed-wheel tests on macOS Apple silicon and Ubuntu 24.04 check exact bytes, scoped consumers, regeneration and durable restart. Other platforms and outside-user acceptance remain open.

Read the checks and their scope
  • Reviewed public export — passed

    171 allowlisted files at the reviewed tag; no original private history, working notes or operational store included.

  • Installed native wheel — passed

    533 installed-wheel Python checks passed. Temporary two-consumer, exact Cell regeneration and durable close/reopen checks passed.

  • Platform acceptance and user outcomes — partial

    macOS Apple silicon/Python 3.12 and Ubuntu 24.04/Python 3.12 native installed-wheel checks pass. Windows/other platforms, production stores and outside-user outcomes remain unmeasured.

Source and conformance checks are separate from demonstrated benefit. Comparative effectiveness and outside-user outcomes are not established by this site.

Fictional examples explain the capability. Tests check the stated behavior. Outside-user outcomes need their own evidence.