YourMemory

La tua IA ha la memoria di un pesce rosso. Non più.

Memoria persistente e auto-migliorativa per agenti AI — basata sulla scienza di come gli umani ricordano.

▶ Prova la demo interattiva dal vivo · Sito web · Benchmark

Il problema

Ogni mattina il tuo agente AI ti tratta come uno sconosciuto. Stesso contesto ri-spiegato. Stesse preferenze dimenticate. Ogni sessione ricomincia da zero.

La maggior parte degli strumenti di "memoria" collega un database vettoriale a un agente e lo considera finito — ma quella è solo archiviazione. Accumula ogni quasi-duplicato finché il recupero non annega nel rumore. Un pesce rosso con una ciotola più grande.

YourMemory è diverso: memoria che funziona come un cervello, non un database.

flowchart LR
    A["🧠 Tu dici qualcosa<br/>al tuo AI"] --> B["Estrae fatti<br/>durevoli"]
    B --> C["Dedup + embed<br/>+ grafo-collega"]
    C --> D[("Archivio<br/>memoria")]
    D -->|"i fatti correlati si accumulano"| E["✨ Consolida<br/>N → 1 riassunto"]
    D -->|"obsoleto + non usato"| F["📉 Decadimento<br/>+ potatura"]
    D -->|"nuova sessione"| G["♻️ Recupero<br/>ibrido + grafo"]
    E --> D
    G --> H["🤖 Il tuo agente<br/>riprende da dove<br/>aveva lasciato"]
    style D fill:#0a2540,stroke:#19cdff,color:#fff
    style E fill:#0c2b3a,stroke:#5eead4,color:#fff
    style H fill:#0c2b3a,stroke:#19cdff,color:#fff

✨ Cosa lo rende diverso

Un comando per installare. DuckDB per impostazione predefinita (zero configurazione), Postgres + pgvector per i team.

Indice

• 🏆 Benchmark
• 🚀 Avvio rapido
• 🧠 Come funziona la memoria
  • Consolidamento
  • Decadimento
  • Recupero ibrido
• 🔒 Fiducia e traccia di controllo
• 👥 Pool di memoria di squadra
• 🛡️ Diritti dei dati e conformità
• 🎛️ Dashboard
• 🔧 Strumenti MCP
• ⚡ Chiedi senza chiamata LLM
• 🔀 Proxy API — Memoria garantita
• 🏗️ Architettura e stack
• 🩺 Risoluzione dei problemi
• 🤝 Contribuire

🏆 Benchmark

Tre dataset esterni. Ogni numero indipendentemente riproducibile — il codice dei benchmark vive nel repository. Metodologia completa in BENCHMARKS.md.

LoCoMo-10 — memoria conversazionale multi-sessione

xychart-beta
    title "Recall@5 · LoCoMo-10 (più alto è meglio)"
    x-axis ["Mem0", "Zep Cloud", "Supermemory", "YourMemory"]
    y-axis "percentuale Recall@5" 0 --> 70
    bar [18, 28, 31, 59]

Recupero 2× migliore di Zep Cloud su tutti i 10 campioni. *Supermemory e Mem0 hanno esaurito le quote del livello gratuito a metà benchmark; punteggi calcolati sull'intero insieme di 1.534 coppie.

LongMemEval-S — 500 domande, ~53 sessioni distrattore ciascuna

Il benchmark standard più difficile per la memoria a lungo termine. Ogni domanda è sepolta in circa 53 sessioni.

HotpotQA — 200 domande multi-hop

Gli archi del grafo delle entità aggiungono +12 pp — attraversano dal Fatto 1 al Fatto 2 anche quando il Fatto 2 ha una bassa similarità di embedding con la query.

Articolo: Ho costruito il decadimento della memoria per agenti AI usando la curva dell'oblio di Ebbinghaus

🚀 Avvio rapido

Python 3.11–3.14. Nessun Docker, nessuna configurazione del database. Tutta la memoria archiviata localmente in ~/.yourmemory/.

pip install yourmemory
yourmemory-register <il-tuo-token>
yourmemory-setup

Ottieni il tuo token: visita yourmemoryai.xyz → inserisci la tua email → verifica con un codice a 6 cifre → copia il tuo token.

yourmemory-setup rileva e configura automaticamente Claude Code, Claude Desktop, Cursor, Windsurf e Cline, poi chiede quale backend utilizzare:

