iflow-mcp_ujisati_anki-mcp 0.1.0__py3-none-any.whl

anki_mcp/__init__.py

@@ -0,0 +1,37 @@
+import asyncio
+
+from fastmcp import FastMCP
+
+from .card_service import card_mcp
+from .deck_service import deck_mcp
+from .media_service import media_mcp
+from .model_service import model_mcp
+from .note_service import note_mcp
+
+
+anki_mcp = FastMCP(
+    name="AnkiConnectMCP",
+    instructions="""
+    This MCP provides a programmatic interface to Anki flashcard functionality through the AnkiConnect API.
+    It allows AI assistants to interact with Anki decks, cards, notes, models, and media
+    without needing to understand the underlying API details. All interactions are through tools.
+    """,
+)
+
+
+async def setup(run_server: bool = True):
+    await anki_mcp.import_server(deck_mcp)
+    await anki_mcp.import_server(note_mcp)
+    await anki_mcp.import_server(card_mcp)
+    await anki_mcp.import_server(model_mcp)
+    await anki_mcp.import_server(media_mcp)
+    if run_server:
+        await anki_mcp.run_async()
+
+
+def main():
+    asyncio.run(setup(run_server=True))
+
+
+if __name__ == "__main__":
+    main()

anki_mcp/card_service.py

@@ -0,0 +1,116 @@
+from typing import Annotated, Any, Dict, List, Optional
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from .common import anki_call
+
+card_mcp = FastMCP(name="AnkiCardService")
+
+
+@card_mcp.tool(
+    name="findCards",
+    description="Returns an array of card IDs for a given Anki search query.",
+)
+async def find_cards_tool(
+    query: Annotated[
+        str, Field(description="Anki search query (e.g., 'deck:current is:new').")
+    ],
+) -> List[int]:
+    return await anki_call("findCards", query=query)
+
+
+@card_mcp.tool(
+    name="cardsInfo",
+    description="Returns a list of objects containing information for each card ID provided.",
+)
+async def get_cards_info_tool(
+    cards: Annotated[List[int], Field(description="A list of card IDs.")],
+) -> List[Dict[str, Any]]:
+    return await anki_call("cardsInfo", cards=cards)
+
+
+@card_mcp.tool(
+    name="cardsToNotes",
+    description="Returns an unordered array of note IDs for the given card IDs.",
+)
+async def convert_cards_to_notes_tool(
+    cards: Annotated[List[int], Field(description="A list of card IDs.")],
+) -> List[int]:
+    return await anki_call("cardsToNotes", cards=cards)
+
+
+@card_mcp.tool(
+    name="areSuspended",
+    description="Returns an array indicating whether each given card is suspended. Each item is boolean or null if the card doesn't exist.",
+)
+async def check_cards_suspended_tool(
+    cards: Annotated[List[int], Field(description="A list of card IDs.")],
+) -> List[Optional[bool]]:
+    return await anki_call("areSuspended", cards=cards)
+
+
+@card_mcp.tool(
+    name="cardsModTime",
+    description="Returns modification time for each card ID provided. Result is a list of objects with 'cardId' and 'modTime' (timestamp).",
+)
+async def get_cards_modification_time_tool(
+    cards: Annotated[List[int], Field(description="A list of card IDs.")],
+) -> List[Dict[str, Any]]:                                                  
+    return await anki_call("cardsModTime", cards=cards)
+
+
+@card_mcp.tool(
+    name="suspended",
+    description="Checks if a single card is suspended by its ID. Returns true if suspended, false otherwise.",
+)
+async def check_card_suspended_tool(
+    card: Annotated[int, Field(description="The ID of the card.")],
+) -> bool:
+    return await anki_call("suspended", card=card)
+
+
+@card_mcp.tool(
+    name="suspend", description="Suspends the specified cards. Returns true on success."
+)
+async def suspend_cards_tool(
+    cards: Annotated[List[int], Field(description="A list of card IDs to suspend.")],
+) -> bool:
+    return await anki_call("suspend", cards=cards)
+
+
+@card_mcp.tool(
+    name="unsuspend",
+    description="Unsuspends the specified cards. Returns true on success.",
+)
+async def unsuspend_cards_tool(
+    cards: Annotated[List[int], Field(description="A list of card IDs to unsuspend.")],
+) -> bool:
+    return await anki_call("unsuspend", cards=cards)
+
+
+@card_mcp.tool(
+    name="setSpecificValueOfCard",
+    description="Sets specific values of a single card. Use with caution. Returns list of booleans indicating success for each key.",
+)
+async def set_specific_card_value_tool(
+    card: Annotated[int, Field(description="The ID of the card to modify.")],
+    keys: Annotated[
+        List[str],
+        Field(
+            description="List of card property keys to change (e.g., 'flags', 'odue')."
+        ),
+    ],
+    newValues: Annotated[
+        List[Any],                                                             
+        Field(description="List of new values corresponding to the keys."),
+    ],
+    warning_check: Annotated[
+        Optional[bool],
+        Field(description="Set to True for potentially risky operations."),
+    ] = None,
+) -> List[bool]:
+    params: Dict[str, Any] = {"card": card, "keys": keys, "newValues": newValues}
+    if warning_check is not None:
+        params["warning_check"] = warning_check
+    return await anki_call("setSpecificValueOfCard", **params)

