🌐 Lingua

CORE: Il tuo Cervello Digitale - Memoria + Azioni per Strumenti AI

Le tue informazioni critiche sono sparse tra strumenti che non comunicano tra loro. La tua conversazione con l’IA inizia con “ti do un po’ di contesto”. Le tue esperienze e conoscenze sono ancora solo nella tua testa, e la tua testa non è scalabile.

CORE ricorda. Non è un database. Non è una barra di ricerca. È un cervello digitale che apprende ciò che conta, collega ciò che è correlato e ti mostra ciò di cui hai bisogno.

Per gli Sviluppatori

CORE offre ai tuoi strumenti di IA memoria persistente e la capacità di agire nelle app che usi.

Contesto preservato tra Claude Code, Cursor e altri agenti di coding
Esegui azioni su Linear, GitHub, Slack, Gmail, Google Sheets e altre app che utilizzi
Connettiti una volta tramite MCP, funziona ovunque
Open-source e auto-ospitabile; i tuoi dati, il tuo controllo

---

Cosa Puoi Fare

1. Mai ripeterti, il contesto fluisce automaticamente

CORE diventa il tuo strato di memoria persistente per gli agenti di coding. Chiedi a qualsiasi strumento di IA di recuperare il contesto rilevante.

Search core memory for architecture decisions on the payment service

What my content guidelines from core to create the blog?

2. Esegui azioni nelle tue app da Claude/Cursor

Collega le tue app una volta, esegui azioni da qualsiasi luogo.

Crea/Leggi task su GitHub, Linear
Scrivi/Inviia/Leggi email e archivia le informazioni rilevanti in CORE
Gestisci il tuo calendario, aggiorna fogli di calcolo

3. Riprendi da dove avevi lasciato codice claude/cursor

Stai tornando su una funzionalità dopo una settimana? Aggiornati all’istante.

What did we discuss about the checkout flow? Summarize from memory.

Refer to past discussions and remind me where we left off on the API refactor

Cosa Rende CORE Diverso

Grafico del Contesto Temporale: CORE non memorizza solo fatti — ricorda la storia. Quando sono accadute le cose, come si è evoluto il tuo pensiero, cosa ha portato a ogni decisione. Le tue preferenze, obiettivi e scelte passate — tutto collegato in un grafico che comprende sequenza e contesto.

88,24% di Accuratezza nel Richiamo: Testato sul benchmark LoCoMo. Quando chiedi qualcosa a CORE, trova ciò che è rilevante. Non semplice corrispondenza di parole chiave, ma vera comprensione semantica con ragionamento multi-hop.

Tu Hai il Controllo: La tua memoria, le tue regole. Modifica ciò che è errato. Elimina ciò che non appartiene. Visualizza come la tua conoscenza si connette. CORE è trasparente, vedi esattamente ciò che conosce.

Open Source: Nessun black box. Nessun vincolo con fornitori. Il tuo cervello digitale appartiene a te.

---

🚀 Avvio Rapido

Scegli la tua strada:

| | CORE Cloud | Self-Host | |---|---|---| | Tempo di configurazione | 5 minuti | 15 minuti | | Ideale per | Prova veloce, senza infrastruttura | Controllo totale, i tuoi server | | Requisiti | Solo un account | Docker, 4GB RAM |

Cloud

Registrati su app.getcore.me
Collega una fonte (Claude, Cursor, o qualsiasi tool compatibile MCP)
Inizia a usare CORE per eseguire qualsiasi azione o memorizzare informazioni su di te

Self-Host

Distribuzione Rapida

Oppure con Docker

Clona il repository:

git clone https://github.com/RedPlanetHQ/core.git
cd core

Configura le variabili d'ambiente in core/.env:

OPENAI_API_KEY=your_openai_api_key

Avvia il servizio

docker-compose up -d

Una volta distribuito, puoi configurare i tuoi provider AI (OpenAI, Anthropic) e iniziare a costruire il tuo grafo della memoria.

👉 Visualizza la guida completa per il self-hosting

Nota: Abbiamo provato modelli open-source come Ollama o GPT OSS ma la generazione di fatti non era buona, stiamo ancora cercando di capire come migliorare e poi supporteremo anche i modelli OSS.

🛠️ Installazione

Consigliato

Installa su Claude Code CLI

Esegui questo comando nel tuo terminale per connettere CORE con Claude Code:

claude mcp add --transport http --scope user core-memory https://mcp.getcore.me/api/v1/mcp?source=Claude-Code

Digita /mcp e apri MCP di core-memory per l'autenticazione

Installa in Cursor

