Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

chore: remove MCP server

boojack2a4638b3321f
diff --git a/AGENTS.md b/AGENTS.md
index fb12935ad..f90ba0bb9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -45,7 +45,6 @@ server/
│ ├── api/v1/ # 8 gRPC services (Connect + Gateway)
│ │ ├── acl_config.go # Public endpoints whitelist
│ │ ├── sse_hub.go # Server-Sent Events (live updates)
-│ │ └── mcp/ # MCP server for AI assistants
│ ├── frontend/ # SPA static file serving
│ ├── fileserver/ # Native HTTP file server (thumbnails, range requests)
│ └── rss/ # RSS feeds
diff --git a/go.mod b/go.mod
index 6da2894e9..7c69a9be9 100644
--- a/go.mod
+++ b/go.mod
@@ -18,7 +18,6 @@ require (
github.com/labstack/echo/v5 v5.1.0
github.com/lib/pq v1.12.3
github.com/lithammer/shortuuid/v4 v4.2.0
- github.com/mark3labs/mcp-go v0.49.0
github.com/moby/moby/api v1.54.2
github.com/openai/openai-go/v3 v3.32.0
github.com/pion/opus v0.0.0-20260430223319-81a9c5dc5013
@@ -72,7 +71,6 @@ require (
github.com/go-ole/go-ole v1.3.0 // indirect
github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
github.com/google/go-cmp v0.7.0 // indirect
- github.com/google/jsonschema-go v0.4.3 // indirect
github.com/google/s2a-go v0.1.9 // indirect
github.com/googleapis/enterprise-certificate-proxy v0.3.15 // indirect
github.com/googleapis/gax-go/v2 v2.22.0 // indirect
@@ -108,7 +106,6 @@ require (
github.com/tidwall/sjson v1.2.5 // indirect
github.com/tklauser/go-sysconf v0.3.16 // indirect
github.com/tklauser/numcpus v0.11.0 // indirect
- github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
github.com/yusufpapurcu/wmi v1.2.4 // indirect
go.opentelemetry.io/auto/sdk v1.2.1 // indirect
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.68.0 // indirect
diff --git a/go.sum b/go.sum
index e53922882..d4b6ad130 100644
--- a/go.sum
+++ b/go.sum
@@ -115,8 +115,6 @@ github.com/google/cel-go v0.28.0 h1:KjSWstCpz/MN5t4a8gnGJNIYUsJRpdi/r97xWDphIQc=
github.com/google/cel-go v0.28.0/go.mod h1:X0bD6iVNR8pkROSOoHVdgTkzmRcosof7WQqCD6wcMc8=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/jsonschema-go v0.4.3 h1:/DBOLZTfDow7pe2GmaJNhltueGTtDKICi8V8p+DQPd0=
-github.com/google/jsonschema-go v0.4.3/go.mod h1:r5quNTdLOYEz95Ru18zA0ydNbBuYoo9tgaYcxEYhJVE=
github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
@@ -163,8 +161,6 @@ github.com/lufia/plan9stats v0.0.0-20260330125221-c963978e514e h1:Q6MvJtQK/iRcRt
github.com/lufia/plan9stats v0.0.0-20260330125221-c963978e514e/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mark3labs/mcp-go v0.49.0 h1:7Ssx4d7/T86qnWoJIdye7wEEvUzv39UIbnZb/FqUZMY=
-github.com/mark3labs/mcp-go v0.49.0/go.mod h1:BflTAZAzXlrTpiO44gmjMu89n2FO56rJ9m31fp4zd5k=
github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
github.com/mdelapenya/tlscert v0.2.0 h1:7H81W6Z/4weDvZBNOfQte5GpIMo0lGYEeWbkGp5LJHI=
@@ -254,8 +250,6 @@ github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYI
github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI=
github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw=
github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ=
-github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
-github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
github.com/yuin/goldmark v1.8.2 h1:kEGpgqJXdgbkhcOgBxkC0X0PmoPG1ZyoZ117rDVp4zE=
github.com/yuin/goldmark v1.8.2/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
diff --git a/server/router/frontend/frontend.go b/server/router/frontend/frontend.go
index 0d95ec781..78c1b1c62 100644
--- a/server/router/frontend/frontend.go
+++ b/server/router/frontend/frontend.go
@@ -85,7 +85,6 @@ func shouldSkipFrontendStatic(requestPath string) bool {
}
return hasPathPrefix(requestPath, "/api") ||
hasPathPrefix(requestPath, "/file") ||
- hasPathPrefix(requestPath, "/mcp") ||
requestPath == "/memos.api.v1" ||
strings.HasPrefix(requestPath, "/memos.api.v1.")
}
diff --git a/server/router/mcp/README.md b/server/router/mcp/README.md
deleted file mode 100644
index cd2fbf182..000000000
--- a/server/router/mcp/README.md
+++ /dev/null
@@ -1,167 +0,0 @@
-# MCP Server
-
-This package implements a [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server embedded in the Memos HTTP process. It exposes memo operations as MCP tools, making Memos accessible to any MCP-compatible AI client (Claude Desktop, Cursor, Zed, etc.).
-
-## Endpoint
-
-```
-POST /mcp (tool calls, initialize)
-GET /mcp (optional SSE stream for server-to-client messages)
-DELETE /mcp (optional session termination)
-```
-
-Transport: [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports) (single endpoint, MCP spec 2025-03-26).
-
-### Tool Filtering
-
-The default `/mcp` endpoint exposes all tools. Clients can opt into a smaller
-tool surface with GitHub-style headers or route aliases:
-
-| Control | Description |
-|---|---|
-| `X-MCP-Readonly: true` | Hide and block mutating tools |
-| `X-MCP-Toolsets: memos,tags,attachments,relations,reactions` | Limit the default tool list to selected toolsets |
-| `X-MCP-Tools: list_tags,get_memo` | Add specific tools to the selected toolset list |
-| `X-MCP-Exclude-Tools: delete_memo` | Remove specific tools |
-
-Equivalent aliases:
-
-```text
-/mcp/readonly
-/mcp/x/{toolsets}
-/mcp/x/{toolsets}/readonly
-```
-
-Examples:
-
-```text
-/mcp/x/memos,tags/readonly
-X-MCP-Toolsets: memos
-X-MCP-Tools: list_tags
-X-MCP-Exclude-Tools: delete_memo
-```
-
-## Capabilities
-
-The server advertises the following MCP capabilities:
-
-| Capability | Enabled | Details |
-|---|---|---|
-| Tools | Yes | List changed notifications supported |
-| Resources | Yes | Subscribe + list changed supported |
-| Prompts | Yes | List changed notifications supported |
-| Logging | Yes | Structured log events |
-
-## Authentication
-
-Public reads can be used without authentication. Personal Access Tokens (PATs) or short-lived JWT session tokens are required for:
-
-- Reading non-public memos or attachments
-- Any tool that mutates data
-
-When authenticating, send a Bearer token:
-
-```
-Authorization: Bearer <your-PAT>
-```
-
-PATs are long-lived tokens created in Settings → My Account → Access Tokens. Short-lived JWT session tokens are also accepted. Requests with an invalid token receive `HTTP 401`.
-
-## Origin Validation
-
-For Streamable HTTP safety, requests with an `Origin` header must be same-origin with the current request host or match the configured `instance-url`. Requests without an `Origin` header, such as desktop MCP clients and CLI tools, are allowed.
-
-## Tools
-
-### Memo Tools
-
-| Tool | Description | Required params | Optional params |
-|---|---|---|---|
-| `list_memos` | List memos | — | `page_size`, `page`, `state`, `order_by_pinned`, `filter` (supported subset of standard CEL syntax) |
-| `get_memo` | Get a single memo | `name` | — |
-| `search_memos` | Full-text search | `query` | — |
-| `create_memo` | Create a memo | `content` | `visibility` |
-| `update_memo` | Update a memo | `name` | `content`, `visibility`, `pinned`, `state` |
-| `delete_memo` | Delete a memo | `name` | — |
-| `list_memo_comments` | List comments | `name` | — |
-| `create_memo_comment` | Add a comment | `name`, `content` | — |
-
-### Tag Tools
-
-| Tool | Description | Required params |
-|---|---|---|
-| `list_tags` | List all tags with counts | — |
-
-### Attachment Tools
-
-| Tool | Description | Required params | Optional params |
-|---|---|---|---|
-| `list_attachments` | List user's attachments | — | `page_size`, `page`, `memo` |
-| `get_attachment` | Get attachment metadata | `name` | — |
-| `delete_attachment` | Delete an attachment | `name` | — |
-| `link_attachment_to_memo` | Link attachment to a memo you own | `name`, `memo` | — |
-
-### Relation Tools
-
-| Tool | Description | Required params | Optional params |
-|---|---|---|---|
-| `list_memo_relations` | List relations (refs + comments) | `name` | `type` |
-| `create_memo_relation` | Create a reference relation from a memo you own to a memo you can read | `name`, `related_memo` | — |
-| `delete_memo_relation` | Delete a reference relation from a memo you own | `name`, `related_memo` | — |
-
-### Reaction Tools
-
-| Tool | Description | Required params |
-|---|---|---|
-| `list_reactions` | List reactions on a memo | `name` |
-| `upsert_reaction` | Add a reaction emoji | `name`, `reaction_type` |
-| `delete_reaction` | Remove a reaction | `id` |
-
-## Resources
-
-| URI Template | Description | MIME Type |
-|---|---|---|
-| `memo://memos/{uid}` | Memo content with YAML frontmatter | `text/markdown` |
-
-## Prompts
-
-| Prompt | Description | Arguments |
-|---|---|---|
-| `capture` | Quick-save a thought as a memo | `content` (required), `tags`, `visibility` |
-| `review` | Search and summarize memos on a topic | `topic` (required) |
-| `daily_digest` | Summarize recent memo activity | `days` |
-| `organize` | Suggest tags/relations for unorganized memos | `scope` |
-
-## Resource Names
-
-- Memos: `memos/<uid>` (e.g. `memos/abc123`)
-- Attachments: `attachments/<uid>` (e.g. `attachments/def456`)
-
-## Connecting Claude Code
-
-```bash
-claude mcp add --transport http memos http://localhost:5230/mcp \
- --header "Authorization: Bearer <your-PAT>"
-```
-
-Use `--scope user` to make it available across all projects:
-
-```bash
-claude mcp add --scope user --transport http memos http://localhost:5230/mcp \
- --header "Authorization: Bearer <your-PAT>"
-```
-
-## Package Structure
-
-| File | Responsibility |
-|---|---|
-| `mcp.go` | `MCPService` struct, constructor, route registration, auth middleware, tool filtering |
-| `tool_metadata.go` | Toolsets, read-only metadata, annotations, structured result helpers |
-| `api_helpers.go` | Conversion helpers for calling API service methods from MCP tools |
-| `tools_memo.go` | Memo CRUD tools + helpers (JSON types, visibility/access checks) |
-| `tools_tag.go` | Tag listing tool |
-| `tools_attachment.go` | Attachment listing, metadata, deletion, linking tools |
-| `tools_relation.go` | Memo relation (reference) tools |
-| `tools_reaction.go` | Reaction (emoji) tools |
-| `resources_memo.go` | Memo resource template handler |
-| `prompts.go` | Prompt handlers (capture, review, daily_digest, organize) |
diff --git a/server/router/mcp/access.go b/server/router/mcp/access.go
deleted file mode 100644
index eadc11f83..000000000
--- a/server/router/mcp/access.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package mcp
-
-import (
- "context"
- "net/http"
- "net/url"
- "strconv"
- "strings"
-
- "github.com/pkg/errors"
-
- "github.com/usememos/memos/store"
-)
-
-// checkMemoAccess returns an error if the caller cannot read the memo.
-// userID == 0 means anonymous.
-func checkMemoAccess(memo *store.Memo, userID int32) error {
- if memo.RowStatus == store.Archived && memo.CreatorID != userID {
- return errors.New("permission denied")
- }
-
- switch memo.Visibility {
- case store.Protected:
- if userID == 0 {
- return errors.New("permission denied")
- }
- case store.Private:
- if memo.CreatorID != userID {
- return errors.New("permission denied")
- }
- default:
- // store.Public and any unknown visibility: allow.
- }
- return nil
-}
-
-func checkMemoOwnership(memo *store.Memo, userID int32) error {
- if memo.CreatorID != userID {
- return errors.New("permission denied")
- }
- return nil
-}
-
-func hasMemoOwnership(memo *store.Memo, userID int32) bool {
- return memo.CreatorID == userID
-}
-
-// applyVisibilityFilter restricts find to memos the caller may see.
-func applyVisibilityFilter(find *store.FindMemo, userID int32, rowStatus *store.RowStatus) {
- if rowStatus != nil && *rowStatus == store.Archived {
- if userID == 0 {
- impossibleCreatorID := int32(-1)
- find.CreatorID = &impossibleCreatorID
- return
- }
- find.CreatorID = &userID
- return
- }
- if userID == 0 {
- find.VisibilityList = []store.Visibility{store.Public}
- return
- }
- find.Filters = append(find.Filters, "creator_id == "+itoa32(userID)+` || visibility in ["PUBLIC", "PROTECTED"]`)
-}
-
-func (s *MCPService) checkAttachmentAccess(ctx context.Context, attachment *store.Attachment, userID int32) error {
- if attachment.CreatorID == userID {
- return nil
- }
- if attachment.MemoID == nil {
- return errors.New("permission denied")
- }
-
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{ID: attachment.MemoID})
- if err != nil {
- return errors.Wrap(err, "failed to get linked memo")
- }
- if memo == nil {
- return errors.New("linked memo not found")
- }
- return checkMemoAccess(memo, userID)
-}
-
-func (s *MCPService) isAllowedOrigin(r *http.Request) bool {
- origin := r.Header.Get("Origin")
- if origin == "" {
- return true
- }
-
- originURL, err := url.Parse(origin)
- if err != nil || originURL.Scheme == "" || originURL.Host == "" {
- return false
- }
-
- if sameOriginHost(originURL.Host, r.Host) {
- return true
- }
-
- if s.profile.InstanceURL == "" {
- return false
- }
-
- instanceURL, err := url.Parse(s.profile.InstanceURL)
- if err != nil || instanceURL.Scheme == "" || instanceURL.Host == "" {
- return false
- }
-
- return strings.EqualFold(originURL.Scheme, instanceURL.Scheme) && sameOriginHost(originURL.Host, instanceURL.Host)
-}
-
-func sameOriginHost(a, b string) bool {
- return strings.EqualFold(a, b)
-}
-
-func itoa32(v int32) string {
- return strconv.FormatInt(int64(v), 10)
-}
diff --git a/server/router/mcp/api_helpers.go b/server/router/mcp/api_helpers.go
deleted file mode 100644
index d561ea970..000000000
--- a/server/router/mcp/api_helpers.go
+++ /dev/null
@@ -1,74 +0,0 @@
-package mcp
-
-import (
- "context"
-
- "github.com/pkg/errors"
-
- v1pb "github.com/usememos/memos/proto/gen/api/v1"
- apiv1 "github.com/usememos/memos/server/router/api/v1"
- "github.com/usememos/memos/store"
-)
-
-func visibilityToProto(visibility store.Visibility) v1pb.Visibility {
- switch visibility {
- case store.Protected:
- return v1pb.Visibility_PROTECTED
- case store.Public:
- return v1pb.Visibility_PUBLIC
- default:
- return v1pb.Visibility_PRIVATE
- }
-}
-
-func rowStatusToProto(rowStatus store.RowStatus) v1pb.State {
- switch rowStatus {
- case store.Archived:
- return v1pb.State_ARCHIVED
- default:
- return v1pb.State_NORMAL
- }
-}
-
-func (s *MCPService) loadMemoJSONByName(ctx context.Context, name string) (memoJSON, error) {
- uid, err := parseMemoUID(name)
- if err != nil {
- return memoJSON{}, err
- }
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return memoJSON{}, errors.Wrap(err, "failed to get memo")
- }
- if memo == nil {
- return memoJSON{}, errors.New("memo not found")
- }
- return storeMemoToJSONWithStore(ctx, s.store, memo)
-}
-
-func (s *MCPService) loadReactionJSONByID(ctx context.Context, reactionID int32) (reactionJSON, error) {
- reaction, err := s.store.GetReaction(ctx, &store.FindReaction{ID: &reactionID})
- if err != nil {
- return reactionJSON{}, errors.Wrap(err, "failed to get reaction")
- }
- if reaction == nil {
- return reactionJSON{}, errors.New("reaction not found")
- }
- creator, err := lookupUsername(ctx, s.store, reaction.CreatorID)
- if err != nil {
- return reactionJSON{}, errors.Wrap(err, "failed to resolve reaction creator")
- }
- return reactionJSON{
- ID: reaction.ID,
- Creator: creator,
- ReactionType: reaction.ReactionType,
- CreateTime: reaction.CreatedTs,
- }, nil
-}
-
-func (s *MCPService) loadReactionJSONByName(ctx context.Context, name string) (reactionJSON, error) {
- _, reactionID, err := apiv1.ExtractMemoReactionIDFromName(name)
- if err != nil {
- return reactionJSON{}, err
- }
- return s.loadReactionJSONByID(ctx, reactionID)
-}
diff --git a/server/router/mcp/mcp.go b/server/router/mcp/mcp.go
deleted file mode 100644
index a5ec3820c..000000000
--- a/server/router/mcp/mcp.go
+++ /dev/null
@@ -1,251 +0,0 @@
-package mcp
-
-import (
- "context"
- "fmt"
- "net/http"
- "strings"
-
- "github.com/labstack/echo/v5"
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
-
- "github.com/usememos/memos/internal/profile"
- "github.com/usememos/memos/server/auth"
- apiv1 "github.com/usememos/memos/server/router/api/v1"
- "github.com/usememos/memos/store"
-)
-
-const (
- headerMCPReadonly = "X-MCP-Readonly"
- headerMCPToolsets = "X-MCP-Toolsets"
- headerMCPTools = "X-MCP-Tools"
- headerMCPExcludeTools = "X-MCP-Exclude-Tools"
-)
-
-type mcpRequestConfigContextKey struct{}
-
-type MCPService struct {
- profile *profile.Profile
- store *store.Store
- apiV1Service *apiv1.APIV1Service
- authenticator *auth.Authenticator
-}
-
-func NewMCPService(profile *profile.Profile, store *store.Store, secret string, apiV1Service *apiv1.APIV1Service) *MCPService {
- return &MCPService{
- profile: profile,
- store: store,
- apiV1Service: apiV1Service,
- authenticator: auth.NewAuthenticator(store, secret),
- }
-}
-
-func (s *MCPService) RegisterRoutes(echoServer *echo.Echo) {
- mcpSrv := mcpserver.NewMCPServer("Memos", "1.0.0",
- mcpserver.WithToolCapabilities(true),
- mcpserver.WithResourceCapabilities(true, true),
- mcpserver.WithPromptCapabilities(true),
- mcpserver.WithLogging(),
- mcpserver.WithToolFilter(s.filterTools),
- mcpserver.WithToolHandlerMiddleware(s.enforceToolAccess),
- mcpserver.WithRecovery(),
- mcpserver.WithResourceRecovery(),
- )
- s.registerMemoTools(mcpSrv)
- s.registerTagTools(mcpSrv)
- s.registerAttachmentTools(mcpSrv)
- s.registerRelationTools(mcpSrv)
- s.registerReactionTools(mcpSrv)
- s.registerMemoResources(mcpSrv)
- s.registerPrompts(mcpSrv)
-
- httpHandler := mcpserver.NewStreamableHTTPServer(mcpSrv,
- mcpserver.WithHTTPContextFunc(s.withRequestConfig),
- )
-
- mcpGroup := echoServer.Group("")
- mcpGroup.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
- return func(c *echo.Context) error {
- if !s.isAllowedOrigin(c.Request()) {
- return c.JSON(http.StatusForbidden, map[string]string{"message": "invalid origin"})
- }
- if origin := c.Request().Header.Get("Origin"); origin != "" {
- headers := c.Response().Header()
- headers.Set("Vary", "Origin")
- headers.Set("Access-Control-Allow-Origin", origin)
- headers.Set("Access-Control-Allow-Headers", strings.Join([]string{
- "Authorization",
- "Content-Type",
- "Accept",
- "Mcp-Session-Id",
- "MCP-Protocol-Version",
- "Last-Event-ID",
- headerMCPReadonly,
- headerMCPToolsets,
- headerMCPTools,
- headerMCPExcludeTools,
- }, ", "))
- headers.Set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS")
- if c.Request().Method == http.MethodOptions {
- return c.NoContent(http.StatusNoContent)
- }
- }
-
- authHeader := c.Request().Header.Get("Authorization")
- if authHeader != "" {
- result := s.authenticator.Authenticate(c.Request().Context(), authHeader)
- if result == nil {
- return c.JSON(http.StatusUnauthorized, map[string]string{"message": "invalid or expired token"})
- }
- ctx := auth.ApplyToContext(c.Request().Context(), result)
- c.SetRequest(c.Request().WithContext(ctx))
- }
- return next(c)
- }
- })
- mcpGroup.Any("/mcp", echo.WrapHandler(httpHandler))
- mcpGroup.Any("/mcp/readonly", echo.WrapHandler(httpHandler))
- mcpGroup.Any("/mcp/x/:toolsets", echo.WrapHandler(httpHandler))
- mcpGroup.Any("/mcp/x/:toolsets/readonly", echo.WrapHandler(httpHandler))
-}
-
-func (*MCPService) withRequestConfig(ctx context.Context, r *http.Request) context.Context {
- return context.WithValue(ctx, mcpRequestConfigContextKey{}, parseMCPRequestConfig(r))
-}
-
-func (*MCPService) filterTools(ctx context.Context, tools []mcp.Tool) []mcp.Tool {
- cfg := mcpRequestConfigFromContext(ctx)
- filtered := make([]mcp.Tool, 0, len(tools))
- for _, tool := range tools {
- if cfg.allowsTool(tool.Name) {
- filtered = append(filtered, tool)
- }
- }
- return filtered
-}
-
-func (*MCPService) enforceToolAccess(next mcpserver.ToolHandlerFunc) mcpserver.ToolHandlerFunc {
- return func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- cfg := mcpRequestConfigFromContext(ctx)
- if !cfg.allowsTool(req.Params.Name) {
- return mcp.NewToolResultError(fmt.Sprintf("tool %q is not enabled by MCP configuration", req.Params.Name)), nil
- }
- return next(ctx, req)
- }
-}
-
-type mcpRequestConfig struct {
- readOnly bool
- toolsets map[string]struct{}
- includeTools map[string]struct{}
- excludeTools map[string]struct{}
-}
-
-func mcpRequestConfigFromContext(ctx context.Context) mcpRequestConfig {
- if cfg, ok := ctx.Value(mcpRequestConfigContextKey{}).(mcpRequestConfig); ok {
- return cfg
- }
- return mcpRequestConfig{}
-}
-
-func parseMCPRequestConfig(r *http.Request) mcpRequestConfig {
- cfg := mcpRequestConfig{}
-
- pathToolsets, pathReadonly := parseMCPPathConfig(r.URL.Path)
- cfg.readOnly = pathReadonly || parseBoolHeader(r.Header.Get(headerMCPReadonly))
- cfg.toolsets = mergeStringSets(cfg.toolsets, pathToolsets)
- cfg.toolsets = mergeStringSets(cfg.toolsets, parseCommaSet(r.Header.Get(headerMCPToolsets), strings.ToLower))
- cfg.includeTools = parseCommaSet(r.Header.Get(headerMCPTools), keepString)
- cfg.excludeTools = parseCommaSet(r.Header.Get(headerMCPExcludeTools), keepString)
- return cfg
-}
-
-func parseMCPPathConfig(path string) (map[string]struct{}, bool) {
- trimmed := strings.Trim(path, "/")
- if trimmed == "mcp/readonly" {
- return nil, true
- }
- const prefix = "mcp/x/"
- if !strings.HasPrefix(trimmed, prefix) {
- return nil, false
- }
-
- rest := strings.TrimPrefix(trimmed, prefix)
- readOnly := false
- if strings.HasSuffix(rest, "/readonly") {
- readOnly = true
- rest = strings.TrimSuffix(rest, "/readonly")
- }
- return parseCommaSet(rest, strings.ToLower), readOnly
-}
-
-func (cfg mcpRequestConfig) allowsTool(name string) bool {
- if _, known := allMCPToolNames[name]; !known {
- return false
- }
- if cfg.readOnly {
- if _, mutates := mcpMutationTools[name]; mutates {
- return false
- }
- }
- if _, excluded := cfg.excludeTools[name]; excluded {
- return false
- }
- if _, included := cfg.includeTools[name]; included {
- return true
- }
- if len(cfg.toolsets) == 0 {
- return true
- }
- for toolset := range cfg.toolsets {
- if _, ok := mcpToolsByToolset[toolset][name]; ok {
- return true
- }
- }
- return false
-}
-
-func parseBoolHeader(value string) bool {
- switch strings.ToLower(strings.TrimSpace(value)) {
- case "1", "t", "true", "y", "yes", "on":
- return true
- default:
- return false
- }
-}
-
-func parseCommaSet(value string, normalize func(string) string) map[string]struct{} {
- if value == "" {
- return nil
- }
- result := map[string]struct{}{}
- for _, item := range strings.Split(value, ",") {
- item = strings.TrimSpace(item)
- if item == "" {
- continue
- }
- result[normalize(item)] = struct{}{}
- }
- if len(result) == 0 {
- return nil
- }
- return result
-}
-
-func mergeStringSets(dst map[string]struct{}, src map[string]struct{}) map[string]struct{} {
- if len(src) == 0 {
- return dst
- }
- if dst == nil {
- dst = map[string]struct{}{}
- }
- for item := range src {
- dst[item] = struct{}{}
- }
- return dst
-}
-
-func keepString(s string) string {
- return s
-}
diff --git a/server/router/mcp/mcp_test.go b/server/router/mcp/mcp_test.go
deleted file mode 100644
index 7e1e0dbfb..000000000
--- a/server/router/mcp/mcp_test.go
+++ /dev/null
@@ -1,605 +0,0 @@
-package mcp
-
-import (
- "bytes"
- "context"
- "encoding/json"
- "net/http"
- "net/http/httptest"
- "reflect"
- "testing"
- "time"
- "unsafe"
-
- "github.com/labstack/echo/v5"
- "github.com/lithammer/shortuuid/v4"
- "github.com/mark3labs/mcp-go/mcp"
- "github.com/stretchr/testify/require"
-
- "github.com/usememos/memos/internal/profile"
- storepb "github.com/usememos/memos/proto/gen/store"
- "github.com/usememos/memos/server/auth"
- apiv1service "github.com/usememos/memos/server/router/api/v1"
- "github.com/usememos/memos/store"
- teststore "github.com/usememos/memos/store/test"
-)
-
-type testMCPService struct {
- service *MCPService
- store *store.Store
-}
-
-func newTestMCPService(t *testing.T) *testMCPService {
- t.Helper()
-
- ctx := context.Background()
- stores := teststore.NewTestingStore(ctx, t)
- t.Cleanup(func() {
- require.NoError(t, stores.Close())
- })
-
- profile := &profile.Profile{
- Driver: "sqlite",
- InstanceURL: "https://notes.example.com",
- }
- apiV1Service := apiv1service.NewAPIV1Service("test-secret", profile, stores)
- svc := NewMCPService(profile, stores, "test-secret", apiV1Service)
- return &testMCPService{
- service: svc,
- store: stores,
- }
-}
-
-func (s *testMCPService) createUser(t *testing.T, username string) *store.User {
- t.Helper()
-
- user, err := s.store.CreateUser(context.Background(), &store.User{
- Username: username,
- Role: store.RoleUser,
- Email: username + "@example.com",
- })
- require.NoError(t, err)
- return user
-}
-
-func (s *testMCPService) createMemo(t *testing.T, creatorID int32, visibility store.Visibility, content string) *store.Memo {
- t.Helper()
-
- memo, err := s.store.CreateMemo(context.Background(), &store.Memo{
- UID: shortuuid.New(),
- CreatorID: creatorID,
- RowStatus: store.Normal,
- Visibility: visibility,
- Content: content,
- })
- require.NoError(t, err)
- return memo
-}
-
-func (s *testMCPService) archiveMemo(t *testing.T, memoID int32) {
- t.Helper()
-
- rowStatus := store.Archived
- require.NoError(t, s.store.UpdateMemo(context.Background(), &store.UpdateMemo{
- ID: memoID,
- RowStatus: &rowStatus,
- }))
-}
-
-func (s *testMCPService) createAttachment(t *testing.T, creatorID int32, memoID *int32) *store.Attachment {
- t.Helper()
-
- attachment, err := s.store.CreateAttachment(context.Background(), &store.Attachment{
- UID: shortuuid.New(),
- CreatorID: creatorID,
- Filename: "note.txt",
- Type: "text/plain",
- Size: 4,
- StorageType: storepb.AttachmentStorageType_ATTACHMENT_STORAGE_TYPE_UNSPECIFIED,
- Reference: "db://attachment/note.txt",
- MemoID: memoID,
- })
- require.NoError(t, err)
- return attachment
-}
-
-func withUser(ctx context.Context, userID int32) context.Context {
- return context.WithValue(ctx, auth.UserIDContextKey, userID)
-}
-
-func toolRequest(name string, arguments map[string]any) mcp.CallToolRequest {
- return mcp.CallToolRequest{
- Params: mcp.CallToolParams{
- Name: name,
- Arguments: arguments,
- },
- }
-}
-
-func firstText(t *testing.T, result *mcp.CallToolResult) string {
- t.Helper()
- require.NotEmpty(t, result.Content)
- text, ok := result.Content[0].(mcp.TextContent)
- require.True(t, ok)
- return text.Text
-}
-
-func initializeMCPHTTP(t *testing.T, e *echo.Echo, path string, headers map[string]string) string {
- t.Helper()
- payload := map[string]any{
- "jsonrpc": "2.0",
- "id": 1,
- "method": "initialize",
- "params": map[string]any{
- "protocolVersion": "2025-06-18",
- "capabilities": map[string]any{},
- "clientInfo": map[string]any{
- "name": "mcp-test",
- "version": "1.0.0",
- },
- },
- }
- resp := postMCPHTTP(t, e, path, "", headers, payload)
- require.Equal(t, http.StatusOK, resp.Code, resp.Body.String())
- sessionID := resp.Header().Get("Mcp-Session-Id")
- require.NotEmpty(t, sessionID)
- return sessionID
-}
-
-func callMCPHTTP(t *testing.T, e *echo.Echo, path string, sessionID string, headers map[string]string, method string, params any) map[string]any {
- t.Helper()
- payload := map[string]any{
- "jsonrpc": "2.0",
- "id": 2,
- "method": method,
- }
- if params != nil {
- payload["params"] = params
- }
- resp := postMCPHTTP(t, e, path, sessionID, headers, payload)
- require.Equal(t, http.StatusOK, resp.Code, resp.Body.String())
- var decoded map[string]any
- require.NoError(t, json.Unmarshal(resp.Body.Bytes(), &decoded))
- return decoded
-}
-
-func postMCPHTTP(t *testing.T, e *echo.Echo, path string, sessionID string, headers map[string]string, payload map[string]any) *httptest.ResponseRecorder {
- t.Helper()
- body, err := json.Marshal(payload)
- require.NoError(t, err)
- req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(body))
- req.Header.Set("Content-Type", "application/json")
- if sessionID != "" {
- req.Header.Set("Mcp-Session-Id", sessionID)
- }
- for key, value := range headers {
- req.Header.Set(key, value)
- }
- resp := httptest.NewRecorder()
- e.ServeHTTP(resp, req)
- return resp
-}
-
-func toolNamesFromListResponse(t *testing.T, response map[string]any) map[string]struct{} {
- t.Helper()
- result, ok := response["result"].(map[string]any)
- require.True(t, ok, "missing result: %#v", response)
- rawTools, ok := result["tools"].([]any)
- require.True(t, ok, "missing tools: %#v", result)
- names := map[string]struct{}{}
- for _, rawTool := range rawTools {
- tool, ok := rawTool.(map[string]any)
- require.True(t, ok)
- name, ok := tool["name"].(string)
- require.True(t, ok)
- names[name] = struct{}{}
- }
- return names
-}
-
-func requireToolPresent(t *testing.T, names map[string]struct{}, name string) {
- t.Helper()
- _, ok := names[name]
- require.True(t, ok, "expected tool %q to be present in %#v", name, names)
-}
-
-func requireToolAbsent(t *testing.T, names map[string]struct{}, name string) {
- t.Helper()
- _, ok := names[name]
- require.False(t, ok, "expected tool %q to be absent in %#v", name, names)
-}
-
-func nextSSEEvent(t *testing.T, client *apiv1service.SSEClient) *apiv1service.SSEEvent {
- t.Helper()
- events := sseClientEvents(t, client)
- var data []byte
- select {
- case eventData, ok := <-events:
- require.True(t, ok, "SSE client channel closed")
- data = eventData
- case <-time.After(time.Second):
- t.Fatal("timed out waiting for SSE event")
- }
- var event apiv1service.SSEEvent
- require.NoError(t, json.Unmarshal(data, &event))
- return &event
-}
-
-func requireNoSSEEvent(t *testing.T, client *apiv1service.SSEClient) {
- t.Helper()
- select {
- case eventData, ok := <-sseClientEvents(t, client):
- require.True(t, ok, "SSE client channel closed")
- t.Fatalf("unexpected SSE event received: %s", string(eventData))
- case <-time.After(150 * time.Millisecond):
- }
-}
-
-func sseClientEvents(t *testing.T, client *apiv1service.SSEClient) <-chan []byte {
- t.Helper()
- field := reflect.ValueOf(client).Elem().FieldByName("events")
- events, ok := reflect.NewAt(field.Type(), unsafe.Pointer(field.UnsafeAddr())).Elem().Interface().(chan []byte)
- require.True(t, ok)
- return events
-}
-
-func TestHandleGetMemoAndReadResourceDenyArchivedMemoToNonCreator(t *testing.T) {
- ts := newTestMCPService(t)
- owner := ts.createUser(t, "owner")
- other := ts.createUser(t, "other")
-
- memo := ts.createMemo(t, owner.ID, store.Public, "archived")
- ts.archiveMemo(t, memo.ID)
-
- ctx := withUser(context.Background(), other.ID)
- result, err := ts.service.handleGetMemo(ctx, toolRequest("get_memo", map[string]any{
- "name": "memos/" + memo.UID,
- }))
- require.NoError(t, err)
- require.True(t, result.IsError)
- require.Contains(t, firstText(t, result), "permission denied")
-
- _, err = ts.service.handleReadMemoResource(ctx, mcp.ReadResourceRequest{
- Params: mcp.ReadResourceParams{
- URI: "memo://memos/" + memo.UID,
- },
- })
- require.ErrorContains(t, err, "permission denied")
-}
-
-func TestHandleListMemosArchivedOnlyReturnsCreatorMemos(t *testing.T) {
- ts := newTestMCPService(t)
- owner := ts.createUser(t, "owner")
- other := ts.createUser(t, "other")
-
- ownerMemo := ts.createMemo(t, owner.ID, store.Public, "owner archived")
- ts.archiveMemo(t, ownerMemo.ID)
- otherMemo := ts.createMemo(t, other.ID, store.Public, "other archived")
- ts.archiveMemo(t, otherMemo.ID)
-
- result, err := ts.service.handleListMemos(withUser(context.Background(), owner.ID), toolRequest("list_memos", map[string]any{
- "state": "ARCHIVED",
- }))
- require.NoError(t, err)
- require.False(t, result.IsError)
-
- var payload struct {
- Memos []memoJSON `json:"memos"`
- }
- require.NoError(t, json.Unmarshal([]byte(firstText(t, result)), &payload))
- require.Len(t, payload.Memos, 1)
- require.Equal(t, "memos/"+ownerMemo.UID, payload.Memos[0].Name)
-
- anonResult, err := ts.service.handleListMemos(context.Background(), toolRequest("list_memos", map[string]any{
- "state": "ARCHIVED",
- }))
- require.NoError(t, err)
- require.NoError(t, json.Unmarshal([]byte(firstText(t, anonResult)), &payload))
- require.Empty(t, payload.Memos)
-}
-
-func TestHandleListMemoRelationsFiltersUnreadableTargets(t *testing.T) {
- ts := newTestMCPService(t)
- owner := ts.createUser(t, "owner")
- privateUser := ts.createUser(t, "private-user")
- publicUser := ts.createUser(t, "public-user")
-
- source := ts.createMemo(t, owner.ID, store.Public, "source")
- privateTarget := ts.createMemo(t, privateUser.ID, store.Private, "private")
- publicTarget := ts.createMemo(t, publicUser.ID, store.Public, "public")
-
- _, err := ts.store.UpsertMemoRelation(context.Background(), &store.MemoRelation{
- MemoID: source.ID,
- RelatedMemoID: privateTarget.ID,
- Type: store.MemoRelationReference,
- })
- require.NoError(t, err)
- _, err = ts.store.UpsertMemoRelation(context.Background(), &store.MemoRelation{
- MemoID: source.ID,
- RelatedMemoID: publicTarget.ID,
- Type: store.MemoRelationReference,
- })
- require.NoError(t, err)
-
- result, err := ts.service.handleListMemoRelations(context.Background(), toolRequest("list_memo_relations", map[string]any{
- "name": "memos/" + source.UID,
- }))
- require.NoError(t, err)
- require.False(t, result.IsError)
-
- var relations []relationJSON
- require.NoError(t, json.Unmarshal([]byte(firstText(t, result)), &relations))
- require.Len(t, relations, 1)
- require.Equal(t, "memos/"+publicTarget.UID, relations[0].RelatedMemo)
-
- denied, err := ts.service.handleListMemoRelations(context.Background(), toolRequest("list_memo_relations", map[string]any{
- "name": "memos/" + privateTarget.UID,
- }))
- require.NoError(t, err)
- require.True(t, denied.IsError)
- require.Contains(t, firstText(t, denied), "permission denied")
-}
-
-func TestHandleLinkAttachmentToMemoRequiresMemoOwnership(t *testing.T) {
- ts := newTestMCPService(t)
- attachmentOwner := ts.createUser(t, "attachment-owner")
- memoOwner := ts.createUser(t, "memo-owner")
-
- attachment := ts.createAttachment(t, attachmentOwner.ID, nil)
- memo := ts.createMemo(t, memoOwner.ID, store.Public, "target")
-
- result, err := ts.service.handleLinkAttachmentToMemo(withUser(context.Background(), attachmentOwner.ID), toolRequest("link_attachment_to_memo", map[string]any{
- "name": "attachments/" + attachment.UID,
- "memo": "memos/" + memo.UID,
- }))
- require.NoError(t, err)
- require.True(t, result.IsError)
- require.Contains(t, firstText(t, result), "permission denied")
-}
-
-func TestHandleGetAttachmentDeniesArchivedLinkedMemoToNonCreator(t *testing.T) {
- ts := newTestMCPService(t)
- owner := ts.createUser(t, "owner")
- other := ts.createUser(t, "other")
-
- memo := ts.createMemo(t, owner.ID, store.Public, "memo")
- ts.archiveMemo(t, memo.ID)
- attachment := ts.createAttachment(t, owner.ID, &memo.ID)
-
- result, err := ts.service.handleGetAttachment(withUser(context.Background(), other.ID), toolRequest("get_attachment", map[string]any{
- "name": "attachments/" + attachment.UID,
- }))
- require.NoError(t, err)
- require.True(t, result.IsError)
- require.Contains(t, firstText(t, result), "permission denied")
-}
-
-func TestIsAllowedOrigin(t *testing.T) {
- ts := newTestMCPService(t)
-
- t.Run("allow missing origin", func(t *testing.T) {
- req := httptest.NewRequest("POST", "http://localhost:5230/mcp", nil)
- require.True(t, ts.service.isAllowedOrigin(req))
- })
-
- t.Run("allow same origin as request host", func(t *testing.T) {
- req := httptest.NewRequest("POST", "http://localhost:5230/mcp", nil)
- req.Header.Set("Origin", "http://localhost:5230")
- require.True(t, ts.service.isAllowedOrigin(req))
- })
-
- t.Run("allow configured instance origin", func(t *testing.T) {
- req := httptest.NewRequest("POST", "http://127.0.0.1:5230/mcp", nil)
- req.Host = "127.0.0.1:5230"
- req.Header.Set("Origin", "https://notes.example.com")
- require.True(t, ts.service.isAllowedOrigin(req))
- })
-
- t.Run("reject cross origin", func(t *testing.T) {
- req := httptest.NewRequest("POST", "http://localhost:5230/mcp", nil)
- req.Header.Set("Origin", "https://evil.example.com")
- require.False(t, ts.service.isAllowedOrigin(req))
- })
-}
-
-func TestMCPToolFilteringRoutesAndHeaders(t *testing.T) {
- ts := newTestMCPService(t)
- e := echo.New()
- ts.service.RegisterRoutes(e)
-
- t.Run("default endpoint lists all tools", func(t *testing.T) {
- sessionID := initializeMCPHTTP(t, e, "/mcp", nil)
- response := callMCPHTTP(t, e, "/mcp", sessionID, nil, "tools/list", map[string]any{})
- names := toolNamesFromListResponse(t, response)
- require.Len(t, names, len(allMCPToolNames))
- requireToolPresent(t, names, "create_memo")
- requireToolPresent(t, names, "list_tags")
- requireToolPresent(t, names, "upsert_reaction")
- })
-
- t.Run("readonly header hides and blocks mutation tools", func(t *testing.T) {
- headers := map[string]string{headerMCPReadonly: "true"}
- sessionID := initializeMCPHTTP(t, e, "/mcp", nil)
- response := callMCPHTTP(t, e, "/mcp", sessionID, headers, "tools/list", map[string]any{})
- names := toolNamesFromListResponse(t, response)
- requireToolPresent(t, names, "list_memos")
- requireToolPresent(t, names, "list_tags")
- requireToolAbsent(t, names, "create_memo")
- requireToolAbsent(t, names, "delete_memo")
-
- callResponse := callMCPHTTP(t, e, "/mcp", sessionID, headers, "tools/call", map[string]any{
- "name": "create_memo",
- "arguments": map[string]any{"content": "blocked"},
- })
- result, ok := callResponse["result"].(map[string]any)
- require.True(t, ok)
- require.Equal(t, true, result["isError"])
- rawContent, ok := result["content"].([]any)
- require.True(t, ok)
- content, ok := rawContent[0].(map[string]any)
- require.True(t, ok)
- require.Contains(t, content["text"], "not enabled")
- })
-
- t.Run("readonly alias applies path config", func(t *testing.T) {
- sessionID := initializeMCPHTTP(t, e, "/mcp/readonly", nil)
- response := callMCPHTTP(t, e, "/mcp/readonly", sessionID, nil, "tools/list", map[string]any{})
- names := toolNamesFromListResponse(t, response)
- requireToolPresent(t, names, "get_memo")
- requireToolAbsent(t, names, "create_memo")
- requireToolAbsent(t, names, "upsert_reaction")
- })
-
- t.Run("toolsets include and exclude compose", func(t *testing.T) {
- headers := map[string]string{
- headerMCPToolsets: "memos",
- headerMCPTools: "list_tags",
- headerMCPExcludeTools: "get_memo",
- }
- sessionID := initializeMCPHTTP(t, e, "/mcp", nil)
- response := callMCPHTTP(t, e, "/mcp", sessionID, headers, "tools/list", map[string]any{})
- names := toolNamesFromListResponse(t, response)
- requireToolPresent(t, names, "list_memos")
- requireToolPresent(t, names, "list_tags")
- requireToolAbsent(t, names, "get_memo")
- requireToolAbsent(t, names, "list_attachments")
- })
-
- t.Run("path toolsets and readonly compose", func(t *testing.T) {
- sessionID := initializeMCPHTTP(t, e, "/mcp/x/memos,tags/readonly", nil)
- response := callMCPHTTP(t, e, "/mcp/x/memos,tags/readonly", sessionID, nil, "tools/list", map[string]any{})
- names := toolNamesFromListResponse(t, response)
- requireToolPresent(t, names, "list_memos")
- requireToolPresent(t, names, "list_tags")
- requireToolAbsent(t, names, "create_memo")
- requireToolAbsent(t, names, "list_attachments")
- })
-
- t.Run("unknown toolset returns empty tool list", func(t *testing.T) {
- sessionID := initializeMCPHTTP(t, e, "/mcp/x/notreal", nil)
- response := callMCPHTTP(t, e, "/mcp/x/notreal", sessionID, nil, "tools/list", map[string]any{})
- names := toolNamesFromListResponse(t, response)
- require.Empty(t, names)
- })
-}
-
-func TestMCPMemoAndReactionMutationsEmitSSEEvents(t *testing.T) {
- ts := newTestMCPService(t)
- user := ts.createUser(t, "author")
- ctx := withUser(context.Background(), user.ID)
- client := ts.service.apiV1Service.SSEHub.Subscribe(user.ID, store.RoleUser)
- defer ts.service.apiV1Service.SSEHub.Unsubscribe(client)
-
- createResult, err := ts.service.handleCreateMemo(ctx, toolRequest("create_memo", map[string]any{
- "content": "created from MCP",
- "visibility": "PRIVATE",
- }))
- require.NoError(t, err)
- require.False(t, createResult.IsError)
- createEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventMemoCreated, createEvent.Type)
-
- var created memoJSON
- require.NoError(t, json.Unmarshal([]byte(firstText(t, createResult)), &created))
-
- updateResult, err := ts.service.handleUpdateMemo(ctx, toolRequest("update_memo", map[string]any{
- "name": created.Name,
- "content": "updated from MCP",
- }))
- require.NoError(t, err)
- require.False(t, updateResult.IsError)
- updateEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventMemoUpdated, updateEvent.Type)
-
- commentResult, err := ts.service.handleCreateMemoComment(ctx, toolRequest("create_memo_comment", map[string]any{
- "name": created.Name,
- "content": "comment from MCP",
- }))
- require.NoError(t, err)
- require.False(t, commentResult.IsError)
- commentEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventMemoCommentCreated, commentEvent.Type)
- require.Equal(t, created.Name, commentEvent.Name)
-
- upsertReactionResult, err := ts.service.handleUpsertReaction(ctx, toolRequest("upsert_reaction", map[string]any{
- "name": created.Name,
- "reaction_type": "👍",
- }))
- require.NoError(t, err)
- require.False(t, upsertReactionResult.IsError)
- reactionEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventReactionUpserted, reactionEvent.Type)
-
- var reaction reactionJSON
- require.NoError(t, json.Unmarshal([]byte(firstText(t, upsertReactionResult)), &reaction))
- deleteReactionResult, err := ts.service.handleDeleteReaction(ctx, toolRequest("delete_reaction", map[string]any{
- "id": float64(reaction.ID),
- }))
- require.NoError(t, err)
- require.False(t, deleteReactionResult.IsError)
- deleteReactionEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventReactionDeleted, deleteReactionEvent.Type)
-
- deleteResult, err := ts.service.handleDeleteMemo(ctx, toolRequest("delete_memo", map[string]any{
- "name": created.Name,
- }))
- require.NoError(t, err)
- require.False(t, deleteResult.IsError)
- deleteEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventMemoDeleted, deleteEvent.Type)
-}
-
-func TestMCPRelationAndAttachmentMutationsEmitMemoUpdated(t *testing.T) {
- ts := newTestMCPService(t)
- user := ts.createUser(t, "owner")
- ctx := withUser(context.Background(), user.ID)
- source := ts.createMemo(t, user.ID, store.Private, "source")
- target := ts.createMemo(t, user.ID, store.Private, "target")
- attachment := ts.createAttachment(t, user.ID, nil)
- client := ts.service.apiV1Service.SSEHub.Subscribe(user.ID, store.RoleUser)
- defer ts.service.apiV1Service.SSEHub.Unsubscribe(client)
-
- relationResult, err := ts.service.handleCreateMemoRelation(ctx, toolRequest("create_memo_relation", map[string]any{
- "name": "memos/" + source.UID,
- "related_memo": "memos/" + target.UID,
- }))
- require.NoError(t, err)
- require.False(t, relationResult.IsError)
- relationEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventMemoUpdated, relationEvent.Type)
- require.Equal(t, "memos/"+source.UID, relationEvent.Name)
-
- duplicateRelationResult, err := ts.service.handleCreateMemoRelation(ctx, toolRequest("create_memo_relation", map[string]any{
- "name": "memos/" + source.UID,
- "related_memo": "memos/" + target.UID,
- }))
- require.NoError(t, err)
- require.False(t, duplicateRelationResult.IsError)
- requireNoSSEEvent(t, client)
-
- selfRelationResult, err := ts.service.handleCreateMemoRelation(ctx, toolRequest("create_memo_relation", map[string]any{
- "name": "memos/" + source.UID,
- "related_memo": "memos/" + source.UID,
- }))
- require.NoError(t, err)
- require.True(t, selfRelationResult.IsError)
- require.Contains(t, firstText(t, selfRelationResult), "itself")
-
- linkResult, err := ts.service.handleLinkAttachmentToMemo(ctx, toolRequest("link_attachment_to_memo", map[string]any{
- "name": "attachments/" + attachment.UID,
- "memo": "memos/" + source.UID,
- }))
- require.NoError(t, err)
- require.False(t, linkResult.IsError)
- attachmentEvent := nextSSEEvent(t, client)
- require.Equal(t, apiv1service.SSEEventMemoUpdated, attachmentEvent.Type)
- require.Equal(t, "memos/"+source.UID, attachmentEvent.Name)
-
- relinkResult, err := ts.service.handleLinkAttachmentToMemo(ctx, toolRequest("link_attachment_to_memo", map[string]any{
- "name": "attachments/" + attachment.UID,
- "memo": "memos/" + source.UID,
- }))
- require.NoError(t, err)
- require.False(t, relinkResult.IsError)
- requireNoSSEEvent(t, client)
-}
diff --git a/server/router/mcp/prompts.go b/server/router/mcp/prompts.go
deleted file mode 100644
index 353c6b773..000000000
--- a/server/router/mcp/prompts.go
+++ /dev/null
@@ -1,192 +0,0 @@
-package mcp
-
-import (
- "context"
- "errors"
- "fmt"
- "strings"
-
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
-)
-
-func (s *MCPService) registerPrompts(mcpSrv *mcpserver.MCPServer) {
- // capture — turns free-form user input into a structured create_memo call.
- mcpSrv.AddPrompt(
- mcp.NewPrompt("capture",
- mcp.WithPromptDescription("Capture a thought, idea, or note as a new memo. "+
- "Use this prompt when the user wants to quickly save something. "+
- "The assistant will call create_memo with the provided content."),
- mcp.WithArgument("content",
- mcp.ArgumentDescription("The text to save as a memo"),
- mcp.RequiredArgument(),
- ),
- mcp.WithArgument("tags",
- mcp.ArgumentDescription("Comma-separated tags to apply, e.g. \"work,project\""),
- ),
- mcp.WithArgument("visibility",
- mcp.ArgumentDescription("Memo visibility: PRIVATE (default), PROTECTED, or PUBLIC"),
- ),
- ),
- s.handleCapturePrompt,
- )
-
- // review — surfaces existing memos on a topic for summarisation.
- mcpSrv.AddPrompt(
- mcp.NewPrompt("review",
- mcp.WithPromptDescription("Search and review memos on a given topic. "+
- "The assistant will call search_memos and summarise the results, "+
- "including memo resource URIs for easy reference."),
- mcp.WithArgument("topic",
- mcp.ArgumentDescription("Topic or keyword to search for"),
- mcp.RequiredArgument(),
- ),
- ),
- s.handleReviewPrompt,
- )
-
- // daily_digest — summarise recent activity.
- mcpSrv.AddPrompt(
- mcp.NewPrompt("daily_digest",
- mcp.WithPromptDescription("Get a summary of recent memo activity. "+
- "The assistant will list recent memos, group them by tags, and highlight "+
- "any incomplete tasks or pinned items."),
- mcp.WithArgument("days",
- mcp.ArgumentDescription("Number of days to look back (default: 1)"),
- ),
- ),
- s.handleDailyDigestPrompt,
- )
-
- // organize — suggest tags and relations for untagged memos.
- mcpSrv.AddPrompt(
- mcp.NewPrompt("organize",
- mcp.WithPromptDescription("Analyze untagged or loosely organized memos and suggest "+
- "tags, relations, and groupings to improve discoverability."),
- mcp.WithArgument("scope",
- mcp.ArgumentDescription("Scope of analysis: \"untagged\" (default) for memos without tags, \"all\" for all recent memos"),
- ),
- ),
- s.handleOrganizePrompt,
- )
-}
-
-func (*MCPService) handleCapturePrompt(_ context.Context, req mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
- content := req.Params.Arguments["content"]
- if content == "" {
- return nil, errors.New("content argument is required")
- }
-
- tags := req.Params.Arguments["tags"]
- visibility := req.Params.Arguments["visibility"]
- if visibility == "" {
- visibility = "PRIVATE"
- }
-
- var sb strings.Builder
- sb.WriteString("Save the following as a new memo using the create_memo tool.\n\n")
- fmt.Fprintf(&sb, "Visibility: %s\n\n", visibility)
- sb.WriteString("Content:\n")
- sb.WriteString(content)
- if tags != "" {
- fmt.Fprintf(&sb, "\n\nAppend these tags inline using #tag syntax: %s", tags)
- }
- sb.WriteString("\n\nAfter creating the memo, confirm by showing the memo resource name (e.g. memo://memos/<uid>) so it can be referenced later.")
-
- return &mcp.GetPromptResult{
- Description: "Capture a memo",
- Messages: []mcp.PromptMessage{
- mcp.NewPromptMessage(mcp.RoleUser, mcp.NewTextContent(sb.String())),
- },
- }, nil
-}
-
-func (*MCPService) handleReviewPrompt(_ context.Context, req mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
- topic := req.Params.Arguments["topic"]
- if topic == "" {
- return nil, errors.New("topic argument is required")
- }
-
- instruction := fmt.Sprintf(
- `Use the search_memos tool to find memos about %q, then:
-
-1. Group results by theme or tag
-2. For each memo, include its resource reference (memo://memos/<uid>) so the user can access it directly
-3. Provide a concise summary of what has been written on this topic
-4. Highlight any memos with incomplete tasks (has_incomplete_tasks)
-5. Note the most recent update times to show currency of the information`,
- topic,
- )
-
- return &mcp.GetPromptResult{
- Description: fmt.Sprintf("Review memos about %q", topic),
- Messages: []mcp.PromptMessage{
- mcp.NewPromptMessage(mcp.RoleUser, mcp.NewTextContent(instruction)),
- },
- }, nil
-}
-
-func (*MCPService) handleDailyDigestPrompt(_ context.Context, req mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
- days := req.Params.Arguments["days"]
- if days == "" {
- days = "1"
- }
-
- instruction := fmt.Sprintf(
- `Generate a daily digest of memo activity from the last %s day(s):
-
-1. Use list_memos to fetch recent memos (order by update time, check multiple pages if needed)
-2. Use list_tags to get the current tag landscape
-3. Group memos by tags and summarize each group
-4. Highlight:
- - Pinned memos (important items)
- - Memos with incomplete tasks (action items)
- - New memos created vs. memos updated
-5. Include memo resource references (memo://memos/<uid>) for each item
-6. End with a brief "action items" section listing incomplete tasks across all memos`, days,
- )
-
- return &mcp.GetPromptResult{
- Description: "Daily memo digest",
- Messages: []mcp.PromptMessage{
- mcp.NewPromptMessage(mcp.RoleUser, mcp.NewTextContent(instruction)),
- },
- }, nil
-}
-
-func (*MCPService) handleOrganizePrompt(_ context.Context, req mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
- scope := req.Params.Arguments["scope"]
- if scope == "" {
- scope = "untagged"
- }
-
- var filter string
- if scope == "untagged" {
- filter = `Focus on memos that have no tags. Use list_memos and identify those with empty tag arrays.`
- } else {
- filter = `Analyze all recent memos regardless of tagging status.`
- }
-
- instruction := fmt.Sprintf(
- `Analyze memos and suggest organizational improvements:
-
-1. %s
-2. Use list_tags to understand the existing tag taxonomy
-3. For each unorganized memo, suggest:
- - Appropriate tags from the existing taxonomy, or new tags if needed
- - Potential relations (references) to other memos on similar topics
-4. Present suggestions as a structured list:
- - Memo: memo://memos/<uid> (first line of content as preview)
- - Suggested tags: #tag1, #tag2
- - Related to: memo://memos/<other-uid> (brief reason)
-5. After presenting suggestions, ask the user which changes to apply
-6. Apply approved changes using update_memo (for tags in content) and create_memo_relation (for references)`, filter,
- )
-
- return &mcp.GetPromptResult{
- Description: fmt.Sprintf("Organize memos (scope: %s)", scope),
- Messages: []mcp.PromptMessage{
- mcp.NewPromptMessage(mcp.RoleUser, mcp.NewTextContent(instruction)),
- },
- }, nil
-}
diff --git a/server/router/mcp/resources_memo.go b/server/router/mcp/resources_memo.go
deleted file mode 100644
index 1577feb04..000000000
--- a/server/router/mcp/resources_memo.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package mcp
-
-import (
- "context"
- "fmt"
- "strings"
-
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
- "github.com/pkg/errors"
-
- "github.com/usememos/memos/server/auth"
- "github.com/usememos/memos/store"
-)
-
-// Memo resource URI scheme: memo://memos/{uid}
-// Clients can read any memo they have access to by URI without calling a tool.
-
-func (s *MCPService) registerMemoResources(mcpSrv *mcpserver.MCPServer) {
- mcpSrv.AddResourceTemplate(
- mcp.NewResourceTemplate(
- "memo://memos/{uid}",
- "Memo",
- mcp.WithTemplateDescription("A single Memos note identified by its UID. Returns the memo content as Markdown with a YAML frontmatter header containing metadata."),
- mcp.WithTemplateMIMEType("text/markdown"),
- ),
- s.handleReadMemoResource,
- )
-}
-
-func (s *MCPService) handleReadMemoResource(ctx context.Context, req mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
- userID := auth.GetUserID(ctx)
-
- // URI format: memo://memos/{uid}
- uid := strings.TrimPrefix(req.Params.URI, "memo://memos/")
- if uid == req.Params.URI || uid == "" {
- return nil, errors.Errorf("invalid memo URI %q: expected memo://memos/<uid>", req.Params.URI)
- }
-
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return nil, errors.Wrap(err, "failed to get memo")
- }
- if memo == nil {
- return nil, errors.Errorf("memo not found: %s", uid)
- }
- if err := checkMemoAccess(memo, userID); err != nil {
- return nil, err
- }
-
- j, err := storeMemoToJSONWithStore(ctx, s.store, memo)
- if err != nil {
- return nil, errors.Wrap(err, "failed to resolve memo creator")
- }
- text := formatMemoMarkdown(j)
-
- return []mcp.ResourceContents{
- mcp.TextResourceContents{
- URI: req.Params.URI,
- MIMEType: "text/markdown",
- Text: text,
- },
- }, nil
-}
-
-// formatMemoMarkdown renders a memo as Markdown with a YAML frontmatter header.
-func formatMemoMarkdown(j memoJSON) string {
- var sb strings.Builder
-
- sb.WriteString("---\n")
- fmt.Fprintf(&sb, "name: %s\n", j.Name)
- fmt.Fprintf(&sb, "creator: %s\n", j.Creator)
- fmt.Fprintf(&sb, "visibility: %s\n", j.Visibility)
- fmt.Fprintf(&sb, "state: %s\n", j.State)
- fmt.Fprintf(&sb, "pinned: %v\n", j.Pinned)
- if len(j.Tags) > 0 {
- fmt.Fprintf(&sb, "tags: [%s]\n", strings.Join(j.Tags, ", "))
- }
- fmt.Fprintf(&sb, "create_time: %d\n", j.CreateTime)
- fmt.Fprintf(&sb, "update_time: %d\n", j.UpdateTime)
- if j.Parent != "" {
- fmt.Fprintf(&sb, "parent: %s\n", j.Parent)
- }
- sb.WriteString("---\n\n")
- sb.WriteString(j.Content)
-
- return sb.String()
-}
diff --git a/server/router/mcp/tool_metadata.go b/server/router/mcp/tool_metadata.go
deleted file mode 100644
index 61c4284af..000000000
--- a/server/router/mcp/tool_metadata.go
+++ /dev/null
@@ -1,102 +0,0 @@
-package mcp
-
-import "github.com/mark3labs/mcp-go/mcp"
-
-var mcpToolsByToolset = map[string]map[string]struct{}{
- "memos": stringSet(
- "list_memos",
- "get_memo",
- "create_memo",
- "update_memo",
- "delete_memo",
- "search_memos",
- "list_memo_comments",
- "create_memo_comment",
- ),
- "tags": stringSet(
- "list_tags",
- ),
- "attachments": stringSet(
- "list_attachments",
- "get_attachment",
- "delete_attachment",
- "link_attachment_to_memo",
- ),
- "relations": stringSet(
- "list_memo_relations",
- "create_memo_relation",
- "delete_memo_relation",
- ),
- "reactions": stringSet(
- "list_reactions",
- "upsert_reaction",
- "delete_reaction",
- ),
-}
-
-var allMCPToolNames = func() map[string]struct{} {
- names := map[string]struct{}{}
- for _, tools := range mcpToolsByToolset {
- for name := range tools {
- names[name] = struct{}{}
- }
- }
- return names
-}()
-
-var mcpMutationTools = stringSet(
- "create_memo",
- "update_memo",
- "delete_memo",
- "create_memo_comment",
- "delete_attachment",
- "link_attachment_to_memo",
- "create_memo_relation",
- "delete_memo_relation",
- "upsert_reaction",
- "delete_reaction",
-)
-
-type deletedJSON struct {
- Deleted bool `json:"deleted"`
-}
-
-func stringSet(values ...string) map[string]struct{} {
- result := make(map[string]struct{}, len(values))
- for _, value := range values {
- result[value] = struct{}{}
- }
- return result
-}
-
-func readOnlyToolOptions(title string, description string, opts ...mcp.ToolOption) []mcp.ToolOption {
- return annotatedToolOptions(title, description, true, false, true, false, opts...)
-}
-
-func createToolOptions(title string, description string, idempotent bool, opts ...mcp.ToolOption) []mcp.ToolOption {
- return annotatedToolOptions(title, description, false, false, idempotent, false, opts...)
-}
-
-func updateToolOptions(title string, description string, opts ...mcp.ToolOption) []mcp.ToolOption {
- return annotatedToolOptions(title, description, false, true, false, false, opts...)
-}
-
-func annotatedToolOptions(title string, description string, readOnly bool, destructive bool, idempotent bool, openWorld bool, opts ...mcp.ToolOption) []mcp.ToolOption {
- base := []mcp.ToolOption{
- mcp.WithTitleAnnotation(title),
- mcp.WithDescription(description),
- mcp.WithReadOnlyHintAnnotation(readOnly),
- mcp.WithDestructiveHintAnnotation(destructive),
- mcp.WithIdempotentHintAnnotation(idempotent),
- mcp.WithOpenWorldHintAnnotation(openWorld),
- }
- return append(base, opts...)
-}
-
-func newToolResultJSON(v any) (*mcp.CallToolResult, error) {
- return mcp.NewToolResultJSON(v)
-}
-
-func newDeletedToolResult() (*mcp.CallToolResult, error) {
- return newToolResultJSON(deletedJSON{Deleted: true})
-}
diff --git a/server/router/mcp/tools_attachment.go b/server/router/mcp/tools_attachment.go
deleted file mode 100644
index 86b14745e..000000000
--- a/server/router/mcp/tools_attachment.go
+++ /dev/null
@@ -1,327 +0,0 @@
-package mcp
-
-import (
- "context"
- "fmt"
- "strings"
-
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
- "github.com/pkg/errors"
-
- v1pb "github.com/usememos/memos/proto/gen/api/v1"
- storepb "github.com/usememos/memos/proto/gen/store"
- "github.com/usememos/memos/server/auth"
- "github.com/usememos/memos/store"
-)
-
-type attachmentJSON struct {
- Name string `json:"name"`
- Creator string `json:"creator"`
- CreateTime int64 `json:"create_time"`
- Filename string `json:"filename"`
- Type string `json:"type"`
- Size int64 `json:"size"`
- StorageType string `json:"storage_type"`
- ExternalLink string `json:"external_link,omitempty"`
- Memo string `json:"memo,omitempty"`
-}
-
-type attachmentListJSON struct {
- Attachments []attachmentJSON `json:"attachments"`
- HasMore bool `json:"has_more"`
-}
-
-func storeAttachmentToJSON(ctx context.Context, stores *store.Store, a *store.Attachment) (attachmentJSON, error) {
- creator, err := lookupUsername(ctx, stores, a.CreatorID)
- if err != nil {
- return attachmentJSON{}, errors.Wrap(err, "lookup attachment creator username")
- }
- j := attachmentJSON{
- Name: "attachments/" + a.UID,
- Creator: creator,
- CreateTime: a.CreatedTs,
- Filename: a.Filename,
- Type: a.Type,
- Size: a.Size,
- }
- switch a.StorageType {
- case storepb.AttachmentStorageType_LOCAL:
- j.StorageType = "LOCAL"
- case storepb.AttachmentStorageType_S3:
- j.StorageType = "S3"
- j.ExternalLink = a.Reference
- case storepb.AttachmentStorageType_EXTERNAL:
- j.StorageType = "EXTERNAL"
- j.ExternalLink = a.Reference
- default:
- j.StorageType = "DATABASE"
- }
- if a.MemoUID != nil && *a.MemoUID != "" {
- j.Memo = "memos/" + *a.MemoUID
- }
- return j, nil
-}
-
-func storeAttachmentToJSONWithUsernames(a *store.Attachment, usernamesByID map[int32]string) (attachmentJSON, error) {
- creator, err := lookupUsernameFromCache(usernamesByID, a.CreatorID)
- if err != nil {
- return attachmentJSON{}, errors.Wrap(err, "lookup attachment creator username from cache")
- }
- j := attachmentJSON{
- Name: "attachments/" + a.UID,
- Creator: creator,
- CreateTime: a.CreatedTs,
- Filename: a.Filename,
- Type: a.Type,
- Size: a.Size,
- }
- switch a.StorageType {
- case storepb.AttachmentStorageType_LOCAL:
- j.StorageType = "LOCAL"
- case storepb.AttachmentStorageType_S3:
- j.StorageType = "S3"
- j.ExternalLink = a.Reference
- case storepb.AttachmentStorageType_EXTERNAL:
- j.StorageType = "EXTERNAL"
- j.ExternalLink = a.Reference
- default:
- j.StorageType = "DATABASE"
- }
- if a.MemoUID != nil && *a.MemoUID != "" {
- j.Memo = "memos/" + *a.MemoUID
- }
- return j, nil
-}
-
-func parseAttachmentUID(name string) (string, error) {
- uid, ok := strings.CutPrefix(name, "attachments/")
- if !ok || uid == "" {
- return "", errors.Errorf(`attachment name must be "attachments/<uid>", got %q`, name)
- }
- return uid, nil
-}
-
-func (s *MCPService) registerAttachmentTools(mcpSrv *mcpserver.MCPServer) {
- mcpSrv.AddTool(mcp.NewTool("list_attachments",
- readOnlyToolOptions("List attachments", "List attachments owned by the authenticated user. Supports pagination and optional filtering by linked memo.",
- mcp.WithNumber("page_size", mcp.Description("Maximum attachments to return (1–100, default 20)")),
- mcp.WithNumber("page", mcp.Description("Zero-based page index (default 0)")),
- mcp.WithString("memo", mcp.Description(`Filter by linked memo resource name, e.g. "memos/abc123"`)),
- mcp.WithOutputSchema[attachmentListJSON](),
- )...,
- ), s.handleListAttachments)
-
- mcpSrv.AddTool(mcp.NewTool("get_attachment",
- readOnlyToolOptions("Get attachment", "Get a single attachment's metadata by resource name. Requires authentication.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Attachment resource name, e.g. "attachments/abc123"`)),
- mcp.WithOutputSchema[attachmentJSON](),
- )...,
- ), s.handleGetAttachment)
-
- mcpSrv.AddTool(mcp.NewTool("delete_attachment",
- updateToolOptions("Delete attachment", "Permanently delete an attachment and its stored file. Requires authentication and ownership.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Attachment resource name, e.g. "attachments/abc123"`)),
- mcp.WithOutputSchema[deletedJSON](),
- )...,
- ), s.handleDeleteAttachment)
-
- mcpSrv.AddTool(mcp.NewTool("link_attachment_to_memo",
- createToolOptions("Link attachment to memo", "Link an existing attachment to a memo. Requires authentication and ownership of the attachment.", true,
- mcp.WithString("name", mcp.Required(), mcp.Description(`Attachment resource name, e.g. "attachments/abc123"`)),
- mcp.WithString("memo", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- mcp.WithOutputSchema[attachmentJSON](),
- )...,
- ), s.handleLinkAttachmentToMemo)
-}
-
-func (s *MCPService) handleListAttachments(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID, err := extractUserID(ctx)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- pageSize := req.GetInt("page_size", 20)
- if pageSize <= 0 {
- pageSize = 20
- }
- if pageSize > 100 {
- pageSize = 100
- }
- page := req.GetInt("page", 0)
- if page < 0 {
- page = 0
- }
-
- limit := pageSize + 1
- offset := page * pageSize
- find := &store.FindAttachment{
- CreatorID: &userID,
- Limit: &limit,
- Offset: &offset,
- }
-
- if memoName := req.GetString("memo", ""); memoName != "" {
- memoUID, err := parseMemoUID(memoName)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &memoUID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to find memo: %v", err)), nil
- }
- if memo == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- find.MemoID = &memo.ID
- }
-
- attachments, err := s.store.ListAttachments(ctx, find)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list attachments: %v", err)), nil
- }
-
- hasMore := len(attachments) > pageSize
- if hasMore {
- attachments = attachments[:pageSize]
- }
- creatorIDs := make([]int32, 0, len(attachments))
- for _, attachment := range attachments {
- creatorIDs = append(creatorIDs, attachment.CreatorID)
- }
- usernamesByID, err := preloadUsernames(ctx, s.store, creatorIDs)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to preload attachment creators: %v", err)), nil
- }
-
- results := make([]attachmentJSON, len(attachments))
- for i, a := range attachments {
- result, err := storeAttachmentToJSONWithUsernames(a, usernamesByID)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve attachment creator: %v", err)), nil
- }
- results[i] = result
- }
-
- return newToolResultJSON(attachmentListJSON{Attachments: results, HasMore: hasMore})
-}
-
-func (s *MCPService) handleGetAttachment(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- uid, err := parseAttachmentUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- attachment, err := s.store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get attachment: %v", err)), nil
- }
- if attachment == nil {
- return mcp.NewToolResultError("attachment not found"), nil
- }
-
- if err := s.checkAttachmentAccess(ctx, attachment, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- result, err := storeAttachmentToJSON(ctx, s.store, attachment)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve attachment creator: %v", err)), nil
- }
- return newToolResultJSON(result)
-}
-
-func (s *MCPService) handleDeleteAttachment(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- if _, err := extractUserID(ctx); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- uid, err := parseAttachmentUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- if _, err := s.apiV1Service.DeleteAttachment(ctx, &v1pb.DeleteAttachmentRequest{Name: "attachments/" + uid}); err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to delete attachment: %v", err)), nil
- }
- return newDeletedToolResult()
-}
-
-func (s *MCPService) handleLinkAttachmentToMemo(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID, err := extractUserID(ctx)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- uid, err := parseAttachmentUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- attachment, err := s.store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get attachment: %v", err)), nil
- }
- if attachment == nil {
- return mcp.NewToolResultError("attachment not found"), nil
- }
- if attachment.CreatorID != userID {
- return mcp.NewToolResultError("permission denied"), nil
- }
-
- memoUID, err := parseMemoUID(req.GetString("memo", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &memoUID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get memo: %v", err)), nil
- }
- if memo == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- if err := checkMemoOwnership(memo, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- currentAttachments, err := s.store.ListAttachments(ctx, &store.FindAttachment{MemoID: &memo.ID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list memo attachments: %v", err)), nil
- }
- requestAttachments := make([]*v1pb.Attachment, 0, len(currentAttachments)+1)
- var currentTarget *store.Attachment
- for _, current := range currentAttachments {
- requestAttachments = append(requestAttachments, &v1pb.Attachment{Name: "attachments/" + current.UID})
- if current.ID == attachment.ID {
- currentTarget = current
- }
- }
- if currentTarget != nil {
- result, err := storeAttachmentToJSON(ctx, s.store, currentTarget)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve attachment creator: %v", err)), nil
- }
- return newToolResultJSON(result)
- }
- requestAttachments = append(requestAttachments, &v1pb.Attachment{Name: "attachments/" + uid})
-
- if _, err := s.apiV1Service.SetMemoAttachments(ctx, &v1pb.SetMemoAttachmentsRequest{
- Name: "memos/" + memoUID,
- Attachments: requestAttachments,
- }); err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to link attachment: %v", err)), nil
- }
-
- // Re-fetch to get updated memo UID.
- updated, err := s.store.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to fetch updated attachment: %v", err)), nil
- }
- result, err := storeAttachmentToJSON(ctx, s.store, updated)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve attachment creator: %v", err)), nil
- }
- return newToolResultJSON(result)
-}
diff --git a/server/router/mcp/tools_memo.go b/server/router/mcp/tools_memo.go
deleted file mode 100644
index 86539159d..000000000
--- a/server/router/mcp/tools_memo.go
+++ /dev/null
@@ -1,607 +0,0 @@
-package mcp
-
-import (
- "context"
- "fmt"
- "strings"
-
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
- "github.com/pkg/errors"
- "google.golang.org/protobuf/types/known/fieldmaskpb"
-
- v1pb "github.com/usememos/memos/proto/gen/api/v1"
- "github.com/usememos/memos/server/auth"
- "github.com/usememos/memos/store"
-)
-
-// propertyJSON is the serialisable form of MemoPayload.Property.
-type propertyJSON struct {
- HasLink bool `json:"has_link"`
- HasTaskList bool `json:"has_task_list"`
- HasCode bool `json:"has_code"`
- HasIncompleteTasks bool `json:"has_incomplete_tasks"`
-}
-
-// memoJSON is the canonical response shape for all MCP memo results.
-// It serialises correctly with standard encoding/json (no proto marshalling needed).
-type memoJSON struct {
- Name string `json:"name"`
- Creator string `json:"creator"`
- CreateTime int64 `json:"create_time"`
- UpdateTime int64 `json:"update_time"`
- Content string `json:"content,omitempty"`
- Visibility string `json:"visibility"`
- Tags []string `json:"tags"`
- Pinned bool `json:"pinned"`
- State string `json:"state"`
- Property *propertyJSON `json:"property,omitempty"`
- Parent string `json:"parent,omitempty"`
-}
-
-type memoListJSON struct {
- Memos []memoJSON `json:"memos"`
- HasMore bool `json:"has_more"`
-}
-
-func storeMemoToJSON(m *store.Memo) memoJSON {
- j := memoJSON{
- Name: "memos/" + m.UID,
- CreateTime: m.CreatedTs,
- UpdateTime: m.UpdatedTs,
- Content: m.Content,
- Visibility: string(m.Visibility),
- Pinned: m.Pinned,
- State: string(m.RowStatus),
- Tags: []string{},
- }
- if m.Payload != nil {
- if len(m.Payload.Tags) > 0 {
- j.Tags = m.Payload.Tags
- }
- if p := m.Payload.Property; p != nil && (p.HasLink || p.HasTaskList || p.HasCode || p.HasIncompleteTasks) {
- j.Property = &propertyJSON{
- HasLink: p.HasLink,
- HasTaskList: p.HasTaskList,
- HasCode: p.HasCode,
- HasIncompleteTasks: p.HasIncompleteTasks,
- }
- }
- }
- if m.ParentUID != nil {
- j.Parent = "memos/" + *m.ParentUID
- }
- return j
-}
-
-func lookupUsername(ctx context.Context, stores *store.Store, userID int32) (string, error) {
- user, err := stores.GetUser(ctx, &store.FindUser{ID: &userID})
- if err != nil {
- return "", errors.Wrapf(err, "failed to get creator user %d", userID)
- }
- if user == nil {
- return "", errors.Errorf("creator user %d not found", userID)
- }
- return "users/" + user.Username, nil
-}
-
-func preloadUsernames(ctx context.Context, stores *store.Store, userIDs []int32) (map[int32]string, error) {
- if len(userIDs) == 0 {
- return map[int32]string{}, nil
- }
-
- uniqueUserIDs := make([]int32, 0, len(userIDs))
- seenUserIDs := make(map[int32]struct{}, len(userIDs))
- for _, userID := range userIDs {
- if _, seen := seenUserIDs[userID]; seen {
- continue
- }
- seenUserIDs[userID] = struct{}{}
- uniqueUserIDs = append(uniqueUserIDs, userID)
- }
-
- users, err := stores.ListUsers(ctx, &store.FindUser{IDList: uniqueUserIDs})
- if err != nil {
- return nil, errors.Wrap(err, "failed to list creator users")
- }
-
- usernamesByID := make(map[int32]string, len(users))
- for _, user := range users {
- usernamesByID[user.ID] = "users/" + user.Username
- }
- return usernamesByID, nil
-}
-
-func lookupUsernameFromCache(usernamesByID map[int32]string, userID int32) (string, error) {
- username, ok := usernamesByID[userID]
- if !ok {
- return "", errors.Errorf("creator user %d not found", userID)
- }
- return username, nil
-}
-
-func storeMemoToJSONWithStore(ctx context.Context, stores *store.Store, m *store.Memo) (memoJSON, error) {
- j := storeMemoToJSON(m)
- creator, err := lookupUsername(ctx, stores, m.CreatorID)
- if err != nil {
- return memoJSON{}, err
- }
- j.Creator = creator
- return j, nil
-}
-
-func storeMemoToJSONWithUsernames(m *store.Memo, usernamesByID map[int32]string) (memoJSON, error) {
- j := storeMemoToJSON(m)
- creator, err := lookupUsernameFromCache(usernamesByID, m.CreatorID)
- if err != nil {
- return memoJSON{}, err
- }
- j.Creator = creator
- return j, nil
-}
-
-// parseMemoUID extracts the UID from a "memos/<uid>" resource name.
-func parseMemoUID(name string) (string, error) {
- uid, ok := strings.CutPrefix(name, "memos/")
- if !ok || uid == "" {
- return "", errors.Errorf(`memo name must be in the format "memos/<uid>", got %q`, name)
- }
- return uid, nil
-}
-
-// parseVisibility validates a visibility string and returns the store constant.
-func parseVisibility(s string) (store.Visibility, error) {
- switch v := store.Visibility(s); v {
- case store.Public, store.Protected, store.Private:
- return v, nil
- default:
- return "", errors.Errorf("visibility must be PRIVATE, PROTECTED, or PUBLIC; got %q", s)
- }
-}
-
-// parseRowStatus validates a state string and returns the store constant.
-func parseRowStatus(s string) (store.RowStatus, error) {
- switch rs := store.RowStatus(s); rs {
- case store.Normal, store.Archived:
- return rs, nil
- default:
- return "", errors.Errorf("state must be NORMAL or ARCHIVED; got %q", s)
- }
-}
-
-func extractUserID(ctx context.Context) (int32, error) {
- id := auth.GetUserID(ctx)
- if id == 0 {
- return 0, errors.New("unauthenticated: a personal access token is required")
- }
- return id, nil
-}
-
-func (s *MCPService) registerMemoTools(mcpSrv *mcpserver.MCPServer) {
- mcpSrv.AddTool(mcp.NewTool("list_memos",
- readOnlyToolOptions("List memos", "List memos visible to the caller. Authenticated users see their own memos plus public and protected memos; unauthenticated callers see only public memos.",
- mcp.WithNumber("page_size", mcp.Description("Maximum memos to return (1–100, default 20)")),
- mcp.WithNumber("page", mcp.Description("Zero-based page index for pagination (default 0)")),
- mcp.WithString("state",
- mcp.Enum("NORMAL", "ARCHIVED"),
- mcp.Description("Filter by state: NORMAL (default) or ARCHIVED"),
- ),
- mcp.WithBoolean("order_by_pinned", mcp.Description("When true, pinned memos appear first (default false)")),
- mcp.WithString("filter", mcp.Description(`Optional CEL filter (supported subset of standard CEL syntax), e.g. content.contains("keyword") or tags.exists(t, t == "work")`)),
- mcp.WithOutputSchema[memoListJSON](),
- )...,
- ), s.handleListMemos)
-
- mcpSrv.AddTool(mcp.NewTool("get_memo",
- readOnlyToolOptions("Get memo", "Get a single memo by resource name. Public memos are accessible without authentication.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- mcp.WithOutputSchema[memoJSON](),
- )...,
- ), s.handleGetMemo)
-
- mcpSrv.AddTool(mcp.NewTool("create_memo",
- createToolOptions("Create memo", "Create a new memo. Requires authentication.", false,
- mcp.WithString("content", mcp.Required(), mcp.Description("Memo content in Markdown. Use #tag syntax for tagging.")),
- mcp.WithString("visibility",
- mcp.Enum("PRIVATE", "PROTECTED", "PUBLIC"),
- mcp.Description("Visibility (default: PRIVATE)"),
- ),
- mcp.WithOutputSchema[memoJSON](),
- )...,
- ), s.handleCreateMemo)
-
- mcpSrv.AddTool(mcp.NewTool("update_memo",
- updateToolOptions("Update memo", "Update a memo's content, visibility, pin state, or archive state. Requires authentication and ownership. Omit any field to leave it unchanged.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- mcp.WithString("content", mcp.Description("New Markdown content")),
- mcp.WithString("visibility",
- mcp.Enum("PRIVATE", "PROTECTED", "PUBLIC"),
- mcp.Description("New visibility"),
- ),
- mcp.WithBoolean("pinned", mcp.Description("Pin or unpin the memo")),
- mcp.WithString("state",
- mcp.Enum("NORMAL", "ARCHIVED"),
- mcp.Description("Set to ARCHIVED to archive, NORMAL to restore"),
- ),
- mcp.WithOutputSchema[memoJSON](),
- )...,
- ), s.handleUpdateMemo)
-
- mcpSrv.AddTool(mcp.NewTool("delete_memo",
- updateToolOptions("Delete memo", "Permanently delete a memo. Requires authentication and ownership.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- mcp.WithOutputSchema[deletedJSON](),
- )...,
- ), s.handleDeleteMemo)
-
- mcpSrv.AddTool(mcp.NewTool("search_memos",
- readOnlyToolOptions("Search memos", "Search memo content. Authenticated users search their own and visible memos; unauthenticated callers search public memos only.",
- mcp.WithString("query", mcp.Required(), mcp.Description("Text to search for in memo content")),
- )...,
- ), s.handleSearchMemos)
-
- mcpSrv.AddTool(mcp.NewTool("list_memo_comments",
- readOnlyToolOptions("List memo comments", "List comments on a memo. Visibility rules for comments match those of the parent memo.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- )...,
- ), s.handleListMemoComments)
-
- mcpSrv.AddTool(mcp.NewTool("create_memo_comment",
- createToolOptions("Create memo comment", "Add a comment to a memo. The comment inherits the parent memo's visibility. Requires authentication.", false,
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name to comment on, e.g. "memos/abc123"`)),
- mcp.WithString("content", mcp.Required(), mcp.Description("Comment content in Markdown")),
- mcp.WithOutputSchema[memoJSON](),
- )...,
- ), s.handleCreateMemoComment)
-}
-
-func (s *MCPService) handleListMemos(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- pageSize := req.GetInt("page_size", 20)
- if pageSize <= 0 {
- pageSize = 20
- }
- if pageSize > 100 {
- pageSize = 100
- }
- page := req.GetInt("page", 0)
- if page < 0 {
- page = 0
- }
-
- var rowStatus *store.RowStatus
- if state := req.GetString("state", "NORMAL"); state != "" {
- rs, err := parseRowStatus(state)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- rowStatus = &rs
- }
-
- limit := pageSize + 1
- offset := page * pageSize
- find := &store.FindMemo{
- ExcludeComments: true,
- RowStatus: rowStatus,
- Limit: &limit,
- Offset: &offset,
- OrderByPinned: req.GetBool("order_by_pinned", false),
- }
- applyVisibilityFilter(find, userID, rowStatus)
- if filter := req.GetString("filter", ""); filter != "" {
- find.Filters = append(find.Filters, filter)
- }
-
- memos, err := s.store.ListMemos(ctx, find)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list memos: %v", err)), nil
- }
-
- hasMore := len(memos) > pageSize
- if hasMore {
- memos = memos[:pageSize]
- }
- creatorIDs := make([]int32, 0, len(memos))
- for _, memo := range memos {
- creatorIDs = append(creatorIDs, memo.CreatorID)
- }
- usernamesByID, err := preloadUsernames(ctx, s.store, creatorIDs)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to preload memo creators: %v", err)), nil
- }
-
- results := make([]memoJSON, len(memos))
- for i, m := range memos {
- result, err := storeMemoToJSONWithUsernames(m, usernamesByID)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve memo creator: %v", err)), nil
- }
- results[i] = result
- }
-
- return newToolResultJSON(memoListJSON{Memos: results, HasMore: hasMore})
-}
-
-func (s *MCPService) handleGetMemo(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get memo: %v", err)), nil
- }
- if memo == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- if err := checkMemoAccess(memo, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- result, err := storeMemoToJSONWithStore(ctx, s.store, memo)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve memo creator: %v", err)), nil
- }
- return newToolResultJSON(result)
-}
-
-func (s *MCPService) handleCreateMemo(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- if _, err := extractUserID(ctx); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- content := req.GetString("content", "")
- if content == "" {
- return mcp.NewToolResultError("content is required"), nil
- }
- visibility, err := parseVisibility(req.GetString("visibility", "PRIVATE"))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- created, err := s.apiV1Service.CreateMemo(ctx, &v1pb.CreateMemoRequest{
- Memo: &v1pb.Memo{
- Content: content,
- Visibility: visibilityToProto(visibility),
- },
- })
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to create memo: %v", err)), nil
- }
-
- result, err := s.loadMemoJSONByName(ctx, created.Name)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- return newToolResultJSON(result)
-}
-
-func (s *MCPService) handleUpdateMemo(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- if _, err := extractUserID(ctx); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- update := &v1pb.Memo{Name: "memos/" + uid}
- updateMask := &fieldmaskpb.FieldMask{}
- args := req.GetArguments()
-
- if v := req.GetString("content", ""); v != "" {
- update.Content = v
- updateMask.Paths = append(updateMask.Paths, "content")
- }
- if v := req.GetString("visibility", ""); v != "" {
- vis, err := parseVisibility(v)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- update.Visibility = visibilityToProto(vis)
- updateMask.Paths = append(updateMask.Paths, "visibility")
- }
- if v := req.GetString("state", ""); v != "" {
- rs, err := parseRowStatus(v)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- update.State = rowStatusToProto(rs)
- updateMask.Paths = append(updateMask.Paths, "state")
- }
- if _, ok := args["pinned"]; ok {
- update.Pinned = req.GetBool("pinned", false)
- updateMask.Paths = append(updateMask.Paths, "pinned")
- }
-
- if len(updateMask.Paths) == 0 {
- return mcp.NewToolResultError("at least one field must be provided to update"), nil
- }
-
- updated, err := s.apiV1Service.UpdateMemo(ctx, &v1pb.UpdateMemoRequest{
- Memo: update,
- UpdateMask: updateMask,
- })
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to update memo: %v", err)), nil
- }
-
- result, err := s.loadMemoJSONByName(ctx, updated.Name)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- return newToolResultJSON(result)
-}
-
-func (s *MCPService) handleDeleteMemo(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- if _, err := extractUserID(ctx); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- if _, err := s.apiV1Service.DeleteMemo(ctx, &v1pb.DeleteMemoRequest{Name: "memos/" + uid}); err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to delete memo: %v", err)), nil
- }
- return newDeletedToolResult()
-}
-
-func (s *MCPService) handleSearchMemos(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- query := req.GetString("query", "")
- if query == "" {
- return mcp.NewToolResultError("query is required"), nil
- }
-
- limit := 50
- zero := 0
- rowStatus := store.Normal
- find := &store.FindMemo{
- ExcludeComments: true,
- RowStatus: &rowStatus,
- Limit: &limit,
- Offset: &zero,
- Filters: []string{fmt.Sprintf(`content.contains(%q)`, query)},
- }
- applyVisibilityFilter(find, userID, find.RowStatus)
-
- memos, err := s.store.ListMemos(ctx, find)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to search memos: %v", err)), nil
- }
- creatorIDs := make([]int32, 0, len(memos))
- for _, memo := range memos {
- creatorIDs = append(creatorIDs, memo.CreatorID)
- }
- usernamesByID, err := preloadUsernames(ctx, s.store, creatorIDs)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to preload memo creators: %v", err)), nil
- }
-
- results := make([]memoJSON, len(memos))
- for i, m := range memos {
- result, err := storeMemoToJSONWithUsernames(m, usernamesByID)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve memo creator: %v", err)), nil
- }
- results[i] = result
- }
- return newToolResultJSON(results)
-}
-
-func (s *MCPService) handleListMemoComments(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- parent, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get memo: %v", err)), nil
- }
- if parent == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- if err := checkMemoAccess(parent, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- relationType := store.MemoRelationComment
- relations, err := s.store.ListMemoRelations(ctx, &store.FindMemoRelation{
- RelatedMemoID: &parent.ID,
- Type: &relationType,
- })
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list relations: %v", err)), nil
- }
- if len(relations) == 0 {
- return newToolResultJSON([]memoJSON{})
- }
-
- commentIDs := make([]int32, len(relations))
- for i, r := range relations {
- commentIDs[i] = r.MemoID
- }
-
- memos, err := s.store.ListMemos(ctx, &store.FindMemo{IDList: commentIDs})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list comments: %v", err)), nil
- }
- creatorIDs := make([]int32, 0, len(memos))
- for _, memo := range memos {
- if checkMemoAccess(memo, userID) == nil {
- creatorIDs = append(creatorIDs, memo.CreatorID)
- }
- }
- usernamesByID, err := preloadUsernames(ctx, s.store, creatorIDs)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to preload memo creators: %v", err)), nil
- }
-
- results := make([]memoJSON, 0, len(memos))
- for _, m := range memos {
- if checkMemoAccess(m, userID) == nil {
- result, err := storeMemoToJSONWithUsernames(m, usernamesByID)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve memo creator: %v", err)), nil
- }
- results = append(results, result)
- }
- }
- return newToolResultJSON(results)
-}
-
-func (s *MCPService) handleCreateMemoComment(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID, err := extractUserID(ctx)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- content := req.GetString("content", "")
- if content == "" {
- return mcp.NewToolResultError("content is required"), nil
- }
-
- parent, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get memo: %v", err)), nil
- }
- if parent == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- if err := checkMemoAccess(parent, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- comment, err := s.apiV1Service.CreateMemoComment(ctx, &v1pb.CreateMemoCommentRequest{
- Name: "memos/" + uid,
- Comment: &v1pb.Memo{
- Content: content,
- Visibility: visibilityToProto(parent.Visibility),
- },
- })
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to create comment: %v", err)), nil
- }
-
- result, err := s.loadMemoJSONByName(ctx, comment.Name)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- return newToolResultJSON(result)
-}
diff --git a/server/router/mcp/tools_reaction.go b/server/router/mcp/tools_reaction.go
deleted file mode 100644
index 705c898a4..000000000
--- a/server/router/mcp/tools_reaction.go
+++ /dev/null
@@ -1,180 +0,0 @@
-package mcp
-
-import (
- "context"
- "fmt"
-
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
-
- v1pb "github.com/usememos/memos/proto/gen/api/v1"
- "github.com/usememos/memos/server/auth"
- "github.com/usememos/memos/store"
-)
-
-type reactionJSON struct {
- ID int32 `json:"id"`
- Creator string `json:"creator"`
- ReactionType string `json:"reaction_type"`
- CreateTime int64 `json:"create_time"`
-}
-
-func (s *MCPService) registerReactionTools(mcpSrv *mcpserver.MCPServer) {
- mcpSrv.AddTool(mcp.NewTool("list_reactions",
- readOnlyToolOptions("List reactions", "List all reactions on a memo. Returns reaction type and creator for each reaction.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- )...,
- ), s.handleListReactions)
-
- mcpSrv.AddTool(mcp.NewTool("upsert_reaction",
- createToolOptions("Upsert reaction", "Add a reaction (emoji) to a memo. If the same reaction already exists from the same user, this is a no-op. Requires authentication.", true,
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- mcp.WithString("reaction_type", mcp.Required(), mcp.Description(`Reaction emoji, e.g. "👍", "❤️", "🎉"`)),
- mcp.WithOutputSchema[reactionJSON](),
- )...,
- ), s.handleUpsertReaction)
-
- mcpSrv.AddTool(mcp.NewTool("delete_reaction",
- updateToolOptions("Delete reaction", "Remove a reaction by its ID. Requires authentication and ownership of the reaction.",
- mcp.WithNumber("id", mcp.Required(), mcp.Description("Reaction ID to delete")),
- mcp.WithOutputSchema[deletedJSON](),
- )...,
- ), s.handleDeleteReaction)
-}
-
-func (s *MCPService) handleListReactions(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get memo: %v", err)), nil
- }
- if memo == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- if err := checkMemoAccess(memo, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- contentID := "memos/" + uid
- reactions, err := s.store.ListReactions(ctx, &store.FindReaction{ContentID: &contentID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list reactions: %v", err)), nil
- }
- creatorIDs := make([]int32, 0, len(reactions))
- for _, reaction := range reactions {
- creatorIDs = append(creatorIDs, reaction.CreatorID)
- }
- usernamesByID, err := preloadUsernames(ctx, s.store, creatorIDs)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to preload reaction creators: %v", err)), nil
- }
-
- results := make([]reactionJSON, len(reactions))
- for i, r := range reactions {
- creator, err := lookupUsernameFromCache(usernamesByID, r.CreatorID)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve reaction creator: %v", err)), nil
- }
- results[i] = reactionJSON{
- ID: r.ID,
- Creator: creator,
- ReactionType: r.ReactionType,
- CreateTime: r.CreatedTs,
- }
- }
-
- return newToolResultJSON(results)
-}
-
-func (s *MCPService) handleUpsertReaction(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID, err := extractUserID(ctx)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- reactionType := req.GetString("reaction_type", "")
- if reactionType == "" {
- return mcp.NewToolResultError("reaction_type is required"), nil
- }
-
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get memo: %v", err)), nil
- }
- if memo == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- if err := checkMemoAccess(memo, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- // Validate reaction type against allowed reactions.
- memoRelatedSetting, err := s.store.GetInstanceMemoRelatedSetting(ctx)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get reaction settings: %v", err)), nil
- }
- allowed := false
- for _, r := range memoRelatedSetting.Reactions {
- if r == reactionType {
- allowed = true
- break
- }
- }
- if !allowed {
- return mcp.NewToolResultError(fmt.Sprintf("reaction %q is not in the allowed reaction list", reactionType)), nil
- }
-
- contentID := "memos/" + uid
- reaction, err := s.apiV1Service.UpsertMemoReaction(ctx, &v1pb.UpsertMemoReactionRequest{
- Name: contentID,
- Reaction: &v1pb.Reaction{
- ContentId: contentID,
- ReactionType: reactionType,
- },
- })
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to upsert reaction: %v", err)), nil
- }
-
- result, err := s.loadReactionJSONByName(ctx, reaction.Name)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- return newToolResultJSON(result)
-}
-
-func (s *MCPService) handleDeleteReaction(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- if _, err := extractUserID(ctx); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- reactionID := int32(req.GetInt("id", 0))
- if reactionID == 0 {
- return mcp.NewToolResultError("id is required"), nil
- }
-
- reaction, err := s.store.GetReaction(ctx, &store.FindReaction{ID: &reactionID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get reaction: %v", err)), nil
- }
- if reaction == nil {
- return mcp.NewToolResultError("reaction not found"), nil
- }
-
- if _, err := s.apiV1Service.DeleteMemoReaction(ctx, &v1pb.DeleteMemoReactionRequest{
- Name: fmt.Sprintf("%s/reactions/%d", reaction.ContentID, reactionID),
- }); err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to delete reaction: %v", err)), nil
- }
- return newDeletedToolResult()
-}
diff --git a/server/router/mcp/tools_relation.go b/server/router/mcp/tools_relation.go
deleted file mode 100644
index e395f45c4..000000000
--- a/server/router/mcp/tools_relation.go
+++ /dev/null
@@ -1,297 +0,0 @@
-package mcp
-
-import (
- "context"
- "fmt"
-
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
-
- v1pb "github.com/usememos/memos/proto/gen/api/v1"
- "github.com/usememos/memos/server/auth"
- "github.com/usememos/memos/store"
-)
-
-type relationJSON struct {
- Memo string `json:"memo"`
- RelatedMemo string `json:"related_memo"`
- Type string `json:"type"`
-}
-
-func (s *MCPService) registerRelationTools(mcpSrv *mcpserver.MCPServer) {
- mcpSrv.AddTool(mcp.NewTool("list_memo_relations",
- readOnlyToolOptions("List memo relations", "List all relations (references and comments) for a memo. Requires read access to the memo.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Memo resource name, e.g. "memos/abc123"`)),
- mcp.WithString("type",
- mcp.Enum("REFERENCE", "COMMENT"),
- mcp.Description("Filter by relation type (optional)"),
- ),
- )...,
- ), s.handleListMemoRelations)
-
- mcpSrv.AddTool(mcp.NewTool("create_memo_relation",
- createToolOptions("Create memo relation", "Create a reference relation between two memos. Requires authentication. For comments, use create_memo_comment instead.", true,
- mcp.WithString("name", mcp.Required(), mcp.Description(`Source memo resource name, e.g. "memos/abc123"`)),
- mcp.WithString("related_memo", mcp.Required(), mcp.Description(`Target memo resource name, e.g. "memos/def456"`)),
- mcp.WithOutputSchema[relationJSON](),
- )...,
- ), s.handleCreateMemoRelation)
-
- mcpSrv.AddTool(mcp.NewTool("delete_memo_relation",
- updateToolOptions("Delete memo relation", "Delete a reference relation between two memos. Requires authentication and ownership of the source memo.",
- mcp.WithString("name", mcp.Required(), mcp.Description(`Source memo resource name, e.g. "memos/abc123"`)),
- mcp.WithString("related_memo", mcp.Required(), mcp.Description(`Target memo resource name, e.g. "memos/def456"`)),
- mcp.WithOutputSchema[deletedJSON](),
- )...,
- ), s.handleDeleteMemoRelation)
-}
-
-func (s *MCPService) handleListMemoRelations(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- uid, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- memo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &uid})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get memo: %v", err)), nil
- }
- if memo == nil {
- return mcp.NewToolResultError("memo not found"), nil
- }
- if err := checkMemoAccess(memo, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- find := &store.FindMemoRelation{
- MemoIDList: []int32{memo.ID},
- }
- if typeStr := req.GetString("type", ""); typeStr != "" {
- switch store.MemoRelationType(typeStr) {
- case store.MemoRelationReference, store.MemoRelationComment:
- t := store.MemoRelationType(typeStr)
- find.Type = &t
- default:
- return mcp.NewToolResultError(fmt.Sprintf("type must be REFERENCE or COMMENT, got %q", typeStr)), nil
- }
- }
-
- relations, err := s.store.ListMemoRelations(ctx, find)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list relations: %v", err)), nil
- }
-
- // Resolve memo IDs to UIDs.
- idSet := make(map[int32]struct{})
- for _, r := range relations {
- idSet[r.MemoID] = struct{}{}
- idSet[r.RelatedMemoID] = struct{}{}
- }
- ids := make([]int32, 0, len(idSet))
- for id := range idSet {
- ids = append(ids, id)
- }
- memos, err := s.store.ListMemos(ctx, &store.FindMemo{IDList: ids, ExcludeContent: true})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to resolve memos: %v", err)), nil
- }
- memoByID := make(map[int32]*store.Memo, len(memos))
- for _, m := range memos {
- memoByID[m.ID] = m
- }
-
- results := make([]relationJSON, 0, len(relations))
- for _, r := range relations {
- srcMemo, ok1 := memoByID[r.MemoID]
- relatedMemo, ok2 := memoByID[r.RelatedMemoID]
- if !ok1 || !ok2 {
- continue
- }
- if checkMemoAccess(srcMemo, userID) != nil || checkMemoAccess(relatedMemo, userID) != nil {
- continue
- }
- results = append(results, relationJSON{
- Memo: "memos/" + srcMemo.UID,
- RelatedMemo: "memos/" + relatedMemo.UID,
- Type: string(r.Type),
- })
- }
-
- return newToolResultJSON(results)
-}
-
-func (s *MCPService) handleCreateMemoRelation(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID, err := extractUserID(ctx)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- srcUID, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- dstUID, err := parseMemoUID(req.GetString("related_memo", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- if srcUID == dstUID {
- return mcp.NewToolResultError("cannot create a relation from a memo to itself"), nil
- }
-
- srcMemo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &srcUID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get source memo: %v", err)), nil
- }
- if srcMemo == nil {
- return mcp.NewToolResultError("source memo not found"), nil
- }
- if !hasMemoOwnership(srcMemo, userID) {
- return mcp.NewToolResultError("permission denied: must own the source memo"), nil
- }
-
- dstMemo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &dstUID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get related memo: %v", err)), nil
- }
- if dstMemo == nil {
- return mcp.NewToolResultError("related memo not found"), nil
- }
- if err := checkMemoAccess(dstMemo, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- relations, changed, err := s.buildReferenceRelationSet(ctx, srcMemo, &dstMemo.UID, nil)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to build relation set: %v", err)), nil
- }
- if changed {
- if _, err := s.apiV1Service.SetMemoRelations(ctx, &v1pb.SetMemoRelationsRequest{
- Name: "memos/" + srcUID,
- Relations: relations,
- }); err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to create relation: %v", err)), nil
- }
- }
-
- return newToolResultJSON(relationJSON{
- Memo: "memos/" + srcUID,
- RelatedMemo: "memos/" + dstUID,
- Type: string(store.MemoRelationReference),
- })
-}
-
-func (s *MCPService) handleDeleteMemoRelation(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID, err := extractUserID(ctx)
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- srcUID, err := parseMemoUID(req.GetString("name", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
- dstUID, err := parseMemoUID(req.GetString("related_memo", ""))
- if err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- srcMemo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &srcUID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get source memo: %v", err)), nil
- }
- if srcMemo == nil {
- return mcp.NewToolResultError("source memo not found"), nil
- }
- if !hasMemoOwnership(srcMemo, userID) {
- return mcp.NewToolResultError("permission denied: must own the source memo"), nil
- }
-
- dstMemo, err := s.store.GetMemo(ctx, &store.FindMemo{UID: &dstUID})
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to get related memo: %v", err)), nil
- }
- if dstMemo == nil {
- return mcp.NewToolResultError("related memo not found"), nil
- }
- if err := checkMemoAccess(dstMemo, userID); err != nil {
- return mcp.NewToolResultError(err.Error()), nil
- }
-
- relations, changed, err := s.buildReferenceRelationSet(ctx, srcMemo, nil, &dstMemo.UID)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to build relation set: %v", err)), nil
- }
- if changed {
- if _, err := s.apiV1Service.SetMemoRelations(ctx, &v1pb.SetMemoRelationsRequest{
- Name: "memos/" + srcUID,
- Relations: relations,
- }); err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to delete relation: %v", err)), nil
- }
- }
- return newDeletedToolResult()
-}
-
-func (s *MCPService) buildReferenceRelationSet(ctx context.Context, source *store.Memo, includeUID *string, excludeUID *string) ([]*v1pb.MemoRelation, bool, error) {
- referenceType := store.MemoRelationReference
- relations, err := s.store.ListMemoRelations(ctx, &store.FindMemoRelation{
- MemoIDList: []int32{source.ID},
- Type: &referenceType,
- })
- if err != nil {
- return nil, false, err
- }
-
- idSet := make(map[int32]struct{}, len(relations))
- for _, relation := range relations {
- idSet[relation.RelatedMemoID] = struct{}{}
- }
- ids := make([]int32, 0, len(idSet))
- for id := range idSet {
- ids = append(ids, id)
- }
-
- memosByID := map[int32]*store.Memo{}
- if len(ids) > 0 {
- memos, err := s.store.ListMemos(ctx, &store.FindMemo{IDList: ids, ExcludeContent: true})
- if err != nil {
- return nil, false, err
- }
- for _, memo := range memos {
- memosByID[memo.ID] = memo
- }
- }
-
- result := make([]*v1pb.MemoRelation, 0, len(relations)+1)
- seenUIDs := map[string]struct{}{}
- changed := false
- for _, relation := range relations {
- relatedMemo := memosByID[relation.RelatedMemoID]
- if relatedMemo == nil {
- continue
- }
- if excludeUID != nil && relatedMemo.UID == *excludeUID {
- changed = true
- continue
- }
- result = append(result, newReferenceRelation(source.UID, relatedMemo.UID))
- seenUIDs[relatedMemo.UID] = struct{}{}
- }
- if includeUID != nil {
- if _, seen := seenUIDs[*includeUID]; !seen && source.UID != *includeUID {
- result = append(result, newReferenceRelation(source.UID, *includeUID))
- changed = true
- }
- }
- return result, changed, nil
-}
-
-func newReferenceRelation(sourceUID string, relatedUID string) *v1pb.MemoRelation {
- return &v1pb.MemoRelation{
- Memo: &v1pb.MemoRelation_Memo{Name: "memos/" + sourceUID},
- RelatedMemo: &v1pb.MemoRelation_Memo{Name: "memos/" + relatedUID},
- Type: v1pb.MemoRelation_REFERENCE,
- }
-}
diff --git a/server/router/mcp/tools_tag.go b/server/router/mcp/tools_tag.go
deleted file mode 100644
index ff9199644..000000000
--- a/server/router/mcp/tools_tag.go
+++ /dev/null
@@ -1,74 +0,0 @@
-package mcp
-
-import (
- "context"
- "fmt"
- "slices"
-
- "github.com/mark3labs/mcp-go/mcp"
- mcpserver "github.com/mark3labs/mcp-go/server"
-
- "github.com/usememos/memos/server/auth"
- "github.com/usememos/memos/store"
-)
-
-func (s *MCPService) registerTagTools(mcpSrv *mcpserver.MCPServer) {
- mcpSrv.AddTool(mcp.NewTool("list_tags",
- readOnlyToolOptions("List tags", "List all tags with their memo counts. Authenticated users see tags from their own and visible memos; unauthenticated callers see tags from public memos only. Results are sorted by count descending, then alphabetically.")...,
- ), s.handleListTags)
-}
-
-type tagEntry struct {
- Tag string `json:"tag"`
- Count int `json:"count"`
-}
-
-func (s *MCPService) handleListTags(ctx context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
- userID := auth.GetUserID(ctx)
-
- rowStatus := store.Normal
- find := &store.FindMemo{
- ExcludeComments: true,
- ExcludeContent: true,
- RowStatus: &rowStatus,
- }
- applyVisibilityFilter(find, userID, find.RowStatus)
-
- memos, err := s.store.ListMemos(ctx, find)
- if err != nil {
- return mcp.NewToolResultError(fmt.Sprintf("failed to list memos: %v", err)), nil
- }
-
- counts := make(map[string]int)
- for _, m := range memos {
- if m.Payload == nil {
- continue
- }
- for _, tag := range m.Payload.Tags {
- counts[tag]++
- }
- }
-
- entries := make([]tagEntry, 0, len(counts))
- for tag, count := range counts {
- entries = append(entries, tagEntry{Tag: tag, Count: count})
- }
- slices.SortFunc(entries, func(a, b tagEntry) int {
- if a.Count != b.Count {
- if a.Count > b.Count {
- return -1
- }
- return 1
- }
- switch {
- case a.Tag < b.Tag:
- return -1
- case a.Tag > b.Tag:
- return 1
- default:
- return 0
- }
- })
-
- return newToolResultJSON(entries)
-}
diff --git a/server/server.go b/server/server.go
index dac5079a0..028bd9428 100644
--- a/server/server.go
+++ b/server/server.go
@@ -20,7 +20,6 @@ import (
apiv1 "github.com/usememos/memos/server/router/api/v1"
"github.com/usememos/memos/server/router/fileserver"
"github.com/usememos/memos/server/router/frontend"
- mcprouter "github.com/usememos/memos/server/router/mcp"
"github.com/usememos/memos/server/router/rss"
"github.com/usememos/memos/server/runner/s3presign"
"github.com/usememos/memos/store"
@@ -89,10 +88,6 @@ func NewServer(ctx context.Context, profile *profile.Profile, store *store.Store
return nil, errors.Wrap(err, "failed to register gRPC gateway")
}
- // Register MCP server.
- mcpService := mcprouter.NewMCPService(s.Profile, s.Store, s.Secret, apiV1Service)
- mcpService.RegisterRoutes(echoServer)
-
return s, nil
}