anki_mcp/common.py

@@ -0,0 +1,23 @@
+from typing import Any
+
+import httpx
+
+ANKICONNECT_URL = "http://127.0.0.1:8765"
+
+
+async def anki_call(action: str, **params: Any) -> Any:
+    async with httpx.AsyncClient() as client:
+        payload = {"action": action, "version": 6, "params": params}
+        result = await client.post(ANKICONNECT_URL, json=payload)
+        result.raise_for_status()                                      
+        result_json = result.json()
+        error = result_json.get("error")
+        if error:
+            raise Exception(f"AnkiConnect error for action '{action}': {error}")
+        response = result_json.get("result")
+                                                             
+                                                                                                     
+                                                                                        
+        if "result" in result_json:
+            return response
+        return result_json                                                                        

anki_mcp/deck_service.py

@@ -0,0 +1,91 @@
+from typing import Annotated, Any, Dict, List
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from .common import anki_call
+
+deck_mcp = FastMCP(name="AnkiDeckService")
+
+
+@deck_mcp.tool(
+    name="deckNamesAndIds",
+    description="Gets the complete list of deck names and their respective IDs. Returns a dictionary mapping deck names to their IDs.",
+)
+async def list_deck_names_and_ids_tool() -> Dict[str, int]:
+    return await anki_call("deckNamesAndIds")
+
+
+@deck_mcp.tool(
+    name="getDeckConfig",
+    description="Gets the configuration group object for the given deck name. Returns the deck configuration object.",
+)
+async def get_deck_config_tool(
+    deck: Annotated[str, Field(description="The name of the deck (e.g., 'Default').")],
+) -> Dict[str, Any]:
+    return await anki_call("getDeckConfig", deck=deck)
+
+
+@deck_mcp.tool(
+    name="deckNames",
+    description="Gets the complete list of deck names for the current user. Returns a list of deck names.",
+)
+async def list_deck_names_tool() -> List[str]:
+    return await anki_call("deckNames")
+
+
+@deck_mcp.tool(
+    name="createDeck",
+    description="Creates a new empty deck. Will not overwrite an existing deck with the same name. Returns the ID of the created deck.",
+)
+async def create_deck_tool(
+    deck: Annotated[
+        str,
+        Field(description="The name of the deck to create (e.g., 'Japanese::Tokyo')."),
+    ],
+) -> int:
+    return await anki_call("createDeck", deck=deck)
+
+
+@deck_mcp.tool(
+    name="deleteDecks",
+    description="Deletes decks with the given names. The 'cardsToo' argument must be specified and set to true.",
+)
+async def delete_decks_tool(
+    decks: Annotated[List[str], Field(description="A list of deck names to delete.")],
+    cardsToo: Annotated[
+        bool,
+        Field(
+            description="Must be true to confirm deletion of cards within the decks."
+        ),
+    ],
+) -> None:
+    if not cardsToo:
+        raise ValueError("cardsToo must be true to delete decks.")
+    return await anki_call("deleteDecks", decks=decks, cardsToo=cardsToo)
+
+
+@deck_mcp.tool(
+    name="changeDeck",
+    description="Moves cards with the given IDs to a different deck, creating the deck if it doesn't exist yet.",
+)
+async def change_deck_tool(
+    cards: Annotated[List[int], Field(description="A list of card IDs to move.")],
+    deck: Annotated[str, Field(description="The target deck name.")],
+) -> None:
+    return await anki_call("changeDeck", cards=cards, deck=deck)
+
+
+@deck_mcp.tool(
+    name="saveDeckConfig",
+    description="Saves the given configuration group. Returns true on success, false otherwise.",
+)
+async def save_deck_config_tool(
+    config: Annotated[
+        Dict[str, Any],
+        Field(
+            description="The deck configuration object to save. Must include an 'id'."
+        ),
+    ],
+) -> bool:
+    return await anki_call("saveDeckConfig", config=config)

