Model or dataset
TeleAI-UAGI/telemem avatar
TeleAI-UAGI/telemem

telemem: a drop-in replacement that subclasses Mem0 and calls three private helpers, an mcp extra that installs nothing, and a pinned PostHog client next to a no-data-leaves claim

TeleMem is a high-performance drop-in replacement for Mem0, featuring semantic deduplication, long-term dialogue memory, and multimodal video reasoning.

493 stars36 forksPythonApache-2.0

At a glance

What is it?
TeleMem is an agent memory layer that presents itself as a Mem0 replacement you activate with one import, adds per-character memory isolation and a video pipeline, and ships as both a PyPI package and an MCP server. The dependency metadata is where the honesty lives, because a comment in pyproject.toml admits the drop-in surface is backed by calls to Mem0 internals, and the frozen requirements file pins an analytics client that the no-cloud claim does not mention.
Who is it for?
TeleMem is the more interesting of the two projects if you need per-character memory isolation or video memory and want the code, and the per-release notes are unusually candid about what each version fixed. Read the dependency comment before you rely on the drop-in claim, because `import telemem as mem0` is an API-shape promise maintained by pinning `mem0ai>=2.0,<2.1`, and a private helper rename upstream would surface as a runtime error rather than a version conflict.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 6 days ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • TeleAI-UAGI/telemem493 ★ · +4
Star history
Repository2026-09-112026-11-15
TeleAI-UAGI/telemem489493

4 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The drop-in promise and the private-helper comment say opposite things

The headline is a one-line swap, `import telemem as mem0`, with `add()` and `search()` taking the same arguments and returning the same `{"results": [...]}` shapes. The dependency metadata carries a comment that qualifies it:

> # TeleMem extends mem0's Memory class and calls some private helpers > # (_create_memory, _search_vector_store, _create_procedural_memory), so > # the supported range is pinned to the tested minor series.

So the compatibility is real at the signature level and false at the coupling level. Three of those helpers are Mem0 internals, so they have to keep their names and their behaviour across every install, which is why the dependency is `mem0ai>=2.0,<2.1` rather than a floor, and why the frozen environment resolves to `mem0ai==2.0.5`. The comment is the most useful line in the file: it tells a user precisely which upstream change would break them and why the range is narrower than it looks.

The drop-in API shipped a month before three of its arguments worked

The release list gives the timeline. On 2026-06-12, v1.5.0 is announced with a true mem0 drop-in API, a lightweight core install, and CI. On 2026-07-11, v1.8.0 is described as the claims equals contracts release, and its contents include `infer=False` / `prompt` / `memory_type` now fully honored. The word now is the load-bearing part. Between those two dates, the drop-in API accepted three arguments and did the wrong thing with them, in the same release line the README advertises as the reason to switch. The same release also turns telemetry off by default and adds an offline contract test suite, which is the shape of a release that admits a documented claim did not match the code. A reader who upgraded at v1.5.0 and read no further would have had the wrong behaviour for a month.

No data leaves your machine, beside a pinned analytics client

The reason-to-use list promises a fully local default: it runs end to end on your hardware with Qwen and FAISS, with no cloud service, no paid tier, and no data leaving your machine. The frozen `requirements.txt` pins `posthog==7.18.1`, which is an analytics client, alongside `opentelemetry-api==1.44.0` for tracing. The claim is now true only in the past tense of a release note: v1.8.0 lists telemetry disabled by default among its changes, which means it was not disabled before. So the local-only promise describes the state after v1.8.0 rather than the design, and nothing in the visible documentation says what a user on v1.5.0 through v1.7.x was sending. The dependency file is the honest artefact here, since a pinned analytics client cannot be an accident of resolution.

The mcp extra installs nothing because mcp is already a core dependency

The core dependency list ends with `mcp>=2.0.0,<3`, annotated as implementing MCP spec 2026-07-28 while still serving 2025-era clients, and noting that v1 with its FastMCP import path is maintenance-only and incompatible with the project's imports. Then the optional dependency table defines an extra with the same name and the same range:

code
mcp = [
    "mcp>=2.0.0,<3"
]

The accompanying comment says the extra is kept as an alias for backward compatibility so that `uvx telemem` works without extras, following the MCP registry convention. That is a defensible reason for keeping it. The consequence is that `pip install telemem[mcp]` resolves to nothing beyond `pip install telemem`, and any documentation telling a user to install the extra to get MCP support is describing a package that is already present. The wider range is also worth noting: v1 is excluded by the comment rather than by the range, which stops at 3.0, so a future 2.y is admitted even though only one line of it is locked in the environment at `mcp==2.0.0`.

requirements.txt is a 57-package freeze against an 8-dependency core

Two install paths with two very different shapes. `pyproject.toml` declares eight runtime dependencies: `mem0ai`, `openai`, `pydantic`, `faiss-cpu`, `numpy`, `pyyaml`, `tqdm`, and `mcp`. `requirements.txt` pins fifty-seven packages with exact versions, and among the extras that no core declaration accounts for are `azure-core`, `azure-identity`, `qdrant-client`, `nano-vectordb`, `sqlalchemy`, `uvicorn`, `starlette`, `grpcio`, `opencv-python-headless`, `yt-dlp`, and `pytest`. Those look like the video extras and the test harness flattened into one file. Two HTTP stacks are present as well, `httpx==0.28.1` alongside `httpx2==2.9.1` and `httpcore==1.0.9` alongside `httpcore2==2.9.1`, which is worth confirming against your own resolution before building anything on that freeze. The advertised user path is `pip install telemem` from PyPI, which uses the eight-dependency metadata, so the frozen file serves the project's own development rather than its users.

