DOCUMENTACIÓN

La capa de conocimiento soberano para inteligencia artificial.

VISIÓN

ChainMemory no es una herramienta de memoria. Es una capa de conocimiento soberano para sistemas de IA.

Todos los modelos de IA actuales sufren la misma limitación fundamental: cuando una conversación termina, todo lo aprendido desaparece. El contexto se pierde. Las decisiones se olvidan. El progreso se reinicia a cero. ChainMemory existe para resolver esto permanentemente.

Las memorias que guardás son el mecanismo. El Project State — una vista estructurada, versionada y consolidada del conocimiento de tu proyecto — es el producto. La blockchain es la prueba. Y la interoperabilidad entre cualquier modelo de IA es la consecuencia.

Qué permite ChainMemory

• Memoria portable entre modelos — Tu conocimiento funciona con ChatGPT hoy, Claude mañana, y cualquier modelo futuro. Sin vendor lock-in, nunca.
• Continuidad verificable — Cada estado de proyecto se ancla on-chain con una prueba criptográfica. Podés demostrar que una decisión existía en un momento específico.
• Pista de auditoría de decisiones — Cada decisión se rastrea hasta las conversaciones que la produjeron. Procedencia completa, responsabilidad total.
• Identidad persistente para flujos de IA — Tu asistente de IA no arranca de cero en cada sesión. Hereda el conocimiento acumulado de cada interacción previa.
• Conocimiento soberano — Vos sos dueño de tus datos. No OpenAI, no Anthropic, no Google. Tus memorias viven en tu cuenta, ancladas a una blockchain pública que podés verificar de forma independiente.

QUÉ ES CHAINMEMORY

ChainMemory es una plataforma de memoria persistente, portable y verificable para inteligencia artificial. Cada conversación importante, cada decisión, cada contexto de proyecto se guarda como una memoria individual, vinculada a un proyecto, y anclada en una blockchain soberana.

Tu IA olvida cada vez que cerrás la pestaña. ChainMemory resuelve eso. Funciona con ChatGPT, Claude, Gemini, Copilot, Perplexity y cualquier modelo que soporte MCP o API.

POR QUÉ CHAINMEMORY

El problema es invisible hasta que perdés semanas de trabajo

Cada conversación con IA hoy empieza de cero. La IA no recuerda qué decidiste ayer, qué arquitectura elegiste la semana pasada, ni por qué rechazaste un enfoque hace tres meses. Los equipos que usan IA acumulan conocimiento crítico — y lo pierden cuando cierran la pestaña.

Antes y después

Qué lo hace diferente

Otras herramientas guardan conversaciones. ChainMemory guarda conocimiento — estructurado, verificado y portable. La diferencia:

• Estructurado, no crudo — El Motor de Consolidación extrae decisiones, hitos, riesgos y stack de conversaciones crudas. Obtenés un Project State, no un dump de transcripciones.
• Verificado, no confiado — Cada estado es hasheado y anclado on-chain. Cualquiera puede verificar de forma independiente sin depender de los servidores de ChainMemory.
• Portable, no bloqueado — Funciona con ChatGPT, Claude, Gemini, Copilot, Perplexity y cualquier herramienta compatible con MCP. Tu conocimiento se mueve con vos.
• Inyectado, no buscado — El contexto se inyecta automáticamente en nuevas conversaciones con IA. La IA recibe lo que necesita sin que copies ni pegues nada.

INICIO RÁPIDO

Guardar → Recuperar → Verificar → Probar en 5 minutos

Prerequisitos

• Google Chrome (o cualquier navegador Chromium)
• Una cuenta ChainMemory — creá una acá
• Tu API Key (desde la configuración de la Extensión o el dashboard)

Opción A — Extensión Chrome (más rápida)

Opción B — Servidor MCP (para Claude / Cursor)

Opción C — API REST (control total)

Opción D — Hermes Agent

Hermes Agent es un framework de agentes IA open-source. Usá ChainMemory dentro de Hermes mediante el servidor MCP (herramientas nativas en el chat) o el wrapper cm.py CLI (control total desde terminal).

Configurar MCP

Editá ~/.hermes/config.yaml y agregá:

YAML
mcp_servers:
  chainmemory:
    command: "python"
    args: ["C:\\Users\\\\.hermes\\skills\\chainmemory-mcp\\chainmemory_mcp_server.py"]
    env:
      CHAINMEMORY_API_KEY: "aic_..."

Reiniciá Hermes. Las herramientas aparecen como mcp_chainmemory_* en el chat.

O usá cm.py CLI

Instalá el skill de ChainMemory y usá cm save, cm recall, cm state desde terminal.

Verificar

En el chat de Hermes: "Recordá: decidimos usar PostgreSQL". O ejecutá cm whoami en terminal.

bash
# 1. Guardar una memoria
curl -X POST https://api.chainmemory.ai/v1/memory \
  -H "x-api-key: TU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"summary":"Decidimos usar PostgreSQL para la DB de usuarios","category":"decision","importance":8}'

# 2. Recuperar memorias
curl https://api.chainmemory.ai/v1/memories/list?project=mi-proyecto \
  -H "x-api-key: TU_API_KEY"

# 3. Obtener estado del proyecto (incluye hash)
curl https://api.chainmemory.ai/v1/project/mi-proyecto/state \
  -H "x-api-key: TU_API_KEY"

# 4. Verificar ancla (público — sin autenticación)
curl https://api.chainmemory.ai/v1/project/mi-proyecto/state/anchor

CREÁ TU CUENTA

Registro

Las cuentas de ChainMemory se crean a través de la Extensión Chrome. Tu cuenta te da acceso a los tres métodos de integración: Extensión, Servidor MCP, y API REST.

Creá tu primer proyecto

Los proyectos agrupan memorias relacionadas. Cada proyecto tiene su propia línea de tiempo, estado consolidado, y ancla on-chain independiente.

bash
curl -X POST https://api.chainmemory.ai/v1/projects \
  -H "x-api-key: tu-api-key" \
  -H "Content-Type: application/json" \
  -d '{"name": "mi-saas", "description": "Mi producto SaaS"}'
    

Resumen de credenciales

ARQUITECTURA

ChainMemory tiene una arquitectura de 3 capas:

Capa 1: Captura

La extensión Chrome, el servidor MCP o llamadas directas a la API capturan contenido de conversaciones con IA. El contenido se procesa, se le asignan tags, y se vincula a un proyecto.

Capa 2: Almacenamiento y Consolidación

Cada memoria se guarda en la base de datos episódica con su hash SHA-256. El Motor de Consolidación analiza las memorias y extrae operaciones estructuradas: decisiones, hitos, riesgos, stack tecnológico, dependencias.

Capa 3: Verificación On-Chain

El estado consolidado de cada proyecto se ancla periódicamente en la blockchain ChainMemory (Chain ID 202604). El hash del estado se registra en el contrato ProjectStateAnchor, creando una prueba inmutable de que ese estado existió en ese momento.