anki_mcp/media_service.py

@@ -0,0 +1,91 @@
+from typing import Annotated, Any, Dict, List, Optional
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from .common import anki_call
+
+media_mcp = FastMCP(name="AnkiMediaService")
+
+
+@media_mcp.tool(
+    name="retrieveMediaFile",
+    description="Retrieves the base64-encoded contents of the specified media file. Returns the base64 string or false if not found.",
+)
+async def retrieve_media_file_tool(
+    filename: Annotated[
+        str, Field(description="The name of the media file in Anki's collection.")
+    ],
+) -> Any:                                          
+    return await anki_call("retrieveMediaFile", filename=filename)
+
+
+@media_mcp.tool(
+    name="getMediaFilesNames",
+    description="Gets the names of media files matching the glob pattern. Returns a list of filenames.",
+)
+async def list_media_files_names_tool(                                               
+    pattern: Annotated[
+        str, Field(description="A glob pattern to match filenames (e.g., '*.jpg').")
+    ],
+) -> List[str]:
+    return await anki_call("getMediaFilesNames", pattern=pattern)
+
+
+@media_mcp.tool(
+    name="storeMediaFile",
+    description="Stores a media file in Anki's media folder. Provide one of 'data' (base64), 'path', or 'url'. Returns the stored filename or false on error.",
+)
+async def store_media_file_tool(
+    filename: Annotated[
+        str, Field(description="The desired filename in Anki's media collection.")
+    ],
+    data: Annotated[
+        Optional[str], Field(description="Base64-encoded file content.")
+    ] = None,
+    path: Annotated[
+        Optional[str], Field(description="Absolute local path to the file.")
+    ] = None,
+    url: Annotated[
+        Optional[str], Field(description="URL to download the file from.")
+    ] = None,
+    deleteExisting: Annotated[                                                            
+        Optional[bool],
+        Field(
+            description="Whether to delete an existing file with the same name. Default is true."
+        ),
+    ] = True,
+) -> Any:                                            
+    params: Dict[str, Any] = {"filename": filename}
+    source_count = sum(1 for src in (data, path, url) if src is not None)
+    if source_count != 1:
+        raise ValueError(
+            "Exactly one of 'data', 'path', or 'url' must be provided for storeMediaFile."
+        )
+
+    if data:
+        params["data"] = data
+    elif path:
+        params["path"] = path
+    elif url:
+        params["url"] = url
+
+    if (
+        deleteExisting is not None
+    ):                                                                
+        params["deleteExisting"] = deleteExisting
+
+    return await anki_call("storeMediaFile", **params)
+
+
+@media_mcp.tool(
+    name="deleteMediaFile",
+    description="Deletes the specified file from Anki's media folder.",
+)
+async def delete_media_file_tool(
+    filename: Annotated[
+        str,
+        Field(description="The name of the file to delete from the media collection."),
+    ],
+) -> None:
+    return await anki_call("deleteMediaFile", filename=filename)

anki_mcp/model_service.py