The container copies neither server.json nor assets, yet the project is on the registry

The v1.7.1 note announces the server on the official MCP registry, runnable with `uvx telemem` and no install. The container image built for that server copies three things:

code
WORKDIR /app
COPY pyproject.toml README.md ./
COPY telemem/ telemem/
RUN pip install --no-cache-dir .

ENTRYPOINT ["telemem-mcp"]

The repository root also holds `server.json` and `glama.json`, the two registry manifests, plus `assets/`, `config/`, `baselines/`, and `data/`, and none of them is copied. An image built this way can serve tools but cannot be published from, since the manifest that describes it is not in the image. The version is another casualty of the same cut: `pyproject.toml` declares `dynamic = ["version"]`, so the version is read out of the copied package directory rather than from a visible field. The base image is `python:3.12-slim` while the library declares `requires-python = ">=3.10"` and classifiers for 3.10 through 3.12, so the container tests only one of the three supported interpreters.

The headline accuracy figure has no baseline and an ambiguous percentage

The research highlights lead with 86.33 percent accuracy on the ZH-4O Chinese multi-character long-dialogue benchmark, described as 19 percent higher than Mem0, followed by doubled speed and greatly reduced token cost. None of the three numbers comes with a protocol. No Mem0 score is printed, so the 19 percent cannot be resolved: if it means 19 percentage points, the baseline is 67.33; if it means relative, the baseline is about 72.5. No judging model, temperature, retrieval depth, or metric definition is given for a benchmark whose name encodes a model generation but not a judge. Speed is described as doubled with no baseline either. The repository does hold `baselines/`, `tests/`, and a LongMemEval harness with built-in baselines announced in the same v1.7.1 note, so the machinery for a reproducible comparison exists somewhere; what the headline page shows is the conclusion without the table.

The entrypoint is telemem-mcp and the documented zero-install command is uvx telemem

The same server has two names. The container sets `ENTRYPOINT ["telemem-mcp"]`, and the two example invocations in the Dockerfile header use `telemem-mcp`: a stdio run with `-i --rm -e OPENAI_API_KEY`, and a streamable HTTP run publishing port 8421 with `--host 0.0.0.0`. The release notes and the registry announcement both say `uvx telemem`, which invokes the package's other console script. The scripts table that would settle it sits below the visible part of the metadata. The two Docker examples also share a smaller problem with the local-only claim: both name `OPENAI_API_KEY`, and `openai` is an unconditional core dependency, so the fully local path depends on configuration the container documentation never shows. The repository does carry `.python-version` and `uv.lock`, so uv is the project's own tool while pip is the path it asks users to take.

Editorial conclusion

TeleMem is the more interesting of the two projects if you need per-character memory isolation or video memory and want the code, and the per-release notes are unusually candid about what each version fixed. Read the dependency comment before you rely on the drop-in claim, because `import telemem as mem0` is an API-shape promise maintained by pinning `mem0ai>=2.0,<2.1`, and a private helper rename upstream would surface as a runtime error rather than a version conflict. Verify the claims that matter to you: the 86.33 percent accuracy figure arrives without a baseline number or a judging protocol, telemetry was on by default until v1.8.0, and the container image omits the registry manifest. Install from PyPI, not from the frozen requirements file.

Frequently asked questions

How do I use telemem as a drop-in replacement for Mem0?

Import it under the Mem0 name with `import telemem as mem0`. The `add()` and `search()` methods take the same arguments and return the same `{"results": [...]}` shapes. TeleMem extends Mem0's Memory class and calls three private helpers, so the dependency is pinned to `mem0ai>=2.0,<2.1`.

Which Python versions and licences does telemem support?

`requires-python` is `>=3.10` with classifiers for 3.10, 3.11, and 3.12, and the licence is Apache-2.0. The container image is built on `python:3.12-slim`.

What does the telemem MCP server provide?

Eight memory tools registered under `mcp__telemem__*`, served over stdio or a streamable HTTP transport on port 8421. Since v1.9.0 it runs on MCP Python SDK v2 implementing spec 2026-07-28, and since v1.7.1 it can be launched with no install using `uvx telemem`.

What benchmark results does telemem report?

86.33 percent accuracy on the ZH-4O Chinese multi-character long-dialogue benchmark, stated as 19 percent higher than Mem0, along with a doubled speed claim and reduced token cost. No Mem0 baseline score, judging model, or evaluation protocol is given alongside those figures.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. TeleAI-UAGI/telemem on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/teleai-uagi-telemem.svg)](https://hysenlabs.com/projects/teleai-uagi-telemem)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/teleai-uagi-telemem.svg)](https://hysenlabs.com/projects/teleai-uagi-telemem)

Was this useful?