• DuckDB — zero configurazione, singolo file locale (predefinito)
• Postgres — condiviso / produzione; fornisci un DATABASE_URL (necessita dell'estensione pgvector)

Opzionale — estrazione locale più intelligente: YourMemory funziona subito con euristiche incorporate. Per un'estrazione di fatti completamente locale di qualità superiore, installa Ollama e yourmemory-setup scarica il modello (qwen2.5:7b, ~4.7 GB) automaticamente. Preferisci il cloud? Imposta YOURMEMORY_EXTRACT_BACKEND=anthropic.

Oppure installa da un binario — nessun Python richiesto

Preferisci non toccare pip? Scarica il binario autonomo per la tua piattaforma dall'ultima release:

# macOS / Linux — scarica, estrai, esegui
tar -xzf yourmemory-macos-arm64.tar.gz
./yourmemory-macos-arm64 register <il-tuo-token>
./yourmemory-macos-arm64 setup
./yourmemory-macos-arm64            # avvia il server

Un singolo eseguibile gestisce ogni comando: register, setup, ask "<domanda>", path e (senza argomenti) avvia il server.

Completamente autonomo e offline — il binario raggruppa Python, ogni dipendenza e entrambi i modelli ML (il modello di embedding + spaCy). Nulla viene scaricato al primo avvio. Il compromesso è la dimensione (~2 GB). Costruisci il tuo con un singolo comando — ./build-binary.sh — e i binari per più piattaforme vengono prodotti automaticamente dal workflow di build.

🧠 Come funziona la memoria

YourMemory tratta la memoria come un sistema vivente — cresce, consolida, dimentica e collega, come fa un cervello.

Consolidamento — N → 1

La maggior parte degli strumenti di memoria continua solo a crescere. YourMemory osserva i cluster di fatti correlati e, una volta che se ne accumulano abbastanza, li comprime in un unico riassunto pulito — archiviando gli originali (mai cancellando, quindi nulla viene perso).

flowchart LR
    subgraph before [I fatti correlati si accumulano]
        A1["Railway usa Nixpacks"]
        A2["Railway su piano Pro"]
        A3["Le variabili d'ambiente di Railway<br/>contengono l'URL Postgres"]
        A4["Distribuisce su Railway<br/>con Postgres"]
    end
    before --> C{"cluster +<br/>LLM riassume"}
    C --> S["✨ Riassunto<br/>Distribuisce su Railway (Pro,<br/>Nixpacks) con Postgres<br/>tramite variabili d'ambiente"]
    C -.->|"archiviato, recuperabile"| ARC[("archivio")]
    style S fill:#0a2540,stroke:#5eead4,color:#fff
    style C fill:#0c2b3a,stroke:#19cdff,color:#fff

Esempio reale da un archivio di produzione: 444 memorie → 16 riassunti — stessa conoscenza, una frazione del rumore. Il consolidamento è guidato dagli eventi (innescato quando le memorie correlate si accumulano), non un lavoro notturno cieco.

Decadimento — la curva dell'oblio

La forza della memoria decade esponenzialmente. L'importanza e la frequenza di richiamo rallentano quel decadimento:

λ_effettivo  = λ_base × (1 − importanza × 0.8)
forza        = clamp(importanza × e^(−λ_effettivo × giorni_attivi) × (1 + conteggio_richiami × 0.2), 0, 1)

giorni_attivi conta solo i giorni in cui eri attivo — le vacanze non causano perdita di memoria. Le memorie con forza inferiore a 0.05 vengono potate automaticamente. Ogni categoria invecchia al proprio ritmo:

Potatura sensibile al grafo: una memoria decaduta viene mantenuta in vita se un qualsiasi vicino del grafo è ancora forte — il contesto portante sopravvive anche quando viene interrogato raramente direttamente.

Recupero ibrido — Vettore + BM25 + Grafo

Il recupero avviene in due round in modo da portare in superficie sia ciò che hai chiesto sia ciò che hai dimenticato di chiedere:

flowchart LR
    Q["query"] --> R1["Ricerca ibrida<br/>Vettore + BM25"]
    R1 --> R2["Espansione del grafo<br/>(quello che hai dimenticato di chiedere)"]
    R2 --> S["classifica per<br/>similarità × forza"]
    S --> OUT["🎯 Memorie classificate"]
    style OUT fill:#0a2540,stroke:#19cdff,color:#fff

Deduplicazione sensibile al soggetto viene eseguita prima di ogni archiviazione — incorpora il soggetto di ogni frase in modo che "Sachit usa DuckDB" e "YourMemory usa DuckDB" rimangano separati (entità diverse), mentre "YourMemory usa DuckDB" e "YourMemory archivia dati in DuckDB" si fondono (stessa entità). Nessuna lista di parole codificata; si generalizza a qualsiasi lingua.

🔒 Fiducia e traccia di controllo

Le aziende non permetteranno a una scatola nera opaca di memorizzare i loro dati. Quindi ogni operazione — lettura, scrittura, aggiornamento, cancellazione, consolidamento — viene aggiunta a un registro di controllo con catena di hash, a prova di manomissione.

flowchart LR
    E0["GENESI"] --> E1
    subgraph E1 [Evento 1]
        H1["row_hash =<br/>sha256(prev + dati)"]
    end
    E1 --> E2
    subgraph E2 [Evento 2]
        H2["row_hash =<br/>sha256(#1.hash + dati)"]
    end
    E2 --> E3
    subgraph E3 [Evento 3]
        H3["row_hash =<br/>sha256(#2.hash + dati)"]
    end
    E3 --> V{"GET /audit/verify"}
    V -->|catena intatta| OK["✅ verificato"]
    V -->|qualsiasi riga alterata| BAD["❌ catena si rompe<br/>in quella riga"]
    style OK fill:#0a2540,stroke:#5eead4,color:#fff
    style BAD fill:#3a0c14,stroke:#fb7185,color:#fff

Ogni riga registra il timestamp, l'attore utente + agente, l'azione, l'operazione, la memoria di destinazione, la fonte (http vs mcp) e l'hash della riga precedente. Modifica qualsiasi record storico e verify_chain() individua esattamente dove la catena si è rotta.

GET  /audit            # sfoglia la traccia (filtra per utente / azione / operazione)
GET  /audit/verify     # verifica crittograficamente che la catena non sia manomessa
POST /audit/prune      # pulizia basata sulla retention (minimo 90 giorni, mai inferiore)

La registrazione degli audit è fail-open — non blocca mai un'operazione di memoria — e gli eventi di lettura/elenco dal ciclo di rendering del dashboard sono esclusi, quindi la traccia rimane segnale, non rumore.

👥 Pool di memoria di squadra

Dai a tutti gli agenti di una squadra un unico cervello condiviso — senza far trapelare il contesto privato di nessuno. Le memorie sono condivise (visibili al pool) o private (visibili solo al loro proprietario).

flowchart TB
    P(("🧠 Pool di squadra<br/>memoria condivisa"))
    A["Agente di Alice"] <-->|condivisa| P
    B["Agente di Bob"] <-->|condivisa| P
    C["Agente di Carol"] <-->|condivisa| P
    A -. privata .-> AP["🔒 Solo Alice"]
    B -. privata .-> BP["🔒 Solo Bob"]
    style P fill:#0a2540,stroke:#19cdff,color:#fff
    style AP fill:#0c1424,stroke:#5a6b80,color:#8294a8
    style BP fill:#0c1424,stroke:#5a6b80,color:#8294a8

L'accesso basato sui ruoli è applicato per agente — ciò che l'agente di un ingegnere impara, l'intera squadra ne beneficia immediatamente; il contesto sensibile rimane confinato al suo proprietario.

POST   /pools                          # crea un pool
POST   /pools/{id}/members             # aggiungi un membro (con ruolo)
POST   /pools/{id}/memories            # contribuisci con una memoria condivisa
POST   /pools/{id}/retrieve            # recupera attraverso il pool

🛡️ Diritti dei dati e conformità

Poiché la memoria che archivia dati reali necessita dei controlli per essere affidabile:

Combinata con la traccia di controllo con catena di hash e il minimo di retention di 90 giorni, queste si mappano direttamente sui controlli documentati in SECURITY.md (allineati SOC 2).

🎛️ Dashboard

Due interfacce browser integrate — nessuna configurazione aggiuntiva, si avviano automaticamente con il server.

Dashboard della memoria — http://localhost:3033/ui

Una vista completa di lettura/scrittura con schede Memorie · Audit · Pool: barra delle statistiche (Forte / In decadimento / Quasi potatura), schede per agente, schede memoria con barre di forza in tempo reale, filtri per categoria, la traccia di controllo e la gestione dei pool.

Visualizzatore del grafo — http://localhost:3033/graph

Una mappa interattiva a forza diretta di come le memorie si collegano — memoria radice come nodo luminoso, vicini codificati a colori per categoria, spessore degli archi = forza della connessione. Trascina, zoomma e clicca su qualsiasi nodo per il contenuto completo.

http://localhost:3033/graph?memoryId=42&userId=alex&depth=2

🔧 Strumenti MCP

Tre strumenti, chiamati automaticamente dal tuo AI.

# Archivia con contesto spaziale
store_memory(
    "Alex preferisce i tab agli spazi in Python",
    importance=0.9, category="fact",
    context_paths=["/projects/backend"],
)

# Prossima sessione — il potenziamento spaziale si attiva quando si lavora in quella directory
recall_memory("formattazione Python", current_path="/projects/backend")
# → {"content": "Alex preferisce i tab agli spazi in Python", "strength": 0.87}

⚡ Chiedi senza chiamata LLM

L'unico sistema di memoria in grado di rispondere alle domande senza effettuare alcuna chiamata API LLM:

yourmemory ask "che database usa questo progetto"
# → YourMemory usa DuckDB localmente e Postgres in produzione.

yourmemory ask "come si risolve un deployment kubernetes"
# → Contesto di memoria insufficiente per rispondere senza un LLM.

Quando la memoria è abbastanza forte, risponde istantaneamente — zero token, zero costo cloud, zero latenza. Quando non lo è, rifiuta educatamente piuttosto che allucinare. La tua query non lascia mai la tua macchina.

🔀 Proxy API — Memoria garantita

Gli strumenti MCP vengono chiamati a discrezione dell'AI. Il proxy API rimuove questa incertezza — intercetta ogni chiamata LLM, inietta automaticamente le memorie pertinenti e gestisce store_memory / update_memory senza configurazione del modello.

Avvia il server (yourmemory), poi punta il tuo client su localhost:3033:

from anthropic import Anthropic

client = Anthropic(
    api_key="sk-ant-...",
    base_url="http://localhost:3033/proxy/anthropic",
    default_headers={"X-YourMemory-User": "alex"},  # memoria per utente
)

# La memoria viene iniettata automaticamente — nessun'altra modifica necessaria
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Che database uso?"}],
)

