# Anytype MCP Server: let Claude or ChatGPT drive your Anytype spaces

> The official MCP server for the Anytype API turns your local wiki into something an AI assistant can read and write. Here is how the OpenAPI-to-tools bridge works, how to install it, and where it stops.

**anyproto/anytype-mcp** — An MCP server enabling AI assistants to interact with Anytype - your encrypted, local and collaborative wiki - to organize objects, lists, and more through natural language.

- Repository: https://github.com/anyproto/anytype-mcp
- Website: https://npmjs.com/package/@anyproto/anytype-mcp
- Stars: 524 · Forks: 60
- Language: TypeScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/anyproto-anytype-mcp

## What anytype-mcp solves, and who it is for

Anytype is an encrypted, local and collaborative wiki. Its API is a REST surface described by an OpenAPI specification, and the repository anyproto/anytype-api holds that specification. The anytype-mcp package is the official Model Context Protocol server that sits between that API and an AI assistant.

The problem it addresses is mechanical. An assistant cannot call a REST API it has never seen, and hand-writing tool definitions for every Anytype endpoint would go stale the moment the API changes. This project generates the MCP tool surface from the OpenAPI specification instead, so the tools track the spec rather than a hand-maintained list.

The audience is narrow and specific: people who already run the Anytype desktop application, who have created an API key in it, and who want Claude Desktop, Claude Code, Cursor, Windsurf, Raycast, LM Studio or Kiro to manipulate their own knowledge base through conversation. If you do not run Anytype locally, there is nothing for this server to talk to.

## How the OpenAPI specification becomes MCP tools

The package.json dependencies tell most of the story. The server pulls in @modelcontextprotocol/sdk for the protocol itself, openapi-client-axios and openapi-types to consume the specification, openapi-schema-validator to check it, and zod for schema handling. The build script runs tsc -build and then node scripts/build-cli.js, and a separate parse-openapi script exists in the scripts directory, which is where the specification is turned into tool definitions.

At runtime the flow is one-directional. The MCP client launches the server as a child process, the server reads OPENAPI_MCP_HEADERS from its environment and uses the Authorization bearer token plus the Anytype-Version header on every call it makes to the Anytype API. The default base URL is http://127.0.0.1:31009, and ANYTYPE_API_BASE_URL overrides it.

The feature list maps to that API surface rather than to a custom abstraction: global and space search, spaces and members, objects and lists, properties and tags, types and templates. There is no caching layer and no local index described in the README, so each tool call is a request against your running Anytype instance.

## Installing anytype-mcp and running a first real request

You need an API key before anything else. The README gives two routes: open Anytype, go to App Settings, then API Keys, then click Create new. The command-line alternative is the get-key subcommand.

```bash
npx -y @anyproto/anytype-mcp get-key
```

That prints a key you then paste into your MCP client configuration. The most common client setup is this JSON block, with the placeholder replaced by the real key. Note that OPENAPI_MCP_HEADERS is a JSON string nested inside the outer JSON, and that Anytype-Version is pinned to 2025-11-08.

```json
{
  "mcpServers": {
    "anytype": {
      "command": "npx",
      "args": ["-y", "@anyproto/anytype-mcp"],
      "env": {
        "OPENAPI_MCP_HEADERS": "{\"Authorization\":\"Bearer <YOUR_API_KEY>\", \"Anytype-Version\":\"2025-11-08\"}"
      }
    }
  }
}
```

Claude Code users can skip the file and register the server from the shell. The -s user flag writes it at user scope so it applies across projects.

```bash
claude mcp add anytype -e OPENAPI_MCP_HEADERS='{"Authorization":"Bearer <YOUR_API_KEY>", "Anytype-Version":"2025-11-08"}' -s user -- npx -y @anyproto/anytype-mcp
```

After restarting the client, the server should appear in its MCP server list. A reasonable first request, taken from the README's own examples, is to ask the assistant to create a space called Project Ideas with the description A space for storing project ideas. If the tool call succeeds, the space shows up in Anytype itself, which is the actual confirmation that the bearer token and the version header were accepted.

## The local-first constraint and what happens when it breaks

The default base URL is http://127.0.0.1:31009. That single default is the project's biggest operational constraint: the Anytype application has to be running on the same machine as the MCP server, and its API has to be listening on that port. A containerised assistant, a remote dev box, or a client that runs the server somewhere other than your laptop will not reach it without ANYTYPE_API_BASE_URL pointing at a reachable host, and the README does not describe how to expose the Anytype API beyond localhost.

