AI Note

Sincronização de arquivos entre dispositivos, CRUD de documentos de desenvolvimento, gerenciamento de tarefas e transferências de sessão para agentes de IA - superfície dupla MCP + OpenAPI.

Ver em ainote.devExperimente este MCPPatrocinado

Documentação

Notas que a AI Note manipula diretamente

Claude · Cursor · Windsurf · ChatGPT · LangChain editam suas notas diretamente.
26 ferramentas MCP + mirror OpenAPI 3.1 — o padrão para notas agent-native.

🤖

Agent-native, protocolo duplo

MCP JSON-RPC e OpenAPI 3.1 — duas superfícies compartilham as mesmas definições de ferramentas.
Cobre tanto o ecossistema Claude quanto o OpenAI/LangChain ao mesmo tempo.

Guia para 5 ecossistemas de agentes

🛡️

Mais de 50 anotações de ferramentas

readOnlyHint · destructiveHint · idempotentHint · openWorldHint — agentes autônomos bloqueiam chamadas destrutivas antecipadamente.

Tabela de mapeamento de anotações

🤝

Handoffs de sessão (HHMM)

handoff_save · handoff_get · handoff_list. Separação por horário em múltiplas sessões no mesmo dia.
Purga automática em 7 dias.

API de handoff

📦

Vault + Sync com GitHub

Repositório git compatível com Obsidian. Ferramentas vault_* + sync_* para sincronização sem perdas em múltiplos dispositivos.

Modelo de Vault

🧠

Completude do Backend

Backend rigoroso, usuário simples.
Todo o rastreamento de estado fica no backend; a UI foca apenas na tomada de decisão.

Filosofia de design

📱

Todas as plataformas

Web · iOS · Android · macOS · Apple Watch · Extensões Chrome / Safari · PWA · Bot do Telegram.

Matriz de plataformas

Resumo em 30 segundos

ainote é um backend de notas, tarefas, memória e sincronização multi-dispositivo chamado diretamente por IA. Os mesmos 50+ ferramentas são expostos simultaneamente em dois 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 · LangChain remote tools · AutoGen · outros agentes HTTP-first

