# MemSlides splits memory by lifetime, and its version numbers disagree across three surfaces

> MemSlides is a research runtime for personalized slide generation whose central idea is separation by duration: profile memory that persists, working memory that lasts one deck, and tool memory that records how edits went before. Revision is scoped to the smallest affected slide region instead of regenerating. Around that core sit the ordinary facts of a research repository, including three disagreeing version numbers and an explicit warning about a fake website.

**huohua325/Memslides** — A hierarchical memory framework for personalized presentation agents. Try it at memslides.com.

- Repository: https://github.com/huohua325/Memslides
- Website: https://arxiv.org/abs/2606.17162
- Stars: 1,069 · Forks: 37
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/huohua325-memslides

## Three memories, sorted by how long they are meant to last

The organizing idea is that personalization signals have different lifetimes, so they are stored differently. Profile memory is persistent and holds recurring preferences that should follow a user across jobs. Working memory holds the active session: temporary preferences, session state and the constraints of the current revision round. Tool memory holds execution experience, so that a later edit similar to one that failed before can start from what happened.

Profile memory is described as intent-conditioned, which means it routes by presentation intent rather than applying everything at once, and then applies the matched preferences across theme, visual style, layout, template use, content strategy and general presentation habits.

That split is also the difference between round zero and later rounds. Round-zero personalization reads the profile store; revision rounds read working memory and tool memory. The claim attached to tool memory is specific: it retrieves prior task and tool-chain experience before a similar edit operation, to reduce repeated execution failures, which is a cache of outcomes rather than a cache of text.

## Revision patches the smallest affected region, not the deck

Most generators treat a revision request as a regeneration request. MemSlides does not: user feedback is projected onto the smallest affected slide region, and the change is applied as a scoped local patch rather than rewriting the whole deck.

The stated benefit is drift control. Content that was already aligned stays aligned, because the region that was not requested is not re-sampled. In a deck of twenty slides where the user says tighten the title, the blast radius is the title, not the file.

The framing at the top of the page is worth repeating because it explains why the memory layers exist at all: presentation generation is treated as a stateful authoring process rather than a one-shot conversion from source to slides. Working memory carrying edit-state records across feedback turns in the same deck is what makes a multi-turn conversation coherent, and scoped revision is what keeps each turn from undoing the previous one.

## The README names a fake website built on the project's name

Near the top of the page sits an official website notice with an unusual amount of detail. `memslides.com` is stated to be the official MemSlides trial website. `memslides.org` is stated to be a fake website, not operated by this project, and not affiliated with the repository.

Projects rarely publish that paragraph, so it is worth reading as a fact about the ecosystem rather than as marketing. A research project with a paper, a GitHub Pages site and a Docker Hub image attracts name-squatting quickly, and the response is to deny the domain outright rather than to file quietly.

The rest of the outbound links are conventional: the arXiv paper as the project homepage in the metadata, a GitHub Pages site, the demo video, the Docker Hub repository, and the trial site. The repository is Apache-2.0 licensed, is not archived, and its last push is dated 2026-09-21.

## Three surfaces report three different versions

The Python package declares `name = "memslides"` at version 1.0.0, described as a memory-aware presentation generation runtime. The Node package next to it declares `name = "memslides-runtime"` at version 1.0.0 as well, marked private.

The container is where they part. The compose file builds from `docker/Dockerfile` and then sets `image: ${MEMSLIDES_DOCKER_IMAGE:-huohua325/memslides:v2.0.1}`, so the default image tag is v2.0.1 while both manifests say 1.0.0. That default is overridable through an environment variable, which means the version you actually run depends on whether that variable is set, and the page never explains which is newer.

The release list has a single entry, a tag named `version_1` labelled with the project name, dated 2026-06-15. So the tag scheme does not carry a version either. Anyone pinning should pin a commit and say so, because neither the manifests nor the tag answer the question.

## A Python package that ships a Node runtime inside the wheel

The wheel is not only Python. The package data list includes `presentation_export/*.js`, `presentation_export/package.json`, MCP configuration JSON, role YAML files, memory SQL files, template guide markdown and Jinja templates, and the experiment suite YAML files.

Alongside it sits a small Node project called memslides-runtime, private and CommonJS, with four dependencies: fast-glob, minimist, playwright pinned at exactly 1.60.0, pptxgenjs and sharp. Its single script, `check:pptx-export`, runs `node scripts/check-pptx-export-runtime.js`, and the development checks section tells you to run `npm ci` and then that script as part of the same gate as pytest and ruff.

The Python side pins the same version: `playwright==1.60.0` is the only exact pin in the dependency list. So the export path depends on a Node package and a Python package agreeing on one Playwright build, and the CI check exists because that agreement is the fragile part.

## The install asks for LibreOffice, poppler and CJK fonts

The source install begins with system packages:

```bash
sudo apt-get update
sudo apt-get install -y libreoffice fontconfig fonts-noto-cjk poppler-utils
```

That line is the whole story of the document pipeline. LibreOffice is the converter for Office formats, poppler-utils provides the PDF utilities, fontconfig and the Noto CJK fonts are there because rendering text correctly on a headless Linux box needs them, and the last part installs Chromium and ffmpeg through Playwright.

