Anki MCP

officiel

Un serveur MCP qui permet aux assistants IA d'interagir avec Anki, l'application de flashcards à répétition espacée.

GitHub

408

Que pouvez-vous faire avec Anki MCP ?

Review due cards interactively — Demandez à votre assistant de récupérer les cartes à réviser avec get_due_cards, présentez-les via present_card, et enregistrez votre évaluation avec rate_card.
Create and style custom note types — Créez un nouveau type de note avec des champs spécifiques, des modèles de cartes et du CSS en utilisant createModel, updateModelStyling et updateModelTemplates.
Batch-add flashcards from a list — Fournissez un ensemble de notes et demandez à l'assistant de toutes les créer en une fois avec addNotes, en partageant le même paquet et le même modèle.
Search and update existing notes — Recherchez des notes par paquet, étiquette ou statut d'échéance avec findNotes, puis modifiez leurs champs ou étiquettes à l'aide de updateNoteFields, addTags ou removeTags.
Manage media in your collection — Téléchargez des images ou de l'audio depuis un chemin de fichier local avec storeMediaFile, listez les fichiers stockés via getMediaFilesNames, ou supprimez les médias inutilisés.
Open Anki's GUI for manual editing — Utilisez guiBrowse pour ouvrir le Navigateur de cartes, guiAddCards pour pré-remplir la boîte de dialogue Ajouter des cartes, ou guiEditNote pour modifier une note spécifique.

Documentation

Serveur MCP Anki

Intégrez de manière transparente Anki avec des assistants IA via le Model Context Protocol

Beta - Ce projet est en développement actif. Les API et fonctionnalités peuvent changer.

Un serveur Model Context Protocol (MCP) qui permet aux assistants IA d'interagir avec Anki, l'application de flashcards à répétition espacée.

Transformez votre expérience Anki avec une interaction en langage naturel - comme avoir un tuteur privé. L'assistant IA ne se contente pas de présenter des questions et des réponses ; il peut expliquer des concepts, rendre le processus d'apprentissage plus engageant et humain, fournir du contexte et s'adapter à votre style d'apprentissage. Il peut créer et modifier des notes à la volée, transformant vos sessions d'étude en conversations dynamiques. Plus de fonctionnalités à venir prochainement !

Exemples et Tutoriels

Pour des guides complets, des exemples concrets et des tutoriels étape par étape sur l'utilisation de ce serveur MCP avec Claude Desktop, visitez :

ankimcp.ai - Documentation complète avec des exemples pratiques et des cas d'utilisation

Voir docs/ pour une documentation supplémentaire, y compris le guide de configuration du réviseur et le paquet de cartes Anki d'exemple.

Exemples de Cas d'Utilisation

Trois invites représentatives montrant les flux d'outils que ce serveur permet :

"Aide-moi à réviser mon paquet d'espagnol." — L'assistant se synchronise avec AnkiWeb (sync), récupère les cartes dues (get_due_cards avec filtre de paquet), présente chaque carte (present_card), et enregistre votre évaluation (rate_card). Conversation d'étude naturelle avec des explications adaptées à vous.
"Crée 10 cartes de vocabulaire arabe avec un style RTL." — L'assistant liste les types de notes (modelNames), crée un modèle RTL personnalisé si nécessaire (createModel + updateModelStyling pour le CSS de droite à gauche), puis crée les cartes par lot (addNotes).
"Importe cette image de mon dossier Téléchargements au recto de la note sélectionnée." — L'assistant téléverse le fichier local (storeMediaFile avec un chemin de fichier), lit la note actuellement sélectionnée dans le navigateur (guiSelectedNotes + notesInfo), et met à jour le champ recto avec une balise <img> (updateNoteFields).

Outils Disponibles

Le serveur expose 42 outils MCP — 31 outils essentiels pour les opérations quotidiennes d'Anki et 11 outils GUI qui pilotent l'interface de bureau Anki pour les flux de travail d'édition/création de notes.

Outils Essentiels

Révision & Étude

sync - Synchroniser avec AnkiWeb pour récupérer les dernières données et pousser les modifications
get_due_cards - Obtenir les cartes dues pour révision, optionnellement filtrées par paquet
get_cards - Obtenir des cartes avec un filtrage flexible par état (dues, nouvelles, en apprentissage, suspendues, enterrées) et par paquet
present_card - Afficher une carte pour révision avec son côté question/recto
rate_card - Évaluer la performance de la carte (Encore, Difficile, Bon, Facile) et planifier la prochaine révision

Note : Le contenu front/back de la carte est rendu par carte à partir de son propre modèle (tel qu'Anki l'affiche), de sorte que les cartes inversées et à trous affichent la direction correcte. Le texte statique ajouté par vos modèles de cartes apparaît également dans la sortie.

Gestion des Paquets

listDecks - Lister tous les paquets, optionnellement avec des statistiques de nombre de cartes par paquet
deckStats - Obtenir des statistiques complètes pour un seul paquet (comptes, distributions de facilité/intervalle)
createDeck - Créer un nouveau paquet vide (supporte Parent::Child, max 2 niveaux)
changeDeck - Déplacer des cartes vers un paquet différent (créé s'il n'existe pas)

Gestion des Notes

addNote - Créer une seule note avec des champs et des balises spécifiés
addNotes - Créer par lot jusqu'à 100 notes partageant un paquet et un modèle (succès partiel supporté)
findNotes - Rechercher des notes en utilisant la syntaxe de requête Anki (deck:, tag:, is:due, etc.)
notesInfo - Obtenir des informations détaillées sur les notes (champs, balises, style CSS)
updateNoteFields - Mettre à jour les champs de notes existantes (sensible au CSS, supporte le contenu HTML)
deleteNotes - Supprimer des notes et toutes les cartes associées (destructif, nécessite confirmation)

Gestion des Balises

