kibela_create_note

Create and manage notes in Kibela by specifying title, content, folders, and groups. Enable co-editing, draft mode, and assign authors for collaborative documentation.

Instructions

Create a new note in Kibela.

Input Schema

TableJSON Schema

Name	Required	Description
`authorId`	No	ID of the author of the note. If not specified, the note will be created by the authenticated user.
`coediting`	No	required: Whether to enable co-editing for the note
`content`	Yes	required: Content of the note in markdown format
`draft`	No	Whether to create the note as a draft
`folders`	No	IDs of the folders to add the note to.
`groupIds`	No	required: IDs of the groups to create the note in.
`title`	Yes	required: Title of the note

Implementation Reference

src/tools/createNote.ts:61-87 (handler)

The handler function for 'kibela_create_note' tool that validates required parameters and calls the GraphQL 'createNote' mutation to create the note.

handler: async ({ title, content, groupIds, folders, authorId, coediting, draft }) => {
  if (!title || !content || !groupIds || !coediting) {
    throw new Error('Title, content, groupIds, and coediting are required')
  }

  const response = await createNote({
    input: {
      clientMutationId: uuid(),
      title,
      content,
      groupIds,
      folders,
      authorId,
      coediting,
      draft,
    },
  })

  return {
    content: [
      {
        type: 'text',
        text: JSON.stringify(response.createNote, null, 2),
      },
    ],
  }
},

src/tools/createNote.ts:16-60 (schema)

The tool definition including name, description, and input schema for parameter validation.

tool: {
  name: 'kibela_create_note',
  description: 'Create a new note in Kibela.',
  inputSchema: {
    type: 'object',
    properties: {
      title: {
        type: 'string',
        description: 'required: Title of the note',
      },
      content: {
        type: 'string',
        description: 'required: Content of the note in markdown format',
      },
      groupIds: {
        type: 'array',
        items: {
          type: 'string',
        },
        description: 'required: IDs of the groups to create the note in.',
      },
      folders: {
        type: 'array',
        items: {
          type: 'string',
        },
        description: 'IDs of the folders to add the note to.',
      },
      authorId: {
        type: 'string',
        description:
          'ID of the author of the note. If not specified, the note will be created by the authenticated user.',
      },
      coediting: {
        type: 'boolean',
        description: 'required: Whether to enable co-editing for the note',
      },
      draft: {
        type: 'boolean',
        description: 'Whether to create the note as a draft',
      },
    },
    required: ['title', 'content'],
  },
},

src/tools/index.ts:9-16 (registration)

Registration of the 'kibela_create_note' tool by mapping it to createNoteTool in the toolDefinitions object.

const toolDefinitions = {
  kibela_search_notes: searchNotesTool,
  kibela_get_my_notes: getMyNotesTool,
  kibela_get_note_content: getNoteContentTool,
  kibela_get_note_from_path: getNoteFromPathTool,
  kibela_update_note_content: updateNoteContentTool,
  kibela_create_note: createNoteTool,
} as const

src/graphql/queries/createNote.ts:30-46 (helper)

GraphQL mutation definition and helper function used by the tool handler to perform the actual note creation.

const createNoteMutation: TypedDocumentNode<CreateNoteResponse, CreateNoteVariables> = gql`
  mutation CreateNote($input: CreateNoteInput!) {
    createNote(input: $input) {
      clientMutationId
      note {
        id
        title
        content
        url
      }
    }
  }
`

export async function createNote(variables: CreateNoteVariables): Promise<CreateNoteResponse> {
  return gqlRequest(createNoteMutation, variables)
}

MCP Kibela