For ChatGPT, Claude, and MCP-compatible AI clients

Manage Memly cardsfrom your AI chatManage Memly cards from your AI chat

Connect Memly MCP and ask your AI client to save, edit, search, or delete cards for you. Free users can look up decks and cards. Plus and Pro users can create, update, delete, and restore content in Memly.

Remote MCP

Endpoint

https://app.memly.ai/mcp

URL to enter

Use https://app.memly.ai/mcp as the Remote MCP server URL in your AI client.

Free reads, paid writes

Free users can search and view Memly content. Creating, editing, deleting, or restoring decks and cards requires Memly Plus or Pro.

Only your account

The connector can only access the Memly account you authorize. It cannot read or change another user's decks or cards.

Setup

Setup steps in your AI client

Choose the AI client you use and only that setup path stays visible. You do not need to configure both Claude and ChatGPT.

Before setup

Prepare Memly

Memly MCP uses per-user OAuth. It does not use a shared API key or a fixed Memly account.

Sign in to Memly with an active Plus or Pro account.
If you want to save into an existing deck, confirm the deck name in Memly first.
Use https://app.memly.ai/mcp as the remote MCP server URL.

Selected

Add Memly to Claude

For Claude custom connectors, enter only the connector name and the remote MCP server URL.

1Open Claude settings or Customize, then open Connectors.
2Choose Add custom connector and enter Memly as the name.
3Enter https://app.memly.ai/mcp in Remote MCP server URL.
4Leave OAuth Client ID and OAuth Client Secret blank.
5On the Memly consent screen, confirm the Memly account shown and approve the connection.

The connection is ready when Claude shows list_decks and import_flashcards.

If it fails: If authorization fails

Old connector registrations can keep stale OAuth settings even after the server is fixed.

1Delete the Memly connector and add it again with the same URL.
2Prefer https://app.memly.ai/mcp without a trailing slash.
3On the consent screen, confirm that the scopes are email and profile only.
4After approval, confirm that Claude or your AI client shows a connected state or the tool list.

If Authorization with the MCP server failed still appears, record the ofid reference and the time of the attempt.

Flow

How you use it

Use it like a normal conversation. Memly still checks authentication, plan access, ownership, and content safety before changing anything.

01
1. Connect Memly
Add Memly's Remote MCP URL in ChatGPT, Claude, or another MCP-compatible AI client.
02
2. Approve your account
Confirm the Memly account shown on the consent screen and approve the connection.
03
3. Ask in plain language
Say things like, 'turn this into five flashcards' or 'add this to my Edo period deck.'
04
4. Memly applies the change
The AI client calls the Memly tool, and Memly saves, updates, deletes, or restores content after server-side checks.

MCP

What Memly MCP can do

The latest implementation covers more than importing new cards. It can help with day-to-day deck and card maintenance too.

Find and view decks

The AI client can list your Memly decks and resolve a deck by name before saving cards.

Search and view cards

It can search cards by text, show card details, and help you inspect what's already in a deck.

Add and edit cards

Plus and Pro users can import new cards, edit existing cards, update tags, and move cards between owned decks.

Delete and restore

Plus and Pro users can delete cards or decks. Restore tools are available for deleted cards and decks when needed.

Safety

Safety and limits

Even when an AI client sends the request, Memly treats it as untrusted input and checks who is acting, what they can change, and whether the content is safe.

Auth and authorization

Memly checks the OAuth 2.1 bearer token, Plus/Pro subscription, and deck ownership.

Input checks

Memly checks required fields, text length, card count, tag count, and basic card shape before saving.

HTML sanitization

Rich HTML keeps only allowed tags. Script, iframe, style, and event attributes are not stored.

Consent before writing

Creating cards is a write operation, so the guide tells AI clients to show the action and ask for user confirmation before invoking the tool.

How to ask

Ways to ask your AI client

You can ask in normal language. If you want to review before saving, say so in the same message.

Create new cards

"Turn this explanation into five flashcards and add them to my Edo period deck."

Edit an existing card

"Find the Tokugawa Ienari card and make the answer shorter."

Remove test content

"Delete the Test deck and delete the cards inside it too."

Rules for good Memly cards

Ask about one concept, definition, decision rule, process step, or comparison per card.
Make answers self-contained enough to understand without reopening the source.
Cover reasons, distinctions, examples, and common mistakes, not only terms.
Avoid duplicates that merely rephrase the same fact.
Preserve exact terms and proper nouns; write explanations in the requested language.

Common errors

401 Unauthorized

Authentication required

403 Subscription required

Plus/Pro only

An active Plus or Pro subscription is required.

400 Invalid cards

Payload issue

Fix empty cards, missing fields, length overages, or disallowed HTML.

404 Deck not found

Deck mismatch

The deckId does not exist or does not belong to the authenticated user.

JSON-RPC protocol error

Connection/auth issue

Use this when the MCP request itself cannot be processed, such as missing auth, insufficient scope, or invalid session state.

Tool result isError: true

Tool execution issue

