TahubuSF

Tahubu-AI/TahubuSF

3.3

If you are the rightful owner of TahubuSF and would like to certify it and/or have it hosted online, please leave a comment on the right or send an email to henry@mcphub.com.

TahubuSF MCP Server provides seamless access to Sitefinity CMS data and operations through MCP integration and REST API access.

Tools
5
Resources
0
Prompts
0

TahubuSF

TahubuSF MCP Server

A Model Context Protocol (MCP) server that provides seamless access to Sitefinity CMS data and operations. Built with FastMCP 2.x, it offers both MCP integration for Claude Desktop and REST API access for web applications.

Environment setup

To run the MCP server, you need to have Python 3.13 or higher installed on your machine. You can download it from the official website: Python Downloads.

1. Create a Virtual Environment

In VS Code, create a new Python environment by opening the terminal and running:

python -m venv .venv

This will create a new virtual environment named .venv. Activate the virtual environment:

  • On Windows:
.venv\Scripts\Activate.ps1
  • On macOS and Linux:
source .venv/bin/activate

You should see (.venv) or (tahubusf) at the beginning of your terminal prompt, indicating you're working within the virtual environment.

2. Install Dependencies

Using uv (recommended):

First, install uv by following the instructions in the uv documentation.

Then install the dependencies:

uv pip install -r requirements.txt
Using pip:
pip install -r requirements.txt

3. Configure Environment Variables

The TahubuSF application uses environment variables for configuration, the most important being:

  • SITEFINITY_SITE_PREFIX: Base URL for your Sitefinity site

Set this by creating a .env file in the project root:

SITEFINITY_SITE_PREFIX=https://your-sitefinity-site.com

Or set it in your environment before running any server:

# Windows PowerShell
$env:SITEFINITY_SITE_PREFIX="https://your-sitefinity-site.com"

# Linux/macOS
export SITEFINITY_SITE_PREFIX="https://your-sitefinity-site.com"

For a complete list of environment variables, see .

4. Authentication Configuration

Sitefinity web services require authentication for most operations. TahubuSF supports three authentication methods:

Anonymous Access

For public content or services that don't require authentication:

SITEFINITY_AUTH_TYPE=anonymous
API Key Authentication

For web services configured with API key access:

SITEFINITY_AUTH_TYPE=apikey
SITEFINITY_API_KEY=your-api-key-from-sitefinity

In Sitefinity, generate an API key at: Administration → Settings → Advanced → WebServices → WebServiceAccessKey

Access Key

For user-specific authentication:

SITEFINITY_AUTH_TYPE=accesskey
SITEFINITY_AUTH_KEY=your-access-key

In Sitefinity, you can generate an Access Key by following these steps:

  1. Create a user with appropriate permissions for the web service
  2. Navigate to Administration → Users
  3. Click Actions → Generate access key for the specific user
  4. Copy the key immediately (it will only be shown once)

For more details, see Sitefinity's official documentation on generating access keys.

Choose the appropriate authentication method based on your Sitefinity's web services configuration:

  • For "Anonymous users", use anonymous
  • For "API key authentication", use apikey
  • For "Authenticated users", use accesskey

5. FastAPI Dependencies (for Azure Deployment)

If you plan to use the FastAPI server for Azure deployment, install the additional dependencies:

# Within your activated virtual environment:
uv pip install fastapi uvicorn[standard] pydantic

Or if using pip:

# Within your activated virtual environment:
pip install -r requirements.txt
pip install fastapi uvicorn[standard] pydantic

Troubleshooting Dependencies

If you encounter dependency conflicts with packages like LangChain, try these solutions:

  1. Create a separate virtual environment for this project:

    python -m venv fresh_venv
.\fresh_venv\Scripts\Activate.ps1
pip install -r requirements.txt

  2. Use --no-deps flag to avoid dependency resolution conflicts:

    pip install --force-reinstall fastapi==0.110.0 uvicorn[standard]==0.27.0 pydantic==2.6.0 --no-deps

  3. Ensure the correct Python interpreter is being used in VS Code by selecting it from the Python interpreter list.

🚀 Quick Start

For Claude Desktop (MCP Integration)

# 1. Install dependencies
pip install -r requirements.txt

# 2. Start MCP server
python run.py

# 3. Add to Claude Desktop config

For Web/API Access

Start the FastAPI server to access tools via HTTP API:

# Production/Standard Use
cd fastapi_server
python run.py

# Development/Testing (auto-opens browser to Inspector)
python run_fastapi_dev.py

The run_fastapi_dev.py script provides the easiest way to get started - it automatically:

  • Installs dependencies if needed
  • Starts the FastAPI server
  • Opens your browser to the Inspector interface
  • Handles cleanup when you stop the server
API Endpoints

Once the FastAPI server is running, you can access:

Inspector Interface

The web interface provides an easy way to test your MCP tools:

  • inspector/index.html: Main testing interface
  • inspector/css/styles.css: Styling
  • inspector/js/: JavaScript modules for tool interaction

📋 Available Tools

28 Sitefinity MCP Tools including:

📰 Content Management

  • getNews - Get news articles
  • getBlogPosts - Get blog posts with content
  • getBlogPostById - Get a specific blog post by its ID
  • getPages - Get standard pages
  • getSharedContent - Get shared content blocks

📅 Events & Media

  • getEvents - Get calendar events
  • getCalendars - Get available calendars
  • getImages - Get image galleries
  • getDocuments - Get document libraries

