@payloadcms/plugin-mcp 4.0.0-internal.e387174 → 4.0.0-internal.e38d3ac

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/plugin-mcp",
-  "version": "4.0.0-internal.e387174",
+  "version": "4.0.0-internal.e38d3ac",
   "description": "MCP (Model Context Protocol) capabilities with Payload",
   "keywords": [
     "plugin",
@@ -55,16 +55,16 @@
     "bin.js"
   ],
   "dependencies": {
-    "@modelcontextprotocol/server": "2.0.0-beta.3",
+    "@modelcontextprotocol/server": "2.0.0",
     "tsx": "4.22.4",
     "zod": "^4.2.0"
   },
   "devDependencies": {
     "@payloadcms/eslint-config": "3.28.0",
-    "payload": "4.0.0-internal.e387174"
+    "payload": "4.0.0-internal.e38d3ac"
   },
   "peerDependencies": {
-    "payload": "4.0.0-internal.e387174"
+    "payload": "4.0.0-internal.e38d3ac"
   },
   "//deps_notes": {
     "zod": "zod is a hard dependency of @modelcontextprotocol/server, thus we can safely use it without it impacting bundle size. Make extra sure the zod version here matches exactly what's defined in the dependencies of @modelcontextprotocol/server to avoid duplicate versions being installed.",

package/src/mcp/builtin/collections/createTool.ts

@@ -11,12 +11,13 @@ import {
 } from '../../../utils/getVirtualFieldNames.js'
 import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
 import { validateCollectionData } from '../validateEntityData.js'
+import { fileInputSchema, resolveFile } from './fileInput.js'
 import { formatCollectionError } from './formatCollectionError.js'
 
 const DEFAULT_DESCRIPTION =
-  'Create a document in any collection by passing the collection slug and data.'
+  'Create one or more documents. Each can have different data or a file. Prefer uploadReference after upload, externalURL for URLs, or base64 for small local files.'
 
-export const createDocumentTool = defineCollectionTool({
+export const createDocumentsTool = defineCollectionTool({
   access: (args) =>
     defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.create),
   annotations: {
@@ -24,15 +25,10 @@ export const createDocumentTool = defineCollectionTool({
     idempotentHint: false,
     openWorldHint: false,
     readOnlyHint: false,
-    title: 'Create Document',
+    title: 'Create Documents',
   },
   description: DEFAULT_DESCRIPTION,
   input: z.object({
-    data: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'The document fields to create. Only include fields permitted by the schema returned by getCollectionSchema.',
-      ),
     depth: z
       .number()
       .int()
@@ -41,6 +37,19 @@ export const createDocumentTool = defineCollectionTool({
       .describe('How many levels deep to populate relationships in response')
       .optional()
       .default(0),
+    documents: z
+      .array(
+        z.object({
+          data: z
+            .record(z.string(), z.unknown())
+            .describe(
+              'The document fields to create. Only include fields permitted by the schema returned by getCollectionSchema.',
+            ),
+          file: fileInputSchema.optional(),
+        }),
+      )
+      .min(1)
+      .describe('The documents to create, in order'),
     draft: z
       .boolean()
       .describe(
@@ -55,7 +64,7 @@ export const createDocumentTool = defineCollectionTool({
     locale: z
       .string()
       .describe(
-        'Optional: locale code to create the document in (e.g., "en", "es"). Defaults to the default locale',
+        'Optional: locale code to create the documents in (e.g., "en", "es"). Defaults to the default locale',
       )
       .optional(),
     select: z
@@ -68,50 +77,92 @@ export const createDocumentTool = defineCollectionTool({
 }).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
+  const { depth, documents, draft, fallbackLocale, locale, select } = input
 
-  const { data, depth, draft, fallbackLocale, locale, select } = input
-
-  logger.info(
-    `Creating document in collection: ${collectionSlug}${locale ? ` with locale: ${locale}` : ''}`,
-  )
+  logger.info(`Creating ${documents.length} documents in collection: ${collectionSlug}`)
 
   try {
     const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
-    const inputData = stripVirtualFields(data, virtualFieldNames)
-    const validationError = validateCollectionData({ collectionSlug, data: inputData, req })
+    const docs: Array<{ doc: Record<string, unknown>; index: number }> = []
+    const errors: Array<{ index: number; message: string }> = []
+    let validationSchema: Record<string, unknown> | undefined
 
-    if (validationError) {
-      return validationError
-    }
+    for (const [index, document] of documents.entries()) {
+      try {
+        const inputData = stripVirtualFields(document.data, virtualFieldNames)
+        const validationError = validateCollectionData({ collectionSlug, data: inputData, req })
+
+        if (validationError) {
+          const firstContent = validationError.content[0]
+          const validationContent = validationError.structuredContent as
+            | Record<string, unknown>
+            | undefined
+          const schema = validationContent?.schema
 
-    const parsedData = transformPointDataToPayload(inputData)
+          if (!validationSchema && schema && typeof schema === 'object') {
+            validationSchema = schema as Record<string, unknown>
+          }
 
-    const result = await payload.create({
-      collection: collectionSlug,
-      data: parsedData,
-      depth,
-      draft,
-      overrideAccess: authorizedMCP.overrideAccess,
-      req,
-      ...(locale ? { locale } : {}),
-      ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-    })
+          errors.push({
+            index,
+            message:
+              firstContent?.type === 'text'
+                ? (firstContent.text.split('\n\nUse this schema')[0] ?? 'Invalid document data')
+                : 'Invalid document data',
+          })
+          continue
+        }
 
-    logger.info(`Successfully created document in ${collectionSlug} with ID: ${result.id}`)
+        const parsedData = transformPointDataToPayload(inputData)
+        const file = await resolveFile({ collectionSlug, input: document.file, req })
+        const result = await payload.create({
+          collection: collectionSlug,
+          data: parsedData,
+          depth,
+          draft,
+          overrideAccess: authorizedMCP.overrideAccess,
+          req,
+          ...(file ? { file } : {}),
+          ...(locale ? { locale } : {}),
+          ...(fallbackLocale ? { fallbackLocale } : {}),
+          ...(select ? { select: select as SelectType } : {}),
+        })
+
+        docs.push({ doc: result as Record<string, unknown>, index })
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error'
+
+        logger.error(`Error creating document at index ${index} in ${collectionSlug}: ${message}`)
+        errors.push({ index, message })
+      }
+    }
+
+    const batchResult = { docs, errors }
+    const retryMessage = errors.length > 0 ? '\nRetry failed indexes only.' : ''
+    const schemaMessage = validationSchema
+      ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(validationSchema)}\n\`\`\``
+      : ''
+    const structuredContent = validationSchema
+      ? { ...batchResult, schema: validationSchema }
+      : batchResult
+
+    logger.info(`Created ${docs.length} of ${documents.length} documents in ${collectionSlug}`)
 
     return {
       content: [
         {
           type: 'text',
-          text: `Document created successfully in collection "${collectionSlug}"!\nCreated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Created ${docs.length} of ${documents.length} documents in collection "${collectionSlug}".${retryMessage}\nResults:\n\`\`\`json\n${JSON.stringify(batchResult)}\n\`\`\`${schemaMessage}`,
         },
       ],
-      doc: result as Record<string, unknown>,
+      doc: structuredContent as unknown as Record<string, unknown>,
+      isError: docs.length === 0 && errors.length > 0,
+      structuredContent,
     }
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error creating document in ${collectionSlug}: ${errorMessage}`)
+    const message = error instanceof Error ? error.message : 'Unknown error'
+
+    logger.error(`Error creating documents in ${collectionSlug}: ${message}`)
     return formatCollectionError({ action: 'creating', collectionSlug, error, req })
   }
 })

package/src/mcp/builtin/collections/fileInput.spec.ts

@@ -0,0 +1,93 @@
+import type { PayloadRequest } from 'payload'
+
+import { describe, expect, it } from 'vitest'
+
+import { fileInputSchema, resolveFile } from './fileInput.js'
+
+describe('MCP file input', () => {
+  it('should reject malformed MIME types', () => {
+    const result = fileInputSchema.safeParse({
+      data: 'aGVsbG8=',
+      mimeType: 'text/plain\r\nx-test: value',
+      name: 'hello.txt',
+      source: 'base64',
+    })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('should accept a prepared upload', () => {
+    const result = fileInputSchema.safeParse({
+      file: {
+        filename: 'image.png',
+        mimeType: 'image/png',
+        size: 123,
+        uploadReference: { uploadId: 'upload-id' },
+      },
+      source: 'uploadReference',
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('should reject oversized base64 files', async () => {
+    const req = createRequest({ maxFileSize: 4 })
+
+    await expect(
+      resolveFile({
+        collectionSlug: 'media',
+        input: {
+          data: Buffer.from('hello').toString('base64'),
+          mimeType: 'text/plain',
+          name: 'hello.txt',
+          source: 'base64',
+        },
+        req,
+      }),
+    ).rejects.toThrow('File exceeds the 4 byte upload limit.')
+  })
+
+  it('should reject URLs outside the collection allowlist', async () => {
+    const req = createRequest({
+      allowList: [{ hostname: 'assets.example.com', protocol: 'https' }],
+    })
+
+    await expect(
+      resolveFile({
+        collectionSlug: 'media',
+        input: {
+          source: 'externalURL',
+          url: 'https://example.com/image.png',
+        },
+        req,
+      }),
+    ).rejects.toThrow('The provided file URL is not allowed.')
+  })
+})
+
+function createRequest({
+  allowList,
+  maxFileSize,
+}: {
+  allowList?: Array<{ hostname: string; protocol: 'http' | 'https' }>
+  maxFileSize?: number
+}): PayloadRequest {
+  return {
+    payload: {
+      collections: {
+        media: {
+          config: {
+            upload: allowList ? { pasteURL: { allowList } } : {},
+          },
+        },
+      },
+      config: {
+        upload: {
+          limits: {
+            fileSize: maxFileSize,
+          },
+        },
+      },
+    },
+  } as unknown as PayloadRequest
+}

package/src/mcp/builtin/collections/fileInput.ts

@@ -0,0 +1,164 @@
+import type { CollectionSlug, File, FileData, PayloadRequest } from 'payload'
+
+import { APIError } from 'payload'
+import { getExternalFile, getFileFromUploadInstructions, isURLAllowed } from 'payload/internal'
+import { sanitizeFilename } from 'payload/shared'
+import { z } from 'zod'
+
+const mimeTypeSchema = z
+  .string()
+  .regex(/^[!#$%&'*+.^`|~\w-]+\/[!#$%&'*+.^`|~\w-]+$/, 'MIME type must use the type/subtype format')
+
+const uploadFileSchema = z.object({
+  filename: z.string(),
+  mimeType: z.string(),
+  size: z.number().int().nonnegative(),
+  uploadReference: z.record(z.string(), z.unknown()),
+})
+
+export const fileInputSchema = z
+  .discriminatedUnion('source', [
+    z.object({
+      name: z.string().min(1).describe('The file name, including its extension'),
+      data: z.string().describe('The base64-encoded file bytes, without a data URL prefix'),
+      mimeType: mimeTypeSchema.describe('The file MIME type, for example image/png'),
+      source: z.literal('base64'),
+    }),
+    z.object({
+      name: z.string().min(1).describe('Optional file name override').optional(),
+      source: z.literal('externalURL'),
+      url: z.url().describe('The http or https URL to download'),
+    }),
+    z.object({
+      file: uploadFileSchema.describe('getUploadInstructions file field post-upload'),
+      source: z.literal('uploadReference'),
+    }),
+  ])
+  .describe(
+    'A file for an upload collection. Prefer uploadReference after its upload succeeds; use base64 only for small local files or externalURL for an online file.',
+  )
+
+type FileInput = z.infer<typeof fileInputSchema>
+
+export async function resolveFile({
+  collectionSlug,
+  input,
+  req,
+}: {
+  collectionSlug: CollectionSlug
+  input?: FileInput
+  req: PayloadRequest
+}): Promise<File | undefined> {
+  if (!input) {
+    return undefined
+  }
+
+  if (input.source === 'uploadReference') {
+    try {
+      return await getFileFromUploadInstructions({ collectionSlug, file: input.file, req })
+    } catch (error) {
+      if (error instanceof Error && error.message === 'Staged upload was not found.') {
+        throw new APIError(
+          'Staged upload not found. Complete the upload action first, or use base64 for small local files.',
+          400,
+        )
+      }
+      throw error
+    }
+  }
+
+  const uploadConfig = req.payload.collections[collectionSlug]?.config.upload
+
+  if (!uploadConfig) {
+    throw new APIError(`Collection "${collectionSlug}" does not support file uploads.`, 400)
+  }
+
+  const maxFileSize = req.payload.config.upload.limits?.fileSize
+  let file: File
+
+  if (input.source === 'base64') {
+    const data = decodeBase64({ maxFileSize, value: input.data })
+
+    file = {
+      name: sanitizeFilename(input.name),
+      data,
+      mimetype: input.mimeType,
+      size: data.length,
+    }
+  } else {
+    if (uploadConfig.pasteURL === false) {
+      throw new APIError(
+        `Uploading files from URLs is disabled for collection "${collectionSlug}".`,
+        400,
+      )
+    }
+
+    const url = new URL(input.url)
+
+    if (!['http:', 'https:'].includes(url.protocol)) {
+      throw new APIError('File URLs must use http or https.', 400)
+    }
+
+    if (
+      typeof uploadConfig.pasteURL === 'object' &&
+      !isURLAllowed(input.url, uploadConfig.pasteURL.allowList)
+    ) {
+      throw new APIError('The provided file URL is not allowed.', 400)
+    }
+
+    file = await getExternalFile({
+      data: {
+        filename: sanitizeFilename(input.name || getURLFilename(url)),
+        url: input.url,
+      } as FileData,
+      req,
+      uploadConfig: {
+        ...uploadConfig,
+        externalFileHeaderFilter: uploadConfig.externalFileHeaderFilter ?? (() => ({})),
+      },
+    })
+    file.mimetype = file.mimetype?.split(';')[0] || 'application/octet-stream'
+    file.size = file.data.length
+  }
+
+  if (maxFileSize !== undefined && Number.isFinite(maxFileSize) && file.size > maxFileSize) {
+    throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400)
+  }
+
+  return file
+}
+
+function decodeBase64({ maxFileSize, value }: { maxFileSize?: number; value: string }): Buffer {
+  const normalized = value.replace(/\s/g, '')
+
+  if (!/^[a-z0-9+/]*={0,2}$/i.test(normalized) || normalized.length % 4 === 1) {
+    throw new APIError('File data must be valid base64.', 400)
+  }
+
+  if (maxFileSize !== undefined && Number.isFinite(maxFileSize)) {
+    const paddingLength = normalized.endsWith('==') ? 2 : normalized.endsWith('=') ? 1 : 0
+    const decodedSize = Math.floor((normalized.length * 3) / 4) - paddingLength
+
+    if (decodedSize > maxFileSize) {
+      throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400)
+    }
+  }
+
+  const data = Buffer.from(normalized, 'base64')
+
+  if (data.toString('base64').replace(/=+$/, '') !== normalized.replace(/=+$/, '')) {
+    throw new APIError('File data must be valid base64.', 400)
+  }
+
+  return data
+}
+
+function getURLFilename(url: URL): string {
+  const pathSegment = url.pathname.split('/').pop() || 'upload'
+
+  try {
+    return decodeURIComponent(pathSegment)
+  } catch {
+    return pathSegment
+  }
+}

package/src/mcp/builtin/collections/getCollectionSchemaTool.ts

@@ -48,16 +48,33 @@ export const getCollectionSchemaTool = defineCollectionTool({
     }
   }
 
+  const uploadConfig = req.payload.collections[collectionSlug]?.config.upload
+  const maxFileSize = req.payload.config.upload.limits?.fileSize
+  const upload = uploadConfig
+    ? {
+        enabled: true,
+        filesRequiredOnCreate: uploadConfig.filesRequiredOnCreate !== false,
+        mimeTypes: uploadConfig.mimeTypes ?? ['*/*'],
+        sources: [
+          ...(uploadConfig.pasteURL !== false ? ['externalURL'] : []),
+          'base64',
+          'uploadReference',
+        ],
+        ...(typeof maxFileSize === 'number' && Number.isFinite(maxFileSize) ? { maxFileSize } : {}),
+      }
+    : { enabled: false }
+
   return {
     content: [
       {
         type: 'text',
-        text: `Schema for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
+        text: `Schema for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\`\nUpload configuration:\n\`\`\`json\n${JSON.stringify(upload)}\n\`\`\``,
       },
     ],
     structuredContent: {
       collectionSlug,
       schema: inputSchema,
+      upload,
     },
   }
 })

package/src/mcp/builtin/collections/updateTool.ts

@@ -13,10 +13,11 @@ import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEnt
 import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
 import { whereSchema } from '../../../utils/whereSchema.js'
 import { validateCollectionData } from '../validateEntityData.js'
+import { fileInputSchema, resolveFile } from './fileInput.js'
 import { formatCollectionError } from './formatCollectionError.js'
 
 const DEFAULT_DESCRIPTION =
-  'Update documents in any collection by passing the collection slug and data.'
+  'Update documents. Prefer uploadReference after upload, externalURL for URLs, or base64 for small local files.'
 
 export const updateDocumentTool = defineCollectionTool({
   access: (args) =>
@@ -52,7 +53,7 @@ export const updateDocumentTool = defineCollectionTool({
       .string()
       .describe('Optional: fallback locale code to use when requested locale is not available')
       .optional(),
-    filePath: z.string().describe('File path for file uploads').optional(),
+    file: fileInputSchema.optional(),
     locale: z
       .string()
       .describe(
@@ -97,7 +98,7 @@ export const updateDocumentTool = defineCollectionTool({
     depth,
     draft,
     fallbackLocale,
-    filePath,
+    file: fileInput,
     locale,
     overrideLock,
     overwriteExistingFiles,
@@ -131,6 +132,7 @@ export const updateDocumentTool = defineCollectionTool({
     }
 
     const parsedData = transformPointDataToPayload(inputData)
+    const file = await resolveFile({ collectionSlug, input: fileInput, req })
 
     const whereClause: Where = where ?? {}
 
@@ -144,7 +146,7 @@ export const updateDocumentTool = defineCollectionTool({
         overrideAccess: authorizedMCP.overrideAccess,
         overrideLock,
         req,
-        ...(filePath ? { filePath } : {}),
+        ...(file ? { file } : {}),
         ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
         ...(publishAllLocales !== undefined ? { publishAllLocales } : {}),
         ...(locale ? { locale } : {}),
@@ -172,7 +174,7 @@ export const updateDocumentTool = defineCollectionTool({
       overrideLock,
       req,
       where: whereClause,
-      ...(filePath ? { filePath } : {}),
+      ...(file ? { file } : {}),
       ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
       ...(publishAllLocales !== undefined ? { publishAllLocales } : {}),
       ...(locale ? { locale } : {}),

package/src/mcp/builtin/collections/uploadInstructionsTool.ts

@@ -0,0 +1,64 @@
+import { getUploadInstructions as getPayloadUploadInstructions } from 'payload/internal'
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+
+export const getUploadInstructionsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) &&
+    Boolean(
+      args.permissions?.collections?.[args.collectionSlug]?.create ||
+        args.permissions?.collections?.[args.collectionSlug]?.update,
+    ),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+    title: 'Get Upload Instructions',
+  },
+  description:
+    'Prepare uploads for createDocuments or updateDocument. This does not upload bytes; finish the returned action before use.',
+  input: z.object({
+    docPrefix: z.string().describe('Optional document folder or prefix').optional(),
+    filename: z.string().describe('The original file name'),
+    filesize: z.number().int().nonnegative().describe('The file size in bytes'),
+    mimeType: z.string().describe('The file MIME type'),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  try {
+    const instructions = await getPayloadUploadInstructions({
+      ...input,
+      collectionSlug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+    })
+
+    const nextStep =
+      instructions.type === 'http'
+        ? 'Upload bytes with instructions.request. After success, pass { source: "uploadReference", file: instructions.file }.'
+        : `Call "${instructions.name}" with file and data. After success, pass { source: "uploadReference", file: instructions.file }.`
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Upload instructions for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(instructions)}\n\`\`\`\n${nextStep}`,
+        },
+      ],
+      structuredContent: { instructions },
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error'
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error getting upload instructions for collection "${collectionSlug}": ${message}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtinTools.ts

@@ -10,7 +10,7 @@ import {
 } from './builtin/collections/authTools.js'
 import { countDocumentsTool } from './builtin/collections/countTool.js'
 import { countVersionsTool } from './builtin/collections/countVersionsTool.js'
-import { createDocumentTool } from './builtin/collections/createTool.js'
+import { createDocumentsTool } from './builtin/collections/createTool.js'
 import { deleteDocumentsTool } from './builtin/collections/deleteTool.js'
 import { duplicateDocumentTool } from './builtin/collections/duplicateTool.js'
 import { findDistinctTool } from './builtin/collections/findDistinctTool.js'
@@ -20,6 +20,7 @@ import { findVersionsTool } from './builtin/collections/findVersionsTool.js'
 import { getCollectionSchemaTool } from './builtin/collections/getCollectionSchemaTool.js'
 import { restoreVersionTool } from './builtin/collections/restoreVersionTool.js'
 import { updateDocumentTool } from './builtin/collections/updateTool.js'
+import { getUploadInstructionsTool } from './builtin/collections/uploadInstructionsTool.js'
 import { getConfigInfoTool } from './builtin/getConfigInfoTool.js'
 import { countGlobalVersionsTool } from './builtin/globals/countVersionsTool.js'
 import { findGlobalTool } from './builtin/globals/findTool.js'
@@ -32,6 +33,7 @@ import { updateGlobalTool } from './builtin/globals/updateTool.js'
 type CollectionBuiltin = {
   mcpName: string
   requiresDuplicateEnabled?: boolean
+  requiresUpload?: boolean
   requiresVersions?: boolean
   tool: CollectionTool
 }
@@ -54,7 +56,7 @@ export const TOOL_BUILTINS = {
 export const COLLECTION_BUILTINS = {
   count: { mcpName: 'countDocuments', tool: countDocumentsTool },
   countVersions: { mcpName: 'countVersions', requiresVersions: true, tool: countVersionsTool },
-  create: { mcpName: 'createDocument', tool: createDocumentTool },
+  create: { mcpName: 'createDocuments', tool: createDocumentsTool },
   delete: { mcpName: 'deleteDocuments', tool: deleteDocumentsTool },
   duplicate: {
     mcpName: 'duplicateDocument',
@@ -70,6 +72,11 @@ export const COLLECTION_BUILTINS = {
   },
   findVersions: { mcpName: 'findVersions', requiresVersions: true, tool: findVersionsTool },
   getCollectionSchema: { mcpName: 'getCollectionSchema', tool: getCollectionSchemaTool },
+  getUploadInstructions: {
+    mcpName: 'getUploadInstructions',
+    requiresUpload: true,
+    tool: getUploadInstructionsTool,
+  },
   restoreVersion: { mcpName: 'restoreVersion', requiresVersions: true, tool: restoreVersionTool },
   update: { mcpName: 'updateDocument', tool: updateDocumentTool },
 } satisfies Record<string, CollectionBuiltin>