@fredrika/mcp-mochi 1.0.1 → 1.0.3

package/README.md

@@ -1,14 +1,11 @@
 # Mochi MCP Server
 
-This MCP server provides integration with the Mochi flashcard system, allowing you to manage and review your flashcards through the Model Context Protocol.
+This MCP server provides integration with the Mochi flashcard system, allowing you to manage your flashcards through the Model Context Protocol.
 
 ## Features
 
 - Create, update, and delete flashcards
-- Get flashcards due for review
-- Review flashcards and track progress
-- View study statistics
-- Tag-based organization
+- List flashcards, decks, and templates
 
 ## Setup
 
@@ -33,40 +30,38 @@ This MCP server provides integration with the Mochi flashcard system, allowing y
 
 ## Available Tools
 
-### `createFlashcard`
-Create a new flashcard.
+### `mochi_create_card`
+Create a new flashcard in Mochi.
 - Parameters:
-  - `front`: string (front side content)
-  - `back`: string (back side content)
-  - `tags`: string[] (optional tags)
-
-### `updateFlashcard`
-Update an existing flashcard.
+  - `content`: string (Markdown content of the card. Separate front and back using a horizontal rule `---`)
+  - `deck-id`: string (ID of the deck to create the card in)
+  - `template-id`: string (optional, template to use for the card)
+  - `manual-tags`: string[] (optional, tags to add to the card)
+  - `fields`: object (map of field IDs to field values, required if using a template)
+
+### `mochi_update_card`
+Update or delete an existing flashcard in Mochi. To delete, set `trashed` to true.
 - Parameters:
-  - `id`: string (flashcard ID)
-  - `front`: string (optional)
-  - `back`: string (optional)
-  - `tags`: string[] (optional)
+  - `card-id`: string (ID of the card to update)
+  - Any updatable card fields (see code for all options)
+  - To delete: set `trashed?` to `'true'` (string)
 
-### `deleteFlashcard`
-Delete a flashcard.
+### `mochi_list_cards`
+List cards (paginated).
 - Parameters:
-  - `id`: string (flashcard ID)
-
-### `getDueFlashcards`
-Get a list of flashcards that are due for review.
-- No parameters required
+  - `deck-id`: string (optional, filter by deck)
+  - `limit`: number (optional, 1-100)
+  - `bookmark`: string (optional, for pagination)
 
-### `reviewFlashcard`
-Submit a review for a flashcard.
+### `mochi_list_decks`
+List all decks.
 - Parameters:
-  - `id`: string (flashcard ID)
-  - `success`: boolean (whether the review was successful)
-  - `timeSpentMs`: number (time spent reviewing in milliseconds)
+  - `bookmark`: string (optional, for pagination)
 
-### `getStats`
-Get study statistics.
-- No parameters required
+### `mochi_list_templates`
+List all templates.
+- Parameters:
+  - `bookmark`: string (optional, for pagination)
 
 ## Example Usage
 
@@ -85,29 +80,34 @@ Here's how to use the MCP server with the MCP Inspector:
 3. Create a new flashcard:
    ```json
    {
-     "tool": "createFlashcard",
+     "tool": "mochi_create_card",
      "params": {
-       "front": "What is MCP?",
-       "back": "Model Context Protocol - a protocol for providing context to LLMs",
-       "tags": ["tech", "protocols"]
+       "content": "What is MCP?\n---\nModel Context Protocol - a protocol for providing context to LLMs",
+       "deck-id": "<YOUR_DECK_ID>"
      }
    }
    ```
 
-4. Get flashcards due for review:
+4. List all decks:
    ```json
    {
-     "tool": "getDueFlashcards"
+     "tool": "mochi_list_decks",
+     "params": {}
    }
    ```
 
+5. Delete a flashcard (set `trashed` to true via update):
+   ```json
+   {
+     "tool": "mochi_update_card",
+     "params": {
+       "card-id": "<CARD_ID>",
+       "trashed?": "true"
+     }
+   }
+   ```
 
-## Setup
-
-### Personal Access Token
-TODO
-
-### Usage with Claude Desktop
+## Usage with Claude Desktop
 To use this with Claude Desktop, add the following to your `claude_desktop_config.json`:
 
 #### Docker

package/dist/common/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "1.0.2";

package/dist/common/version.js

@@ -0,0 +1,3 @@
+// If the format of this file changes, so it doesn't simply export a VERSION constant,
+// this will break .github/workflows/version-check.yml.
+export const VERSION = "1.0.2";