Como as duas superfícies compartilham um único registro de ferramentas (Api::McpController#apply_tool_annotations!), as definições nunca divergem. Uma ferramenta adicionada uma vez fica imediatamente visível em todos os ecossistemas de agentes.

Estado atual em 2026-05-14

✅ 26 ferramentas em produção + anotações de ferramentas com 4 dicas
✅ npm @ainote/mcp v1.3.0
✅ Mirror OpenAPI 3.1 em api.ainote.dev/api/mcp/openapi.json
🔜 MCP resources / subscriptions (Fase 2), OAuth 2.1 DCR (Fase 3), A2A AgentCard (Fase 4)

Completude do Backend — nossa filosofia de design

"Backend rigoroso, usuário simples."

Toda decisão da ainote segue essa única linha.

Backend (rigor)	Frontend / Agente (simplicidade)
Rastreia toda mudança de estado (created_at / reviewed_at / reviewed_by / auto_approved)	Mostra apenas o que o usuário precisa
Metadados completos (rejection_reason / access_token / expires_at)	Decisão rápida (2–3 botões)
Lógica de negócio complexa (regras de aprovação automática / máquina de estados / casos extremos)	Baixa carga cognitiva
Toda informação via API (estado / detalhes / histórico / trilha de auditoria)	UX natural em formato de DM
Auditoria · análise · rastreamento de problemas	Sem exposição de estado, detalhes ou filtros

Como essa separação leva à compatibilidade com agentes:

Quando handoff_list é chamado, o backend purga automaticamente handoffs com mais de 7 dias. O agente apenas recebe a lista e não sabe da limpeza — mas as anotações anunciam destructiveHint: true para que agentes autônomos reconheçam chamadas destrutivas
Quando vault_sync(action: push) é chamado, o backend detecta e resolve conflitos. O agente toma apenas uma decisão com conflictResolution: merge|overwrite|abort
login_and_get_key gera automaticamente uma chave MCP no backend se ela não existir. O agente apenas solicita "obter chave"

→ Ver o princípio completo de Completude do Backend

Matriz de mais de 50 ferramentas

Categoria	Ferramenta	Anotações
Tarefas (5)	`list_tasks`	🔒 ♻️
	`create_task`
	`update_task`	♻️
	`delete_task`	⚠️ ♻️
	`list_categories`	🔒 ♻️
Dev Docs (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`	⚠️ 🌐
Sync (3)	`sync_push`	⚠️ ♻️
	`sync_pull`	🔒 ♻️
	`sync_list`	🔒 ♻️
Handoffs (3)	`handoff_save`	♻️
	`handoff_list`	⚠️
	`handoff_get`	⚠️

Legenda: 🔒 somente leitura · ⚠️ destrutivo · ♻️ idempotente · 🌐 mundo aberto (chama sistemas externos)

Por que handoff_list / handoff_get são destrutivos: ao serem chamados, também executam a purga de dados antigos de 7 dias. Marcados para que agentes autônomos evitem chamadas destrutivas sem intenção de limpeza.

→ Mapeamento completo de anotações + critérios de decisão

Matriz de superfícies — as mesmas ferramentas em qualquer lugar

Ponto de entrada	Protocolo	URL / comando	Guia de configuração
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	ferramenta 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
Extensões Chrome / Safari	navegador	Chrome Web Store	/agents/extensions
Telegram	Bot	Clawdbot	/mcp/telegram

Gateway de protocolo duplo — como funciona

Em um único lugar no código, as duas superfícies se dividem:

# 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

→ O MCP tools/list emite as anotações diretamente; o mirror OpenAPI expõe as mesmas anotações como extensão x-mcp-annotations. Estrutura que impede a divergência entre as duas superfícies.

→ Detalhes do código

Quickstart — um ecossistema por vez

Claude Code (HTTP, recomendado)

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

→ Guia completo · Para obter a chave MCP, basta dizer ao Claude: "me cadastre na 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>"
      }
    }
  }
}

→ Guia completo

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>

→ Guia completo

Cenário 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 → 같은 데이터

O mesmo padrão se aplica a tarefas / dev-doc / sync_push / vault_sync. Todos os dispositivos enxergam o mesmo backend.

Segurança e Open Source

Licença MIT — hospedagem própria possível (Docker / Render / Fly.io)
Criptografia E2E com age — a categoria mcp (mcpServers + chaves de API) é criptografada com age no cliente antes do upload. O servidor nunca vê o texto puro
Integração com Keychain do SO — a identidade age por dispositivo fica no macOS Keychain / libsecret / Credential Manager
Localização dos dados — PostgreSQL da Render em Singapura + git vault (repositório GitHub do usuário)
Device flow RFC 8628 — PKCE (S256) obrigatório no login via CLI
Direito de exclusão — todas as ferramentas destrutivas, como delete_task · delete_dev_doc, podem ser chamadas pelo usuário. Exclusão permanente após janela de lixeira de 30 dias

→ Política de Privacidade · Termos de Serviço · Divulgação de segurança

Perguntas frequentes

P. Posso testar sem criar conta? — Sim. Após registrar o MCP, basta dizer ao Claude "me cadastre na ainote" e signup_and_get_key será chamado para emitir a chave.

P. Sou usuário do Obsidian, consigo migrar? — Sim. Crie um vault com vault_create e conecte seu vault Obsidian existente como remote git. Como é Markdown, os wikilinks [[...]] continuam compatíveis.

P. Posso publicar na OpenAI Custom GPT Store? — Sim. O api.ainote.dev/api/mcp/openapi.json tem a spec OpenAPI 3.1 e o domínio raiz da URL da política de privacidade (ainote.dev/legal/privacy) é o mesmo → após verificação DNS TXT do domínio, a publicação pública é possível.

P. Onde os dados ficam armazenados? — Hospedado: PostgreSQL da Render (Singapura) + repositório GitHub do usuário (vault). Self-hosted: instância própria. Exportação de dados disponível a qualquer momento.

P. A IA vê todas as minhas notas? — Somente quando as ferramentas MCP são chamadas. Você pode aprovar cada chamada (no Claude Code). Modelo de permissão: separação de leitura/escrita por chave de API.

P. Qual o próximo passo além de Anthropic / OpenAI / Google A2A? — MCP (agora) → OpenAPI (agora) → A2A AgentCard (Fase 4 em andamento) → AGNTCY / Letta (monitoramento). Roadmap completo

P. Preços? — Self-hosted gratuito (MIT). Plano hospedado: TBD.

→ FAQ completo

Jogue tudo de uma vez para a IA/LLM

Com o padrão llms.txt, todo o documento é fornecido em formato amigável para LLMs:

📥 /llms.txt — índice da página + resumo de 1 linha
📥 /llms-full.txt — todo o conteúdo em um único arquivo

Cole no ChatGPT/Claude e diga "me explica o que é a ainote e como integrar" — pronto.

Privacidade · Termos · Segurança · Contato (Telegram · Kakao Open Chat)
Licença MIT · Criado por Seunghan Kim · ainote.dev — suas notas pertencem a você.