🔧 System Operations

  • getSites - Get site information
  • getForms - Get available forms
  • getUsers - Get user accounts
  • searchContent - Search across content types

🛠️ Administrative

  • createContent - Create new content
  • updateContent - Update existing content
  • deleteContent - Delete content
  • publishContent - Publish/unpublish content

🏗️ Architecture

STDIO Transport (MCP)

Claude Desktop → MCP Protocol → STDIO → TahubuSF Server → Sitefinity API

FastAPI Server (HTTP)

Web Browser → HTTP/REST → FastAPI → TahubuSF Tools → Sitefinity API

⚙️ Configuration

Claude Desktop Setup

{
    "mcpServers":{
        "TahubuSF": {
            "command": "uv",
            "args": [
                "--directory",
                "D:\\repos\\TahubuSF",
                "run",
                "run.py"
            ]
        }
    }
}

🧪 Testing

Test MCP Server

# Test server functionality
python -c "from tahubu_sf.app import create_app; app = create_app(); print('✅ MCP Server Working!')"

# Test STDIO transport
python run.py --verbose

Test FastAPI Server

# Automated testing
python fastapi_http_test.py

# Manual API testing
curl http://localhost:8000/health
curl http://localhost:8000/api/list-tools

📂 Project Structure

Project Structure

├── tahubu_sf/           # Core library package
│   ├── api/             # API endpoint modules
│   │   ├── blog_posts.py    # Blog post management endpoints
│   │   ├── news.py          # News-related endpoints
│   │   ├── pages.py         # Pages and templates endpoints
│   │   └── sites.py         # Site information endpoints
│   ├── config/          # Configuration settings
│   │   └── settings.py    # URL and app configuration
│   ├── utils/           # Utility functions
│   │   ├── http.py        # HTTP request utilities
│   │   └── string_utils.py # String manipulation utilities
│   └── app.py           # Application factory
│
├── fastapi_server/      # FastAPI implementation
│   ├── main.py          # FastAPI application definition
│   ├── routes.py        # API route definitions
│   ├── config.py        # Configuration settings
│   ├── wsgi.py          # WSGI entry point
│   ├── azure_deploy.py  # Azure deployment utility
│   └── tests/           # API tests
│
├── inspector/           # Web interface for testing
│   ├── css/             # CSS stylesheets
│   │   └── styles.css   # Main stylesheet
│   ├── js/              # JavaScript files
│   │   ├── utils.js     # Utility functions
│   │   ├── formatters.js # Result formatters
│   │   └── tools.js     # Tool interaction functions
│   └── index.html       # Main HTML page
│
├── media/               # Static media files
├── docs/                # Documentation files
├── run_fastapi_dev.py   # FastAPI development utility to start server and open inspector
├── fastapi_http_test.py # FastAPI HTTP transport and tool testing utility
└── run.py               # Entry point for Claude Desktop

🚢 Deployment

Local Development

# MCP/Claude Desktop
python run.py

# Web/API server and Inspector for development
python run_fastapi_dev.py

# Web/API production server
cd fastapi_server && python run.py

Production (HTTP)

# FastAPI production server
cd fastapi_server
python run.py --host 0.0.0.0 --port 8000

# Or with uvicorn directly
uvicorn main:app --host 0.0.0.0 --port 8000

Docker Deployment

To deploy the FastAPI server using Docker, create a Dockerfile in the fastapi_server directory:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
WORKDIR /app/fastapi_server
CMD ["python", "run.py", "--host", "0.0.0.0", "--port", "8000"]

🔍 API Documentation

When running the FastAPI server, comprehensive API documentation is available at:

🛠️ Development

Adding New Tools

  1. Create tool function in tahubu_sf/api/
  2. Add MCP tool wrapper in tahubu_sf/tools/
  3. Register tool in tahubu_sf/app.py
  4. Test with both STDIO and FastAPI

Contributing

  1. Fork the repository
  2. Create a feature branch
  3. Add tests for new functionality
  4. Submit a pull request

📚 Documentation

  • - STDIO vs HTTP transport
  • - Complete tool documentation
  • - Sitefinity API integration
  • - Configuration guide

🐛 Troubleshooting

Common Issues

Claude Desktop Connection

  • Verify JSON configuration syntax
  • Check file paths (use double backslashes on Windows)
  • Ensure uv is installed and accessible

FastAPI Server

  • Check port availability with netstat -an | findstr :8000
  • Verify Sitefinity API connectivity
  • Review server logs for detailed errors

Dependencies

  • Run pip install -r requirements.txt
  • For uv: Run uv sync to ensure consistency

Support

  • Check Issues for known problems
  • Create new issue with detailed error information
  • Include system details and configuration

Ready to integrate Sitefinity with Claude Desktop and web applications! 🎉

Professional Services

Tahubu offers comprehensive consulting and training services in the following specialized areas:

  • Sitefinity Development & Implementation - Expert guidance on Progress Sitefinity CMS solutions, architecture, and best practices
  • Artificial Intelligence Integration - Strategic AI implementation, workflow optimization, and custom AI solution development
  • Model Context Protocol (MCP) - Advanced consulting on MCP frameworks, integration strategies, and technical implementation

Our experienced team provides tailored solutions to help organizations leverage these cutting-edge technologies effectively. Whether you need strategic guidance, hands-on implementation support, or comprehensive training programs, we deliver results that drive your business forward.

Ready to get started? Contact us today to discuss your project requirements and explore how our expertise can benefit your organization.

Get in Touch: https://tahubu.com/contact