package/dist/index.d.ts

@@ -3,10 +3,7 @@ import { z } from "zod";
 declare const CreateCardRequestSchema: z.ZodObject<{
     content: z.ZodString;
     "deck-id": z.ZodString;
-    "template-id": z.ZodOptional<z.ZodString>;
-    archived: z.ZodOptional<z.ZodBoolean>;
-    "review-reverse": z.ZodOptional<z.ZodBoolean>;
-    pos: z.ZodOptional<z.ZodString>;
+    "template-id": z.ZodDefault<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
     "manual-tags": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
@@ -21,10 +18,7 @@ declare const CreateCardRequestSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     content: string;
     "deck-id": string;
-    "template-id"?: string | undefined;
-    archived?: boolean | undefined;
-    "review-reverse"?: boolean | undefined;
-    pos?: string | undefined;
+    "template-id": string | null;
     "manual-tags"?: string[] | undefined;
     fields?: Record<string, {
         id: string;
@@ -33,16 +27,50 @@ declare const CreateCardRequestSchema: z.ZodObject<{
 }, {
     content: string;
     "deck-id": string;
-    "template-id"?: string | undefined;
-    archived?: boolean | undefined;
-    "review-reverse"?: boolean | undefined;
-    pos?: string | undefined;
+    "template-id"?: string | null | undefined;
     "manual-tags"?: string[] | undefined;
     fields?: Record<string, {
         id: string;
         value: string;
     }> | undefined;
 }>;
+declare const UpdateCardRequestSchema: z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+    "deck-id": z.ZodOptional<z.ZodString>;
+    "template-id": z.ZodOptional<z.ZodString>;
+    "archived?": z.ZodOptional<z.ZodBoolean>;
+    "trashed?": z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        value: string;
+    }, {
+        id: string;
+        value: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    content?: string | undefined;
+    "deck-id"?: string | undefined;
+    "template-id"?: string | undefined;
+    fields?: Record<string, {
+        id: string;
+        value: string;
+    }> | undefined;
+    "archived?"?: boolean | undefined;
+    "trashed?"?: string | undefined;
+}, {
+    content?: string | undefined;
+    "deck-id"?: string | undefined;
+    "template-id"?: string | undefined;
+    fields?: Record<string, {
+        id: string;
+        value: string;
+    }> | undefined;
+    "archived?"?: boolean | undefined;
+    "trashed?"?: string | undefined;
+}>;
 declare const ListDecksParamsSchema: z.ZodObject<{
     bookmark: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -63,54 +91,134 @@ declare const ListCardsParamsSchema: z.ZodObject<{
     bookmark?: string | undefined;
     limit?: number | undefined;
 }>;
-type ListCardsParams = z.infer<typeof ListCardsParamsSchema>;
-type ListDecksParams = z.infer<typeof ListDecksParamsSchema>;
-type CreateCardRequest = z.infer<typeof CreateCardRequestSchema>;
-declare const CreateCardResponseSchema: z.ZodObject<{
-    status: z.ZodString;
-    error_message: z.ZodOptional<z.ZodString>;
+declare const ListTemplatesParamsSchema: z.ZodObject<{
+    bookmark: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    status: string;
-    error_message?: string | undefined;
+    bookmark?: string | undefined;
 }, {
-    status: string;
-    error_message?: string | undefined;
+    bookmark?: string | undefined;
 }>;
-declare const ListDecksResponseSchema: z.ZodObject<{
+declare const ListTemplatesResponseSchema: z.ZodObject<{
     bookmark: z.ZodString;
     docs: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        sort: z.ZodNumber;
         name: z.ZodString;
-        archived: z.ZodOptional<z.ZodBoolean>;
+        content: z.ZodString;
+        pos: z.ZodString;
+        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            pos: z.ZodString;
+            options: z.ZodOptional<z.ZodObject<{
+                "multi-line?": z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                "multi-line?"?: boolean | undefined;
+            }, {
+                "multi-line?"?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }, {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     bookmark: string;
     docs: {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }[];
 }, {
     bookmark: string;
     docs: {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }[];
 }>;
+type ListTemplatesParams = z.infer<typeof ListTemplatesParamsSchema>;
+type ListTemplatesResponse = z.infer<typeof ListTemplatesResponseSchema>;
+type ListCardsParams = z.infer<typeof ListCardsParamsSchema>;
+type ListDecksParams = z.infer<typeof ListDecksParamsSchema>;
+type CreateCardRequest = z.infer<typeof CreateCardRequestSchema>;
+type UpdateCardRequest = z.infer<typeof UpdateCardRequestSchema>;
+declare const CreateCardResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    content: z.ZodString;
+    name: z.ZodString;
+    "deck-id": z.ZodString;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    content: string;
+    "deck-id": string;
+    tags: string[];
+    fields?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    id: string;
+    content: string;
+    "deck-id": string;
+    tags: string[];
+    fields?: Record<string, unknown> | undefined;
+}>;
 declare const ListCardsResponseSchema: z.ZodObject<{
     bookmark: z.ZodString;
     docs: z.ZodArray<z.ZodObject<{
@@ -119,43 +227,21 @@ declare const ListCardsResponseSchema: z.ZodObject<{
         content: z.ZodString;
         name: z.ZodString;
         "deck-id": z.ZodString;
-        fields: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        pos: z.ZodString;
-        references: z.ZodArray<z.ZodUnknown, "many">;
-        reviews: z.ZodArray<z.ZodUnknown, "many">;
-        "created-at": z.ZodObject<{
-            date: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            date: string;
-        }, {
-            date: string;
-        }>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }, {
         name: string;
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     bookmark: string;
@@ -164,14 +250,8 @@ declare const ListCardsResponseSchema: z.ZodObject<{
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }[];
 }, {
     bookmark: string;
@@ -180,25 +260,56 @@ declare const ListCardsResponseSchema: z.ZodObject<{
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }[];
 }>;
 type CreateCardResponse = z.infer<typeof CreateCardResponseSchema>;
-type ListDecksResponse = z.infer<typeof ListDecksResponseSchema>;
+type ListDecksResponse = z.infer<typeof ListDecksResponseSchema>["docs"];
 type ListCardsResponse = z.infer<typeof ListCardsResponseSchema>;
+declare const ListDecksResponseSchema: z.ZodObject<{
+    bookmark: z.ZodString;
+    docs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sort: z.ZodNumber;
+        name: z.ZodString;
+        archived: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }, {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    bookmark: string;
+    docs: {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }[];
+}, {
+    bookmark: string;
+    docs: {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }[];
+}>;
 export declare class MochiClient {
     private api;
     private token;
     constructor(token: string);
     createCard(request: CreateCardRequest): Promise<CreateCardResponse>;
+    updateCard(cardId: string, request: UpdateCardRequest): Promise<CreateCardResponse>;
     listDecks(params?: ListDecksParams): Promise<ListDecksResponse>;
     listCards(params?: ListCardsParams): Promise<ListCardsResponse>;
+    listTemplates(params?: ListTemplatesParams): Promise<ListTemplatesResponse>;
 }
 export {};

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -28,68 +28,143 @@ class MochiError extends Error {
 }
 // Zod schemas for request validation
 const CreateCardFieldSchema = z.object({
-    id: z.string(),
-    value: z.string(),
+    id: z.string().describe("Unique identifier for the field"),
+    value: z.string().describe("Value of the field"),
 });
 const CreateCardRequestSchema = z.object({
-    content: z.string().min(1),
-    "deck-id": z.string().min(1),
-    "template-id": z.string().optional(),
-    archived: z.boolean().optional(),
-    "review-reverse": z.boolean().optional(),
-    pos: z.string().optional(),
-    "manual-tags": z.array(z.string()).optional(),
-    fields: z.record(z.string(), CreateCardFieldSchema).optional(),
+    content: z
+        .string()
+        .min(1)
+        .describe("Markdown content of the card. Separate front and back using a horizontal rule (---)"),
+    "deck-id": z.string().min(1).describe("ID of the deck to create the card in"),
+    "template-id": z
+        .string()
+        .optional()
+        .nullable()
+        .default(null)
+        .describe("Optional template ID to use for the card. Defaults to null if not set."),
+    "manual-tags": z
+        .array(z.string())
+        .optional()
+        .describe("Optional array of tags to add to the card"),
+    fields: z
+        .record(z.string(), CreateCardFieldSchema)
+        .optional()
+        .describe("Map of field IDs to field values. Required only when using a template"),
+});
+const UpdateCardRequestSchema = z.object({
+    content: z
+        .string()
+        .optional()
+        .describe("Updated markdown content of the card"),
+    "deck-id": z
+        .string()
+        .optional()
+        .describe("ID of the deck to move the card to"),
+    "template-id": z
+        .string()
+        .optional()
+        .describe("Template ID to use for the card"),
+    "archived?": z.boolean().optional().describe("Whether the card is archived"),
+    "trashed?": z.string().optional().describe("Whether the card is trashed"),
+    fields: z
+        .record(z.string(), CreateCardFieldSchema)
+        .optional()
+        .describe("Updated map of field IDs to field values"),
 });
 const ListDecksParamsSchema = z.object({
-    bookmark: z.string().optional(),
+    bookmark: z
+        .string()
+        .optional()
+        .describe("Pagination bookmark for fetching next page of results"),
 });
 const ListCardsParamsSchema = z.object({
-    "deck-id": z.string().optional(),
-    limit: z.number().min(1).max(100).optional(),
-    bookmark: z.string().optional(),
+    "deck-id": z.string().optional().describe("Get cards from deck ID"),
+    limit: z
+        .number()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Number of cards to return per page (1-100)"),
+    bookmark: z
+        .string()
+        .optional()
+        .describe("Pagination bookmark for fetching next page of results"),
 });
-// Response Zod schemas
-const CreateCardResponseSchema = z
+const ListTemplatesParamsSchema = z.object({
+    bookmark: z
+        .string()
+        .optional()
+        .describe("Pagination bookmark for fetching next page of results"),
+});
+const TemplateFieldSchema = z.object({
+    id: z.string().describe("Unique identifier for the template field"),
+    name: z.string().describe("Display name of the field"),
+    pos: z.string().describe("Position of the field in the template"),
+    options: z
+        .object({
+        "multi-line?": z
+            .boolean()
+            .optional()
+            .describe("Whether the field supports multiple lines of text"),
+    })
+        .optional()
+        .describe("Additional options for the field"),
+});
+const TemplateSchema = z
     .object({
-    status: z.string(),
-    error_message: z.string().optional(),
+    id: z.string().describe("Unique identifier for the template"),
+    name: z.string().describe("Display name of the template"),
+    content: z.string().describe("Template content in markdown format"),
+    pos: z.string().describe("Position of the template in the list"),
+    fields: z
+        .record(z.string(), TemplateFieldSchema)
+        .describe("Map of field IDs to field definitions"),
 })
     .strip();
-const DeckSchema = z
+const ListTemplatesResponseSchema = z
     .object({
-    id: z.string(),
-    sort: z.number(),
-    name: z.string(),
-    archived: z.boolean().optional(),
+    bookmark: z.string().describe("Pagination bookmark for fetching next page"),
+    docs: z.array(TemplateSchema).describe("Array of templates"),
 })
     .strip();
-const ListDecksResponseSchema = z
+// Response Zod schemas
+const CardSchema = z
     .object({
-    bookmark: z.string(),
-    docs: z.array(DeckSchema),
+    id: z.string().describe("Unique identifier for the card"),
+    tags: z
+        .array(z.string())
+        .describe("Array of tags associated with the card"),
+    content: z
+        .string()
+        .describe('Markdown content of the card. Separate front and back of card with "---"'),
+    name: z.string().describe("Display name of the card"),
+    "deck-id": z.string().describe("ID of the deck containing the card"),
+    fields: z
+        .record(z.unknown())
+        .optional()
+        .describe("Map of field IDs to field values. Need to match the field IDs in the template"),
 })
     .strip();
-const CardSchema = z
+const CreateCardResponseSchema = CardSchema.strip();
+const ListCardsResponseSchema = z
     .object({
-    id: z.string(),
-    tags: z.array(z.string()),
-    content: z.string(),
-    name: z.string(),
-    "deck-id": z.string(),
-    fields: z.record(z.unknown()),
-    pos: z.string(),
-    references: z.array(z.unknown()),
-    reviews: z.array(z.unknown()),
-    "created-at": z.object({
-        date: z.string(),
-    }),
+    bookmark: z.string().describe("Pagination bookmark for fetching next page"),
+    docs: z.array(CardSchema).describe("Array of cards"),
 })
     .strip();
-const ListCardsResponseSchema = z
+const DeckSchema = z
     .object({
-    bookmark: z.string(),
-    docs: z.array(CardSchema),
+    id: z.string().describe("Unique identifier for the deck"),
+    sort: z.number().describe("Sort order of the deck"),
+    name: z.string().describe("Display name of the deck"),
+    archived: z.boolean().optional().describe("Whether the deck is archived"),
+})
+    .strip();
+const ListDecksResponseSchema = z
+    .object({
+    bookmark: z.string().describe("Pagination bookmark for fetching next page"),
+    docs: z.array(DeckSchema).describe("Array of decks"),
 })
     .strip();
 function getApiKey() {
@@ -118,12 +193,16 @@ export class MochiClient {
         const response = await this.api.post("/cards", request);
         return CreateCardResponseSchema.parse(response.data);
     }
+    async updateCard(cardId, request) {
+        const response = await this.api.post(`/cards/${cardId}`, request);
+        return CreateCardResponseSchema.parse(response.data);
+    }
     async listDecks(params) {
         const validatedParams = params
             ? ListDecksParamsSchema.parse(params)
             : undefined;
         const response = await this.api.get("/decks", { params: validatedParams });
-        return ListDecksResponseSchema.parse(response.data);
+        return ListDecksResponseSchema.parse(response.data).docs.filter((deck) => !deck.archived);
     }
     async listCards(params) {
         const validatedParams = params
@@ -132,15 +211,25 @@ export class MochiClient {
         const response = await this.api.get("/cards", { params: validatedParams });
         return ListCardsResponseSchema.parse(response.data);
     }
+    async listTemplates(params) {
+        const validatedParams = params
+            ? ListTemplatesParamsSchema.parse(params)
+            : undefined;
+        const response = await this.api.get("/templates", {
+            params: validatedParams,
+        });
+        return ListTemplatesResponseSchema.parse(response.data);
+    }
 }
 // Server setup
 const server = new Server({
     name: "mcp-server/mochi",
-    version: "0.1.0",
+    version: "1.0.3",
 }, {
     capabilities: {
         tools: {},
         resources: {},
+        prompts: {},
     },
 });
 // Set up request handlers
@@ -148,58 +237,243 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
             name: "mochi_create_card",
-            description: "Create a new flashcard",
+            description: `Create a new flashcard in Mochi. Use this whenever I ask questions about something that is interesting to remember. E.g. if I ask "What is the capital of France?", you should create a new flashcard with the content "What is the capital of France?\n---\nParis".
+
+## Parameters
+
+### deck-id (required)
+ALWAYS look up deck-id with the mochi_list_decks tool.
+
+### content (required)
+The markdown content of the card. Separate front and back using a horizontal rule (---).
+
+### template-id (optional)
+When using a template, the field ids MUST match the template ones. If not using a template, omit this field.
+
+### fields (optional)
+A map of field IDs (keyword) to field values. Only required when using a template. The field IDs must correspond to the fields defined on the template.
+
+## Example without template
+{
+  "content": "What is the capital of France?\n---\nParis",
+  "deck-id": "btmZUXWM"
+}
+
+## Example with template
+{
+  "content": "New card from API. ![](@media/foobar03.png)",
+  "deck-id": "btmZUXWM",
+  "template-id": "8BtaEAXe",
+  "fields": {
+    "name": {
+      "id": "name",
+      "value": "Hello,"
+    },
+    "JNEnw1e7": {
+      "id": "JNEnw1e7",
+      "value": "World!"
+    }
+  }
+}
+
+## Properties of good flashcards:
+- **focused:** A question or answer involving too much detail will dull your concentration and stimulate incomplete retrievals, leaving some bulbs unlit.
+- **precise** about what they're asking for. Vague questions will elicit vague answers, which won't reliably light the bulbs you're targeting.
+- **consistent** answers, lighting the same bulbs each time you perform the task.
+- **tractable**: Write prompts which you can almost always answer correctly. This often means breaking the task down, or adding cues
+- **effortful**: You shouldn't be able to trivially infer the answer.
+`,
             inputSchema: zodToJsonSchema(CreateCardRequestSchema),
+            annotations: {
+                title: "Create flashcard on Mochi",
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+        },
+        {
+            name: "mochi_update_card",
+            description: `Update or delete an existing flashcard in Mochi. To delete set trashed to true.`,
+            inputSchema: zodToJsonSchema(z.object({
+                "card-id": z.string(),
+                ...UpdateCardRequestSchema.shape,
+            })),
+            annotations: {
+                title: "Update flashcard on Mochi",
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
         },
         {
             name: "mochi_list_cards",
             description: "List cards in pages of 10 cards per page",
             inputSchema: zodToJsonSchema(ListCardsParamsSchema),
+            annotations: {
+                title: "List flashcards on Mochi",
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
         },
         {
             name: "mochi_list_decks",
             description: "List all decks",
             inputSchema: zodToJsonSchema(ListDecksParamsSchema),
+            annotations: {
+                title: "List decks on Mochi",
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+        },
+        {
+            name: "mochi_list_templates",
+            description: `Templates can be used to create cards with pre-defined fields using the template_id field. 
+
+Example response:
+{
+  "bookmark": "g1AAAABAeJzLYWBgYMpgSmHgKy5JLCrJTq2MT8lPzkzJBYpzVBn4JgaaVZiC5Dlg8igyWQAxwRHd",
+  "docs": [
+    {
+      "id": "YDELNZSu",
+      "name": "Simple flashcard",
+      "content": "# << Front >>\n---\n<< Back >>",
+      "pos": "s",
+      "fields": {
+        "name": {
+          "id": "name",
+          "name": "Front",
+          "pos": "a"
+        },
+        "Ysrde7Lj": {
+          "id": "Ysrde7Lj",
+          "name": "Back",
+          "pos": "m",
+          "options": {
+            "multi-line?": true
+          }
+        }
+      }
+    },
+    ...
+  ]
+}`,
+            inputSchema: zodToJsonSchema(ListTemplatesParamsSchema),
+            annotations: {
+                title: "List templates on Mochi",
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
         },
     ],
 }));
+// Create Mochi client
+const mochiClient = new MochiClient(MOCHI_API_KEY);
 // Add resource handlers
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    const decks = await mochiClient.listDecks();
     return {
-        resources: decks.docs.map((deck) => ({
-            uri: `mochi://decks/${deck.id}`,
-            name: deck.name + ` (Deck ID: ${deck.id})`,
-            description: `Deck ID: ${deck.id}`,
-            mimeType: "application/json",
-        })),
+        resources: [
+            {
+                uri: `mochi://decks`,
+                name: "All Mochi Decks",
+                description: `List of all decks in Mochi.`,
+                mimeType: "application/json",
+            },
+            {
+                uri: `mochi://templates`,
+                name: "All Mochi Templates",
+                description: `List of all templates in Mochi.`,
+                mimeType: "application/json",
+            },
+        ],
     };
 });
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const uri = request.params.uri;
-    const match = uri.match(/^mochi:\/\/decks\/(.+)$/);
-    if (!match) {
-        throw new Error("Invalid resource URI");
+    switch (uri) {
+        case "mochi://decks": {
+            const decks = await mochiClient.listDecks();
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(decks.map((deck) => ({
+                            id: deck.id,
+                            name: deck.name,
+                            archived: deck.archived,
+                        })), null, 2),
+                    },
+                ],
+            };
+        }
+        case "mochi://templates": {
+            const templates = await mochiClient.listTemplates();
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(templates, null, 2),
+                    },
+                ],
+            };
+        }
+        default: {
+            throw new Error("Invalid resource URI");
+        }
     }