Pipeline
Conversación IA
      |
  Extensión / MCP / API
      |
  Memoria (hash SHA-256)
      |
  Motor de Consolidación (modelo de IA)
      |
  Project State (decisiones, hitos, riesgos, stack)
      |
  Anchor on-chain (tx hash + block number)
      |
  Verificación pública (/v1/project/:name/state/anchor)

CÓMO SE COMPARA CHAINMEMORY

ChainMemory opera en el espacio emergente de infraestructura de memoria para IA. Así se compara con las principales soluciones en 2026:

Matriz de Comparación

Comparaciones Detalladas

ChainMemory vs. Mem0

Mem0 se enfoca en personalización de usuario — extrae facts de conversaciones para construir perfiles. ChainMemory se enfoca en conocimiento de proyecto — extrae decisiones, hitos y riesgos para construir un estado auditable. Mem0 es ideal para "recordar que el usuario prefiere modo oscuro". ChainMemory es ideal para "probar que esta decisión arquitectónica fue tomada el 15 de mayo por Claude basándose en estas 5 conversaciones".

ChainMemory vs. Zep / Graphiti

El motor Graphiti de Zep es excelente en knowledge graphs temporales — rastreando cuándo un hecho se volvió válido y cuándo fue reemplazado, con búsqueda híbrida (semántica + BM25 + traversal de grafos). ChainMemory provee semántica de supersesión temporal similar pero agrega una capa que Zep no tiene: anclaje on-chain. Cuando necesitás probarle a un regulador o auditor que una decisión existía en un momento específico, ChainMemory da prueba criptográfica. Zep da garantía basada en confianza.

ChainMemory vs. Cognee

Cognee es un potente pipeline de procesamiento de datos — ingesta 30+ fuentes, construye knowledge graphs con tripletas sujeto-relación-objeto, soporta múltiples backends. ChainMemory es más opinado: procesa solo memorias de conversaciones IA, pero extrae inteligencia de proyecto estructurada (6 categorías) en vez de nodos genéricos de knowledge graph.

ChainMemory vs. Supermemory

Supermemory se enfoca en memoria semántica a escala — liviano, rápido, corre local, top-ranked en benchmarks. ChainMemory está optimizado para conocimiento de proyecto estructurado con verificación blockchain. Supermemory es la mejor opción para agentes de código que necesitan recall semántico rápido. ChainMemory es la mejor opción cuando necesitás probar qué decidió una IA y por qué.

CONCEPTOS

El modelo Event-Sourcing

ChainMemory sigue una arquitectura event-sourcing. Entender este patrón es clave para entender todo el sistema.

En sistemas tradicionales, guardás el estado actual y lo sobreescribís en cada cambio. En event-sourcing, guardás cada cambio como un evento inmutable, y el estado actual se deriva reproduciendo esos eventos.

En ChainMemory:

• Las memorias son eventos — Cada memoria es un registro inmutable de algo que pasó: se tomó una decisión, se identificó un riesgo, se eligió una tecnología, se alcanzó un hito.
• El Project State es una vista materializada — El Motor de Consolidación procesa todos los eventos-memoria y produce un snapshot estructurado: el Project State. No se almacena directamente — se computa desde el log de eventos.
• La blockchain es la autoridad de tiempo — Cuando un Project State se ancla on-chain, la blockchain certifica que esta vista materializada específica existía en ese block height exacto.

Patrón
Memoria #1 (evento) ─┐
Memoria #2 (evento) ─┤
Memoria #3 (evento) ─┼──→ Motor de Consolidación ──→ Project State v1 ──→ Anchor (bloque 120000)
Memoria #4 (evento) ─┤
Memoria #5 (evento) ─┘

Memoria #6 (evento) ─┐
Memoria #7 (evento) ─┼──→ Motor de Consolidación ──→ Project State v2 ──→ Anchor (bloque 123539)
Memoria #8 (evento) ─┘

Esto significa que siempre podés reconstruir cualquier versión del Project State reproduciendo las memorias hasta ese punto. El log de eventos es la fuente de verdad. El estado es una capa de conveniencia. El anchor es la prueba.

Qué es una memoria

Una memoria es la unidad fundamental de ChainMemory. Es un fragmento de información extraído de una conversación con IA que se considera valioso para el futuro del proyecto.

Cada memoria contiene:

• Contenido — El texto de la conversación o nota
• Hash — SHA-256 del contenido, inmutable
• Proyecto — A qué proyecto pertenece
• Tags — Etiquetas libres para organización (decisión, bug, arquitectura, idea, etc.). Los tags son para tu uso — el Motor de Consolidación usa su propia estructura de 6 categorías (ver Project State)
• Número — Secuencial dentro de tu cuenta (#1, #2...)
• Fuente — Desde dónde se guardó (extensión, MCP, API)
• Timestamp — Momento exacto de creación

Proyectos

Un proyecto agrupa memorias relacionadas. Cada proyecto tiene su propia línea de tiempo, estado consolidado, y ancla on-chain independiente.

Ejemplos de proyectos: mi-saas, tesis-ml, chainmemory, app-mobile.

Project State

El Project State es el resultado del Motor de Consolidación: un modelo de IA analiza todas las memorias del proyecto y extrae información estructurada. Es el corazón de ChainMemory — transforma fragmentos de conversación en una base de conocimiento organizada y auditable.

Las 6 Categorías

Ciclo de Vida del Estado

El estado es incremental: cada consolidación parte de la versión anterior y aplica solo las operaciones nuevas. Esto crea una cadena de versiones con integridad completa:

Cadena de versiones
v1 (3 memorias)  ──hash──▶  v2 (8 memorias)  ──hash──▶  v3 (15 memorias)
     │                           │                           │
     └─ anclado bloque 80,467   └─ anclado bloque 81,102   └─ anclado bloque 82,340

Cada versión contiene:

• state_hash — SHA-256 del estado completo, enlazado a la versión anterior
• version — Número secuencial (v1, v2, v3...)
• previous_hash — Hash de la versión anterior (null para v1)
• operations — Qué cambió: adiciones, actualizaciones, supersesiones
• anchor_tx — Hash de transacción on-chain (una vez sellado)

Ejemplo Real: Project State Completo

JSON — Project State v4
{
  "project_id": "payment-system-v2",
  "version": 4,
  "state_hash": "a3f8c2...e91d",
  "previous_hash": "7b2e1a...f4c0",
  "context": {
    "summary": "Sistema de pagos con aislamiento multi-tenant y detección de fraude",
    "goals": ["Procesar 1000 tx/seg", "Cumplimiento PCI DSS Level 1", "Latencia sub-200ms"]
  },
  "decisions": [
    {
      "id": "d001", "title": "Usar Stripe para procesamiento de pagos",
      "status": "active", "evidence": ["#12", "#45", "#67"],
      "rationale": "Mejor documentación de API, confiabilidad de webhooks, PCI compliance integrado"
    },
    {
      "id": "d002", "title": "PostgreSQL con RLS para multi-tenancy",
      "status": "active", "evidence": ["#15", "#23"]
    },
    {
      "id": "d003", "title": "Usar MySQL para multi-tenancy",
      "status": "superseded", "superseded_by": "d002", "evidence": ["#8"]
    }
  ],
  "milestones": [
    {"id": "m001", "title": "Schema de BD", "status": "completed", "date": "2026-05-15"},
    {"id": "m002", "title": "Integración de pagos", "status": "pending"}
  ],
  "risks": [
    {"id": "r001", "title": "Performance de RLS con 100K tenants", "severity": "medium"}
  ],
  "stack": [
    {"name": "Node.js", "version": "22", "role": "runtime"},
    {"name": "PostgreSQL", "version": "16", "role": "primary-db"},
    {"name": "Redis", "version": "7", "role": "cache"}
  ],
  "dependencies": [
    {"name": "Stripe API", "type": "external", "critical": true}
  ]
}

Operaciones del Motor de Consolidación

• ADD — Nueva decisión, hito, riesgo o entrada de stack detectada en el contenido de la memoria
• UPDATE — Entrada existente recibe nueva evidencia, estado actualizado o detalles enriquecidos
• SUPERSEDE — Una decisión es reemplazada por una más nueva (ambas preservadas en el historial)
• COMPLETE — Un hito pasa de pendiente a completado con fecha
• ESCALATE — La severidad de un riesgo aumenta basándose en nueva evidencia

Mejores Prácticas

• Guardá decisiones explícitamente — "Decidimos usar X porque Y" se consolida mejor que "tal vez deberíamos probar X"
• Incluí la justificación — El motor extrae el razonamiento del contenido. Cuanto más contexto des, más rico será el estado
• Sellá regularmente — Anclá tu estado on-chain después de hitos importantes para crear checkpoints inmutables
• Revisá decisiones reemplazadas — Cuentan la historia de cómo evolucionó tu proyecto. No las ignores

Cadena de evidencia

Cada decisión, hito y riesgo en el Project State lleva un campo evidence — un array de referencias a memorias que justifican su existencia.

JSON
{
  "id": "d001",
  "title": "Usar consenso Clique PoA",
  "statement": "Blockchain soberana usa Proof of Authority para anclaje rápido y económico",
  "status": "vigente",
  "evidence": ["#12", "#45", "#67"]
}

Esto crea una cadena de procedencia completa:

• La decisión d001 existe porque las memorias #12, #45 y #67 la respaldan
• Cada memoria tiene un hash SHA-256 que prueba que su contenido no cambió
• El Project State que contiene esta decisión tiene un state_hash anclado on-chain
• El ancla on-chain tiene un tx_hash y block number que prueban cuándo se registró

Desde una sola decisión, podés rastrear el camino completo: decisión → memorias de respaldo → hashes de contenido → hash del estado → prueba on-chain. Esto es lo que hace que las decisiones de ChainMemory sean auditables e inalterables.

Resolución de conflictos

Cuando dos memorias contienen información contradictoria, el Motor de Consolidación aplica una estrategia de resolución determinística:

Precedencia temporal

La memoria más reciente tiene prioridad. Si la Memoria #20 dice "Usaremos PostgreSQL" y la Memoria #40 dice "Cambiamos a ClickHouse", el motor marca la decisión de PostgreSQL como reemplazada y crea una nueva decisión activa para ClickHouse.

Supersesión explícita

El motor detecta patrones de lenguaje que indican cambio de dirección: "en vez de", "reemplazando", "decidimos cambiar", "ya no usamos". Cuando se detecta, la decisión anterior se marca explícitamente como reemplazada con referencia a la nueva.

Ciclo de vida de estados

Flujo de estados
vigente ──→ reemplazada    (sustituida por una decisión más nueva)
vigente ──→ en evaluación  (bajo revisión, aún no confirmada)
en evaluación ──→ vigente  (confirmada tras evaluación)
en evaluación ──→ rechazada (descartada)

Acumulación de evidencia

Cuando múltiples memorias refuerzan la misma decisión, el motor las agrega al array de evidencia en lugar de crear duplicados. Una decisión con evidencia de 5 memorias es más sólida que una con una sola referencia.

Gobernanza del estado

El ciclo de vida del Project State está gobernado por reglas claras:

Quién puede consolidar?

Solo el dueño del proyecto (la cuenta que lo creó) puede disparar una consolidación. Esto asegura que la extracción de conocimiento estructurado siempre esté controlada por el dueño de los datos.

Cuándo ocurre la consolidación?

• Manual — Vía la herramienta MCP chainmemory_seal, la API, o la vista Project Brain de la extensión
• Automática — Después de un número configurable de nuevas memorias (default: cada 10 nuevas memorias)

Se puede revertir?

Cada consolidación crea una nueva versión (v1, v2, v3...). Las versiones anteriores siguen accesibles. No podés borrar una versión, pero siempre podés consolidar de nuevo para producir un estado corregido. La cadena de versiones es append-only.

Snapshots

Cada versión del Project State es un snapshot. La combinación de número de versión + state_hash + ancla on-chain crea un checkpoint verificable. Podés obtener cualquier versión histórica vía GET /v1/project/:name/state?version=2.

Hash y verificación

Cada memoria genera un hash SHA-256 de su contenido. Este hash es la huella digital única e inmutable de esa memoria. El contenido no se puede modificar sin cambiar el hash.

El state hash es un hash del estado consolidado completo (todas las decisiones, hitos, riesgos, etc.). Este state hash se ancla en la blockchain mediante una transacción en el contrato ProjectStateAnchor.

Verificación pública

La verificación en ChainMemory es pública y sin permisos. Cualquier persona puede:

1. Llamar a GET /v1/project/:name/state/anchor (no requiere API key)
2. Obtener el state_hash y el tx_hash de la transacción
3. Verificar en el explorer que la transacción existe
4. Leer el contrato directamente en la blockchain para confirmar que el hash coincide

Esto demuestra que el estado del proyecto existía exactamente así en el momento del anclaje. No se puede falsificar retroactivamente.

Modelo de privacidad

Una preocupación común con sistemas basados en blockchain es la exposición de datos. ChainMemory aborda esto con una separación estricta:

Qué se guarda dónde

El registro on-chain contiene solamente: identificador del proyecto (hasheado), número de versión del estado, hash del estado, y timestamp. Desde una transacción de blockchain, es imposible reconstruir el contenido de ninguna memoria o los detalles de ninguna decisión.

Este diseño significa que ChainMemory puede proveer verificación criptográfica sin comprometer la privacidad. La blockchain prueba que un estado existió, no qué contenía.

EXTENSIÓN CHROME

Instalación

1. Ir a la Chrome Web Store
2. Click en "Agregar a Chrome"
3. El icono de ChainMemory aparece en la barra de extensiones
4. Click en el icono y creá tu cuenta o iniciá sesión
5. Seleccioná o creá un proyecto

Guardar memorias

Desde cualquier chat de IA soportado, la extensión detecta automáticamente la conversación activa. Tenés dos formas de guardar:

Botón flotante

Un botón dorado aparece en la esquina del chat. Un clic extrae el contenido de la conversación, lo procesa, y lo guarda como memoria.

Popup de la extensión

Click en el icono de ChainMemory en la barra del navegador. Seleccioná el proyecto destino, agregá tags opcionales, y confirmá.

Rescatar tu historial

No tenés que empezar de cero. La extensión puede guardar mensajes de tu historial de chats existente — conversaciones de hace semanas o incluso meses. Abrí cualquier conversación pasada en una IA compatible, y la opción "Save to ChainMemory" funciona en los mensajes viejos igual que en un chat en vivo.

Esto significa que el conocimiento que ya acumulaste en tus conversaciones con IA se convierte en memoria soberana y portable desde el primer día. Una vez guardada, asignás cada memoria al proyecto que quieras — uno existente o uno nuevo — y la organizás como cualquier otra.

Cada memoria guardada recibe:

• Hash SHA-256 único del contenido
• Número secuencial dentro de tu cuenta (#1, #2, #3...)
• Tags para organización (decisión, arquitectura, bug, etc.)
• Vinculación al proyecto activo
• Timestamp del momento de guardado

Inyectar contexto

La función más poderosa: antes de iniciar una nueva conversación con cualquier IA, ChainMemory puede inyectar automáticamente el contexto relevante de tus memorias previas.

Esto significa que tu nueva conversación arranca con el conocimiento acumulado de conversaciones anteriores. Tu IA sabe qué decidiste, qué tecnologías usás, cuáles son tus prioridades.

Cómo funciona

1. Abrí un nuevo chat en cualquier plataforma soportada
2. La extensión detecta el campo de texto
3. Seleccioná las memorias o el estado del proyecto a inyectar
4. El contexto se inserta automáticamente como primer mensaje

Project Brain (Visor de Project State)

Project Brain es el visor de Project State integrado en la extensión — una vista consolidada y estructurada de todo lo que tu proyecto sabe. El Motor de Consolidación analiza todas tus memorias y extrae:

• Decisiones — Qué se decidió y por qué (estado: vigente, reemplazada, en evaluación)
• Hitos — Logros completados y pendientes con fechas
• Riesgos — Amenazas identificadas con severidad y estado
• Stack tecnológico — Herramientas y tecnologías del proyecto
• Dependencias — Relaciones externas
• Contexto — Resumen ejecutivo del proyecto

Este estado tiene un fingerprint verificable anclado on-chain. Podés demostrar que tu proyecto tenía exactamente ese estado en un momento dado.

Plataformas soportadas

La extensión funciona con cualquier chat de IA basado en web:

• ChatGPT (chat.openai.com)
• Claude (claude.ai)
• Gemini (gemini.google.com)
• Perplexity (perplexity.ai)
• Copilot (copilot.microsoft.com)
• Hermes Agent (agent.nousresearch.com) — vía servidor MCP o wrapper cm.py

Si la plataforma tiene un campo de texto y muestra conversaciones, ChainMemory puede capturar el contenido.

SERVIDOR MCP

Configuración

El servidor MCP permite a Claude Desktop, Cursor y otras herramientas compatibles acceder a ChainMemory como herramienta nativa.

Instalación

Agregá esta configuración a tu archivo claude_desktop_config.json:

JSON
{
  "mcpServers": {
    "chainmemory": {
      "command": "npx",
      "args": ["-y", "chainmemory-mcp"],
      "env": {
        "CHAINMEMORY_API_KEY": "tu-api-key"
      }
    }
  }
}

Herramientas disponibles

Una vez configurado, tu IA tiene acceso a estas herramientas:

Consolidación Autónoma (Fase B)

Desde MCP v2.4.0, cualquier cliente de IA puede consolidar el estado del proyecto de forma autónoma usando el tool update_project_state. Esto implementa la arquitectura “el cliente consolida, la cadena verifica”:

Gramática de Operaciones (22 ops)

Cada operación tiene un tipo (op) y argumentos específicos. Usá evidence_memory_ids (array de IDs de memorias) para vincular evidencia — el servidor resuelve los event hashes automáticamente.

Ejemplo

JSON — llamada update_project_state
{
  "project": "mi-proyecto",
  "ops": [
    {
      "op": "add_decision",
      "title": "Migrar a PostgreSQL",
      "statement": "SQLite no soporta escrituras concurrentes a la escala actual",
      "evidence_memory_ids": [142, 145]
    },
    {
      "op": "set_metric",
      "name": "db_migration_status",
      "value": "planificando"
    },
    {
      "op": "add_milestone",
      "title": "Migración a PostgreSQL aprobada por el equipo",
      "status": "done",
      "evidence_memory_ids": [145]
    }
  ],
  "consolidated_until_event": 150
}

Flujo de trabajo

Workflows Avanzados

Claude Desktop — Sesiones de Arquitectura

Claude es excelente para diseño de alto nivel. Usá ChainMemory para preservar decisiones arquitectónicas entre sesiones:

Patrón de prompt — Claude Desktop
"Antes de empezar, inyectá mi contexto de proyecto desde ChainMemory.
Diseñemos el sistema de autenticación.

Después de decidir, guardá las decisiones clave en ChainMemory con tags
'architecture' y 'auth'. Marcá importancia 0.9 para todo lo que
afecte a otros miembros del equipo."

Cursor — Código con Memoria

La integración MCP de Cursor permite que tu IA de código recuerde por qué se escribió código de cierta manera:

JSON — Config MCP de Cursor
{
  "mcpServers": {
    "chainmemory": {
      "command": "npx",
      "args": ["-y", "chainmemory-mcp"],
      "env": {
        "CHAINMEMORY_API_KEY": "tu-api-key"
      }
    }
  }
}

Workflow efectivo en Cursor:

• Inicio de sesión — "Inyectá contexto del proyecto" carga decisiones, stack y hitos recientes
• Durante el código — "Guardá: implementé webhook handler con retry logic, 3 intentos con backoff exponencial"
• Bug fixes — "Guardá: arreglé race condition en procesamiento de pagos — el webhook de Stripe llegaba antes de que la transacción de BD se committeara"
• Fin de sesión — "Sellá el project state" ancla todo on-chain

Windsurf — Memoria Agéntica

El modo Cascade de Windsurf se beneficia de la memoria persistente en sus sesiones autónomas de código. La configuración es idéntica: agregar el bloque MCP en la configuración de Windsurf.

Patrón de Memoria Agéntica

El patrón MCP más poderoso es la memoria agéntica — donde la IA gestiona proactivamente su propio conocimiento:

System prompt para memoria agéntica
Tenés acceso a ChainMemory vía MCP. Seguí estas reglas:

1. Al inicio: llamá inject_memories para cargar contexto
2. Al tomar una decisión significativa: guardala con chainmemory_remember
   - Incluí POR QUÉ elegiste este enfoque
   - Etiquetá con el dominio relevante (architecture, implementation, security)
   - Importancia 0.7+ para decisiones, 0.5 para observaciones
3. Al completar un hito: guardalo y mencioná qué sigue
4. Al identificar un riesgo: guardalo con evaluación de severidad
5. Al finalizar: llamá chainmemory_seal para anclar el estado

API REST

Autenticación

Todas las llamadas a la API requieren autenticación mediante API Key en el header:

HTTP
x-api-key: tu-api-key

Base URL: https://api.chainmemory.ai/v1

Memorias

bash
curl -X POST https://api.chainmemory.ai/v1/memory \
  -H "x-api-key: tu-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "summary": "Decidimos usar PostgreSQL en vez de MongoDB",
    "category": "decision",
    "importance": 8,
    "platform": "manual"
  }'

javascript
const res = await fetch('https://api.chainmemory.ai/v1/memory', {
  method: 'POST',
  headers: {
    'x-api-key': 'tu-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    summary: 'Decidimos usar PostgreSQL en vez de MongoDB',
    category: 'decision',
    importance: 8,
    platform: 'api'
  })
});
const memory = await res.json();
// { id: 207, hash: '0x4f2a...', memory_number: 42 }

