TinaCMS MCP Server (C#)

This project implements a standalone Model Context Protocol (MCP) server using the official C# SDK (modelcontextprotocol/csharp-sdk). Its purpose is to expose tools that allow interaction with content files managed by a TinaCMS project repository.

This enables AI models or other MCP clients to list, read, create, update, and delete content files within a TinaCMS site via the standardized MCP.

Features

Connects to a local TinaCMS project directory.
Uses standard MCP Stdio transport for communication.
Provides tools for basic content management operations:
Listing collections (directories under /content).
Listing documents within a collection (non-recursive and recursive).
Reading document content.
Reading document frontmatter (metadata).
Creating new documents.
Updating existing documents (full content replace).
Updating document frontmatter (metadata merge).
Deleting documents.
Moving/Renaming documents.
Copying documents.
Reading the TinaCMS generated schema (.tina/schema.json).
Includes basic path validation and security checks.

Prerequisites

.NET 8 SDK (or later): Required to build and run the C# server.
Node.js and npm/npx: Required to run the MCP Inspector tool for testing.
A TinaCMS Project: You need a local TinaCMS project whose content you want this server to manage.

Setup

1. Clone/Download: Get the source code for this project.
2. Configure Root Path:
Open the appsettings.json file.
Locate the TinaProject section.
IMPORTANT: Replace the sample path provided for RootPath with the full, absolute path of your target TinaCMS project's root directory (the one containing the .tina folder).
Use forward slashes (/) for the path separators (recommended for cross-platform compatibility) or double backslashes (\\) if preferred on Windows.

    {

      "Logging": { ... },

      "TinaProject": {

        "RootPath": "/path/to/your/tina-project" 

      }

    }

    

3. Restore Dependencies: Open a terminal in the TinaMcpServer project directory and run:

    dotnet restore

    

Development

Build: To compile the project:

    dotnet build

    

Run Locally (for testing): The server is designed to be run by an MCP client (like the Inspector). Running it directly isn't very useful, but you can start it with:

    dotnet run 

    

or by running the compiled DLL:

    dotnet bin/Debug/net8.0/TinaMcpServer.dll

    

The server will start and wait for an MCP client to connect via standard input/output. It will likely exit immediately or show JSON errors if run without a client.

Testing with MCP Inspector

The recommended way to test the server and its tools is using the official MCP Inspector.

1. Ensure the project is built: Run dotnet build if you haven't already.
2. Run the Inspector: In your terminal (in the TinaMcpServer project directory), run the following command. This tells the Inspector to launch your compiled server DLL using dotnet:

    npx @modelcontextprotocol/inspector dotnet bin/Debug/net8.0/TinaMcpServer.dll

    

3. Open Inspector UI: The command will output a URL (e.g., http://127.0.0.1:6274). Open this URL in your web browser.
4. Connect: Click the "Connect" button for the detected TinaMcpServer.
5. Use Tools:
Navigate to the "Tools" tab.
Click "List Tools" to see all available tools.
Click on a specific tool to see its description and arguments.
Fill in the required arguments and click "Run Tool".
Observe the results and check the terminal running the Inspector for logs from the C# server.

Available Tools

(Descriptions are abbreviated here; see tool attributes in code for full details)

ListTinaCollections(): Lists collection directories under /content.
ListCollectionDocuments(collection): Lists files directly within a collection directory.
ListDocumentsRecursive(collection): Lists all files within a collection, including subdirectories.
GetTinaDocument(collection, relativePath): Gets the full text content of a document.
CreateTinaDocument(collection, relativePath, content): Creates a new document; fails if it exists.
UpdateTinaDocument(collection, relativePath, content): Overwrites an existing document; fails if it doesn't exist.
DeleteTinaDocument(collection, relativePath): Deletes an existing document; fails if it doesn't exist.
MoveDocument(collection, oldRelativePath, newRelativePath): Moves/renames a document.
CopyDocument(collection, sourceRelativePath, destinationRelativePath): Copies a document.
GetDocumentMetadata(collection, relativePath): Gets YAML frontmatter as a JSON string.
UpdateDocumentMetadata(collection, relativePath, metadataUpdatesJson): Adds/updates frontmatter fields from a JSON object.
GetCollectionSchemaInfo(collection): Reads the .tina/schema.json file content.

Potential Future Enhancements

Configuration for the assumed /content directory name.
More granular update operations (e.g., partial updates instead of full replace).
Support for different frontmatter formats (e.g., JSON, TOML) if needed.
More robust schema parsing/interaction.
Different transport options (e.g., HTTP/SSE).