@@ -0,0 +1,151 @@
+from typing import Annotated, Any, Dict, List, Optional
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from .common import anki_call
+
+model_mcp = FastMCP(name="AnkiModelService")
+
+
+@model_mcp.tool(
+    name="modelNamesAndIds",
+    description="Gets the complete list of model (note type) names and their IDs. Returns a dictionary mapping model names to IDs.",
+)
+async def list_model_names_and_ids_tool() -> Dict[str, int]:
+    return await anki_call("modelNamesAndIds")
+
+
+@model_mcp.tool(
+    name="findModelsByName",
+    description="Gets a list of model definitions for the provided model names.",
+)
+async def find_models_by_name_tool(
+    modelNames: Annotated[List[str], Field(description="A list of model names.")],
+) -> List[Dict[str, Any]]:
+    return await anki_call("findModelsByName", modelNames=modelNames)
+
+
+@model_mcp.tool(
+    name="modelFieldNames",
+    description="Gets the list of field names for the provided model name.",
+)
+async def get_model_field_names_tool(
+    modelName: Annotated[str, Field(description="The name of the model.")],
+) -> List[str]:
+    return await anki_call("modelFieldNames", modelName=modelName)
+
+
+@model_mcp.tool(
+    name="modelTemplates",
+    description="Returns an object indicating the template content for each card of the specified model.",
+)
+async def get_model_templates_tool(
+    modelName: Annotated[str, Field(description="The name of the model.")],
+) -> Dict[str, Any]:                                                                 
+    return await anki_call("modelTemplates", modelName=modelName)
+
+
+@model_mcp.tool(
+    name="modelStyling",
+    description="Gets the CSS styling for the provided model name. Returns an object containing the 'css' field.",
+)
+async def get_model_styling_tool(
+    modelName: Annotated[str, Field(description="The name of the model.")],
+) -> Dict[str, Any]:                         
+    return await anki_call("modelStyling", modelName=modelName)
+
+
+@model_mcp.tool(
+    name="createModel",
+    description="Creates a new model (note type). Returns the created model object.",
+)
+async def create_model_tool(
+    modelName: Annotated[str, Field(description="The name for the new model.")],
+    inOrderFields: Annotated[
+        List[str], Field(description="List of field names in order.")
+    ],
+    cardTemplates: Annotated[
+        List[Dict[str, Any]],
+        Field(
+            description="List of card template definitions. Each dict needs 'Name', 'Front', 'Back'."
+        ),
+    ],
+    css: Annotated[
+        Optional[str], Field(description="Optional CSS for the model.")
+    ] = None,
+    isCloze: Annotated[
+        Optional[bool], Field(description="Set to true if this is a Cloze model.")
+    ] = False,
+    modelId: Annotated[
+        Optional[int], Field(description="Optional model ID to use.")
+    ] = None,                                   
+) -> Dict[str, Any]:
+    params: Dict[str, Any] = {
+        "modelName": modelName,
+        "inOrderFields": inOrderFields,
+        "cardTemplates": cardTemplates,
+        "isCloze": isCloze,
+    }
+    if css is not None:
+        params["css"] = css
+    if modelId is not None:
+        params["modelId"] = modelId
+    return await anki_call("createModel", **params)
+
+
+@model_mcp.tool(
+    name="updateModelTemplates",
+    description="Modifies the templates of an existing model by name.",
+)
+async def update_model_templates_tool(
+    model: Annotated[
+        Dict[str, Any],
+        Field(
+            description="Model object. Must include 'name' (model name) and 'templates' (dict of template name to Front/Back definitions)."
+        ),
+    ],
+) -> None:
+    return await anki_call("updateModelTemplates", model=model)
+
+
+@model_mcp.tool(
+    name="updateModelStyling",
+    description="Modifies the CSS styling of an existing model by name.",
+)
+async def update_model_styling_tool(
+    model: Annotated[
+        Dict[str, Any],
+        Field(
+            description="Model object. Must include 'name' (model name) and 'css' (the new CSS string)."
+        ),
+    ],
+) -> None:
+    return await anki_call("updateModelStyling", model=model)
+
+
+@model_mcp.tool(
+    name="modelFieldAdd", description="Adds a new field to an existing model."
+)
+async def add_model_field_tool(                                                     
+    modelName: Annotated[str, Field(description="Name of the model to modify.")],
+    fieldName: Annotated[str, Field(description="Name of the new field to add.")],
+    index: Annotated[
+        Optional[int],
+        Field(description="Optional 0-based index to insert the field at."),
+    ] = None,
+) -> None:
+    params: Dict[str, Any] = {"modelName": modelName, "fieldName": fieldName}
+    if index is not None:
+        params["index"] = index
+    return await anki_call("modelFieldAdd", **params)
+
+
+@model_mcp.tool(
+    name="modelFieldRemove", description="Removes a field from an existing model."
+)
+async def remove_model_field_tool(                                                        
+    modelName: Annotated[str, Field(description="Name of the model to modify.")],
+    fieldName: Annotated[str, Field(description="Name of the field to remove.")],
+) -> None:
+    return await anki_call("modelFieldRemove", modelName=modelName, fieldName=fieldName)