python
import requests

res = requests.post(
    'https://api.chainmemory.ai/v1/memory',
    headers={'x-api-key': 'tu-api-key'},
    json={
        'summary': 'Decidimos usar PostgreSQL en vez de MongoDB',
        'category': 'decision',
        'importance': 8,
        'platform': 'api'
    }
)
memory = res.json()
# {'id': 207, 'hash': '0x4f2a...', 'memory_number': 42}

Parámetros

Proyectos

Respuesta
{
  "project": "chainmemory",
  "version": 3,
  "state": {
    "context": {
      "summary": "Plataforma de memoria IA con verificación blockchain",
      "goals": ["Memoria persistente cross-model", "Pista de auditoría criptográfica"]
    },
    "decisions": [
      {
        "id": "d001",
        "title": "Usar Clique PoA",
        "statement": "Consenso PoA para blockchain soberana",
        "status": "vigente",
        "evidence": ["#12", "#45"]
      }
    ],
    "milestones": [
      {
        "id": "m001",
        "title": "MVP API desplegado",
        "status": "completed",
        "date": "2026-04-15",
        "evidence": ["#5", "#18"]
      }
    ],
    "risks": [
      {
        "id": "r001",
        "title": "Latencia del motor de consolidación a escala",
        "severity": "medium",
        "status": "open",
        "mitigation": "Evaluar modelos más grandes al escalar infra",
        "evidence": ["#33"]
      }
    ],
    "stack": [
      {
        "name": "Node.js",
        "category": "runtime",
        "evidence": ["#2"]
      },
      {
        "name": "Geth (Clique PoA)",
        "category": "blockchain",
        "evidence": ["#12"]
      }
    ]
  },
  "state_hash": "a7b3c9f2...",
  "anchor": {
    "status": "anchored",
    "tx_hash": "0xce55a800...",
    "block_number": 123539
  }
}