After that a conda environment is created from `environment.yml`, the package is installed with the research extra, and the entry point is checked with `python -m memslides.experiment --help`. The Python dependencies match the pipeline: python-pptx, PyMuPDF, pypdf, vl-convert-python, markdownify and trafilatura for reading, Pillow and numpy for images, and the research extra adds chromadb, bm25s, jieba, PyStemmer and markitdown, which is a vector store, a BM25 implementation, a Chinese segmenter and an English stemmer sitting side by side.

## Credentials stay outside git, and two cache roots hold state

Generation needs model and service credentials, and the rule is explicit: keep them out of git and supply them through environment variables, a `.env` file, or a private YAML selected with `MEMSLIDES_CONFIG_FILE` or the `--config` flag. The packaged public config is `src/memslides/memslides.yaml`, and its placeholders are expanded from the current process environment when the YAML loads. Generated outputs, caches, private YAML files and credentials must not be committed.

For containers, the private path is a compose override: `docker-compose.private.yml` maps `./memslides.private.yaml` to `/run/secrets/memslides.private.yaml` and points `MEMSLIDES_CONFIG_FILE` at it inside the container.

State lives in two places by design. `.memslides/` is the ignored runtime workspace inside the repository, holding generated outputs and per-experiment directories, while `~/.cache/memslides/` is the user-level cache for logs and shared memory state. In the container all three environment variables point into `/app/.cache/memslides`, and the single volume mount maps the repository's `.memslides` directory there, so both roots collapse into one path.

## Three removed internals are named as things you must not import

The repository structure section does something unusual: it lists what is gone. The generated tool snapshot and two unused internal modules were removed from the source tree, and three paths are named as things not to import, with the instruction to use the MCP configuration and the public CLI instead. They are `memslides/.tools.json`, `memslides.memory.core.protocols` and `memslides.tools.ask_template_selection`.

That is a helpful API boundary, because a research codebase usually accumulates exactly the internal modules that people end up depending on. Here the project says which three those were.

The public surface is then small. The command line entry points are `generate`, `revise` and `template induct`, with a console script named `memslides`, and the experiment runner remains available as a module with `run`, `report` and `personas` subcommands. Development checks mirror continuous integration: compile the sources, run `scripts/check_source_hygiene.py`, run pytest, run ruff, then install the Node dependencies and run the export check. A hygiene script in the gate is a reasonable place to catch the kinds of imports the previous paragraph warns against.

## Conclusion

MemSlides fits a research group reproducing the paper's experiments, or an engineer who wants an editable deck rather than a regenerated one. Verify five things first: which version you are running, since the Python and Node packages say 1.0.0 while the compose file defaults to image tag v2.0.1 and the only GitHub release is version_1; that your host has LibreOffice, poppler and CJK fonts, because the install asks for all three; that Chromium and ffmpeg are installed, since auto-install is disabled by default in both the compose environment and the env template; and where your credentials live, because the rule is that keys never enter git. Use memslides.com for the trial service and ignore memslides.org, which the README names as a fake site.

## FAQ

### What is MemSlides?

It is a hierarchical memory-driven agent framework for personalized slide generation with multi-turn local revision, licensed Apache-2.0 and backed by an arXiv paper. It separates persistent user profile memory, working memory for the current deck, and tool memory for reusable execution experience, and it is intended for research and slide-generation workflows.

### How do I install MemSlides from source?

Install libreoffice, fontconfig, fonts-noto-cjk and poppler-utils with apt, create the environment with `conda env create -f environment.yml`, activate it, run `pip install -e ".[research]"`, then `python -m playwright install chromium ffmpeg`. Check the entry point with `python -m memslides.experiment --help`.

### How do I run MemSlides in Docker?

Run `docker compose build`, then `docker compose run --rm memslides python -m memslides.experiment run smoke_minimal`. To use a private config, layer `docker-compose.private.yml` on top, which maps ./memslides.private.yaml to /run/secrets and sets MEMSLIDES_CONFIG_FILE inside the container.

### What are the public MemSlides commands?

Three: `generate`, `revise` and `template induct`, exposed through the `memslides` console script. The experiment runner stays available as `python -m memslides.experiment` with `run`, `report` and `personas` subcommands, and is described as the main public entry point for suite runs.

### Why does MemSlides need LibreOffice and Playwright?

The install line includes libreoffice, fontconfig, fonts-noto-cjk and poppler-utils, and the Playwright step installs chromium and ffmpeg, which points at a pipeline that converts Office documents and renders pages headlessly. The Python side pairs Playwright with python-pptx, PyMuPDF, pypdf and vl-convert-python, and pins playwright to exactly 1.60.0.

### Is memslides.org an official MemSlides website?

No. The README states that memslides.com is the official trial website and that memslides.org is a fake website, is not operated by this project, and is not affiliated with the repository.

## Sources

- [huohua325/Memslides on GitHub](https://github.com/huohua325/Memslides)
- [License: Apache-2.0](https://github.com/huohua325/Memslides/blob/main/LICENSE)
- [Project website](https://arxiv.org/abs/2606.17162)
- [README](https://github.com/huohua325/Memslides/blob/main/README.md)
- [Releases](https://github.com/huohua325/Memslides/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/huohua325-memslides