anki_mcp/note_service.py

@@ -0,0 +1,130 @@
+from typing import Annotated, Any, Dict, List, Optional
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from .common import anki_call
+
+note_mcp = FastMCP(name="AnkiNoteService")
+
+
+@note_mcp.tool(
+    name="findNotes",
+    description="Returns an array of note IDs for a given Anki search query.",
+)
+async def find_notes_tool(
+    query: Annotated[
+        str, Field(description="Anki search query (e.g., 'deck:current card:1').")
+    ],
+) -> List[int]:
+    return await anki_call("findNotes", query=query)
+
+
+@note_mcp.tool(
+    name="notesInfo",
+    description="Returns a list of objects containing information for each note ID provided.",
+)
+async def get_notes_info_tool(
+    notes: Annotated[List[int], Field(description="A list of note IDs.")],
+) -> List[Dict[str, Any]]:
+    return await anki_call("notesInfo", notes=notes)
+
+
+@note_mcp.tool(
+    name="getNoteTags",
+    description="Gets the tags for a specific note ID. Returns a list of tags.",
+)
+async def get_note_tags_tool(
+    note: Annotated[int, Field(description="The ID of the note.")],
+) -> List[str]:
+    return await anki_call("getNoteTags", note=note)
+
+
+@note_mcp.tool(
+    name="addNote",
+    description="Creates a new note using the given deck, model, fields, and tags. Returns the ID of the created note or null if the note could not be created.",
+)
+async def add_note_tool(
+    note: Annotated[
+        Dict[str, Any],
+        Field(
+            description="A dictionary representing the note to add. Should include 'deckName', 'modelName', 'fields', and optionally 'tags', 'options', 'audio', 'video', 'picture'."
+        ),
+    ],
+) -> Optional[int]:
+    return await anki_call("addNote", note=note)
+
+
+@note_mcp.tool(
+    name="updateNoteFields", description="Modifies the fields of an existing note."
+)
+async def update_note_fields_tool(
+    note: Annotated[
+        Dict[str, Any],
+        Field(
+            description="A dictionary representing the note to update. Must include 'id' and 'fields'. Optionally 'audio', 'video', or 'picture'."
+        ),
+    ],
+) -> None:
+    return await anki_call("updateNoteFields", note=note)
+
+
+@note_mcp.tool(name="deleteNotes", description="Deletes notes with the given IDs.")
+async def delete_notes_tool(
+    notes: Annotated[List[int], Field(description="A list of note IDs to delete.")],
+) -> None:
+    return await anki_call("deleteNotes", notes=notes)
+
+
+@note_mcp.tool(
+    name="addNotes",
+    description="Creates multiple notes. See 'addNote' for the structure of each note object in the list. Returns a list of new note IDs, or null for notes that couldn't be created.",
+)
+async def add_notes_tool(
+    notes: Annotated[
+        List[Dict[str, Any]], Field(description="A list of note objects to add.")
+    ],
+) -> List[Optional[int]]:
+    return await anki_call("addNotes", notes=notes)
+
+
+@note_mcp.tool(name="addTags", description="Adds tags to the specified notes.")
+async def add_tags_tool(
+    notes: Annotated[
+        List[int], Field(description="A list of note IDs to add tags to.")
+    ],
+    tags: Annotated[
+        str,
+        Field(
+            description="A space-separated string of tags to add (e.g., 'tag1 tag2')."
+        ),
+    ],
+) -> None:
+    return await anki_call("addTags", notes=notes, tags=tags)
+
+
+@note_mcp.tool(name="removeTags", description="Removes tags from the specified notes.")
+async def remove_tags_tool(
+    notes: Annotated[
+        List[int], Field(description="A list of note IDs to remove tags from.")
+    ],
+    tags: Annotated[
+        str, Field(description="A space-separated string of tags to remove.")
+    ],
+) -> None:
+    return await anki_call("removeTags", notes=notes, tags=tags)
+
+
+@note_mcp.tool(
+    name="updateNote",
+    description="Modifies the fields and/or tags of an existing note.",
+)
+async def update_note_tool(
+    note: Annotated[
+        Dict[str, Any],
+        Field(
+            description="Note object to update. Must include 'id'. Can include 'fields', 'tags', 'audio', 'video', 'picture'."
+        ),
+    ],
+) -> None:
+    return await anki_call("updateNote", note=note)

iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_ujisati_anki-mcp
+Version: 0.1.0
+Summary: Add your description here
+Author-email: ujisati <98663233+ujisati@users.noreply.github.com>
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: fastmcp>=2.3.3
+Requires-Dist: httpx>=0.28.1
+Description-Content-Type: text/markdown
+
+# anki-mcp
+
+A Model Context Protocol (MCP) server for interacting with Anki flashcards via the AnkiConnect add-on. This server exposes AnkiConnect actions as MCP tools, organized into logical services.
+
+## Prerequisites
+
+- Anki desktop application
+- AnkiConnect add-on installed and configured in Anki
+- Python 3.8+
+- `uv` (for running and installing dependencies, optional but recommended)
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/ujisati/anki-mcp.git
+cd anki-mcp
+
+# Install dependencies (using uv)
+uv pip install -e .
+```
+
+## Usage
+
+To run the MCP server:
+
+```bash
+uv run anki-mcp
+```
+
+The server will start and listen for MCP requests, typically interfacing with AnkiConnect at `http://127.0.0.1:8765`.
+
+### Inspecting the Server
+
+You can use the MCP Inspector to view the available tools:
+
+```bash
+npx @modelcontextprotocol/inspector uv run anki-mcp
+```
+
+## Configuration for MCP Clients
+
+If you're integrating this with an MCP client (like an AI assistant framework), you'll need to configure it to find this server. Here's an example configuration snippet:
+
+```json
+{
+    "mcpServers": {
+        "anki": {
+            "command": "uv",
+            "args": [
+                "run", // uv will find anki-mcp if run from project root
+                "anki-mcp"
+            ],
+            // If running from outside the project directory, specify the path:
+            // "args": [
+            //     "--directory",
+            //     "/ABSOLUTE/PATH/TO/anki-mcp", // Replace with actual path
+            //     "run",
+            //     "anki-mcp"
+            // ]
+        }
+    }
+}
+```
+
+## Available MCP Tools
+
+This MCP server provides access to Anki functionality through tools grouped by services. The tool names correspond directly to AnkiConnect actions.
+
+### Deck Service (`deck.*`)
+- **`deck.deckNamesAndIds`**: Gets the complete list of deck names and their respective IDs.
+- **`deck.getDeckConfig`**: Gets the configuration group object for a given deck name.
+- **`deck.deckNames`**: Gets the complete list of deck names for the current user.
+- **`deck.createDeck`**: Creates a new empty deck.
+- **`deck.deleteDecks`**: Deletes specified decks.
+- **`deck.changeDeck`**: Moves cards to a different deck.
+- **`deck.saveDeckConfig`**: Saves a deck configuration group.
+
+### Note Service (`note.*`)
+- **`note.findNotes`**: Returns note IDs for a given Anki search query.
+- **`note.notesInfo`**: Returns information for specified note IDs.
+- **`note.getNoteTags`**: Gets the tags for a specific note ID.
+- **`note.addNote`**: Creates a new note.
+- **`note.updateNoteFields`**: Modifies the fields of an existing note.
+- **`note.deleteNotes`**: Deletes specified notes.
+- **`note.addNotes`**: Creates multiple notes.
+- **`note.addTags`**: Adds tags to specified notes.
+- **`note.removeTags`**: Removes tags from specified notes.
+- **`note.updateNote`**: Modifies the fields and/or tags of an existing note.
+
+### Card Service (`card.*`)
+- **`card.findCards`**: Returns card IDs for a given Anki search query.
+- **`card.cardsInfo`**: Returns information for specified card IDs.
+- **`card.cardsToNotes`**: Returns note IDs for given card IDs.
+- **`card.areSuspended`**: Checks if specified cards are suspended.
+- **`card.cardsModTime`**: Returns modification time for specified card IDs.
+- **`card.suspended`**: Checks if a single card is suspended.
+- **`card.suspend`**: Suspends specified cards.
+- **`card.unsuspend`**: Unsuspends specified cards.
+- **`card.setSpecificValueOfCard`**: Sets specific values of a single card (use with caution).
+
+### Model Service (`model.*`) (Note Types)
+- **`model.modelNamesAndIds`**: Gets the complete list of model (note type) names and their IDs.
+- **`model.findModelsByName`**: Gets model definitions for provided model names.
+- **`model.modelFieldNames`**: Gets field names for a given model name.
+- **`model.modelTemplates`**: Gets template content for each card of a specified model.
+- **`model.modelStyling`**: Gets CSS styling for a given model name.
+- **`model.createModel`**: Creates a new model (note type).
+- **`model.updateModelTemplates`**: Modifies templates of an existing model.
+- **`model.updateModelStyling`**: Modifies CSS styling of an existing model.
+- **`model.modelFieldAdd`**: Adds a new field to an existing model.
+- **`model.modelFieldRemove`**: Removes a field from an existing model.
+
+### Media Service (`media.*`)
+- **`media.retrieveMediaFile`**: Retrieves the base64-encoded contents of a media file.
+- **`media.getMediaFilesNames`**: Gets names of media files matching a glob pattern.
+- **`media.storeMediaFile`**: Stores a media file (from base64, path, or URL).
+- **`media.deleteMediaFile`**: Deletes a specified media file.
+
+## Development
+
+To set up for development:
+
+```bash
+uv sync
+source .venv/bin/activate
+
+uv pip install -e .
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+## Todo
+
+- [ ] Finish adding all AnkiConnect tools

iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+anki_mcp/__init__.py,sha256=koEUwXZFjc0ZKJFlWMTDIrnLSb7EBiLtMdy3YU_icF0,1009
+anki_mcp/card_service.py,sha256=b-nmzymS1_5UrR_0dYZq9wu9sE5zE6qpzRmmHYvOW8s,3926
+anki_mcp/common.py,sha256=mugKG_69xcFJGyT05MN-BDhA4u73zC1zSMDTsJHWw1c,1028
+anki_mcp/deck_service.py,sha256=M7CwD_08w-n0hgrhw21VRnPLi9KlCD8riB60hOW-ky4,2899
+anki_mcp/media_service.py,sha256=JeRgwgN0a-97J-TS39cMv1CteJcr5fZiiekNJ9P3G5c,3074
+anki_mcp/model_service.py,sha256=J3dQ-jwygrih8WE8L-aE2Wf1IUORWeIoP-iCOiV0knk,5256
+anki_mcp/note_service.py,sha256=-qGed8Z0iArMb_X7asX_qnGQs9gxpEKW8BE_hA-dSEM,4084
+iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/METADATA,sha256=sqQPxCp-pzLMZpeu4yW9Ai8S5At1n6k8QB5x6GLjz6c,5255
+iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/entry_points.txt,sha256=iwp_5h2sAepOxyMntoEj9WzVpCgnDHDLz7q3cOe6Fh8,43
+iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=rB7eke8ySHfrR9MppOeN1SPaAFHlTYrCIL0mpPDxh6A,1064
+iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/RECORD,,

iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+anki-mcp = anki_mcp:main

iflow_mcp_ujisati_anki_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ujisati
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.