# Use Library with MCP

## What MCP access provides

Memside exposes five Library tools through the same authenticated MCP connection
used for Memory features. Library access can be enabled without enabling Memory
access.

The connected tools can:

- search public reviewed Templates;
- show owned Templates and current workflow states;
- read selected content from an owned private draft;
- replace an owned private draft with revision protection;
- create, review, publish, unpublish, or republish an owned Template.

Connected workflows cannot bypass ownership checks or publication review.

## Enable Library tools

1. Open Memside.
2. Open **Settings > AI Permissions**.
3. Enable **Access Library through MCP**.
4. Leave **Access Memories through MCP** enabled or disabled according to the
   intended connection scope.
5. Reconnect the AI client or start a new conversation if its tool list was
   already loaded.

Library tools and Memory tools are independent. See [AI
permissions](/product/ai-permissions/) for example configurations.

## Connect an MCP client

1. Open **Settings > Developer & API**.
2. Copy the Memside MCP server URL.
3. Add the URL to a supported AI client.
4. Complete the Memside sign-in and authorization flow when requested.
5. Start a new client conversation and test a read-only Library search.

Client-specific setup is available for [ChatGPT](/connect/chatgpt/),
[Claude](/connect/claude/), [VS Code](/connect/vscode/),
[Cursor](/connect/cursor/), [Codex](/connect/codex/), and other supported tools.

## Available Library tools

| Tool | Use |
| --- | --- |
| `search_templates` | Find public Templates by ordinary terms, category, or tag. |
| `get_creator_status` | List owned Templates and inspect review or workflow status. |
| `read_template` | Read selected files from an owned draft before making changes. |
| `write_draft` | Save a complete replacement draft after checking the latest revision. |
| `manage_template_workflow` | Create, submit, retry review, publish, unpublish, or republish. |

Search is a public discovery action. Draft reads and creator actions require an
owned Template. Creating a Template requires a Library creator account.

## Search public Templates

Start with a narrow request that states the task and any useful filter.

```text
Search the Memside Library for a weekly planning Template. Return the three most relevant results with their descriptions and licenses.
```

```text
Find public Templates tagged document review and summarize what each one contains. Do not import or download anything.
```

Search does not expose private drafts or private Memories.

## Inspect owned work

Use creator status before editing or publishing:

```text
List the owned Library Templates. Show which drafts are waiting for review, ready to publish, or need changes.
```

Then request only the files needed for the task:

```text
Read README.md and instructions.md from the selected private Template draft. Summarize the current structure without changing it.
```

## Create a draft through MCP

A safe connected creation sequence is:

1. request creation with a name, description, category, tags, and license;
2. inspect the returned private Template status;
3. read the new draft and its root README;
4. prepare the complete intended file tree;
5. request a draft write without review or publication;
6. read the saved draft again and verify every file.

Example:

```text
Create a private Template named Simple Weekly Plan in the Personal Productivity category. Use the CC BY 4.0 license and tags weekly planning and tasks. Do not submit it for review.
```

Follow with a bounded content request:

```text
Add a concise README, an instructions file, and one generic example to the private draft. Show the final file list and keep the Template private.
```

## Review and publish through MCP

Publication remains a separate explicit action. A useful sequence is:

```text
Submit the selected private Template for publication review. Do not publish it. Return the review state and any finding locations.
```

After the result is ready:

```text
Show the reviewed Template name, version candidate, license, and file list. Publish only if the current state is Ready to publish.
```

If review finds a problem, edit the draft and submit it again. A changed draft
must receive a current review result before publication.

## Unpublish or republish

Use explicit wording for visibility changes:

```text
Unpublish the selected owned Template and return its resulting visibility. Do not delete it.
```

```text
Check whether the selected unpublished Template can be republished unchanged. Report the status before taking action.
```

## Troubleshooting

- Missing Library tools: enable Library MCP access and reconnect the client.
- Creator action unavailable: complete the Library creator username setup.
- Draft changed elsewhere: read the latest draft again before writing.
- Review state delayed: request a retry after the current status is confirmed.
- Write rejected: confirm that the connection has read-write access.

## Related pages

- [Connection overview](/connect/mcp-and-api/)
- [Create and publish Templates](/library/create-and-publish/)
- [Use the Library API](/library/use-with-api/)