anki mcp server

Local 2025-08-31 23:47:50 0

Knowledge And Memory @nailuoGG/anki-mcp-server

A Model Context Protocol server that enables LLMs to interact with Anki flashcard software through AnkiConnect, allowing for creation and management of flashcards, decks, and note types.

A Model Context Protocol (MCP) server that enables LLMs to interact with Anki flashcard software through AnkiConnect.

Features

Tools

list_decks - List all available Anki decks
create_deck - Create a new Anki deck
create_note - Create a new note (Basic or Cloze)
batch_create_notes - Create multiple notes at once
search_notes - Search for notes using Anki query syntax
get_note_info - Get detailed information about a note
update_note - Update an existing note
delete_note - Delete a note
list_note_types - List all available note types
create_note_type - Create a new note type
get_note_type_info - Get detailed structure of a note type

Resources

anki://decks/all - Complete list of available decks
anki://note-types/all - List of all available note types
anki://note-types/all-with-schemas - Detailed structure information for all note types
anki://note-types/{modelName} - Detailed structure information for a specific note type

Prerequisites

Anki installed on your system
AnkiConnect add-on installed in Anki

Configuration

Usage with Claude Desktop

Add the server to your claude_desktop_config.json:

{
  "mcpServers": {
    "anki": {
      "command": "npx",
      "args": ["--yes","anki-mcp-server"]
    }
  }
}

Configuration for Cline

Add the server to your Cline MCP settings file inside VSCode's settings cline_mcp_settings.json

{
  "mcpServers": {
    "anki": {
      "command": "npx",
      "args": ["--yes","anki-mcp-server"]
    }
  }
}

Development

Setup

Install dependencies:
```
npm install
```
Build the server:
```
npm run build
```
For development with auto-rebuild:
```
npm run watch
```

Testing

Run the test suite:

npm test

This executes tests for: - Server initialization - AnkiConnect communication - Note operations (create/read/update/delete) - Deck management - Error handling

Debugging

Since MCP servers communicate over stdio, we recommend using the MCP Inspector:

npm run inspector

This provides a browser-based interface for: - Monitoring MCP messages - Testing tool invocations - Viewing server logs - Debugging communication issues

Example Usage

Create a new deck:

Create a new Anki deck called "Programming"

Add a basic card:

Create an Anki card in the "Programming" deck with:
Front: What is a closure in JavaScript?
Back: A closure is the combination of a function and the lexical environment within which that function was declared.

Add a cloze deletion card:

Create a cloze card in the "Programming" deck with:
Text: In JavaScript, {{c1::const}} declares a block-scoped variable that cannot be {{c2::reassigned}}.

Contributing

Fork the repository
Create your feature branch
Run tests: npm test
Submit a pull request

Credits

Icon courtesy of macOS Icons

License

MIT License - see LICENSE file for details

[
  {
    "description": "List all available Anki decks",
    "inputSchema": {
      "properties": {},
      "required": [],
      "type": "object"
    },
    "name": "list_decks"
  },
  {
    "description": "Create a new Anki deck",
    "inputSchema": {
      "properties": {
        "name": {
          "description": "Name of the deck to create",
          "type": "string"
        }
      },
      "required": [
        "name"
      ],
      "type": "object"
    },
    "name": "create_deck"
  },
  {
    "description": "Create a new note (Basic or Cloze)",
    "inputSchema": {
      "properties": {
        "back": {
          "description": "Back content (for Basic notes)",
          "type": "string"
        },
        "backExtra": {
          "description": "Additional back content (for Cloze notes)",
          "type": "string"
        },
        "deck": {
          "description": "Deck name",
          "type": "string"
        },
        "fields": {
          "additionalProperties": true,
          "description": "Custom fields for the note",
          "type": "object"
        },
        "front": {
          "description": "Front content (for Basic notes)",
          "type": "string"
        },
        "tags": {
          "description": "Tags for the note",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "text": {
          "description": "Cloze text (for Cloze notes)",
          "type": "string"
        },
        "type": {
          "description": "Type of note to create",
          "enum": [
            "Basic",
            "Cloze"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "deck"
      ],
      "type": "object"
    },
    "name": "create_note"
  },
  {
    "description": "Create multiple notes at once",
    "inputSchema": {
      "properties": {
        "notes": {
          "items": {
            "properties": {
              "back": {
                "type": "string"
              },
              "backExtra": {
                "type": "string"
              },
              "deck": {
                "type": "string"
              },
              "fields": {
                "additionalProperties": true,
                "type": "object"
              },
              "front": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "text": {
                "type": "string"
              },
              "type": {
                "enum": [
                  "Basic",
                  "Cloze"
                ],
                "type": "string"
              }
            },
            "required": [
              "type",
              "deck"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "stopOnError": {
          "description": "Whether to stop on first error",
          "type": "boolean"
        }
      },
      "required": [
        "notes"
      ],
      "type": "object"
    },
    "name": "batch_create_notes"
  },
  {
    "description": "Search for notes using Anki query syntax",
    "inputSchema": {
      "properties": {
        "query": {
          "description": "Anki search query",
          "type": "string"
        }
      },
      "required": [
        "query"
      ],
      "type": "object"
    },
    "name": "search_notes"
  },
  {
    "description": "Get detailed information about a note",
    "inputSchema": {
      "properties": {
        "noteId": {
          "description": "Note ID",
          "type": "number"
        }
      },
      "required": [
        "noteId"
      ],
      "type": "object"
    },
    "name": "get_note_info"
  },
  {
    "description": "Update an existing note",
    "inputSchema": {
      "properties": {
        "fields": {
          "description": "Fields to update",
          "type": "object"
        },
        "id": {
          "description": "Note ID",
          "type": "number"
        },
        "tags": {
          "description": "New tags for the note",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "id",
        "fields"
      ],
      "type": "object"
    },
    "name": "update_note"
  },
  {
    "description": "Delete a note",
    "inputSchema": {
      "properties": {
        "noteId": {
          "description": "Note ID to delete",
          "type": "number"
        }
      },
      "required": [
        "noteId"
      ],
      "type": "object"
    },
    "name": "delete_note"
  },
  {
    "description": "List all available note types",
    "inputSchema": {
      "properties": {},
      "required": [],
      "type": "object"
    },
    "name": "list_note_types"
  },
  {
    "description": "Create a new note type",
    "inputSchema": {
      "properties": {
        "css": {
          "description": "CSS styling for the note type",
          "type": "string"
        },
        "fields": {
          "description": "Field names for the note type",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "name": {
          "description": "Name of the new note type",
          "type": "string"
        },
        "templates": {
          "description": "Card templates",
          "items": {
            "properties": {
              "back": {
                "type": "string"
              },
              "front": {
                "type": "string"
              },
              "name": {
                "type": "string"
              }
            },
            "required": [
              "name",
              "front",
              "back"
            ],
            "type": "object"
          },
          "type": "array"
        }
      },
      "required": [
        "name",
        "fields",
        "templates"
      ],
      "type": "object"
    },
    "name": "create_note_type"
  }
]