TinaMCP

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).