-    const deckId = match[1];
-    const deck = await mochiClient.listCards({ "deck-id": deckId });
+});
+const CreateFlashcardPromptSchema = z.object({
+    input: z
+        .string()
+        .describe("The information to base the flashcard on.")
+        .optional(),
+});
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
     return {
-        contents: [
+        prompts: [
             {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(deck.docs.map((card) => ({
-                    id: card.id,
-                    name: card.name,
-                    content: card.content,
-                    fields: card.fields,
-                })), null, 2),
+                name: "write-flashcard",
+                description: "Write a flashcard based on user-provided information.",
+                arguments: [
+                    {
+                        name: "input",
+                        description: "The information to base the flashcard on.",
+                    },
+                ],
+            },
+        ],
+    };
+});
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const params = CreateFlashcardPromptSchema.parse(request.params.arguments);
+    const { input } = params;
+    return {
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Create a flashcard using the info below while adhering to these principles: 
+- Keep questions and answers atomic.
+- Utilize cloze prompts when applicable, like "This is a text with {{hidden}} part. Then don't use '---' separator.".
+- Focus on effective retrieval practice by being concise and clear.
+- Make it just challenging enough to reinforce specific facts.
+Input: ${input}
+`,
+                },
             },
         ],
     };
 });
-// Create Mochi client
-const mochiClient = new MochiClient(MOCHI_API_KEY);
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
@@ -216,6 +490,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     isError: false,
                 };
             }
+            case "mochi_update_card": {
+                const { "card-id": cardId, ...updateArgs } = z
+                    .object({
+                    "card-id": z.string(),
+                    ...UpdateCardRequestSchema.shape,
+                })
+                    .parse(request.params.arguments);
+                const response = await mochiClient.updateCard(cardId, updateArgs);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response, null, 2),
+                        },
+                    ],
+                    isError: false,
+                };
+            }
             case "mochi_list_decks": {
                 const validatedArgs = ListDecksParamsSchema.parse(request.params.arguments);
                 const response = await mochiClient.listDecks(validatedArgs);
@@ -242,6 +534,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     isError: false,
                 };
             }
+            case "mochi_list_templates": {
+                const validatedArgs = ListTemplatesParamsSchema.parse(request.params.arguments);
+                const response = await mochiClient.listTemplates(validatedArgs);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response, null, 2),
+                        },
+                    ],
+                    isError: false,
+                };
+            }
             default:
                 return {
                     content: [
@@ -256,13 +561,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     catch (error) {
         if (error instanceof z.ZodError) {
+            const formattedErrors = error.errors.map((err) => {
+                const path = err.path.join(".");
+                const message = err.code === "invalid_type" && err.message.includes("Required")
+                    ? `Required field '${path}' is missing`
+                    : err.message;
+                return `${path ? `${path}: ` : ""}${message}`;
+            });
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Validation error: ${error.errors
-                            .map((e) => e.message)
-                            .join(", ")}`,
+                        text: `Validation error:\n${formattedErrors.join("\n")}`,
                     },
                 ],
                 isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fredrika/mcp-mochi",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "MCP server for Mochi flashcard integration",
   "main": "dist/index.js",
   "type": "module",