OpenAI funziona in modo identico tramite base_url="http://localhost:3033/proxy/openai".

🏗️ Architettura e stack

flowchart LR
    C["Il tuo client AI<br/>Claude · Cursor · qualsiasi MCP"] <--> Y["🧠 YourMemory"]
    Y --> M[("Archivio<br/>memoria")]
    Y --> A[("Registro<br/>audit")]
    style Y fill:#0a2540,stroke:#19cdff,color:#fff
    style M fill:#0c1a2c,stroke:#5eead4,color:#fff
    style A fill:#0c1a2c,stroke:#5eead4,color:#fff

🩺 Risoluzione dei problemi

Le scritture si bloccano / vanno in timeout (lock single-writer di DuckDB). Se il server MCP e il server HTTP vengono eseguiti contemporaneamente, competono per il lock di scrittura di DuckDB. Soluzione:

pkill -f yourmemory 2>/dev/null || true
rm -f ~/.yourmemory/memories.duckdb.wal ~/.yourmemory/memories.duckdb.lock 2>/dev/null || true
# riavvia il tuo client

Stai eseguendo Claude Desktop (MCP) e Claude Code (hook) contemporaneamente? Usa SQLite invece — gestisce lettori/scrittori concorrenti in modo pulito: DATABASE_URL=sqlite:///~/.yourmemory/memories.db

🤝 Contribuire

Le PR sono benvenute — vedi CONTRIBUTORS.md.

📚 Riferimenti ai dataset

• LoCoMo — Maharana et al. (2024)
• LongMemEval — Wu et al. (2024)
• HotpotQA — Yang et al. (2018)

📄 Licenza

Copyright 2026 Sachit Misra — Licenziato sotto CC-BY-NC-4.0.

Gratuito per uso personale, educativo, ricerca accademica e progetti open-source. L'uso commerciale richiede un accordo scritto separato → [email protected]