getTags - Obtenir toutes les balises de la collection (utiliser d'abord pour éviter les doublons)
addTags - Ajouter des balises séparées par des espaces aux notes spécifiées
removeTags - Supprimer des balises séparées par des espaces des notes spécifiées
replaceTags - Renommer une balise sur les notes spécifiées
clearUnusedTags - Supprimer les balises orphelines non utilisées par aucune note (destructif)

Gestion des Médias

getMediaFilesNames - Lister les fichiers médias dans collection.media, optionnellement filtrés par motif
retrieveMediaFile - Télécharger un fichier média en contenu base64
storeMediaFile - Téléverser un média depuis des données base64, un chemin de fichier absolu, ou une URL
deleteMediaFile - Supprimer un fichier média de collection.media (destructif)

💡 Meilleure Pratique pour les Images :

✅ Utiliser les chemins de fichiers (ex., /Users/you/image.png) - Rapide et efficace
✅ Utiliser les URLs (ex., https://example.com/image.jpg) - Téléchargement direct
❌ Éviter le base64 - Extrêmement lent et inefficace en jetons

Dites simplement à Claude où se trouve l'image, et il gérera le téléversement automatiquement en utilisant la méthode la plus efficace.

Gestion des Modèles/Templates

modelNames - Lister tous les types de notes/modèles disponibles
modelFieldNames - Obtenir les noms de champs pour un type de note spécifique
modelStyling - Obtenir les informations de style CSS pour un type de note
modelTemplates - Obtenir les modèles de cartes (HTML Recto et Verso) pour un type de note
createModel - Créer un nouveau type de note avec des champs personnalisés, des modèles de cartes et du CSS (ex., modèles RTL)
updateModelStyling - Mettre à jour le style CSS pour un type de note existant (s'applique à toutes ses cartes)
updateModelTemplates - Mettre à jour les modèles de cartes (HTML Recto et Verso) pour un type de note existant (s'applique à toutes ses cartes)
addModelField - Ajouter un nouveau champ à un type de note existant (ajouté à la fin ou inséré à une position spécifique)
removeModelField - Supprimer un champ d'un type de note existant (supprime son contenu de toutes les notes ; nécessite une confirmation explicite)
renameModelField - Renommer un champ dans un type de note existant (les modèles de cartes référençant l'ancien nom doivent être mis à jour séparément)
repositionModelField - Changer la position d'un champ dans un type de note existant

Statistiques

collection_stats - Statistiques agrégées sur tous les paquets avec une ventilation par paquet
review_stats - Analyse de l'historique de révision (modèles temporels, métriques de rétention, séquences d'étude)

Outils GUI

Outils qui pilotent l'interface de bureau Anki. Destinés aux flux de travail d'édition/création de notes et de gestion de paquets, pas pour les sessions de révision.

guiBrowse - Ouvrir le Navigateur de Cartes et rechercher des cartes
guiSelectCard - Sélectionner une carte spécifique dans le Navigateur de Cartes
guiSelectedNotes - Obtenir les IDs des notes actuellement sélectionnées dans le Navigateur de Cartes
guiAddCards - Ouvrir la boîte de dialogue Ajouter des Cartes avec des détails de note prédéfinis
guiEditNote - Ouvrir l'éditeur de notes pour une note spécifique
guiDeckOverview - Ouvrir la boîte de dialogue Aperçu du Paquet pour un paquet spécifique
guiDeckBrowser - Ouvrir la boîte de dialogue Navigateur de Paquets
guiCurrentCard - Obtenir des informations sur la carte actuelle en mode révision
guiShowQuestion - Afficher le côté question de la carte actuelle
guiShowAnswer - Afficher le côté réponse de la carte actuelle
guiUndo - Annuler la dernière action dans Anki

Prérequis

Anki avec le plugin AnkiConnect installé
Node.js 22.12.0+

Installation

Il y a plusieurs façons d'obtenir le serveur sur votre machine. Une fois installé, allez à Connecter un Client IA pour le relier à votre assistant IA — localement ou à distance.

npm (global ou npx)

La méthode universelle pour installer le serveur, adaptée à tout client MCP qui le lance directement.

Installez-le globalement pour les clients qui exécutent la commande ankimcp :

npm install -g @ankimcp/anki-mcp-server

Ou exécutez-le à la demande sans installation requise :

npx @ankimcp/anki-mcp-server

Bundle MCPB (Recommandé pour Claude Desktop)

Le moyen le plus simple d'installer ce serveur MCP pour Claude Desktop :

Téléchargez le dernier bundle .mcpb depuis la page Releases
Dans Claude Desktop, installez l'extension :
- Méthode 1 : Allez dans Paramètres → Extensions, puis faites glisser-déposer le fichier .mcpb
- Méthode 2 : Allez dans Paramètres → Développeur → Extensions → Installer l'Extension, puis sélectionnez le fichier .mcpb
Configurez l'URL AnkiConnect si nécessaire (par défaut http://localhost:8765)
Redémarrez Claude Desktop

C'est tout ! Le bundle inclut tout le nécessaire pour exécuter le serveur localement.

Pour les réviseurs du Répertoire MCP Anthropic : un guide pas à pas de zéro à l'intégration avec un paquet d'exemple pré-rempli se trouve dans docs/reviewer-setup.md.

Installer depuis la Source (pour le développement)

Pour le développement ou une utilisation avancée :

npm install
npm run build

Connecter un Client IA

Il y a deux façons pour un assistant IA d'atteindre ce serveur, selon l'endroit où l'assistant s'exécute :

Local — le serveur s'exécute sur la même machine que le client IA (Claude Desktop, Cursor, Cline, Zed, ou une session de navigateur locale). Utilisez STDIO pour les clients MCP de bureau, HTTP pour les outils web locaux.
Distant — une IA hébergée/distante (ex. ChatGPT ou Claude.ai dans le cloud) doit atteindre l'Anki s'exécutant sur votre machine locale. Utilisez le Tunnel géré (✅ recommandé — authentifié) ou, comme alternative plus légère non authentifiée, ngrok.

Local

Le serveur s'exécute sur le même ordinateur que votre client IA et communique avec AnkiConnect sur localhost.

STDIO (intégration locale principale)

STDIO est le transport standard pour les clients MCP de bureau locaux — Claude Desktop, Cursor IDE, Cline, Zed Editor, et autres. Le client lance le serveur comme un sous-processus et communique via l'entrée/sortie standard.

Clients Supportés :

Claude Desktop
Cursor IDE - Éditeur de code alimenté par IA
Cline - Extension VS Code pour l'assistance IA
Zed Editor - Éditeur de code moderne et rapide
Autres clients MCP qui supportent le transport STDIO

Pour Claude Desktop, le bundle MCPB est le chemin le plus facile. Pour les autres clients, configurez le paquet npm avec le drapeau --stdio.

Configuration - Choisissez une méthode :

Méthode 1 : Utiliser npx (recommandé - aucune installation nécessaire)

{
  "mcpServers": {
    "anki-mcp": {
      "command": "npx",
      "args": ["-y", "@ankimcp/anki-mcp-server", "--stdio"],
      "env": {
        "ANKI_CONNECT_URL": "http://localhost:8765"
      }
    }
  }
}

Méthode 2 : Utiliser l'installation globale

D'abord, installez globalement :

npm install -g @ankimcp/anki-mcp-server

Puis configurez :

{
  "mcpServers": {
    "anki-mcp": {
      "command": "ankimcp",
      "args": ["--stdio"],
      "env": {
        "ANKI_CONNECT_URL": "http://localhost:8765"
      }
    }
  }
}

Emplacements des fichiers de configuration :

Cursor IDE : ~/.cursor/mcp.json (macOS/Linux) ou %USERPROFILE%\.cursor\mcp.json (Windows)
Cline : Accessible via l'interface des paramètres dans VS Code
Zed Editor : Installer comme extension MCP via le marketplace d'extensions

Pour les fonctionnalités spécifiques au client et le dépannage, consultez la documentation de votre client MCP. Voir aussi Connecter à Claude Desktop pour une configuration qui pointe directement vers un dist/main-stdio.js construit.

HTTP (IA web locale)

Le mode HTTP exécute le serveur comme un serveur web local parlant le protocole MCP Streamable HTTP. C'est le transport auquel un outil IA web s'adresse lorsqu'il est pointé vers votre machine, et c'est aussi ce que les options Distantes exposent au monde extérieur. Seul, le mode HTTP se lie à localhost uniquement.

Liaison au-delà de localhost ? Si vous passez --host 0.0.0.0 (ou exécutez derrière un proxy inverse/domaine public), le serveur n'accepte que les en-têtes de bouclage Host par défaut pour la protection contre le rebinding DNS — définissez ALLOWED_HOSTS sur le(s) nom(s) d'hôte que les clients utilisent. Voir Configuration du Mode HTTP.

Configuration - Choisissez une méthode :

Méthode 1 : Utiliser npx (recommandé - aucune installation nécessaire)

# Quick start
npx @ankimcp/anki-mcp-server

# With custom options
npx @ankimcp/anki-mcp-server --port 8080 --host 0.0.0.0
npx @ankimcp/anki-mcp-server --anki-connect http://localhost:8765

Méthode 2 : Utilisation de l'installation globale

# Install once
npm install -g @ankimcp/anki-mcp-server

# Run the server
ankimcp

# With custom options
ankimcp --port 8080 --host 0.0.0.0
ankimcp --anki-connect http://localhost:8765

Méthode 3 : Installation depuis les sources (pour le développement)

npm install
npm run build
npm run start:prod:http

Pour rendre un serveur HTTP local accessible par une IA hébergée dans le cloud, utilisez l'une des options Distantes ci-dessous.

Distant

Une IA hébergée/distance (comme ChatGPT ou Claude.ai s'exécutant dans le cloud) ne peut pas atteindre localhost directement. Ces options exposent votre Anki local à Internet afin qu'un assistant distant puisse communiquer avec lui.

Tunnel (✅ Recommandé)

Chemin distant recommandé — authentifié et sécurisé. Contrairement à un port public brut, le mode tunnel nécessite une connexion (flux de périphérique OAuth 2.0), de sorte que le point de terminaison n'est pas ouvert à quiconque devine l'URL.

Le mode tunnel permet aux assistants IA basés sur le Web d'atteindre votre Anki local sans exécuter votre propre tunnel. Le serveur se connecte au service de tunnel AnkiMCP géré (wss://tunnel.ankimcp.ai) via un WebSocket et se voit attribuer une URL publique. L'authentification est intégrée — aucun compte ngrok ni processus de tunnel séparé requis, et vous vous connectez une seule fois.

Connexion (flux de périphérique OAuth) :

Le mode tunnel utilise l'octroi d'autorisation de périphérique OAuth 2.0. La connexion ouvre automatiquement votre navigateur sur une page d'approbation avec le code déjà intégré dans l'URL — rien à taper, il suffit d'approuver. (Si le navigateur ne peut pas s'ouvrir, le terminal affiche une URL de vérification et un code à saisir manuellement comme solution de repli.) En cas de succès, les informations d'identification sont enregistrées dans ~/.ankimcp/credentials.json (permissions de fichier 0600).

# Pre-authenticate (optional — --tunnel will trigger this automatically if needed)
ankimcp --login
npx @ankimcp/anki-mcp-server --login

# Clear saved credentials
ankimcp --logout

Démarrer le tunnel :

# Connect to the managed tunnel service (wss://tunnel.ankimcp.ai)
ankimcp --tunnel
npx @ankimcp/anki-mcp-server --tunnel

# Override the tunnel server URL (must be ws:// or wss://) — e.g. for self-hosting
ankimcp --tunnel wss://my-tunnel.example.com

Si aucune information d'identification n'existe, --tunnel démarre automatiquement le flux de connexion en premier, puis continue vers le tunnel. Cette connexion automatique nécessite un terminal interactif — lorsque stdout n'est pas un TTY (systemd, Docker headless, CI), le serveur échoue rapidement et vous demande d'exécuter d'abord ankimcp --login. Une fois connecté, l'URL publique du tunnel est affichée ; appuyez sur Ctrl+C pour vous déconnecter. Partagez cette URL avec votre assistant IA.

Variables d'environnement du mode tunnel :

Variable	Description	Par défaut
`TUNNEL_SERVER_URL`	URL WebSocket du serveur tunnel (la valeur du drapeau `--tunnel`/`--login` remplace ceci)	`wss://tunnel.ankimcp.ai`
`TUNNEL_AUTH_CLIENT_ID`	ID client OAuth pour le flux de périphérique. Avancé — nécessaire uniquement lors du pointage vers un service tunnel/auth auto-hébergé.	(intégré)

Les points de terminaison d'authentification du flux de périphérique (/auth/device, /auth/token) sont dérivés de TUNNEL_SERVER_URL, donc pointer --tunnel (ou TUNNEL_SERVER_URL) vers un hôte différent déplace également l'authentification vers cet hôte.

Comment cela fonctionne : Le mode tunnel exécute le serveur MCP en cours de processus derrière un transport en mémoire (McpModule est démarré sans transport intégré). TunnelMcpService connecte ce transport en mémoire au serveur MCP, et TunnelClient le relie au service de tunnel distant via un WebSocket — relayant les requêtes MCP entrantes et les réponses sortantes. AnkiConnect n'est toujours atteint que sur votre machine locale.

ngrok (alternative non authentifiée)

Si vous préférez exposer le mode HTTP local publiquement sans compte sur le tunnel géré, le drapeau intégré --ngrok lance un sous-processus ngrok (src/services/ngrok.service.ts) et affiche l'URL publique dans la bannière de démarrage :

# One-time ngrok setup, then:
ankimcp --ngrok

Cette route est non authentifiée — toute personne disposant de l'URL peut atteindre votre Anki, elle est donc moins sécurisée que le Tunnel. Préférez le tunnel sauf si vous avez une raison spécifique de gérer votre propre point de terminaison ngrok. (Nécessite une installation globale de ngrok et un authtoken.)

Le drapeau --ngrok lance ngrok avec --host-header=rewrite, de sorte que ngrok réécrit l'en-tête Host amont en localhost avant de le transférer. Cela maintient les requêtes dans la liste d'autorisation d'hôte de boucle locale (voir protection contre le rebinding DNS) sans que vous ayez à ajouter le domaine public *.ngrok à ALLOWED_HOSTS. Si vous exécutez ngrok manuellement à la place, utilisez le même drapeau — ngrok http --host-header=rewrite 3000 — sinon ngrok transmet le nom d'hôte public ngrok comme Host et le serveur le rejette avec 403.

Options CLI (tous les modes)

ankimcp [options]

Options:
  --stdio                        Run in STDIO mode (for MCP clients)
  --tunnel [url]                 Connect via the managed tunnel (authenticated)
  --login                        Authenticate for tunnel mode (OAuth device flow)
  --logout                       Clear saved tunnel credentials
  -p, --port <port>              Port to listen on (HTTP mode, default: 3000)
  -h, --host <host>              Host to bind to (HTTP mode, default: 127.0.0.1)
  -a, --anki-connect <url>       AnkiConnect URL (default: http://localhost:8765)
  --ngrok                        Start ngrok tunnel (requires global ngrok installation)
  --read-only                    Run in read-only mode (blocks all write operations)
  --help                         Show help message

Usage with npx (no installation needed):
  npx @ankimcp/anki-mcp-server                        # HTTP mode
  npx @ankimcp/anki-mcp-server --port 8080            # Custom port
  npx @ankimcp/anki-mcp-server --stdio                # STDIO mode
  npx @ankimcp/anki-mcp-server --tunnel               # Managed tunnel mode
  npx @ankimcp/anki-mcp-server --ngrok                # HTTP mode with ngrok tunnel
  npx @ankimcp/anki-mcp-server --read-only            # Read-only mode

Usage with global installation:
  npm install -g @ankimcp/anki-mcp-server             # Install once
  ankimcp                                             # HTTP mode
  ankimcp --port 8080                                 # Custom port
  ankimcp --stdio                                     # STDIO mode
  ankimcp --tunnel                                    # Managed tunnel mode
  ankimcp --ngrok                                     # HTTP mode with ngrok tunnel
  ankimcp --read-only                                 # Read-only mode

Mode lecture seule (tous les modes)

Le drapeau --read-only empêche toute modification de votre collection Anki. Lorsqu'il est activé :

Toutes les opérations de lecture fonctionnent normalement (parcourir les paquets, visualiser les cartes, rechercher des notes)
Les opérations de révision sont autorisées (synchronisation, answerCards, suspendre/annuler la suspension)
Les modifications de contenu sont bloquées (addNote, deleteNotes, createDeck, updateNoteFields, etc.)
Utile pour explorer en toute sécurité les données Anki sans risque de modifications accidentelles

# HTTP mode with read-only
ankimcp --read-only

# STDIO mode with read-only
ankimcp --stdio --read-only

# Can combine with other flags
ankimcp --ngrok --read-only

Vous pouvez également activer le mode lecture seule via une variable d'environnement :

READ_ONLY=true ankimcp

Ou dans la configuration du client MCP :

{
  "mcpServers": {
    "anki-mcp": {
      "command": "npx",
      "args": ["-y", "@ankimcp/anki-mcp-server", "--stdio", "--read-only"],
      "env": {
        "ANKI_CONNECT_URL": "http://localhost:8765"
      }
    }
  }
}

Connexion à Claude Desktop (Mode Local)

Vous pouvez configurer le serveur dans Claude Desktop soit en :

Allant dans : Paramètres → Développeur → Modifier la configuration
Ou en éditant manuellement le fichier de configuration

Configuration

Ajoutez ce qui suit à votre configuration Claude Desktop :

{
  "mcpServers": {
    "anki-mcp": {
      "command": "node",
      "args": ["/path/to/anki-mcp-server/dist/main-stdio.js"],
      "env": {
        "ANKI_CONNECT_URL": "http://localhost:8765"
      }
    }
  }
}

Remplacez /path/to/anki-mcp-server par le chemin réel de votre projet.

Emplacements des fichiers de configuration

macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
Windows : %APPDATA%\Claude\claude_desktop_config.json
Linux : ~/.config/Claude/claude_desktop_config.json

Pour plus de détails, consultez la documentation officielle MCP.

Variables d'environnement (Optionnelles)

Variable	Description	Par défaut
`ANKI_CONNECT_URL`	URL AnkiConnect	`http://localhost:8765`
`ANKI_CONNECT_API_VERSION`	Version de l'API	`6`
`ANKI_CONNECT_API_KEY`	Clé API si configurée dans AnkiConnect	-
`ANKI_CONNECT_TIMEOUT`	Délai d'expiration de la requête en ms	`5000`
`READ_ONLY`	Activer le mode lecture seule (`true` ou `1`)	`false`
`ALLOWED_HOSTS`	Mode HTTP : valeurs d'en-tête `Host` supplémentaires à accepter au-delà de la boucle locale (noms d'hôte séparés par des virgules). Requis lors de la liaison à une adresse LAN/publique ou de l'exécution derrière un proxy inverse. Voir Configuration du mode HTTP.	boucle locale uniquement
`ALLOWED_ORIGINS`	Mode HTTP : liste d'autorisation séparée par des virgules de modèles `Origin`/`Referer` de navigateur (les caractères génériques sont pris en charge, par exemple `https://*.ngrok.io`).	`http://localhost:,http://127.0.0.1:,https://localhost:,https://127.0.0.1:`
`TUNNEL_SERVER_URL`	URL WebSocket du serveur tunnel (mode tunnel uniquement)	`wss://tunnel.ankimcp.ai`
`MEDIA_ALLOWED_TYPES`	Types MIME supplémentaires à autoriser pour les importations de chemins de fichiers (séparés par des virgules, par exemple, `application/pdf`)	-
`MEDIA_IMPORT_DIR`	Restreindre les importations de chemins de fichiers à ce répertoire	-
`MEDIA_ALLOWED_HOSTS`	Autoriser des hôtes de réseau privé spécifiques pour les importations d'URL (séparés par des virgules, par exemple, `192.168.1.50,my-nas`)	-

Exemples d'utilisation

Recherche et mise à jour de notes

# Search for notes in a specific deck
findNotes(query: "deck:Spanish")

# Get detailed information about notes
notesInfo(notes: [1234567890, 1234567891])

# Update a note's fields (HTML content supported)
updateNoteFields(note: {
  id: 1234567890,
  fields: {
    "Front": "<b>¿Cómo estás?</b>",
    "Back": "How are you?"
  }
})

# Delete notes (requires confirmation)
deleteNotes(notes: [1234567890], confirmDeletion: true)

Exemples de syntaxe de requête Anki

L'outil findNotes prend en charge la syntaxe de requête puissante d'Anki :

"deck:DeckName" - Toutes les notes dans un paquet spécifique
"tag:important" - Notes avec l'étiquette "important"
"is:due" - Cartes à réviser
"is:new" - Nouvelles cartes qui n'ont pas été étudiées
"added:7" - Notes ajoutées au cours des 7 derniers jours
"front:hello" - Notes avec "bonjour" dans le champ avant
"flag:1" - Notes avec drapeau rouge
"prop:due<=2" - Cartes à échéance dans les 2 jours
"deck:Spanish tag:verb" - Notes du paquet espagnol avec l'étiquette verbe (ET)
"deck:Spanish OR deck:French" - Notes de l'un ou l'autre paquet

Notes importantes

Gestion du CSS et du HTML

L'outil notesInfo renvoie des informations de style CSS pour une prise de conscience appropriée du rendu
L'outil updateNoteFields prend en charge le contenu HTML dans les champs et préserve le style CSS
Chaque modèle de note a son propre style CSS - utilisez modelStyling pour obtenir le CSS spécifique au modèle

Avertissement de mise à jour

⚠️ IMPORTANT : Lors de l'utilisation de updateNoteFields, ne visualisez PAS la note dans le navigateur d'Anki pendant la mise à jour, sinon les champs ne seront pas mis à jour correctement. Fermez le navigateur ou passez à une autre note avant de mettre à jour. Voir Problèmes connus pour plus de détails.

Sécurité de suppression

L'outil deleteNotes nécessite une confirmation explicite (confirmDeletion: true) pour éviter les suppressions accidentelles. La suppression d'une note supprime définitivement TOUTES les cartes associées.

Sécurité

Validation du chemin du fichier multimédia et de l'URL

Les outils multimédia (storeMediaFile, retrieveMediaFile, deleteMediaFile) et les champs audio/image updateNoteFields incluent une validation de sécurité pour empêcher toute utilisation abusive via l'injection de prompt :

Les importations de chemins de fichiers sont limitées aux types de fichiers multimédias uniquement (images, audio, vidéo). Les fichiers non multimédias (par exemple, les clés SSH, les informations d'identification, les configurations shell) sont rejetés en fonction du type MIME. Configurez MEDIA_ALLOWED_TYPES pour autoriser des types de fichiers supplémentaires, ou MEDIA_IMPORT_DIR pour restreindre les importations à un répertoire spécifique.
Les importations d'URL sont validées contre les attaques SSRF. Les requêtes vers les réseaux privés (10.x, 172.16.x, 192.168.x), la boucle locale (127.x), la liaison locale (169.254.x) et les schémas non HTTP(S) sont bloquées. Configurez MEDIA_ALLOWED_HOSTS pour autoriser des hôtes de réseau privé spécifiques.
Les noms de fichiers sont assainis pour empêcher le parcours de chemin (par exemple, les séquences ../../ sont supprimées).

Ces protections s'appliquent à storeMediaFile, retrieveMediaFile, deleteMediaFile et aux champs audio/image updateNoteFields.

Vulnérabilité de parcours de chemin signalée par Hideaki Takahashi.

Protection contre le rebinding DNS (transport HTTP)

Lors de l'exécution en mode HTTP, le serveur valide l'en-tête Host à chaque requête. Par défaut, seuls les hôtes de boucle locale (localhost, 127.0.0.1, ::1) sont acceptés, quel que soit le port. Host est un en-tête interdit par le navigateur, donc une page Web malveillante ne peut pas le falsifier — cela ferme le chemin de rebinding DNS où une page rebondie atteint le serveur local avec un Host usurpé et aucun Origin, et atteint les outils MCP. Un Host non autorisé est rejeté avec 403.

Si vous vous liez à 0.0.0.0, exécutez derrière un proxy inverse ou exposez un domaine de tunnel public, définissez ALLOWED_HOSTS (noms d'hôte séparés par des virgules) pour autoriser ces hôtes. Lors de la tunnellisation avec ngrok, le serveur utilise --host-header=rewrite, de sorte que l'amont voit toujours un Host de boucle locale. Voir Configuration du mode HTTP pour la liste complète des options.

Vulnérabilité de rebinding DNS signalée par avishaigo-commits et yotampe-pluto.

Politique de confidentialité

Ce serveur MCP s'exécute localement sur votre machine et ne collecte aucune télémétrie, analyse ou donnée d'utilisation.

Politique complète : https://ankimcp.ai/privacy/

Collecte de données : Le serveur ne collecte rien. Il relaie les requêtes entre votre assistant IA et votre plugin AnkiConnect local.
Utilisation / stockage : Aucun stockage côté serveur. Toutes les données de flashcards restent dans votre installation Anki sur votre propre appareil.
Partage avec des tiers : Aucun. Le serveur ne communique qu'avec l'URL AnkiConnect que vous configurez (par défaut : localhost). Si vous activez la synchronisation AnkiWeb intégrée d'Anki, cela se produit directement entre votre installation Anki et AnkiWeb — en dehors du champ d'application de ce serveur.
Conservation : Non applicable — aucune donnée n'est conservée côté serveur.
Contact : support@ankimcp.ai

Problèmes connus

Pour une liste complète des problèmes connus et des limitations, veuillez consulter notre documentation :

Documentation des problèmes connus

Limitations critiques

Les mises à jour de notes échouent lorsqu'elles sont visualisées dans le navigateur

⚠️ IMPORTANT : Lors de la mise à jour de notes à l'aide de updateNoteFields, la mise à jour échouera silencieusement si la note est actuellement visualisée dans la fenêtre du navigateur d'Anki. Il s'agit d'une limitation en amont d'AnkiConnect.

Solution de contournement : Fermez toujours le navigateur ou naviguez vers une autre note avant de mettre à jour.

Pour plus de détails et d'autres problèmes connus, consultez la documentation complète.

Dépannage

Erreur ERR_REQUIRE_ESM

Si vous voyez une erreur comme :

Error [ERR_REQUIRE_ESM]: require() of ES Module not supported

Cela signifie que votre version de Node.js n'est pas prise en charge. Le serveur nécessite Node.js 22.12.0+.

Remarque : Le runtime minimum pris en charge est Node.js 22.12.0. Node.js 20 (Iron) a atteint sa fin de vie le 30/04/2026 et n'est plus pris en charge.

Vérifiez votre version :

node --version

Solution : Mettez à jour Node.js vers la version 22.12.0 ou supérieure. Vous pouvez le télécharger depuis nodejs.org ou utiliser un gestionnaire de versions comme nvm.

Développement

Modes de transport

Ce serveur prend en charge trois modes de transport MCP via des points d'entrée distincts :

Mode STDIO (par défaut)

Pour les clients MCP locaux comme Claude Desktop
Utilise l'entrée/sortie standard pour la communication
Point d'entrée : dist/main-stdio.js
Exécution : npm run start:prod:stdio ou node dist/main-stdio.js
Bundle MCPB : Utilise le mode STDIO

Mode HTTP (HTTP diffusé en continu)

Pour les clients MCP distants et les intégrations web
Utilise le protocole MCP Streamable HTTP
Point d'entrée : dist/main-http.js
Exécution : npm run start:prod:http ou node dist/main-http.js
Port par défaut : 3000 (configurable via la variable d'env PORT)
Hôte par défaut : 127.0.0.1 (configurable via la variable d'env HOST)
Point de terminaison MCP : http://127.0.0.1:3000/ (chemin racine)

Mode Tunnel (Tunnel WebSocket géré)

Pour les assistants IA basés sur le web via le service de tunnel géré AnkiMCP, avec authentification intégrée
Le serveur MCP s'exécute en cours de processus derrière un transport en mémoire ; TunnelMcpService le connecte au serveur MCP et TunnelClient le relie au service de tunnel via un WebSocket
Point d'entrée : dist/main-tunnel.js
Exécution : node dist/main-tunnel.js --tunnel (ou ankimcp --tunnel)
Auth : ankimcp --login / ankimcp --logout ; les informations d'identification sont stockées dans ~/.ankimcp/credentials.json (0600)
Dev : npm run start:dev:tunnel (mode surveillance, exécute --tunnel --debug)

Construction

npm run build  # Builds once, creates dist/ with all three entry points

main-stdio.js, main-http.js et main-tunnel.js sont tous construits dans le même répertoire dist/. Choisissez celui à exécuter en fonction de vos besoins.

Configuration du mode HTTP

Variables d'environnement :

PORT - Port du serveur HTTP (par défaut : 3000)
HOST - Adresse de liaison (par défaut : 127.0.0.1 pour localhost uniquement)
ALLOWED_HOSTS - Valeurs d'en-tête Host supplémentaires séparées par des virgules à accepter au-delà de l'ensemble de bouclage intégré (localhost, 127.0.0.1, ::1). Nom d'hôte uniquement et indépendant du port. Par défaut : bouclage uniquement.
ALLOWED_ORIGINS - Liste d'autorisation séparée par des virgules de modèles Origin/Referer du navigateur ; les caractères génériques sont pris en charge (par exemple, https://*.ngrok.io). Par défaut : http://localhost:*,http://127.0.0.1:*,https://localhost:*,https://127.0.0.1:*.
LOG_LEVEL - Niveau de journalisation (par défaut : info)

Sécurité :

Validation de l'en-tête Host (protection contre le rebinding DNS) — chaque requête HTTP doit porter un en-tête Host qui correspond à la liste d'autorisation. Par défaut, seuls les hôtes de bouclage (localhost, 127.0.0.1, ::1) sont acceptés, quel que soit le port. Host est un en-tête interdit par le navigateur, donc une page web malveillante ne peut pas le falsifier — cela ferme la voie du rebinding DNS où une page rebondie atteint le serveur avec un Host usurpé et sans Origin. Un Host non autorisé est rejeté avec 403.
Validation de l'en-tête Origin — les requêtes du navigateur avec un Origin/Referer présent mais non autorisé sont rejetées. Les requêtes sans Origin (curl, Postman, clients MCP-over-HTTP) sont autorisées ; la validation de l'hôte est la défense contre le rebinding.
Se lie à localhost (127.0.0.1) par défaut.
Pas d'authentification dans la version actuelle (prise en charge OAuth prévue).

Exposer le mode HTTP au-delà de localhost — si vous vous liez à une adresse LAN/publique ou placez le serveur derrière un proxy inverse ou un domaine public, vous devez définir ALLOWED_HOSTS sur le(s) nom(s) d'hôte que les clients utiliseront, sinon chaque requête non locale est rejetée avec 403 :

# Bind to all interfaces and accept the machine's LAN name + a public domain
ALLOWED_HOSTS=my-nas.local,anki.example.com PORT=8080 HOST=0.0.0.0 node dist/main-http.js

Lorsque vous vous liez à 0.0.0.0/:: sans ALLOWED_HOSTS, le serveur enregistre un avertissement de démarrage indiquant que seuls les en-têtes Host de bouclage seront acceptés.

Docker / proxy inverse / domaine public : la même règle s'applique. Dans Docker, les requêtes arrivent généralement avec le nom d'hôte publié du conteneur ou le Host du proxy, définissez donc ALLOWED_HOSTS en conséquence. Un proxy inverse (nginx, Caddy, Traefik) doit soit transmettre le Host d'origine et avoir ce nom d'hôte répertorié dans ALLOWED_HOSTS, soit réécrire le Host en amont en localhost. L'intégration --ngrok intégrée gère cela automatiquement (voir ci-dessous).

Exemple : Modes d'exécution

# Development - STDIO mode (watch mode with auto-rebuild)
npm run start:dev:stdio

# Development - HTTP mode (watch mode with auto-rebuild)
npm run start:dev:http

# Production - STDIO mode
npm run start:prod:stdio
# or
node dist/main-stdio.js

# Production - HTTP mode
npm run start:prod:http
# or
PORT=8080 HOST=0.0.0.0 node dist/main-http.js

Construction d'un bundle MCPB

Pour créer un bundle MCPB distribuable :

npm run mcpb:bundle

Cette commande va :

Synchroniser la version de package.json vers manifest.json
Supprimer les anciens fichiers .mcpb
Construire le projet TypeScript
Empaqueter dist/ et node_modules/ dans un fichier .mcpb
Exécuter mcpb clean pour supprimer les devDependencies (optimise le bundle d'environ 47 Mo à environ 10 Mo)

Le fichier de sortie sera nommé anki-mcp-server-X.X.X.mcpb et pourra être distribué pour une installation en un clic.

Ce qui est inclus dans le bundle

Le bundle MCPB comprend :

JavaScript compilé (répertoire dist/ - inclut les trois points d'entrée)
Dépendances de production uniquement (node_modules/ - devDependencies supprimées par mcpb clean)
Métadonnées du paquet (package.json)
Configuration du manifeste (manifest.json - configuré pour utiliser main-stdio.js)
Icône (icon.png)

Les fichiers sources, les tests et les configurations de développement sont automatiquement exclus via .mcpbignore.

Journalisation dans Claude Desktop

Lors de l'exécution en tant qu'extension MCPB dans Claude Desktop, les journaux sont écrits dans :

Emplacement du journal : ~/Library/Logs/Claude/ (macOS)

Les journaux sont répartis sur plusieurs fichiers :

main.log - Journaux généraux de l'application Claude Desktop
mcp-server-Anki MCP Server.log - Messages du protocole MCP pour cette extension
mcp.log - Journaux MCP combinés de tous les serveurs

Remarque : La sortie du logger pino (messages INFO, ERROR, WARN du code du serveur) va vers stderr et apparaît dans les fichiers journaux spécifiques à MCP. Claude Desktop détermine quel fichier journal reçoit quels messages, mais généralement :

Démarrage de l'application et communication du protocole MCP → Journal spécifique à MCP
Journalisation interne du serveur (pino) → À la fois le journal spécifique à MCP et parfois main.log

Pour afficher les journaux en temps réel :

tail -f ~/Library/Logs/Claude/mcp-server-Anki\ MCP\ Server.log

Débogage du serveur MCP

Vous pouvez déboguer le serveur MCP à l'aide de MCP Inspector et en attachant un débogueur depuis votre IDE (WebStorm, VS Code, etc.).

Remarque pour le mode HTTP : Lorsque vous testez le mode HTTP (HTTP diffusé en continu) avec MCP Inspector, utilisez « Type de connexion : Via Proxy » pour éviter les erreurs CORS.

Étape 1 : Configurer le serveur de débogage dans MCP Inspector

Le mcp-inspector-config.json inclut déjà une configuration de serveur de débogage :

{
  "mcpServers": {
    "stdio-server-debug": {
      "type": "stdio",
      "command": "node",
      "args": ["--inspect-brk=9229", "dist/main-stdio.js"],
      "env": {
        "MCP_SERVER_NAME": "anki-mcp-stdio-debug",
        "MCP_SERVER_VERSION": "1.0.0",
        "LOG_LEVEL": "debug"
      },
      "note": "Anki MCP server with debugging enabled on port 9229"
    }
  }
}

Étape 2 : Démarrer le serveur de débogage

Exécutez MCP Inspector avec le serveur de débogage :

npm run inspector:debug

Cela démarrera le serveur avec le débogage Node.js activé sur le port 9229 et mettra en pause l'exécution à la première ligne.

Étape 3 : Attacher le débogueur depuis votre IDE

WebStorm

Allez dans Exécuter → Modifier les configurations
Ajoutez une nouvelle configuration Attacher à Node.js/Chrome
Définissez le port sur 9229
Cliquez sur Déboguer pour attacher

VS Code

Ouvrez le panneau Déboguer (Ctrl+Shift+D / Cmd+Shift+D)
Sélectionnez la configuration Debug MCP Server (Attach)
Appuyez sur F5 pour attacher

Étape 4 : Définir des points d'arrêt et déboguer

Une fois attaché, vous pouvez :

Définir des points d'arrêt dans vos fichiers source TypeScript
Parcourir l'exécution du code pas à pas
Inspecter les variables et la pile d'appels
Utiliser la console de débogage pour évaluer des expressions

Le débogueur fonctionnera avec les cartes sources, vous permettant de déboguer le code TypeScript original plutôt que le JavaScript compilé.

Débogage avec Claude Desktop

Vous pouvez également déboguer le serveur MCP pendant qu'il s'exécute dans Claude Desktop en activant le débogueur Node.js et en attachant votre IDE.

Étape 1 : Configurer Claude Desktop pour le débogage

Mettez à jour votre configuration Claude Desktop pour activer le débogage :

macOS : ~/Library/Application Support/Claude/claude_desktop_config.json Windows : %APPDATA%\Claude\claude_desktop_config.json Linux : ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "anki-mcp": {
      "command": "node",
      "args": [
        "--inspect=9229",
        "<path_to_project>/anki-mcp-server/dist/main-stdio.js"
      ],
      "env": {
        "ANKI_CONNECT_URL": "http://localhost:8765"
      }
    }
  }
}

Changement clé : Ajoutez --inspect=9229 avant le chemin vers dist/main-stdio.js

Options de débogage :

--inspect=9229 - Démarre le débogueur immédiatement, sans blocage (recommandé)
--inspect-brk=9229 - Met en pause l'exécution jusqu'à ce que le débogueur s'attache (pour déboguer les problèmes de démarrage)

Étape 2 : Redémarrer Claude Desktop

Après avoir enregistré la configuration, redémarrez Claude Desktop. Le serveur MCP s'exécutera désormais avec le débogage activé sur le port 9229.

Étape 3 : Attacher le débogueur depuis votre IDE

WebStorm

Allez dans Exécuter → Modifier les configurations
Cliquez sur le bouton + et sélectionnez Attacher à Node.js/Chrome
Configurez :
- Nom : Attach to Anki MCP (Claude Desktop)
- Hôte : localhost
- Port : 9229
- Attacher à : Node.js < 8 ou Chrome or Node.js > 6.3 (selon la version de WebStorm)
Cliquez sur OK
Cliquez sur Déboguer (Shift+F9) pour attacher

VS Code

Ajoutez à .vscode/launch.json :

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "Attach to Anki MCP (Claude Desktop)",
      "port": 9229,
      "skipFiles": ["<node_internals>/**"],
      "sourceMaps": true,
      "outFiles": ["${workspaceFolder}/dist/**/*.js"]
    }
  ]
}

Ouvrez le panneau Déboguer (Ctrl+Shift+D / Cmd+Shift+D)
Sélectionnez Attach to Anki MCP (Claude Desktop)
Appuyez sur F5 pour attacher

Étape 4 : Déboguer en temps réel

Une fois attaché, vous pouvez :

Définir des points d'arrêt dans vos fichiers source TypeScript (par exemple, src/mcp/primitives/essential/tools/create-model.tool.ts)
Utiliser Claude Desktop normalement - les points d'arrêt seront atteints lorsque les outils sont invoqués
Parcourir l'exécution du code pas à pas
Inspecter les variables et la pile d'appels
Utiliser la console de débogage

Exemple : Définissez un point d'arrêt dans create-model.tool.ts à la ligne 119, puis demandez à Claude de créer un nouveau modèle. Le débogueur se mettra en pause à votre point d'arrêt !

Remarque : Le débogueur reste attaché tant que Claude Desktop est en cours d'exécution. Vous pouvez vous détacher/rattacher à tout moment sans redémarrer Claude Desktop.

Commandes de construction

npm run build              # Build the project (compile TypeScript to JavaScript)
npm run start:dev:stdio    # STDIO mode with watch (auto-rebuild)
npm run start:dev:http     # HTTP mode with watch (auto-rebuild)
npm run type-check         # Run TypeScript type checking
npm run lint               # Run ESLint
npm run mcpb:bundle        # Sync version, clean, build, and create MCPB bundle

Test du paquet NPM (local)

Testez le paquet npm localement avant de le publier :

# 1. Create local package
npm run pack:local         # Builds and creates @ankimcp/anki-mcp-server-*.tgz

# 2. Install globally from local package
npm run install:local      # Installs from ./@ankimcp/anki-mcp-server-*.tgz

# 3. Test the command
ankimcp                    # Runs HTTP server on port 3000

# 4. Uninstall when done testing
npm run uninstall:local    # Removes global installation

Comment ça fonctionne :

npm pack crée un fichier .tgz identique à ce que npm publish créerait
L'installation à partir de .tgz simule ce que les utilisateurs obtiennent de npm install -g ankimcp
Cela vous permet de tester l'expérience utilisateur complète avant de publier sur npm

Commandes de test

npm test              # Run all tests
npm run test:unit     # Run unit tests only
npm run test:tools    # Run tool-specific tests
npm run test:workflows # Run workflow integration tests
npm run test:e2e      # Run end-to-end tests
npm run test:cov      # Run tests with coverage report
npm run test:watch    # Run tests in watch mode
npm run test:debug    # Run tests with debugger
npm run test:ci       # Run tests for CI (silent, with coverage)

Couverture des tests

Le projet maintient des seuils de couverture minimum de 70 % pour :

Les branches
Les fonctions
Les lignes
Les instructions

Les rapports de couverture sont générés dans le répertoire coverage/.

Gestion des versions

Ce projet suit la Gestion sémantique de version avec une approche de développement pré-1.0 :

0.x.x - Versions Beta/Développement (phase actuelle)
- 0.1.x - Corrections de bogues et correctifs
- 0.2.0+ - Nouvelles fonctionnalités ou améliorations mineures
- Les changements cassants sont acceptables dans les versions 0.x
1.0.0 - Première version stable
- Sera publiée lorsque l'API sera stable et testée
- Les changements cassants nécessiteront des incréments de version majeure (2.0.0, etc.)

Statut actuel : 0.22.0 - Développement bêta actif. Les fonctionnalités récentes incluent l'analyse de révision à l'échelle de la collection (review_stats agrège désormais sur tous les decks lorsque deck est omis), la gestion des champs de modèle (addModelField, removeModelField, renameModelField, repositionModelField), la création de notes par lot (addNotes), le tunneling ngrok intégré (indicateur --ngrok), la gestion des fichiers multimédias, la gestion des modèles/templates et des statistiques de deck complètes. Les API peuvent changer en fonction des retours et des tests.

Évolution de la spécification MCPB

Ce projet cible la spécification de bundle MCPB d'Anthropic, qui est encore en évolution. Nous suivons la spécification sur https://github.com/modelcontextprotocol/mcpb et pouvons introduire des changements cassants pour rester conformes. Les changements cassants sont autorisés dans le cadre du schéma de gestion des versions 0.x.x.

Projets similaires

Si vous explorez les intégrations Anki MCP, voici d'autres projets dans cet espace :

scorzeth/anki-mcp-server

Statut : Semble être abandonné (pas de mises à jour récentes)
Implémentation précoce de l'intégration Anki MCP

nailuoGG/anki-mcp-server

Approche : Implémentation légère en un seul fichier
Architecture : Structure de code procédurale avec tous les outils dans un seul fichier
Idéal pour : Cas d'usage simples, dépendances minimales

Pourquoi ce projet est différent :

Architecture de niveau entreprise : Construit sur NestJS avec injection de dépendances
Conception modulaire : Chaque outil est une classe distincte avec une séparation claire des préoccupations
Maintenabilité : Facile à étendre avec de nouvelles fonctionnalités sans toucher au code existant
Tests : Suite de tests complète avec une exigence de couverture de 70 %
Sécurité de typage : TypeScript strict avec validation Zod
Gestion des erreurs : Gestion robuste des erreurs avec des retours utilisateur utiles
Prêt pour la production : Journalisation appropriée, rapports de progression et prise en charge du bundle MCPB
Scalabilité : Peut facilement évoluer d'outils de base à des flux de travail complexes

Cas d'usage : Si vous avez besoin d'une base solide pour construire des intégrations Anki avancées ou prévoyez d'étendre significativement les fonctionnalités, l'approche architecturale de ce projet facilite la maintenance et la mise à l'échelle au fil du temps.

Liens utiles

Licence et attribution

Ce projet est sous licence MIT — voir LICENSE pour le texte complet.

Attributions tierces

Anki® est une marque déposée d'Ankitects Pty Ltd. Ce projet est un outil tiers non officiel et n'est pas affilié à, approuvé par ou sponsorisé par Ankitects Pty Ltd. Le logo Anki est utilisé sous la licence alternative pour référencer Anki avec un lien vers https://apps.ankiweb.net. Pour l'application Anki officielle, visitez https://apps.ankiweb.net.
Model Context Protocol (MCP) est un standard ouvert d'Anthropic. Le logo MCP provient du dépôt officiel de documentation MCP et est utilisé sous la licence MIT. Pour plus d'informations sur MCP, visitez https://modelcontextprotocol.io.
Ceci est un projet indépendant qui fait le pont entre les technologies Anki et MCP. Toutes les marques commerciales, marques de service, noms commerciaux, noms de produits et logos sont la propriété de leurs détenteurs respectifs.