The header pinning is the second constraint. Anytype-Version is set to 2025-11-08 in every configuration example. The README does not document what happens when the installed Anytype build expects a different version, whether the API rejects the request or silently changes shape, and it does not describe a fallback. If your client starts returning errors after an Anytype update, that header is the first thing to check.

There is also no rollback story. The README does not document an undo, a dry-run mode, or a confirmation step before writes. A model that misreads a request and creates or edits objects does so against your real space. The tool surface is generated from the specification, so the safeguards are whatever your MCP client enforces, not anything the server adds.

## Where it fits against calling the Anytype API directly

The obvious alternative is not another MCP server. It is a script that calls the Anytype API yourself, using the same specification in anyproto/anytype-api and the same bearer token. That approach gives you exact control over which endpoints exist, what arguments they take, and what happens before a write. The trade-off is maintenance: every API change is your problem, and you have to build the tool descriptions that an assistant needs in order to choose the right call.

anytype-mcp inverts that. You get the whole documented surface without writing tool definitions, and you accept that the surface is as broad as the specification. The README's own examples show the assistant chaining operations: create a space, add two Task objects with titles and due dates, then create a collection titled Tasks for this week and add both tasks to it with a shifted due date on the first. That kind of multi-step request is where generated tools pay off, because each step maps to a spec operation the model can select on its own.

If your needs are a fixed handful of operations, a small script is the smaller commitment. If you want the assistant to explore your knowledge base the way you would, the generated surface is the point.

## Building from source, licence and the upgrade path

The published package is the normal install path, but the README also documents a source build. It requires Bun, and the steps are to clone the repository, run bun install, then bun run build, with bun link as an optional step to expose the binary. The package declares an anytype-mcp binary, so a global npm install is also supported, in which case the MCP client configuration uses command anytype-mcp instead of npx.

Development scripts are conventional: vitest for tests, eslint for linting against src and scripts, prettier for formatting, and tsc --noEmit for typechecking. There is a Dockerfile-multi-stage at the repository root, though the README does not document a container workflow or how a container would reach the Anytype API on the host.

The licence is MIT, which permits commercial and closed-source use, modification and redistribution provided the copyright notice and permission notice are kept. That is a permissive arrangement with no copyleft obligation on your own code. It says nothing about the Anytype API or the application itself, whose terms are separate from this server. Nothing here is legal advice; if you redistribute a modified build, read LICENSE.md rather than this summary.

Upgrade cost is low on the surface: the package is versioned (1.2.10 at the time of writing), the last push to the repository was on 2026-09-07, and releases have appeared regularly through 2026. The hidden cost is the version header. Because Anytype-Version is pinned in your client configuration rather than negotiated by the server, an Anytype update and an anytype-mcp update are two separate things you have to keep aligned by hand.

## Conclusion

Adopt anytype-mcp if you already run the Anytype desktop app locally and want Claude Desktop, Claude Code, Cursor or LM Studio to create and edit objects in your spaces without leaving the chat. Skip it if you need a hosted multi-user service, if your Anytype instance is not reachable on 127.0.0.1:31009, or if you expect the server to filter or undo what the model does. Before wiring it into a shared client, create a throwaway space, confirm the Anytype-Version header matches the API build you run, and check whether your client can prompt you before each write.

## FAQ

### What is an MCP plugin?

In this project's case it is a Model Context Protocol server, published as @anyproto/anytype-mcp, that converts Anytype's OpenAPI specification into MCP tools. An AI assistant then uses those tools to search spaces and create or edit objects, lists, properties, tags, types and templates.

### Does Anytype use AI?

Anytype itself is an encrypted, local and collaborative wiki; the AI side comes from external assistants connecting through this MCP server. The server exposes the Anytype API as tools so a client such as Claude Desktop or Cursor can act on your spaces through natural language.

### Is Anytype completely free?

The server package is licensed under MIT, which allows commercial use, modification and redistribution as long as the licence notice is preserved. That covers this package only; the Anytype application and API are governed separately.

### What does Anytype do?

Anytype is described in the README as an encrypted, local and collaborative wiki, and it exposes a REST API whose OpenAPI specification lives in the anyproto/anytype-api repository. This MCP server is the bridge that lets an AI assistant work with that API.

## Sources

- [anyproto/anytype-mcp on GitHub](https://github.com/anyproto/anytype-mcp)
- [License: MIT](https://github.com/anyproto/anytype-mcp/blob/main/LICENSE)
- [Project website](https://npmjs.com/package/@anyproto/anytype-mcp)
- [README](https://github.com/anyproto/anytype-mcp/blob/main/README.md)
- [Releases](https://github.com/anyproto/anytype-mcp/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/anyproto-anytype-mcp