_OpenSource Web4 agent & app starter kit_

# A memory that keeps what you tell it

Say «remember» to your main agent in Telegram or in the terminal: a phrase, a photo, a PDF or a voice note. Months later ask «remind me about…», and the answer comes back with the date, the source and how sure the memory is. All of it stays on your own computer.

[Start](#turn-on)
[Connect your element](#connect)

## How a memory goes

#### You say «remember»

In your own words and in any language, with a photo, a document or a voice note if you like.

#### Your main agent

Understands what you mean, not a fixed word, and hands the words and the file to the memory.

#### The memory

Describes the file in words, turns a voice note into text, splits the phrase into facts and keeps them in your node.

#### «Remind me about…»

The answer gathers what you said, with the date, the source and how sure it is. If it found a thing, you get its file.

While your computer has more than 1 GB free, the memory stays on. With less, your main agent turns it on for a task and off again. If a reminder waits in its calendar, it stays on.

## On, asleep only when memory is short

The element starts with the node. With less than 0.5 GB of free memory the node may put it to sleep; the first call or a calendar entry wakes it in seconds, and above 1 GB free it comes back by itself.

## What changes for you

| Without it | With the deep memory |
| --- | --- |
| Notes, photos and voice messages are scattered across apps | You send them to one bot, and the node keeps them together |
| Search finds only the exact words you typed | It finds things by meaning, in any language |
| A photo is a file without words | A photo is described in words and found by what is on it |
| You never know where an answer came from | Every answer names the date, the source and how sure it is |
| Your notes sit on someone else's server | They stay on your computer, inside your node |
| The reminder lives in one app and what it is about in another | Say «remind me tomorrow at 9…», and the memory keeps the phrase and puts an entry into its own calendar |

## Whose memory it is

## undefined

**The main agent of the node** — Reads every space: what was said through each element of the node.

- **Mom's element** — Only its own: what she told it, her files, its answers to her.
- **Son's element** — Only its own: his lessons and his questions.
- **Your site** — Only its own: what was said through it.

Each element opens the memory with its own key, and one element never finds what was said to another.

A space is everything said through one element: its rows, its search by meaning, its links in the graph, its files. The element's own key decides the space, so it writes and reads only there, whether it asks to remind, opens the journal or a file.

The main agent writes into its own space and reads them all with the node's data key. What you kept before the spaces came stays with it.

Clearing the journal clears the journal of the element that asked. The main agent clears an element's journal only when it names the element.

The stores behind the memory keep each element apart by its own key too. You own the computer and its disk, and nothing on it is hidden from you.

## A reminder at the minute you set

Tell your main agent «remind me tomorrow at 9 to call mum» or «in a week, remind me about my brother's birthday». It works out the date itself. The phrase is kept as usual, and an entry goes into the memory's calendar.

At that minute the memory's clock posts the words into your main chat by itself, marked «⏰ Reminder». No model takes part, and no tokens are spent.

- Repeats: once, every day, on weekdays, every week, every month or every year.
- The agent answers with the date in words, and the entry shows in the node's menu: «Deep memory → Cron events».
- A wrong or past time is refused, and the phrase is not kept without its reminder.
- If the computer is off at that minute, the reminder does not come, and the calendar shows the missed run.

```
You: remind me tomorrow at 9
to call mum

Agent: I will remind you:
Friday, 6 November 2026
at 09:00 — «call mum».
The entry is in the memory's
calendar.

Friday, 09:00, main chat:
⏰ Reminder · Deep memory
call mum
```

## What it does with each kind of file

| What you send | What the memory does |
| --- | --- |
| A photo or a picture | Describes it in words and keeps the picture with the description |
| A PDF | Reads it whole and keeps it with a description, so you find it by what it says |
| A voice note | Turns it into text and reads it like any phrase |
| A video | Reads the frames and the sound when the computer has ffmpeg |
| Documents and code | Reads them as text; code is never run |
| A text longer than 2,000 words | Keeps it whole as one thing, without splitting it into facts |

## How to talk to it

There are no forms to fill in and no menus to learn. You talk to your main agent the way you would talk to a person, and it knows when you mean the memory.

- «remember…», «note down», «save this», «don't forget» — the memory keeps it.
- «remind me about…», «what did I say about…» — the memory answers with what you said before.
- «remind me tomorrow at 9…», «every Monday, remind me…» — the memory puts a reminder into its calendar.
- A photo, a document or a voice note with a few words — kept together and found together.

## Start in three steps

1. Add your OpenAI key in the core's settings. The memory uses it to search by meaning, to hear voice notes and to split phrases into facts.
2. Connect your main agent's Telegram bot in the core, so you can talk to it from your phone.
3. Say «remember…» to it. That is all.

Without the key the memory still keeps what you say, but it does not search by meaning and does not hear voice notes.

## Connect your element

Any element of your node can keep things in the memory and ask it with two calls on this computer, using its own key.

```
// In your element's server code, on this computer: the port comes from the node, the key is your element's own
const base = `http://127.0.0.1:${port}`
const headers = { 'content-type': 'application/json', 'X-Element-Key': process.env.ELEMENT_KEY }
// no from: your own key is your space
await fetch(`${base}/v1/remember`, { method: 'POST', headers, body: JSON.stringify({ text: 'the taxi from the airport cost 40 euro' }) })
const answer = await fetch(`${base}/v1/recall`, { method: 'POST', headers, body: JSON.stringify({ text: 'how much was the taxi?' }) }).then((r) => r.json())
// → { ok: true, text, objects, certainty, answer_id, … }
```

The answer carries the text, the things it found, how sure it is and an `answer_id`. Your element can comment on the answer with `POST /v1/feedback`, and the full contract is at `GET /v1/contract`.

## Under the hood

| Part | What it does |
| --- | --- |
| The data element | Keeps every phrase as a row in the node's database |
| The vectors element | Finds what you said by meaning |
| The graph element | Keeps the facts and their links in a space of their own |
| The storage element | Keeps the photos, documents and recordings |
| OpenAI `gpt-6-luna` | Splits a phrase into facts and describes pictures and PDFs, for a fraction of a cent |
| OpenAI `whisper-1` | Turns voice notes into text |
| Your node | Keeps the memory on while the computer has more than 1 GB free; with less, your main agent turns it on for a task |

## Your own builder comes with it

Every element of the node comes with its own Claude Code agent and can get its own Telegram bot. When something in this element should change, write to its bot from your phone, and the agent updates the logic or the design.

The agent works only in its element's folder and never reads the whole node, so each change costs fewer tokens. Your Claude Code subscription pays for it.

- The element's bot is connected in the core, on its «Telegram» page.
- The agent returns a commit; you look at it in «Preview» and accept it or turn it down.
- At the computer, the agent's terminal is in the core, in this element's «Build».

## Open source

Built by Fractera for the [Lagrix](https://lagrix.dev) protocol and for any web2 project that needs a memory. MIT license, the code is at [github.com/Fractera/fractera-memory-starter](https://github.com/Fractera/fractera-memory-starter).

## Questions and answers

**What can I send it?**
A phrase, a photo, a PDF or a voice message, in any language, through the main agent in Telegram or in the terminal.

**How do I know where an answer came from?**
Every answer carries the date, the source and how sure the memory is.

**Does it work while the computer is busy?**
With less than 1 GB free the main agent turns it on for a task and off after it; a waiting reminder keeps it on.

**Can I keep backups?**
Yes. The element is ready for its programmer agent to set up backups on a schedule or by hand: tell the element's agent in Telegram or in the terminal. It makes no copies on its own until you ask.