package/dist/mochi-client.d.ts

@@ -1,74 +0,0 @@
-export interface Flashcard {
-    id: string;
-    name: string;
-    content: string;
-    tags: string[];
-    'deck-id': string;
-    fields: Record<string, unknown>;
-    pos: string;
-    references: unknown[];
-    reviews: unknown[];
-    'created-at': {
-        date: string;
-    };
-}
-export interface FlashcardInput {
-    front: string;
-    back: string;
-    tags?: string[];
-}
-export interface ReviewResult {
-    success: boolean;
-    timeSpentMs: number;
-}
-export interface ListFlashcardsParams {
-    'deck-id'?: string;
-    limit?: number;
-    bookmark?: string;
-}
-export interface ListFlashcardsResponse {
-    bookmark: string;
-    docs: Flashcard[];
-}
-export interface TemplateField {
-    id: string;
-    name: string;
-    pos: string;
-    options?: {
-        'multi-line?'?: boolean;
-    };
-}
-export interface Template {
-    id: string;
-    name: string;
-    content: string;
-    pos: string;
-    fields: Record<string, TemplateField>;
-}
-export interface ListTemplatesResponse {
-    bookmark: string;
-    docs: Template[];
-}
-export interface ListTemplatesParams {
-    bookmark?: string;
-}
-export declare class MochiClient {
-    private api;
-    private token;
-    constructor(token: string);
-    getFlashcards(params?: ListFlashcardsParams): Promise<ListFlashcardsResponse>;
-    getFlashcard(id: string): Promise<Flashcard>;
-    createFlashcard(input: FlashcardInput): Promise<Flashcard>;
-    updateFlashcard(id: string, input: Partial<FlashcardInput>): Promise<Flashcard>;
-    deleteFlashcard(id: string): Promise<void>;
-    getDueFlashcards(): Promise<Flashcard[]>;
-    reviewFlashcard(id: string, result: ReviewResult): Promise<Flashcard>;
-    getStats(): Promise<{
-        totalCards: number;
-        dueCards: number;
-        averageSuccessRate: number;
-        cardsReviewedToday: number;
-    }>;
-    getTemplate(id: string): Promise<Template>;
-    listTemplates(params?: ListTemplatesParams): Promise<ListTemplatesResponse>;
-}