Use this when the tool call arrived but the import failed, such as invalid cards or a deck ownership mismatch.

Developer details

Technical details for AI clients

Most users do not need this section. It exists so MCP clients and developers can inspect the exact shape used when new cards are added to Memly.

{}MCP tool schema

Adding cards

New cards are added through import_flashcards.

Destination

The AI client can target an existing deck or create/reuse a deck by title.

Result

Memly returns the destination deck, imported count, skipped count, and non-fatal warnings.

Safety

Memly checks authentication, Plus/Pro access, ownership, and HTML sanitization server-side every time.

Open full JSON Schema

{
  "name": "import_flashcards",
  "description": "Import flashcards generated by the AI client into a Memly deck. Use this only after the user asks to save cards to Memly.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "deckId": {
        "type": "integer",
        "description": "Existing Memly deck ID owned by the authenticated user."
      },
      "deckTitle": {
        "type": "string",
        "minLength": 1,
        "maxLength": 120,
        "description": "Deck title to create or reuse when deckId is not provided."
      },
      "sourceTitle": {
        "type": "string",
        "maxLength": 160,
        "description": "Optional source title, document name, URL title, or conversation topic."
      },
      "language": {
        "type": "string",
        "enum": ["ja", "en", "ko"],
        "description": "Main language used for the card explanations."
      },
      "cards": {
        "type": "array",
        "minItems": 1,
        "maxItems": 100,
        "items": {
          "type": "object",
          "additionalProperties": false,
          "required": ["front", "back"],
          "properties": {
            "front": {
              "type": "string",
              "minLength": 1,
              "maxLength": 1000,
              "description": "Question or prompt side of the flashcard. Ask one clear recall target; do not send FSRS, user_id, due, stability, or difficulty fields."
            },
            "back": {
              "type": "string",
              "minLength": 1,
              "maxLength": 4000,
              "description": "Answer or explanation side of the flashcard. Keep it compact but self-contained."
            },
            "frontRich": {
              "type": "string",
              "maxLength": 4000,
              "description": "Optional sanitized HTML. Allowed tags: p, strong, em, mark, ul, ol, li, blockquote, h4, h5, br, code."
            },
            "backRich": {
              "type": "string",
              "maxLength": 8000,
              "description": "Optional sanitized HTML using the same allowed tag set."
            },
            "tags": {
              "type": "array",
              "description": "Short organization labels created by the AI client. Do not include private account identifiers.",
              "maxItems": 12,
              "items": {
                "type": "string",
                "minLength": 1,
                "maxLength": 40
              }
            }
          }
        }
      }
    },
    "required": ["cards"],
    "oneOf": [
      { "required": ["deckId"] },
      { "required": ["deckTitle"] }
    ]
  },
  "outputSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "deckId": {
        "type": "integer",
        "description": "Memly deck ID used for the import."
      },
      "deckTitle": {
        "type": "string",
        "description": "Memly deck title used for the import."
      },
      "importedCount": {
        "type": "integer",
        "minimum": 0,
        "description": "Number of cards created."
      },
      "skippedCount": {
        "type": "integer",
        "minimum": 0,
        "description": "Number of cards skipped as duplicates or invalid after validation."
      },
      "warnings": {
        "type": "array",
        "description": "Non-fatal import notes, such as sanitized HTML or duplicate tags.",
        "items": {
          "type": "string"
        }
      }
    },
    "required": ["deckId", "deckTitle", "importedCount"]
  },
  "annotations": {
    "readOnlyHint": false,
    "destructiveHint": false,
    "openWorldHint": false
  }
}

{}Field reference

deckIddeckId or deckTitle

Existing Memly deck ID owned by the authenticated user.

deckTitledeckId or deckTitle

Deck name to create or reuse when deckId is absent. Up to 120 characters.

sourceTitleOptional

Source document name, URL title, or conversation topic for later traceability.

languageOptional

Main explanation language. Use ja, en, or ko.

cards[].frontRequired

Plain-text prompt side. Ask for one clear recall target.

cards[].backRequired

Plain-text answer side. Keep it compact but self-contained.

cards[].frontRich / backRichOptional

HTML version. Use only allowed tags; Memly sanitizes it server-side.

cards[].tagsOptional

Short tags for search and organization. Maximum 12 is recommended.

structuredContent.deckId / deckTitleOn success

Returned so the AI client can identify which Memly deck received the import.

structuredContent.importedCount / skippedCountOn success

Returned so the conversation can explain how many cards were created and how many were skipped.

structuredContent.warningsOptional

Non-fatal notes such as sanitized HTML or duplicate cards skipped during import.

References

Specification references

Implementers should also check these primary references because MCP and client support can evolve.

MCP Tools specification MCP Authorization specification MCP Streamable HTTP transport ChatGPT Developer mode ChatGPT Developer mode and MCP connectors OpenAI Apps SDK authentication Claude custom connectors with remote MCP Supabase MCP authentication

Prepare the Memly MCP connection

Connect Memly to your AI client. Free users can look things up, and Plus/Pro users can organize decks and cards directly from chat.