Inyección

Respuesta

El endpoint devuelve las memorias seleccionadas formateadas para inyección. Cada memoria llega con su número visible para el usuario y una referencia de verificación, de modo que una IA puede citar la memoria exacta detrás de cualquier afirmación — y vos podés rastrear esa cita hasta su evidencia on-chain. Una afirmación deja de ser "confiá en mí" y pasa a ser "acá está la memoria, verificala vos mismo."

Verificación

Respuesta
{
  "project": "chainmemory",
  "projectId": "0x77f7d980...",
  "version": 3,
  "state_hash": "a7b3c9f2...",
  "anchor": {
    "status": "anchored",
    "tx_hash": "0xce55a800a2a4e30b...",
    "block_number": 123539,
    "contract": "0xa7A8BA51950255b3e223a6745597C67009Fe7875"
  }
}

Códigos de error

Equivalencia de funciones: Extensión ↔ MCP ↔ API

No todas las funciones están disponibles en todos los métodos de integración. Esta tabla muestra qué hay disponible dónde:

Confianza y Gobierno

Cada memoria lleva un estado de confianza desde el momento en que se escribe: trusted, tentative (marcada al escribirse por reglas de evaluación deterministas), o quarantined (condenada por el dueño). Las tentative siempre se entregan marcadas — el agente ve la marca y decide. Las quarantined se excluyen de context, inject, quotes y consultas al oracle, mientras su huella on-chain permanece como evidencia inmutable. Todas las respuestas de lectura incluyen el campo trust.

bash
curl -X POST https://api.chainmemory.ai/v1/memories/487/trust \
  -H "x-api-key: tu-api-key" \
  -H "Content-Type: application/json" \
  -d '{"action": "quarantine"}'

Acciones: approve → trusted · quarantine → quarantined · tentative → tentative. La respuesta incluye el estado anterior para auditoría.

bash
curl https://api.chainmemory.ai/v1/memory/485/forensics \
  -H "x-api-key: tu-api-key"

Eventos: born, trust, batched, checkpoint_anchored, recalled (cada lectura, con endpoint y consulta), injected (cada entrega, con plataforma destino), cited_as_evidence (ítems del Project Brain que citan esta memoria). Incluye contadores con verificación cruzada y prueba de anclaje on-chain. Responde la pregunta forense: qué memoria causó qué, cuándo entró, quién la leyó y a dónde llegó.

bash
curl -X POST https://api.chainmemory.ai/v1/project/miproyecto/state/rollback \
  -H "x-api-key: tu-api-key" \
  -H "Content-Type: application/json" \
  -d '{"to_version": 35}'

Restauración append-only: volver a la versión N jamás borra nada — crea una versión nueva cuyo contenido es byte-idéntico a N. Como los hashes se computan sobre bytes canónicos, el hash de la versión nueva es igual al ya anclado on-chain para N: la fidelidad de la restauración es un hecho matemático, no una promesa. Antes de restaurar, el servidor recomputa el hash del contenido almacenado y se niega (HTTP 409) si no coincide — la corrupción nunca puede restaurarse. La historia jamás se muta.

RED

Datos de la red

Contratos desplegados

El Token AIC es la moneda nativa de la red (no es un contrato ERC-20). Se usa para pagar el gas de transacciones al anclar estados y registrar memorias.

Conectar MetaMask

Para agregar ChainMemory a MetaMask:

1. Ir a chainmemory.ai/network
2. Click en "Add ChainMemory to MetaMask"
3. Confirmar en MetaMask

O agregala manualmente con los datos de la tabla anterior.

Faucet

El faucet entrega AIC gratis para que puedas interactuar con la blockchain:

• URL: faucet.chainmemory.ai
• Cantidad: 1 AIC por claim
• Cooldown: 72 horas entre claims
• Requisito: Resolver un challenge simple (anti-bot)

PROTOCOLO DE IDENTIDAD IA

Cada agente de IA que usa ChainMemory obtiene una identidad única e intransferible en la blockchain — un Soulbound Token (SBT) que prueba quién escribió una memoria, cuándo y desde qué modelo. Esta es la base de la confianza en un mundo multi-agente.

El Problema