package/dist/mochi-client.js

@@ -1,67 +0,0 @@
-import axios from 'axios';
-export class MochiClient {
-    api;
-    token;
-    constructor(token) {
-        this.token = '228b69396efc60896d3033e3';
-        this.api = axios.create({
-            baseURL: 'https://app.mochi.cards/api/',
-            headers: {
-                'Authorization': `Basic ${Buffer.from(`${this.token}:`).toString('base64')}`,
-                'Content-Type': 'application/json'
-            }
-        });
-    }
-    async getFlashcards(params) {
-        try {
-            const response = await this.api.get('/cards', { params });
-            console.log(response.data);
-            return response.data;
-        }
-        catch (error) {
-            console.error('Error fetching flashcards:', error);
-            throw error;
-        }
-    }
-    async getFlashcard(id) {
-        const response = await this.api.get(`/cards/${id}`);
-        return response.data;
-    }
-    async createFlashcard(input) {
-        const response = await this.api.post('/cards', input);
-        return response.data;
-    }
-    async updateFlashcard(id, input) {
-        const response = await this.api.patch(`/cards/${id}`, input);
-        return response.data;
-    }
-    async deleteFlashcard(id) {
-        await this.api.delete(`/cards/${id}`);
-    }
-    async getDueFlashcards() {
-        const response = await this.api.get('/cards');
-        return response.data;
-    }
-    async reviewFlashcard(id, result) {
-        const response = await this.api.post(`/cards/${id}/review`, result);
-        return response.data;
-    }
-    async getStats() {
-        const response = await this.api.get('/v1/stats');
-        return response.data;
-    }
-    async getTemplate(id) {
-        const response = await this.api.get(`/templates/${id}`);
-        return response.data;
-    }
-    async listTemplates(params) {
-        try {
-            const response = await this.api.get('/templates', { params });
-            return response.data;
-        }
-        catch (error) {
-            console.error('Error fetching templates:', error);
-            throw error;
-        }
-    }
-}

