Repository navigation
EverOS 1.7.1 writes each conversation's memory in its own language: a short
call names the language of every memcell before its episode is written, and
the episode, its summary, its atomic facts and a first profile follow it.
Episode summaries are now written offline from the stored episode, a
memcell's atomic facts and clustering embedding are computed once for all of
its owners, and episode hybrid search ranks over three recall lanes, with
bounded recall pools for agentic and vector search. A new
POST /memory/device/add route lets one hardware device keep separate memory
for each person it hears. Foresight, off by default since 1.2.3, is removed.
What changes for an existing setup: hybrid search's top_k now counts
episodes, each carrying at most one atomic fact; a store that ran foresight
has its foresight data removed on first start; and the Python API for
building UserMemoryPipeline and ReflectionOrchestrator, and for
implementing EpisodeStore, changed. HTTP request bodies and the CLI are
unchanged apart from additions. See Upgrade below.
Added
- An episode's language is named before it is written. Each memcell with
a user sender first gets one short call on the newlanguageLLM task
(everalgoLanguageDetector), which names the language of its
conversation -- Chinese, Japanese or English, any other language as English
-- from the sentences the participants write to each other, not from
pasted code or documents, names, or a few words of another language mixed
in. The episode is extracted in that language and stores
it, and its summary, atomic facts and (on first build) profile follow it.
A failed or slow call leaves the language to the episode model, as before,
and the episode stores the language its text is written in; a memcell with
no chat text makes no call.[llm.language]defaults to temperature 0,
64 output tokens, a 3-second timeout and no retries, so the call adds at
most 3 seconds per memcell to a synchronous/add. See
docs/how-memory-works.mdanddocs/configuration.md. - OME strategies
summarize_episodeandsplit_episode_by_owner, both on
by default and named so inome.toml.summarize_episodewrites each
episode's display summary (below);split_episode_by_ownerhands each
owner's copy of an episode to the profile as anEpisodeExtractedForOwner
event of its own, with no model call. POST /memory/device/add: one hardware device, many speakers. Each
utterance names the speaker the device recognized; the route builds the
/memory/addrequest with the sender<device_id>@<slot>, so every person
gets their own episodes and profile, read, searched and deleted by that id
asuser_idon the existing routes. Utterances nobody was identified for
are filed under the device id; a speaker withconsented: falseis not
written at all (one decline in a batch drops all of that slot's lines); a
speaker sent withoutdisplay_namekeeps the name last stored for them,
and only one never named is labelled by the slot (which starts with a
letter, holds a digit or_, and has no.). The ownership rules live in
everos.memory.device, run byMemoryService.add_device.async_modequeues the batch as on/memory/add(202,
with the sameowners). Existing request bodies are unchanged. See
docs/device-assistant.mdanddocs/api.md.
Changed
- Reflection merges in the owner's profile language. Without one, the
merged episodes vote with their stored languages and a language held by
more than 60% of them is used; a closer split leaves it to the reflector
and the language is read off the merged text. The merged episode stores
that language and its atomic facts are written in it; before, the merge
chose its own language and stored none. - Log lines name the language each step writes in.
episode_language_decided/episode_language_undecided(reason
no_chatorfailed) per memcell;episode_writtenwithlanguageand
language_from(decidedortext);atomic_facts_extractedgains
language;user_profile_extractedgainslanguageandlanguage_from
(frozenorevent);reflection_mergedgainslanguageand
language_from(profile,voteortext). everalgo-user-memory0.9.0 -> 0.10.1, which only adds
LanguageDetector.- Episode
hybridsearch ranks three recall lanes. BM25 and the episode
vector are fused with an atomic-fact lane (200 facts max-pooled onto at most
50 episodes) by two RRF passes, and each kept episode is scored on the
better of its own vector and its best atomic fact, LR-calibrated with BM25.
top_know counts episodes, and an episode carries at most one atomic fact,
the one its score came from, when that fact matched the query better than
the episode.radiusfloors the atomic-fact lane, and the facts an episode
is scored on, as it floors the episode vector lane. This replaces the
heap-expand ranking, whosetop_kcounted episodes and facts together. - Episode
agenticsearch reads at most 500 atomic facts per MaxSim lane,
however many facts an owner has, and recalls each episode by its own body
vector and BM25 alongside its facts. The cluster scope holds clustered
episodes only, and at most 100 of them: the base hits first, then the
members closest to the query by body vector. This replaces the un-scoped
hybrid fallback for scopes over 1,000 episodes. When the cluster scope comes
back empty (no cluster yet, or no base hit in one), Round 1 runs on the
un-scoped hybrid instead of returning nothing. - Episodes embed their body only. Indexing and
everos backfillno
longer embed an episode's subject, one embedding call fewer per episode,
and nothing searches the subject vector. Thesubject_vectorcolumn stays
in the index schema, left empty, so existing stores open with no migration
or rebuild. - Episode
vectorsearch reads 200 atomic facts whatever thetop_k, and
returns at most 50 episodes whentop_kis-1. - Agent case and skill
hybridsearch recalltop_k * 2per lane, and 50
whentop_kis-1, so the rerank picks the 10 it returns from a wider
pool. The skill cross-encoder scores the best of the fused skills, as many
as one lane holds. Agent caseagenticsearch returns at most 10 cases when
top_kis-1, as skill search does. - One
EpisodeExtractedper memcell. The event announces a memcell's
episode once and lists every owner's copy incopies(each with its
owner_id,entry_idandowner_name), instead of one event per copy.
Work on the episode runs once and is shared by its owners; work on one
owner's state runs onEpisodeExtractedForOwner. Payloads persisted by
1.7.0 still load, as one-copy events. - Atomic facts are extracted once per memcell.
extract_atomic_facts
makes one model call per episode and writes the facts under every owner of
the memcell, each owner's facts parented to that owner's copy, so a memcell
with several user senders no longer pays one call per sender.
trigger_profile_clusteringlikewise embeds the episode once for all of its
owners. - Episode summaries are written offline, from the episode. Adding a
memcell now makes one model call, the episode. Every copy is stored with a
placeholder summary: the episode's opening, cut at a word boundary to a
width of 120 (a CJK character counts as two) and closed with…, or the
whole episode when it is shorter.summarize_episodethen writes the
model's preview from the stored episode text, in the episode's language,
with[llm.summary], and replaces only the copies still showing the
placeholder, so a summary edited in the meantime is kept. Until it has run,
/getand/searchreturn the placeholder; if its retries are spent, the
placeholder stays. The summary still costs one model call per memcell, now
made offline and reading the episode rather than the conversation.
Replacing a summary re-indexes the episode, which re-embeds it. - The profile runs once per owner.
extract_user_profileruns on
EpisodeExtractedForOwner, so each owner's profile update is a run of its
own, with its own retries. UserMemoryPipelineno longer takessummary_llm, andEpisodeStorehas a
new method,replace_summary, a compare-and-set of one entry's summary.- The
locomoandlocomo-stepbenchmark configs, which turn the profile off,
also turnsplit_episode_by_owneroff. The OME strategy switches are part
of the ingest identity, so a store ingested with an earlier config is not
reused.
Removed
- Foresight. The
extract_foresightstrategy (off by default since
1.2.3; no route ever returned its output), theforesightdaily log,
index table and cascade kind,[llm.foresight], and the
UserPipelineStartedevent it was the only subscriber of. A queued
foresight run left by an earlier release is dropped with an
ome_run_dropped_unknown_strategywarning. On its first start, a store that ran
foresight has itsforesightindex table / collection and every
.foresights/folder removed (logged asretired_kind_data_removed):
nothing reads them, and purge and deletion no longer reach them.
Fixed
everos demokeeps the conversation on its newest line. The conversation
panel follows every new line, also after the reader scrolled up; on a slow
machine it could stay at the top.- Agent-skill extraction no longer fails when the agent is deleted
mid-run. ASKILL.md(or a skill's reference or script) removed between
being found and being read now reads as absent instead of raising
FileNotFoundError, which failed theextract_agent_skillrun.
Upgrade
pip install --upgrade everos # or: uv sync| If you | Then |
|---|---|
enabled extract_foresight in ome.toml |
remove the block; it is ignored with a config_override_unknown_strategy warning |
set [llm.foresight] or EVEROS_LLM__FORESIGHT__* |
remove it: it is ignored, and startup logs an llm.task.retired warning |
| ran foresight and want to keep its output | copy every users/*/.foresights/ folder out before upgrading: the first start removes them and the foresight index table |
subscribe to UserPipelineStarted in your own strategy |
subscribe to EpisodeExtracted (one per memcell, after the episode is written; it carries memcell_id, not the MemCell) |
disabled extract_user_profile in ome.toml |
also disable split_episode_by_owner: it only feeds the profile |
| want no summary call at all | disable summarize_episode; episodes keep their placeholder summary |
read owner_id, episode_entry_id or owner_name from EpisodeExtracted in your own strategy |
read copies (one entry per owner), or subscribe to EpisodeExtractedForOwner |
build UserMemoryPipeline or implement EpisodeStore in Python |
drop summary_llm; add replace_summary |
build UserMemoryPipeline or ReflectionOrchestrator in Python |
pass language_llm, or profile_store |
point [llm] at a model that thinks before it answers |
set [llm.language] to a model with thinking off: thinking runs out of its 64 tokens, and every episode falls back to the model's own language choice (episode_language_undecided, reason="failed") |
Stop the old server normally so it finishes its queued background runs. A
profile run still pending under the 1.7.0 event when the old server stopped
fails on the new server (AttributeError) and is dead-lettered after its
retries; that owner's profile catches up on their next episode, which also
folds their newer episodes still waiting, up to [profile] max_episodes_per_call. Pending atomic-fact, clustering and Reflection runs
resume as they are.
Full changelog: v1.7.0...v1.7.1