# AI use cases for Jev Mem (libingzheren/Jev-Mem)

Repo: [libingzheren/Jev-Mem](https://github.com/libingzheren/Jev-Mem) | Use cases: 4 | Page: https://dedupedai.com/use-cases/libingzheren-jev-mem/

Jev-Mem is a Python research codebase for agent memory, where a System-One controller manages memory writes and graph-based retrieval and a System-Two language model writes the final answer.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Run the offline memory demo in under 15 minutes: https://dedupedai.com/use-cases/libingzheren-jev-mem/run-offline-memory-demo/
- Build and query Jev Mem over your own observations: https://dedupedai.com/use-cases/libingzheren-jev-mem/build-memory-over-own-observations/
- Run Jev Mem memory decisions on a local Laya model: https://dedupedai.com/use-cases/libingzheren-jev-mem/run-memory-control-with-local-laya/
- Compare full Jev Mem against ablated controllers on LoCoMo: https://dedupedai.com/use-cases/libingzheren-jev-mem/benchmark-controller-ablations-on-locomo/

## How to run the offline memory demo in under 15 minutes with Jev Mem

Repo: [libingzheren/Jev-Mem](https://github.com/libingzheren/Jev-Mem) | Difficulty: Intermediate | Time: 15 minutes | Basis: From the README

Install Jev Mem and watch it store observations, retrieve evidence, and print a decision trace with no API keys.

**Who it is for:** A developer evaluating agent memory who wants to see how the pipeline works before spending money on live model calls.

**The problem:** Reading about write, connect, retrieve, and assess steps is hard to picture without seeing them run.

**The outcome:** A printed decision trace from synthetic observations, showing how the memory pipeline behaves on a laptop.

### Steps

1. Clone the repository with `git clone https://github.com/libingzheren/Jev-Mem` and enter it with `cd Jev-Mem`. (inferred, check the README)
2. Create a virtual environment with `python3.11 -m venv .venv`.
3. Activate it with `source .venv/bin/activate` (on Windows, use `.venv\Scripts\Activate.ps1`).
4. Install dependencies with `python -m pip install -r requirements.txt`.
5. Run the demo with `python -m jev_mem.demo` and read the printed decision trace.

### Prompt to paste into your agent

```text
Clone the Jev-Mem repository from https://github.com/libingzheren/Jev-Mem into <target-folder>, create a Python 3.11 virtual environment, install requirements.txt, and run `python -m jev_mem.demo`. Report the printed decision trace and confirm that no API keys were requested.
```

### Caveat

The demo uses deterministic mock decisions and embeddings and does not measure answer quality, so it shows the pipeline rather than the paper's results.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/libingzheren-jev-mem/run-offline-memory-demo/

## How to build and query Jev Mem over your own observations with Jev Mem

Repo: [libingzheren/Jev-Mem](https://github.com/libingzheren/Jev-Mem) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Load your JSON notes into a Jev Mem cache with live models and ask questions answered from retrieved evidence.

**Who it is for:** A developer building a persistent assistant that must remember user preferences across sessions and recall them later.

**The problem:** The assistant forgets details from earlier conversations, and the team needs memory that keeps original observations with timestamps and provenance.

**The outcome:** A local memory cache built from your observations, plus an answer to a question about a stored preference, produced by the OpenAI-compatible model.

### Steps

1. Create a `.env` file in the repository root with `TYPESAFE_API_KEY=your-typesafe-key` and `OPENAI_API_KEY=your-openai-key`.
2. Format your data as a JSON list of strings or objects with `content`, an optional ISO 8601 `timestamp`, and optional `metadata`.
3. Build the cache with `python -m jev_mem --mode build --input examples/observations.json --jev-config config/jev_mem.json --cache-dir ./jev_mem_cache/app`, replacing the input path with your file. (inferred, check the README)
4. Query it with `python -m jev_mem --mode query --question "What reminder does Mira prefer?" --jev-config config/jev_mem.json --cache-dir ./jev_mem_cache/app`, replacing the question with your own. (inferred, check the README)

### Prompt to paste into your agent

```text
In the Jev-Mem repository at <target-folder>, build a cache from <input-json-file> using `python -m jev_mem --mode build` with config/jev_mem.json, then query it with `--mode query` using the question <question>. Return the answer and confirm that the cache folder was created locally.
```

### Caveat

Live runs send your text to the configured providers and may incur charges, and the README says to keep keys, conversations, and caches local, so review SECURITY.md before using private data.

Risk, credentials: The .env file holds provider API keys, so keep it local and out of version control, and avoid pasting keys into agent prompts or logs.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/libingzheren-jev-mem/build-memory-over-own-observations/

## How to run Jev Mem memory decisions on a local Laya model with Jev Mem

Repo: [libingzheren/Jev-Mem](https://github.com/libingzheren/Jev-Mem) | Difficulty: Advanced | Time: 45 minutes | Basis: From the README

Swap the System-One backend to Laya so memory decisions run locally without a TypeSafe API key.

**Who it is for:** A developer who wants to keep memory decisions on their own machine, or on Apple Silicon, instead of calling a hosted decision API.

**The problem:** The default setup depends on a TypeSafe API key for memory decisions, which may not fit a local or offline workflow.

**The outcome:** A local Laya-backed run on the synthetic LoCoMo example that prints results without a TypeSafe key.

### Steps

1. Complete the offline demo setup first so the Python environment exists (see the offline demo use case).
2. Install the Laya extra with `python -m pip install '.[laya]'`.
3. Run the benchmark on synthetic data with `USE_TF=0 python -m jev_mem.benchmarks.locomo --dataset examples/locomo_synthetic.json --jev-config config/laya_mem.json --sample 0 --max-questions 2 --best-of-n 1 --no-parallel`. (inferred, check the README)
4. For Apple Silicon, use `python -m pip install '.[mlx]'` and `config/laya_mlx_mem.json` instead. (inferred, check the README)

### Prompt to paste into your agent

```text
In the Jev-Mem repository at <target-folder>, install the '.[laya]' extra and run the LoCoMo benchmark on examples/locomo_synthetic.json with config/laya_mem.json, using --max-questions 2. Report the output and confirm that no TypeSafe API key was set.
```

### Caveat

The README says the reported results use Jev and Laya has not been benchmarked for the paper, and answer generation and evaluation still need your OpenAI-compatible provider.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/libingzheren-jev-mem/run-memory-control-with-local-laya/

## How to compare full Jev Mem against ablated controllers on LoCoMo with Jev Mem

Repo: [libingzheren/Jev-Mem](https://github.com/libingzheren/Jev-Mem) | Difficulty: Advanced | Time: 1 hour | Basis: From the README

Run LoCoMo questions with full, write-ablated, and read-ablated Jev Mem to see which control layer changes answers.

**Who it is for:** A researcher reproducing or extending the Jev Mem paper who needs to measure the effect of write control and read control separately.

**The problem:** A single score does not show whether write control or read control drives the gains, so each has to be tested alone.

**The outcome:** Scored LoCoMo question results for the full configuration and for each ablation, with timing and retrieval traces recorded.

### Steps

1. Place the LoCoMo dataset at `data/locomo10.json` by following the data setup guide.
2. Run the full configuration with `python -m jev_mem.benchmarks.locomo --dataset data/locomo10.json --jev-config config/jev_mem.json --sample 0 --model gpt-4o-mini --max-questions 10 --category-to-test 1,2,3,4 --best-of-n 1`. (inferred, check the README)
3. Run the write ablation by adding `--no-jev-write` to the same command, and the read ablation by adding `--no-jev-read`, using a separate `--cache-dir PATH` for each run. (inferred, check the README)
4. Compare the scored outputs and the recorded timing and decision traces across the runs.

### Prompt to paste into your agent

```text
In the Jev-Mem repository at <target-folder>, run the LoCoMo benchmark on data/locomo10.json for sample 0 with 10 questions, once with the full config and once each with --no-jev-write and --no-jev-read, using separate --cache-dir paths. Report the three overall scores and confirm that all three runs used the same dataset subset.
```

### Caveat

The README says these commands are starting points and that their subsets and scoring settings do not reproduce the full paper evaluation by themselves.

Risk, credentials: Benchmark runs call the answer and judge models with your keys, so keep the .env file local and do not share keys in agent logs.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/libingzheren-jev-mem/benchmark-controller-ablations-on-locomo/