Da Cursor 1.0, puoi cliccare il pulsante di installazione qui sotto per un'installazione istantanea con un solo clic.

OPPURE

Vai su: Impostazioni -> Strumenti & Integrazioni -> Aggiungi MCP Personalizzato
Inserisci quanto segue nel file mcp.json:

{
  "mcpServers": {
    "core-memory": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=cursor",
      "headers": {}
    }
  }
}

Installare in Claude Desktop

Copia l'URL CORE MCP:

https://mcp.getcore.me/api/v1/mcp?source=Claude

Vai su Impostazioni → Connettori → Fai clic su Aggiungi connettore personalizzato
Fai clic su "Connetti" e concedi a Claude l'autorizzazione per accedere a CORE MCP

CLI

Installa nel Codex CLI

Opzione 1 (Consigliata): Aggiungi al tuo file ~/.codex/config.toml:

[features]
rmcp_client=true[mcp_servers.memory]
url = "https://mcp.getcore.me/api/v1/mcp?source=codex"

Quindi esegui: codex mcp memory login

Opzione 2 (Se l'opzione 1 non funziona): Aggiungi la configurazione della chiave API:

[features]
rmcp_client=true[mcp_servers.memory]
url = "https://mcp.getcore.me/api/v1/mcp?source=codex"
http_headers = { "Authorization" = "Bearer CORE_API_KEY" }

Ottieni la tua chiave API da app.getcore.me → Impostazioni → Chiave API, quindi esegui: codex mcp memory login

Installa in Gemini CLI

Consulta Configurazione di Gemini CLI per i dettagli.

Apri il file delle impostazioni di Gemini CLI. La posizione è ~/.gemini/settings.json (dove ~ è la tua home directory).
Aggiungi quanto segue all'oggetto mcpServers nel tuo file settings.json:

{
  "mcpServers": {
    "corememory": {
      "httpUrl": "https://mcp.getcore.me/api/v1/mcp?source=geminicli",
      "timeout": 5000
    }
  }
}

Se l'oggetto mcpServers non esiste, crealo.

Installa nella Copilot CLI

Aggiungi quanto segue al tuo file ~/.copilot/mcp-config.json:

{
  "mcpServers": {
    "core": {
      "type": "http",
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Copilot-CLI",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

IDE

Installazione in VS Code

Inserisci quanto segue nel file mcp.json:

{
  "servers": {
    "core-memory": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Vscode",
      "type": "http",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Installa in VS Code Insiders

Aggiungi alla tua configurazione MCP di VS Code Insiders:

{
  "mcp": {
    "servers": {
      "core-memory": {
        "type": "http",
        "url": "https://mcp.getcore.me/api/v1/mcp?source=VSCode-Insiders",
        "headers": {
          "Authorization": "Bearer YOUR_API_KEY"
        }
      }
    }
  }
}

Installazione in Windsurf

Inserisci quanto segue nel file mcp_config.json:

{
  "mcpServers": {
    "core-memory": {
      "serverUrl": "https://mcp.getcore.me/api/v1/mcp/source=windsurf",
      "headers": {
        "Authorization": "Bearer "
      }
    }
  }
}

Installa in Zed

Vai su Impostazioni nel Pannello Agente -> Aggiungi Server Personalizzato
Inserisci il codice qui sotto nel file di configurazione e clicca sul pulsante Aggiungi server

{
  "core-memory": {
    "command": "npx",
    "args": ["-y", "mcp-remote", "https://mcp.getcore.me/api/v1/mcp?source=Zed"]
  }
}

Agenti di Codifica

Installazione in Amp

Esegui questo comando nel tuo terminale:

amp mcp add core-memory https://mcp.getcore.me/api/v1/mcp?source=amp

Installa in Augment Code

Aggiungi al tuo file ~/.augment/settings.json:

{
  "mcpServers": {
    "core-memory": {
      "type": "http",
      "url": "https://mcp.getcore.me/api/v1/mcp?source=augment-code",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Installazione in Cline

Apri Cline e clicca sull’icona del menu hamburger (☰) per entrare nella sezione MCP Server
Seleziona la scheda Server Remoti e clicca sul pulsante Modifica Configurazione
Aggiungi quanto segue alla tua configurazione MCP di Cline:

{
  "mcpServers": {
    "core-memory": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Cline",
      "type": "streamableHttp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Installazione in Kilo Code

Vai su Impostazioni → Server MCP → scheda Installato → clicca su Modifica MCP Globale per modificare la tua configurazione.
Aggiungi quanto segue al tuo file di configurazione MCP:

{
  "core-memory": {
    "type": "streamable-http",
    "url": "https://mcp.getcore.me/api/v1/mcp?source=Kilo-Code",
    "headers": {
      "Authorization": "Bearer your-token"
    }
  }
}

Installa in Kiro

Aggiungi in Kiro → MCP Servers:

{
  "mcpServers": {
    "core-memory": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Kiro",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Installazione in Qwen Coder

Consulta Configurazione MCP di Qwen Coder per dettagli.

Aggiungi a ~/.qwen/settings.json:

{
  "mcpServers": {
    "core-memory": {
      "httpUrl": "https://mcp.getcore.me/api/v1/mcp?source=Qwen",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json, text/event-stream"
      }
    }
  }
}

Installazione in Roo Code

Aggiungi alla configurazione MCP di Roo Code:

{
  "mcpServers": {
    "core-memory": {
      "type": "streamable-http",
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Roo-Code",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Installa in Opencode

Aggiungi alla tua configurazione Opencode:

{
  "mcp": {
    "core-memory": {
      "type": "remote",
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Opencode",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      },
      "enabled": true
    }
  }
}

Installa nell'agente di codifica Copilot

Aggiungi a Impostazioni repository → Copilot → Agente di codifica → Configurazione MCP:

{
  "mcpServers": {
    "core": {
      "type": "http",
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Copilot-Agent",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Installa in Qodo Gen

Apri il pannello chat di Qodo Gen in VSCode o IntelliJ
Clicca su Collega altri strumenti, poi clicca su + Aggiungi nuovo MCP
Aggiungi la seguente configurazione:

{
  "mcpServers": {
    "core-memory": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Qodo-Gen"
    }
  }
}

Terminali

Installa in Warp

Aggiungi in Impostazioni → AI → Gestisci server MCP:

{
  "core": {
    "url": "https://mcp.getcore.me/api/v1/mcp?source=Warp",
    "headers": {
      "Authorization": "Bearer YOUR_API_KEY"
    }
  }
}

Installazione in Crush

Aggiungi alla tua configurazione di Crush:

{
  "$schema": "https://charm.land/crush.json",
  "mcp": {
    "core": {
      "type": "http",
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Crush",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

App Desktop

Installa in ChatGPT

Collega ChatGPT al sistema di memoria di CORE tramite estensione del browser:

Installa l'Estensione Core per Browser
Genera una Chiave API: Vai su Impostazioni → Chiave API → Genera nuova chiave → Chiamala "extension"
Aggiungi la Chiave API nell'Estensione Core e clicca su Salva

Installa in Gemini

Collega Gemini al sistema di memoria di CORE tramite estensione del browser:

Installa l'Estensione Core per Browser
Genera una Chiave API: Vai su Impostazioni → Chiave API → Genera nuova chiave → Chiamala "extension"
Aggiungi la Chiave API nell'Estensione Core e clicca su Salva

Installa in Perplexity Desktop

Aggiungi in Perplexity → Impostazioni → Connettori → Aggiungi Connettore → Avanzate:

{
  "core-memory": {
    "command": "npx",
    "args": ["-y", "mcp-remote", "https://mcp.getcore.me/api/v1/mcp?source=perplexity"]
  }
}

Fare clic su Salva per applicare le modifiche
Core sarà disponibile nelle tue sessioni Perplexity

Strumenti di sviluppo

Installa in Factory

Esegui nel terminale:

droid mcp add core https://mcp.getcore.me/api/v1/mcp?source=Factory --type http --header "Authorization: Bearer YOUR_API_KEY"

Digita /mcp all'interno di droid per gestire i server e visualizzare gli strumenti disponibili.

Installazione in Rovo Dev CLI

Modifica la configurazione di mcp:

acli rovodev mcp

Aggiungi alla tua configurazione Rovo Dev MCP:

{
  "mcpServers": {
    "core-memory": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Rovo-Dev"
    }
  }
}

Installazione in Trae

Aggiungi alla configurazione MCP di Trae:

{
  "mcpServers": {
    "core": {
      "url": "https://mcp.getcore.me/api/v1/mcp?source=Trae"
    }
  }
}

🔨 Strumenti Disponibili

CORE Memory MCP fornisce i seguenti strumenti che gli LLM possono utilizzare:

memory_search: Cerca il contesto rilevante in CORE Memory.
memory_ingest: Aggiunge un episodio in CORE Memory.
memory_about_user: Recupera la persona dell'utente da CORE Memory.
initialise_conversation_session: Inizializza la conversazione e assegna un ID sessione alla conversazione.
get_integrations: Recupera quale integrazione rilevante dovrebbe essere utilizzata dalle integrazioni connesse.
get_integrations_actions: Recupera quale strumento deve essere utilizzato dagli strumenti di integrazione per il compito.
execute_integrations_actions: Esegue lo strumento per quell'integrazione.

---

Come Funziona

Ingestione della Memoria

memory-ingest-diagram

Quando salvi un contesto in CORE, attraversa quattro fasi:

Normalizzazione: Collega le nuove informazioni al contesto recente, suddivide i documenti in parti coerenti mantenendo i riferimenti incrociati
Estrazione: Identifica entità (persone, strumenti, progetti), crea dichiarazioni con contesto e tempo, mappa le relazioni
Risoluzione: Rileva contraddizioni, traccia l'evoluzione delle preferenze, preserva prospettive multiple con provenienza
Integrazione nel Grafo: Collega entità, dichiarazioni ed episodi in un grafo di conoscenza temporale

Esempio: "Abbiamo scritto CORE in Next.js" diventa:

Entità: CORE, Next.js
Dichiarazione: CORE è stato sviluppato utilizzando Next.js
Relazione: è stato sviluppato utilizzando

Richiamo della Memoria

memory-search-diagram

Quando interroghi CORE:

Ricerca: Approccio ibrido: keyword + semantica + attraversamento del grafo
Riordina: Mostra i risultati più rilevanti e diversificati
Filtra: Applica filtri su tempo, affidabilità e forza della relazione
Output: Restituisce i fatti E gli episodi da cui provengono

CORE non ricorda solo i fatti — li richiama nel contesto, con tempo e storia, così gli agenti rispondono come faresti tu ricordando.

🛠️ Per i costruttori di agenti

Stai creando agenti AI? CORE ti offre infrastruttura di memoria + integrazioni così puoi concentrarti sulla logica del tuo agente.

Cosa Ottieni

Infrastruttura di Memoria

Grafo di conoscenza temporale con accuratezza LoCoMo dell’88,24%
Ricerca ibrida: semantica + keyword + attraversamento del grafo
Traccia evoluzione del contesto e contraddizioni

Infrastruttura di Integrazioni

Collega GitHub, Linear, Slack, Gmail una sola volta
Il tuo agente ottiene strumenti MCP per tutte le app connesse
Niente flussi OAuth da costruire, niente manutenzione API

Progetti di esempio

core-cli — Un agente task manager che si collega a CORE per la memoria e si sincronizza con Linear, GitHub Issues.

holo — Trasforma la tua memoria CORE in un sito personale con chat.

Risorse

API Reference
Documentazione SDK
Ti serve un’integrazione specifica? Apri una issue su GitHub

---

🔥 Evidenze dalla Ricerca

La memoria CORE raggiunge una precisione media dell’88,24% nel dataset Locomo su tutti i compiti di ragionamento, superando significativamente gli altri fornitori di memoria.

benchmark

| Tipo di Compito | Descrizione | |-----------------|-------------| | Single-hop | Risposte basate su una singola sessione | | Multi-hop | Sintesi di informazioni da più sessioni | | Open-domain | Integrazione di informazioni utente con conoscenza esterna | | Ragionamento temporale | Indizi temporali e comprensione delle sequenze |

Visualizza metodologia e risultati del benchmark →

🔒 Sicurezza

Certificazione CASA Tier 2 — Auditato da terzi per soddisfare i requisiti OAuth di Google.

Crittografia: TLS 1.3 (in transito) + AES-256 (a riposo)
Autenticazione: OAuth 2.0 e magic link
Controllo accessi: Isolamento per workspace, permessi basati sui ruoli
Architettura zero-trust: Mai fidarsi, sempre verificare

I tuoi dati, sotto il tuo controllo:

Modifica ed elimina in qualsiasi momento
Mai utilizzati per l’addestramento di modelli AI
Opzione self-hosting per isolamento totale

Per informazioni dettagliate sulla sicurezza, consulta la nostra Security Policy.

Segnalazione vulnerabilità: harshith@poozle.dev

Documentazione

Esplora la nostra documentazione per ottenere il massimo da CORE

🧑‍💻 Supporto

Hai domande o feedback? Siamo qui per aiutarti:

Discord: Unisciti al canale core-support
Documentazione: docs.getcore.me
Email: manik@poozle.dev

Linee guida sull'utilizzo

Memorizza:

Cronologia delle conversazioni
Preferenze utente
Contesto delle attività
Materiali di riferimento

Non memorizzare:

Dati sensibili (PII)
Credenziali
Log di sistema
Dati temporanei

👥 Contributori

--- Tranlated By Open Ai Tx | Last indexed: 2026-01-10 ---