En los sistemas de IA actuales, no hay forma de responder preguntas fundamentales:

• ¿Qué IA escribió esta respuesta? ¿Fue Claude, GPT-4, o un modelo fine-tuned?
• ¿Es el mismo agente con el que trabajé ayer, o una instancia diferente?
• ¿Puedo confiar en la memoria de este agente si no conozco su identidad?
• ¿Cómo pruebo la procedencia cuando múltiples agentes colaboran?

Sin identidad, no hay responsabilidad. Sin responsabilidad, no hay confianza.

Cómo Funciona

Detalles del Contrato

Trust Score (Roadmap)

El protocolo de identidad habilita un futuro AI Trust Score — una métrica de reputación basada en interacciones verificables:

• Cantidad de memorias — ¿Cuántas memorias verificadas ha producido este agente?
• Consistencia — ¿Con qué frecuencia las memorias del agente pasan la validación anti-alucinación?
• Tasa de anclaje — ¿Qué porcentaje de memorias están respaldadas por pruebas on-chain?
• Historial de colaboración — ¿Ha participado este agente en workflows multi-agente?

Identidad en Workflows Multi-Agente

Cuando múltiples agentes colaboran en el mismo proyecto (ver Sistemas Multi-Agente), las contribuciones de cada agente se atribuyen individualmente:

Cadena de evidencia
Proyecto: "payment-system-v2"
├── Memoria #1 por Claude (ai_id: 0xA1...) — "Usar Stripe para pagos"
├── Memoria #2 por GPT-4 (ai_id: 0xB2...) — "Agregar capa de detección de fraude"
├── Memoria #3 por Cursor (ai_id: 0xC3...) — "Implementado handler de webhooks"
└── Estado v4 anclado — los 3 agentes contribuyeron, todo verificable

La identidad de cada agente es verificable independientemente on-chain. No hay ambigüedad sobre quién contribuyó qué.

Verificar una Identidad

Podés verificar cualquier identidad de IA usando la blockchain directamente:

JavaScript (ethers.js)
const { ethers } = require('ethers');
const provider = new ethers.JsonRpcProvider('https://rpc.chainmemory.ai');

const IDENTITY_CONTRACT = '0xe8E195ba416Fb25F4FC3d0E7908ff9e8666dbb4A';
const ABI = ['function balanceOf(address) view returns (uint256)'];

const contract = new ethers.Contract(IDENTITY_CONTRACT, ABI, provider);
const hasIdentity = await contract.balanceOf(agentWallet);

console.log(hasIdentity > 0 ? 'Identidad IA verificada' : 'Sin identidad registrada');

SISTEMAS MULTI-AGENTE

ChainMemory fue diseñado desde cero para un mundo donde múltiples agentes de IA colaboran en el mismo proyecto. Cada agente lee el mismo Project State, cada contribución se atribuye individualmente, y cada handoff es trazable.

El Problema Multi-Agente

Los flujos de trabajo de desarrollo modernos ya involucran múltiples agentes de IA:

• Claude diseña la arquitectura y escribe documentación
• Cursor implementa el código con asistencia IA inline
• GPT-4 revisa PRs y analiza implicaciones de seguridad
• Gemini procesa codebases grandes para sugerencias de refactoring

Sin memoria compartida, cada agente empieza de cero. Las decisiones tomadas en Claude son invisibles para Cursor. La arquitectura acordada en GPT es desconocida para Gemini. Vos te convertís en el cuello de botella — constantemente re-explicando contexto.

Cómo ChainMemory Resuelve Esto

Project State Compartido

Todos los agentes conectados al mismo proyecto ven el mismo estado consolidado: decisiones, hitos, riesgos, stack y contexto. Cuando Claude marca una decisión como "active", Cursor la ve inmediatamente.

Flujo de Estado Compartido
┌──────────┐    ┌──────────────────────────┐    ┌──────────┐
│  Claude  │───▶│                          │◀───│  Cursor  │
│  (MCP)   │    │   Proyecto ChainMemory   │    │  (MCP)   │
└──────────┘    │                          │    └──────────┘
                │  decisions: [d001, d002]  │
┌──────────┐    │  milestones: [m001]      │    ┌──────────┐
│  GPT-4   │───▶│  risks: [r001, r002]     │◀───│  Gemini  │
│  (API)   │    │  stack: [Node, Redis]    │    │  (API)   │
└──────────┘    └──────────────────────────┘    └──────────┘

Patrón Agent Handoff

Cuando el trabajo pasa de un agente a otro, ChainMemory proporciona transferencia de contexto sin fricciones:

Claude guarda
chainmemory_remember({
  content: "Usar PostgreSQL con row-level security para aislamiento multi-tenant",
  tags: ["architecture", "database", "security"],
  importance: 0.9
})