package/dist/test-mochi-api.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test-mochi-api.js

@@ -1,69 +0,0 @@
-import axios from 'axios';
-import { MochiClient } from './mochi-client.js';
-import { config } from 'dotenv';
-// Load environment variables
-config();
-const MOCHI_TOKEN = process.env.MOCHI_TOKEN;
-if (!MOCHI_TOKEN) {
-    throw new Error("MOCHI_TOKEN environment variable is required");
-}
-// After the check above, TypeScript knows MOCHI_TOKEN is defined
-const token = MOCHI_TOKEN;
-async function testMochiApi() {
-    console.log("Testing Mochi API connection...");
-    console.log("Using token:", token.slice(0, 5) + "..." + token.slice(-5));
-    const client = new MochiClient(token);
-    try {
-        // Test getting stats (simplest operation)
-        console.log("\nTesting getStats...");
-        const stats = await client.getStats();
-        console.log("Stats response:", stats);
-        // Test getting flashcards
-        console.log("\nTesting getFlashcards...");
-        const cards = await client.getFlashcards();
-        console.log("Flashcards response:", cards);
-        // Test creating a flashcard
-        console.log("\nTesting createFlashcard...");
-        const newCard = await client.createFlashcard({
-            front: "Test Front",
-            back: "Test Back",
-            tags: ["test"]
-        });
-        console.log("Created card:", newCard);
-        // Test getting a specific flashcard
-        console.log("\nTesting getFlashcard...");
-        const card = await client.getFlashcard(newCard.id);
-        console.log("Retrieved card:", card);
-        // Test updating the flashcard
-        console.log("\nTesting updateFlashcard...");
-        const updatedCard = await client.updateFlashcard(newCard.id, {
-            front: "Updated Front"
-        });
-        console.log("Updated card:", updatedCard);
-        // Test deleting the flashcard
-        console.log("\nTesting deleteFlashcard...");
-        await client.deleteFlashcard(newCard.id);
-        console.log("Card deleted successfully");
-    }
-    catch (error) {
-        console.error("Error testing Mochi API:", error);
-        if (axios.isAxiosError(error)) {
-            const axiosError = error;
-            if (axiosError.response) {
-                console.error("Response status:", axiosError.response.status);
-                console.error("Response data:", axiosError.response.data);
-                console.error("Response headers:", axiosError.response.headers);
-                console.error("Request URL:", axiosError.config?.url);
-                console.error("Request method:", axiosError.config?.method);
-            }
-            else if (axiosError.request) {
-                console.error("No response received. Request details:", axiosError.request);
-            }
-            else {
-                console.error("Error setting up request:", axiosError.message);
-            }
-        }
-    }
-}
-// Run the test
-testMochiApi().catch(console.error);