Skip to content

EverOS 1.7.1

Latest

Choose a tag to compare

@github-actions github-actions released this 20 Nov 07:48
· 8 commits to main since this release
f1fa762

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 new language LLM task
    (everalgo LanguageDetector), 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.md and docs/configuration.md.
  • OME strategies summarize_episode and split_episode_by_owner, both on
    by default and named so in ome.toml. summarize_episode writes each
    episode's display summary (below); split_episode_by_owner hands each
    owner's copy of an episode to the profile as an EpisodeExtractedForOwner
    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/add request with the sender <device_id>@<slot>, so every person
    gets their own episodes and profile, read, searched and deleted by that id
    as user_id on the existing routes. Utterances nobody was identified for
    are filed under the device id; a speaker with consented: false is not
    written at all (one decline in a batch drops all of that slot's lines); a
    speaker sent without display_name keeps 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 by MemoryService.add_device. async_mode queues the batch as on /memory/add (202,
    with the same owners). Existing request bodies are unchanged. See
    docs/device-assistant.md and docs/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_chat or failed) per memcell; episode_written with language and
    language_from (decided or text); atomic_facts_extracted gains
    language; user_profile_extracted gains language and language_from
    (frozen or event); reflection_merged gains language and
    language_from (profile, vote or text).
  • everalgo-user-memory 0.9.0 -> 0.10.1, which only adds
    LanguageDetector.
  • Episode hybrid search 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_k now 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. radius floors 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, whose top_k counted episodes and facts together.
  • Episode agentic search 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 backfill no
    longer embed an episode's subject, one embedding call fewer per episode,
    and nothing searches the subject vector. The subject_vector column stays
    in the index schema, left empty, so existing stores open with no migration
    or rebuild.
  • Episode vector search reads 200 atomic facts whatever the top_k, and
    returns at most 50 episodes when top_k is -1.
  • Agent case and skill hybrid search recall top_k * 2 per lane, and 50
    when top_k is -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 case agentic search returns at most 10 cases when
    top_k is -1, as skill search does.
  • One EpisodeExtracted per memcell. The event announces a memcell's
    episode once and lists every owner's copy in copies (each with its
    owner_id, entry_id and owner_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 on EpisodeExtractedForOwner. 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_clustering likewise 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_episode then 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,
    /get and /search return 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_profile runs on
    EpisodeExtractedForOwner, so each owner's profile update is a run of its
    own, with its own retries.
  • UserMemoryPipeline no longer takes summary_llm, and EpisodeStore has a
    new method, replace_summary, a compare-and-set of one entry's summary.
  • The locomo and locomo-step benchmark configs, which turn the profile off,
    also turn split_episode_by_owner off. 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_foresight strategy (off by default since
    1.2.3; no route ever returned its output), the foresight daily log,
    index table and cascade kind, [llm.foresight], and the
    UserPipelineStarted event it was the only subscriber of. A queued
    foresight run left by an earlier release is dropped with an
    ome_run_dropped_unknown_strategy warning. On its first start, a store that ran
    foresight has its foresight index table / collection and every
    .foresights/ folder removed (logged as retired_kind_data_removed):
    nothing reads them, and purge and deletion no longer reach them.

Fixed

  • everos demo keeps 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.
    A SKILL.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 the extract_agent_skill run.

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