Cursor recibe (via inject)
Project State v3:
- Decisión d001: "Usar PostgreSQL con RLS" (active, evidence: #12, #15)
- Decisión d002: "API REST con endpoints versionados" (active, evidence: #18)
- Hito m001: "Schema de BD completo" (pendiente)
- Riesgo r001: "Performance de RLS en tenants grandes" (medio, evidence: #15)

Patrones de Handoff

Resolución de Conflictos Entre Agentes

Cuando dos agentes toman decisiones contradictorias, la Resolución de Conflictos de ChainMemory aplica las mismas reglas:

• Precedencia temporal — La decisión más reciente gana, sin importar qué agente la tomó
• Peso de evidencia — Una decisión respaldada por 5 memorias de 3 agentes es más fuerte que una con una sola memoria
• Supersesión explícita — Cualquier agente puede explícitamente reemplazar una decisión anterior referenciándola
• Auditoría completa — Tanto la decisión original como la que la reemplaza se preservan con su respectiva atribución de ai_id

Configurar Multi-Agente

No se necesita configuración especial. Cualquier agente conectado al mismo proyecto participa automáticamente en la colaboración multi-agente:

1. Crear un proyecto vía Extension, MCP, o API
2. Usar la misma API key en todos los agentes (o crear keys específicas por agente bajo la misma cuenta)
3. Cada agente usa inject_memories al inicio de sesión para cargar contexto compartido
4. Cada agente usa chainmemory_remember para guardar contribuciones
5. El Motor de Consolidación fusiona todas las contribuciones en el Project State unificado

GUÍA DE AUDITORÍA

Una de las capacidades más poderosas de ChainMemory es permitir auditorías verificables de decisiones de proyecto asistidas por IA — sin exponer el contenido privado de las conversaciones.

Dos niveles de auditoría

Nivel 1 — Auditoría externa (sin acceso del dueño)

Cualquiera puede verificar que un estado de proyecto fue anclado en un momento específico, sin ver qué contiene. Es como ver un sello notarial cerrado — sabés que existe, no sabés qué dice adentro.

Lo que un auditor externo ve (público, on-chain):

Nivel 1 — Endpoint público
GET /v1/project/nova-logistics/state/anchor

Respuesta:
{
  "project": "nova-logistics",
  "projectId": "0x77f7d980...",     // hasheado — nombre original no se revela
  "version": 5,
  "state_hash": "a7b3c9f2e1...",   // prueba que el estado existió, no revela contenido
  "anchor": {
    "status": "anchored",
    "tx_hash": "0xce55a800...",
    "block_number": 125000,
    "contract": "0xa7A8BA51...e7875"
  }
}

Nivel 2 — Auditoría con disclosure selectivo (el dueño comparte datos)

El dueño del proyecto elige qué compartir con el auditor. El auditor verifica los datos compartidos contra la prueba on-chain. Esta es la auditoría poderosa: demostrás que los datos son auténticos sin intermediarios.

El dueño controla exactamente qué se revela:

Proceso de auditoría paso a paso

Ejemplo: NovaTech, una startup construyendo un SaaS de logística. Después de 4 meses usando ChatGPT y Claude alternadamente, el CTO necesita demostrar trazabilidad del proyecto a inversores.

bash
curl -H "x-api-key: cto-api-key" \
  https://api.chainmemory.ai/v1/project/nova-logistics/state
    

bash
curl -sO https://docs.chainmemory.ai/verify_state.py
python3 verify_state.py state.json
# computed state_hash : 0xa7b3c9f2e1d4...
# declared state_hash : 0xa7b3c9f2e1d4... -> MATCH
# on-chain state_hash : 0xa7b3c9f2e1d4... -> ON-CHAIN MATCH
    

bash
curl https://api.chainmemory.ai/v1/project/nova-logistics/state/anchor
# Retorna: state_hash: "a7b3c9f2e1d4..."
    

Garantías de privacidad durante la auditoría

La garantía crítica: el dueño siempre controla el disclosure.

• Los inversores ven decisiones e hitos — no las conversaciones crudas de IA que las produjeron
• La blockchain prueba autenticidad sin revelar contenido
• El texto de memorias (contenido real de conversaciones) solo es visible si el dueño lo exporta explícitamente
• El registro on-chain contiene solo hashes — aunque la blockchain sea pública, el conocimiento de tu proyecto permanece privado
• Ningún tercero, incluyendo ChainMemory mismo, puede forzar el disclosure del contenido de memorias

QUÉ PREVIENE CHAINMEMORY

Entender contra qué protege ChainMemory es tan importante como entender qué hace.

Pérdida de contexto

Cada conversación de IA hoy es efímera. Cerrás la pestaña y todo lo discutido — decisiones, elecciones de arquitectura, hallazgos de investigación — desaparece. ChainMemory captura esto como memorias permanentes y recuperables. Tu próxima sesión arranca donde terminó la anterior.

Vendor lock-in

Si el conocimiento de tu proyecto existe solo dentro del historial de conversaciones de ChatGPT, estás atrapado. ChainMemory almacena conocimiento independientemente de cualquier proveedor de IA. Cambiá de ChatGPT a Claude a Gemini sin perder una sola decisión o contexto.

Manipulación retroactiva

Sin prueba criptográfica, cualquiera podría afirmar "decidimos X" cuando la decisión real fue Y. El anclaje on-chain de ChainMemory crea un registro a prueba de manipulación. El state hash en el bloque 123539 prueba exactamente cuál era el estado del proyecto en ese momento. No se puede alterar después del hecho.

Fragmentación de conocimiento

Equipos que usan IA terminan con conocimiento crítico disperso en docenas de conversaciones desconectadas, en diferentes herramientas, con diferentes modelos. ChainMemory consolida todo en un único Project State estructurado — sin importar qué IA o herramienta produjo la conversación original.

Dependencia de una sola IA

Cuando un proveedor de IA se cae, cambia su API, o depreca una funcionalidad, proyectos que dependen exclusivamente de ese proveedor pierden continuidad. La arquitectura cross-model de ChainMemory asegura que tu conocimiento acumulado es accesible desde cualquier sistema de IA compatible.

Deriva invisible de decisiones

En proyectos de largo plazo, las decisiones evolucionan durante meses. Sin un sistema que rastree qué cambió, cuándo, y por qué, los equipos pierden el hilo de su propio razonamiento. El ciclo de vida de decisiones del Motor de Consolidación (vigente → reemplazada) con cadenas de evidencia hace cada evolución rastreable.

MODELO DE CONFIANZA

Qué podés — y qué no podés — confiar

ChainMemory combina una API centralizada con verificación descentralizada. Entender los límites de confianza es crítico para evaluar si ChainMemory cumple tus requisitos de seguridad.

Tabla de garantías

Niveles de confianza

Soberanía — no-custodial

ChainMemory está migrando a un modelo no-custodial donde tu llave vive en tu cliente, no en el servidor. Vos firmás tus propias escrituras on-chain; el servidor guarda el texto cifrado y verifica las firmas, pero nunca tiene tu llave privada. Esto se probó de punta a punta — una memoria escrita 100% del lado del cliente, con el servidor sin tocar nunca la llave.

MODELO DE AMENAZAS

Ataques, detección y lo que está fuera de alcance

Ningún sistema es invulnerable. Esta sección mapea la superficie de ataque, qué detecta o previene ChainMemory, y qué sigue siendo responsabilidad del usuario.

Vectores de ataque

Fuera de alcance

ChainMemory no protege contra:

• Usuario almacenando información falsa — si guardás una mentira como memoria, ChainMemory la ancla fielmente. El sistema garantiza integridad (los datos no cambiaron), no veracidad (los datos eran correctos).
• Dispositivo del usuario comprometido — si tu máquina tiene malware, tu API Key y datos locales están expuestos antes de llegar a ChainMemory.
• Alucinaciones de la IA — ChainMemory almacena lo que vos guardás, no lo que una IA genera. No valida si la salida de la IA fue precisa.

VERIFICACIÓN INDEPENDIENTE

Verificá anclas on-chain sin confiar en nadie

No necesitás la API de ChainMemory para verificar que un estado de proyecto fue anclado en un bloque específico. Esta página muestra cómo verificar directamente contra la blockchain usando herramientas Web3 estándar.

Qué necesitás

• El hash del estado del proyecto (de la API o compartido por alguien)
• El hash de la transacción o número de bloque del ancla
• Node.js con ethers instalado — o cualquier librería Web3

Paso 1 — Obtener los datos del ancla

Usá el endpoint público (sin autenticación) de ChainMemory o recibilos de quien compartió la prueba:

bash
curl https://api.chainmemory.ai/v1/project/chainmemory/state/anchor

Respuesta
{
  "project": "chainmemory",
  "projectId": "0x77f7d980...",
  "version": 8,
  "state_hash": "0xa6c45d1db753b1ec96240d169b2d91fb0ce76112558b302a8822b2988aeb8212",
  "anchor": {
    "status": "anchored",
    "onchain_anchor_id": 8,
    "tx_hash": "0x95b732d20b8935a2...",
    "block_number": 173831,
    "contract": "0xa7A8BA51950255b3e223a6745597C67009Fe7875"
  },
  "verify": "ProjectStateAnchor.getStateAnchor(projectId, version)"
}

Paso 2 — Verificar on-chain con Ethers.js

Conectate directamente al RPC de ChainMemory y leé el smart contract. Sin API Key, sin cuenta, sin confianza requerida.

javascript
import { ethers } from 'ethers';

// Conectar al RPC de ChainMemory — sin API Key necesaria
const provider = new ethers.JsonRpcProvider('https://rpc.chainmemory.ai');

// Contrato ProjectStateAnchor
const CONTRACT = '0xa7A8BA51950255b3e223a6745597C67009Fe7875';
const ABI = [
  'function getStateAnchor(bytes32 projectId, uint64 version) view returns (bytes32 stateHash, uint256 anchoredAt, address anchoredBy, uint256 anchorId)'
];

const contract = new ethers.Contract(CONTRACT, ABI, provider);

// El project ID es el keccak256 del nombre del proyecto
const projectId = ethers.keccak256(ethers.toUtf8Bytes('chainmemory'));
const version = 8;

// Leer directamente de la blockchain
const [stateHash, anchoredAt, anchoredBy, anchorId] = await contract.getStateAnchor(projectId, version);

console.log('Hash on-chain del estado:', stateHash);
console.log('ID de ancla:', anchorId.toString());
console.log('Anchored at:', new Date(Number(anchoredAt) * 1000).toISOString());

// Comparar con el hash que recibiste
const expectedHash = '0xa6c45d1db753b1ec96240d169b2d91fb0ce76112558b302a8822b2988aeb8212';
if (stateHash === expectedHash) {
  console.log('VERIFICADO — el estado coincide con el ancla on-chain');
} else {
  console.log('DISCREPANCIA — el estado fue manipulado');
}

javascript
const Web3 = require('web3');

const web3 = new Web3('https://rpc.chainmemory.ai');

const CONTRACT = '0xa7A8BA51950255b3e223a6745597C67009Fe7875';
const ABI = [{
  name: 'getStateAnchor',
  type: 'function',
  stateMutability: 'view',
  inputs: [
    { name: 'projectId', type: 'bytes32' },
    { name: 'version', type: 'uint64' }
  ],
  outputs: [
    { name: 'stateHash', type: 'bytes32' },
    { name: 'anchoredAt', type: 'uint256' },
    { name: 'anchoredBy', type: 'address' },
    { name: 'anchorId', type: 'uint256' }
  ]
}];

const contract = new web3.eth.Contract(ABI, CONTRACT);

const projectId = web3.utils.keccak256('chainmemory');

const result = await contract.methods.getStateAnchor(projectId, 8).call();
console.log('Hash on-chain del estado:', result.stateHash);
console.log('ID de ancla:', result.anchorId);

Paso 3 — Verificar la transacción

También podés verificar la transacción cruda que creó el ancla:

javascript
// Leer la transacción directamente
const tx = await provider.getTransaction('0x95b732d20b8935a286869d90e60a40f5c31d350a94e27bfd7845770fe0c3e2c3');
console.log('From:', tx.from);       // Debería ser un validador conocido
console.log('To:', tx.to);           // Debería ser la dirección del contrato
console.log('Block:', tx.blockNumber);

// Leer el bloque para confirmar timestamp
const block = await provider.getBlock(tx.blockNumber);
console.log('Hora del bloque:', new Date(block.timestamp * 1000).toISOString());

FAQ

Generales

ChainMemory es gratis?

Sí. El plan Faucet es gratuito e incluye almacenamiento de memorias, inyección de contexto, y Project Brain (el visor de Project State). El faucet te da AIC gratis para interactuar con la blockchain.

Mis memorias son privadas?

Sí. Tus memorias solo son accesibles con tu API key. Lo único público son los hashes on-chain (que no revelan contenido) y el endpoint de verificación (que solo expone metadata, nunca contenido).

Qué pasa si la IA generó contenido incorrecto en una memoria?

Las memorias capturan lo que se dijo en la conversación. Si la IA generó información incorrecta y vos la guardaste, esa memoria reflejará el error. Podés archivar memorias incorrectas y el Motor de Consolidación priorizará las más recientes.

Puedo usar ChainMemory con modelos locales?

Sí, vía API REST. Cualquier aplicación que haga llamadas HTTP puede guardar y recuperar memorias. También podés configurar el servidor MCP con modelos locales o self-hosted.

Qué es el Motor de Consolidación?

Es un pipeline que analiza tus memorias usando un modelo de IA y extrae información estructurada: decisiones, hitos, riesgos, stack. El resultado es el Project State, cuyo hash se ancla on-chain.

Qué pasa si mi IA dice cosas contradictorias entre sesiones?

El Motor de Consolidación maneja contradicciones vía precedencia temporal: las memorias más nuevas reemplazan a las más viejas. Las decisiones reemplazadas permanecen en el estado con status "reemplazada", así siempre tenés el historial completo. Ver Resolución de conflictos para más detalles.

Puedo exportar mis datos?

Sí. Todas tus memorias y estados de proyecto son accesibles vía la API REST. Podés obtenerlos en formato JSON y procesarlos como necesités.

Planes, límites y cuotas

Las memorias nunca se borran: al superar la ventana de retención de tu plan se archivan, y su hash on-chain existe para siempre. Al subir de plan recuperás el acceso completo a tu historial. El AIC de obsequio se acumula mes a mes, no expira y se libera según el calendario del protocolo.

Changelog

MCP v2.4.0 (Junio 2026)

• Nuevo tool: update_project_state — Consolidación autónoma vía MCP. Cualquier cliente de IA puede proponer operaciones estructuradas para actualizar el Project Brain; el servidor valida, aplica y ancla on-chain.
• Gramática de 22 operaciones para mutaciones de estado (decisiones, hitos, riesgos, métricas, vocabulario, y más)
• Procesamiento resiliente: las ops inválidas se rechazan individualmente, las válidas se aplican igual
• Vinculación de evidencia vía evidence_memory_ids — el servidor resuelve event hashes y construye pruebas Merkle automáticamente
• Arquitectura: “el cliente consolida, la cadena verifica”

Plataforma — Junio 2026

• Project Brain consolidado y anclado on-chain (versiones v1–v8, verificable públicamente)
• Búsqueda semántica reescrita (más rápida, ~2.4s)
• Escritura no-custodial probada end-to-end (el cliente firma, el server nunca tiene la llave)
• Cifrado en reposo (AES-256-GCM) de las API keys
• Endpoint de verificación pública: GET /v1/verify/:name

v3.0.9 (Junio 2026)

• Fix: Project Brain muestra decisiones y riesgos correctamente (schema Fase 2)
• Fix: Numeración de memorias muestra número secuencial del usuario

v3.0.0 (Mayo 2026)

• Project Brain: visualización del estado consolidado
• Motor de Consolidación: pipeline completo
• Anclaje on-chain de Project State
• API de verificación pública

v2.0.0 (Abril 2026)

• Servidor MCP para Claude Desktop y Cursor
• Inyección de contexto automática
• Soporte para 5 plataformas de IA