AI Note

Sincronización de archivos multi-dispositivo, CRUD de documentos de desarrollo, gestión de tareas y transferencias de sesión para agentes de IA - superficie dual MCP + OpenAPI.

Ver en ainote.devPrueba este MCPPatrocinado

Documentación

Notas que AI Note maneja directamente

Claude · Cursor · Windsurf · ChatGPT · LangChain editan tus notas tal cual.
26 herramientas MCP + mirror OpenAPI 3.1 — el estándar de notas agent-native.

🤖

Agent-native, protocolo dual

MCP JSON-RPC y OpenAPI 3.1: dos superficies comparten la misma definición de herramientas.
Cubre tanto el ecosistema de Claude como el de OpenAI/LangChain.

Guías para 5 ecosistemas de agentes

🛡️

Más de 50 anotaciones de herramientas

readOnlyHint · destructiveHint · idempotentHint · openWorldHint — los agentes autónomos bloquean llamadas destructivas de antemano.

Tabla de mapeo de anotaciones

🤝

Transferencias de sesión (HHMM)

handoff_save · handoff_get · handoff_list. Separación por hora en sesiones múltiples del mismo día.
Purga automática a los 7 días.

API de transferencias

📦

Vault + Sync respaldado por GitHub

Repositorio git compatible con Obsidian. vault_* + sync_* herramientas para sincronización sin pérdidas en múltiples dispositivos.

Modelo de Vault

🧠

Completitud del backend

Backend exhaustivo, usuario simple.
Todo el seguimiento de estado ocurre en el backend; la UI se enfoca solo en la toma de decisiones.

Filosofía de diseño

📱

Todas las plataformas

Web · iOS · Android · macOS · Apple Watch · extensiones Chrome / Safari · PWA · bot de Telegram.

Matriz de plataformas

Resumen en 30 segundos

ainote es un backend de notas, tareas, memoria y sincronización multi-dispositivo que la IA llama directamente. Expone las mismas 50+ herramientas simultáneamente mediante dos protocolos:

MCP JSON-RPC (https://api.ainote.dev/api/mcp) — Claude Desktop · Claude Code · Cursor · Windsurf
OpenAPI 3.1 (https://api.ainote.dev/api/mcp/openapi.json) — OpenAI Custom GPT Actions · herramientas remotas de LangChain · AutoGen · otros agentes HTTP-first

Ambas superficies comparten un único registro de herramientas (Api::McpController#apply_tool_annotations!), por lo que las definiciones nunca divergen. Una herramienta añadida una vez aparece de inmediato en todos los ecosistemas de agentes.

Estado al 2026-05-14

✅ 26 herramientas en producción + anotaciones de herramientas con 4 pistas adjuntas
✅ npm @ainote/mcp v1.3.0
✅ Mirror OpenAPI 3.1 en api.ainote.dev/api/mcp/openapi.json
🔜 Recursos / suscripciones MCP (Fase 2), OAuth 2.1 DCR (Fase 3), A2A AgentCard (Fase 4)

Completitud del backend — nuestra filosofía de diseño

"Backend exhaustivo, usuario simple."

Toda decisión de ainote sigue esta línea.

Backend (exhaustivo)	Frontend / Agente (simple)
Seguimiento de todo cambio de estado (created_at / reviewed_at / reviewed_by / auto_approved)	Solo muestra lo que el usuario necesita
Metadatos completos (rejection_reason / access_token / expires_at)	Toma de decisiones rápida (2-3 botones)
Lógica de negocio compleja (reglas de autoaprobación / máquina de estados / casos límite)	Baja carga cognitiva
Toda la información disponible vía API (estado / detalle / historial / registros de auditoría)	UX natural tipo DM
Auditoría · análisis · seguimiento de problemas	Sin exposición de estado, datos detallados ni filtros

Cómo esta separación se traduce en compatibilidad con agentes:

Cuando se llama a handoff_list, el backend purga automáticamente las transferencias de más de 7 días. El agente solo recibe la lista y no conoce la limpieza — pero las anotaciones anuncian destructiveHint: true para que los agentes autónomos reconozcan la llamada destructiva.
Cuando se llama a vault_sync(action: push), el backend detecta y resuelve conflictos. El agente solo toma una decisión con conflictResolution: merge|overwrite|abort.
login_and_get_key se genera automáticamente en el backend si no hay clave MCP. El agente solo solicita "obtener clave".

→ Ver el principio completo de Completitud del backend

Matriz de más de 50 herramientas

Categoría	Herramienta	Anotaciones
Tareas (5)	`list_tasks`	🔒 ♻️
	`create_task`
	`update_task`	♻️
	`delete_task`	⚠️ ♻️
	`list_categories`	🔒 ♻️
Docs de desarrollo (7)	`list_dev_docs`	🔒 ♻️
	`get_dev_doc`	🔒 ♻️
	`create_dev_doc`
	`update_dev_doc`	♻️
	`pull_dev_docs`	🔒 ♻️
	`delete_dev_doc`	⚠️ ♻️
	`list_dev_categories`	🔒 ♻️
Onboarding (3)	`signup_and_get_key`	🌐
	`login_and_get_key`	🌐
	`get_setup_guide`	🔒 ♻️
Vaults (5)	`vault_list`	🔒 ♻️
	`vault_create`	🌐
	`vault_clone`	🔒 ♻️ 🌐
	`vault_connect_status`	🔒 ♻️ 🌐
	`vault_sync`	⚠️ 🌐
Sincronización (3)	`sync_push`	⚠️ ♻️
	`sync_pull`	🔒 ♻️
	`sync_list`	🔒 ♻️
Transferencias (3)	`handoff_save`	♻️
	`handoff_list`	⚠️
	`handoff_get`	⚠️

Leyenda: 🔒 solo lectura · ⚠️ destructiva · ♻️ idempotente · 🌐 mundo abierto (llama a sistemas externos)

Por qué handoff_list / handoff_get son destructivas: al llamarlas se ejecuta una purga de datos obsoletos de 7 días. Se marcan para que los agentes autónomos eviten llamadas destructivas sin intención de limpieza.

→ Mapeo completo de anotaciones + criterios de decisión

Matriz de superficies — las mismas herramientas en todas partes

Punto de entrada	Protocolo	URL / comando	Guía de configuración
Claude Code	MCP HTTP	`https://api.ainote.dev/api/mcp`	/agents/claude-code
Claude Desktop	MCP stdio	`npx -y @ainote/mcp`	/agents/claude-desktop
Cursor	MCP stdio / HTTP	Igual	/agents/cursor
Windsurf	MCP stdio	Igual	/agents/windsurf
ChatGPT Custom GPT	OpenAPI 3.1	Actions → Importar URL `https://api.ainote.dev/api/mcp/openapi.json`	/agents/openai-custom-gpt
LangChain / LangGraph	OpenAPI	Herramienta remota Python	/agents/langchain
AutoGen	OpenAPI	Igual	/agents/langchain#autogen
App web	HTML	`https://app.ainote.dev`	—
iOS / Android / macOS / Watch	Nativo	App Store / Play Store	/agents/mobile
Extensiones Chrome / Safari	Navegador	Chrome Web Store	/agents/extensions
Telegram	Bot	Clawdbot	/mcp/telegram

Puerta de enlace de protocolo dual — cómo funciona

Desde un mismo código, las dos superficies se separan:

# app/controllers/api/mcp_controller.rb
class Api::McpController < ApplicationController
  MCP_TOOL_ANNOTATIONS = {
    "list_tasks"   => { readOnlyHint: true, idempotentHint: true, ... },
    "delete_task"  => { destructiveHint: true, idempotentHint: true, ... },
    # ... 26개 전체
  }.freeze

  def self.apply_tool_annotations!(tools)
    tools.each { |t| t[:annotations] = MCP_TOOL_ANNOTATIONS[t[:name]] }
    tools
  end
end

# app/controllers/api/mcp/openapi_controller.rb
class Api::Mcp::OpenapiController < ApplicationController
  def mcp_tools
    Api::McpController.apply_tool_annotations!(
      Api::McpController.build_tools_array
    )
  end
end

→ MCP tools/list emite las anotaciones tal cual; el mirror OpenAPI expone las mismas anotaciones como extensión x-mcp-annotations. Es estructuralmente imposible que las dos superficies diverjan.

→ Detalles del código

Inicio rápido — un ecosistema a la vez

Claude Code (HTTP, recomendado)

{
  "mcpServers": {
    "ainote": {
      "type": "http",
      "url": "https://api.ainote.dev/api/mcp",
      "headers": { "Authorization": "McpKey <YOUR_MCP_KEY>" }
    }
  }
}

→ Guía completa · Para obtener una clave MCP, dile a Claude: "regístrame en ainote".

Claude Desktop (stdio, npm)

{
  "mcpServers": {
    "ainote": {
      "command": "npx",
      "args": ["-y", "@ainote/mcp"],
      "env": {
        "AINOTE_API_URL": "https://api.ainote.dev",
        "AINOTE_API_KEY": "<YOUR_KEY>"
      }
    }
  }
}

→ Guía completa

OpenAI Custom GPT Actions

ChatGPT → Create a GPT → Configure → Actions → Create new action
Schema → Import from URL: https://api.ainote.dev/api/mcp/openapi.json
Authentication → API Key → Auth Type: Custom, Header: Authorization, Value: McpKey <YOUR_KEY>

→ Guía completa

Escenario multi-dispositivo

[MacBook · Claude Code]
   handoff_save({project:"logi", topic:"phase4", time:"1555", content:"..."})
   → vault 에 handoffs/logi-phase4-1555-2026-05-14.txt 저장

(다른 디바이스 / 다른 세션)

[Mac mini · Claude Code]
   handoff_get({project:"logi", topic:"phase4"})
   → 동일 핸드오프 회수 → 작업 재개

(iPhone)
   ainote 앱 → 같은 vault → 같은 데이터

El mismo patrón se aplica a tareas / dev-doc / sync_push / vault_sync. Todos los dispositivos ven el mismo backend.

Seguridad y código abierto

Licencia MIT — se puede autoalojar (Docker / Render / Fly.io)
Cifrado E2E con age — la categoría mcp (mcpServers + claves API) se cifra con age en el cliente antes de subirla. El servidor nunca ve el texto plano.
Integración con llaveros del sistema — la identidad age por dispositivo se guarda en macOS Keychain / libsecret / Credential Manager
Ubicación de datos — PostgreSQL de Render Singapur + vault git (repositorio GitHub propiedad del usuario)
Flujo de dispositivo RFC 8628 — PKCE (S256) obligatorio en el inicio de sesión por CLI
Derecho de eliminación — todas las herramientas destructivas como delete_task · delete_dev_doc pueden invocarse libremente. Eliminación permanente tras una ventana de papelera de 30 días.

→ Política de privacidad · Términos de servicio · Divulgación de seguridad

Preguntas frecuentes

P. ¿Puedo probarlo sin crear una cuenta? — Sí. Tras registrar MCP, dile a Claude "regístrame en ainote" y se llamará a signup_and_get_key para emitir una clave.

P. Soy usuario de Obsidian, ¿puedo migrar? — Crea un vault con vault_create y luego conecta tu vault existente de Obsidian como remote git. Como es Markdown, los wikilinks [[...]] son totalmente compatibles.

P. ¿Puedo publicarlo en OpenAI Custom GPT Store? — Sí. api.ainote.dev/api/mcp/openapi.json es la especificación OpenAPI 3.1 y el dominio raíz de la URL de la política de privacidad (ainote.dev/legal/privacy) coincide → tras verificar el dominio con el TXT de DNS, se puede publicar públicamente.

P. ¿Dónde se guardan los datos? — Alojado: PostgreSQL de Render (Singapur) + repositorio GitHub del usuario (vault). Autoalojado: puedes usar tu propia instancia. Exportación de datos disponible en cualquier momento.

P. ¿La IA ve todas mis notas? — Solo cuando se invocan las herramientas MCP. Puedes aprobar cada llamada manualmente (en Claude Code). Modelo de permisos: separación de lectura/escritura por clave API.

P. ¿Qué sigue después de Anthropic / OpenAI / Google A2A? — MCP (ahora) → OpenAPI (ahora) → A2A AgentCard (Fase 4 en curso) → AGNTCY / Letta (en seguimiento). Hoja de ruta completa

P. ¿Precios? — Autoalojado gratis (MIT). Plan alojado: por definir.

→ FAQ completa

Para lanzárselo entero a una IA/LLM

Con el estándar llms.txt, todo el documento está disponible en formato amigable para LLM:

📥 /llms.txt — índice de páginas + resumen de 1 línea
📥 /llms-full.txt — todo el contenido en un solo archivo

Pégalo en ChatGPT/Claude y di "explícame qué es ainote y cómo conectarlo".

Privacidad · Términos · Seguridad · Contacto (Telegram · chat abierto de Kakao)
Licencia MIT · Creado por Seunghan Kim · ainote.dev — tus notas son tuyas.