Msty-admin-mcp: AI System Management MCP for Msty Studio 2.4.0+ with Claude Desktop 155 Integration

Msty Admin MCP

Msty Admin MCP is an AI - driven system management tool designed for Msty Studio Desktop version 2.4.0+. It provides 155 tools through Claude Desktop to implement functions such as database query, configuration management, local AI model orchestration, and hierarchical AI workflow construction.

Artificial intelligence chatbots Developer tools #AI management #Local models #Workflow orchestration #Intelligent routing .Python

rating : 2.5 points

downloads : 5.6K

update time : 2026-03-12

Open Site

What is Msty Admin MCP?

Msty Admin MCP is a Model Context Protocol (MCP) server that transforms Claude Desktop into the intelligent administrator of Msty Studio. You no longer need to manage Msty Studio by clicking menus or manually editing configuration files. You can complete all management tasks just by having a conversation with Claude. This tool supports 155 functional tools, covering aspects from basic service status checks to advanced AI orchestration, including autonomous agent groups, intelligent routing, semantic caching, cost analysis, etc.

How to use Msty Admin MCP?

Using Msty Admin MCP is very simple: 1. Install and configure Claude Desktop and the MCP server. 2. Start Msty Studio to ensure all services are running. 3. Directly ask management questions in Claude. For example, you can ask: - "How is the status of my Msty services?" - "Recommend a fast model suitable for programming." - "Export the conversation records of last week." - "Compare the costs of local models and cloud models." Claude will automatically call the corresponding tools, query data, and return clear analysis results.

Use cases

Msty Admin MCP is most suitable for the following scenarios: 1. **System administrators**: Monitor the status of Msty services, manage configurations, and optimize performance. 2. **AI developers**: Test and compare different models, and create automated workflows. 3. **Content creators**: Manage conversation histories, export content, and optimize prompt templates. 4. **Cost - sensitive users**: Track AI usage costs and optimize the use of local and cloud models. 5. **Research teams**: Conduct A/B tests, analyze conversation patterns, and build multi - agent systems.

Main features

Intelligent model management

Automatically detect and classify over 155 AI models, support filtering by tags (programming, creativity, fast, etc.), and provide hardware - aware model recommendations.

Autonomous agent group

Create professional AI agents (code, research, writing, analysis) that work in parallel, automatically synthesize results, and improve the efficiency of complex task processing.

Intelligent routing system

Zero - configuration task classification and model routing, automatically assign tasks to the most suitable model without manual selection.

Cascading execution

Start with a fast model and upgrade to a more powerful model only when necessary, balance speed and quality, and optimize response time.

Semantic response caching

Cache based on embedding similarity, directly return cached results for repeated or similar queries, saving over 95% of costs.

Cost intelligent analysis

Track token usage and costs in real - time, compare the overhead of local and cloud models, and provide budget alerts and optimization suggestions.

A/B testing framework

Conduct comparative experiments between different models, provide statistical analysis and performance reports to help select the best model.

Conversation archaeology

Deeply search historical conversations, extract key decisions, build timelines, and analyze usage patterns.

Predictive model loading

Learn your usage patterns, predict when and which models are needed, and pre - warm to reduce waiting time.

Dynamic role fusion

Dynamically combine multiple AI roles for complex tasks and create a temporary expert team to handle specific problems.

Advantages

🚀 **155 functional tools**: Cover all aspects of Msty Studio management

🤖 **Intelligent automation**: Complete complex management tasks through natural conversations

💰 **Cost optimization**: Semantic caching and intelligent routing can save over 95% of costs

⚡ **Excellent performance**: Cascading execution and predictive loading optimize response speed

🔧 **Easy to use**: No technical background is required, just have a conversation with Claude

📊 **Comprehensive analysis**: Provide detailed performance indicators and cost reports

🔄 **Continuous updates**: Actively maintained, new features are added regularly

🔒 **Privacy protection**: All data processing is done locally

Limitations

🖥️ **Only macOS**: Currently only supports the macOS system (Apple Silicon is recommended)

📦 **Depends on Msty**: Requires Msty Studio 2.4.0+ version

🔌 **Requires Claude Desktop**: Must use Claude Desktop that supports MCP

💾 **Resource consumption**: Running multiple AI services requires sufficient memory

⚙️ **Initial configuration**: Some technical steps are required for the first - time setup

📚 **Learning curve**: It takes time to get familiar with all the functions of 155 tools

How to use

Installation prerequisites

Ensure your system meets the following requirements: - macOS operating system (Apple Silicon is recommended) - Python 3.10 or higher - Msty Studio Desktop 2.4.0+ is installed - Claude Desktop is installed and supports MCP

Download and install the MCP server

Clone the repository and install dependencies:

Configure Claude Desktop

Edit the Claude Desktop configuration file and add the MCP server configuration: 1. Ensure that run_msty_server.sh is executable: chmod +x run_msty_server.sh 2. Edit ~/Library/Application Support/Claude/claude_desktop_config.json

Start and verify

1. Completely restart Claude Desktop (Cmd+Q and then reopen) 2. Ensure that Msty Studio is running 3. In Claude, you should see 155 msty - admin tools available

Start using

Now you can directly have a conversation with Claude to manage Msty Studio. Try the following commands: - "Check the status of my Msty services" - "List all available AI models" - "Recommend a model suitable for programming"

Usage examples

Case 1: System health check

As an Msty Studio administrator, you need to regularly check the system health status.

Case 2: Model selection optimization

You need to select the most suitable AI model for a specific programming task.

Case 3: Cost analysis and optimization

You are worried about high AI usage costs and want to find ways to save expenses.

Case 4: Multi - agent complex task processing

You have a complex project that requires the assistance of multiple professional AI agents.

Case 5: Historical conversation analysis and export

You need to extract specific information from historical conversations or export content.

Frequently Asked Questions

Is Msty Admin MCP free?

Do I need programming knowledge to use it?

Does it support Windows or Linux?

There are too many 155 tools. How should I start?

How is data privacy protected?

What if Claude Desktop cannot see the msty - admin tools?

Can semantic caching really save 95% of costs?

How to update to a new version?

Related resources

GitHub repository

Source code, issue tracking, and the latest version

Msty Studio official website

The official website of the Msty Studio desktop application

Model Context Protocol

Official documentation and specifications of the MCP protocol

Claude Desktop

Claude Desktop download and installation guide

API reference documentation

Detailed API reference and error code descriptions

Development guide

Guide for contributing code and developing extensions

Change log

Version history, new features, and migration instructions

🚀 Msty Admin MCP

AI-Powered Administration for Msty Studio Desktop 2.4.0+

Msty Admin MCP is an MCP (Model Context Protocol) server that transforms Claude into an intelligent system administrator for Msty Studio Desktop. You can query databases, manage configurations, orchestrate local AI models, and build tiered AI workflows—all through natural conversation.

v9.0.0 - Advanced AI Orchestration release with 155 tools! New features include Autonomous Agent Swarms, Intelligent Auto-Router, Cascade Execution, Semantic Caching, Predictive Model Loading, A/B Testing Framework, Cost Intelligence Dashboard, and Dynamic Persona Fusion.

🚀 Quick Start

Prerequisites

macOS (Apple Silicon recommended)
Python 3.10+
Msty Studio Desktop 2.4.0+ installed
Claude Desktop with MCP support

Installation

# Clone the repository
git clone https://github.com/DBSS/msty-admin-mcp.git
cd msty-admin-mcp

# Create virtual environment
python -m venv .venv
source .venv/bin/activate

# Install dependencies
pip install -r requirements.txt

Claude Desktop Configuration

Important: Claude Desktop doesn't always respect the cwd setting, so we use a shell script launcher.

The repository includes run_msty_server.sh. Make sure it's executable:
```
chmod +x run_msty_server.sh
```

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "msty-admin": {
      "command": "/absolute/path/to/msty-admin-mcp/run_msty_server.sh",
      "env": {
        "MSTY_TIMEOUT": "30"
      }
    }
  }
}

Restart Claude Desktop (Cmd+Q, then reopen)
You should see "msty-admin" in your available tools with 155 tools loaded.

✨ Features

About This Fork

👋 Hey! I'm Dmitri K from DigitalKredit.

I picked up this project when it had 24 tools designed for an older Msty Studio architecture with a separate "Sidecar" service that no longer exists in Msty 2.4.0+.

What I did:

🔧 Rewrote the codebase for Msty 2.4.0+ (services now built into main app)
🏗️ Refactored into a clean modular architecture (30+ modules)
📈 Expanded from 24 tools to 155 fully functional tools
✅ Added comprehensive testing (250+ tests)
🚀 Built major new features: AI agent swarms, intelligent routing, cascade execution, semantic caching, cost intelligence, and more

This fork is actively maintained and tested against Msty Studio 2.4.0+.

What's New in v9.0.0

Advanced AI Orchestration - 42 New Tools Across 10 New Phases

Phase	Tools	Description
Phase 26: Intelligent Auto-Router	4	Zero-config task classification and model routing
Phase 27: Autonomous Agent Swarm	5	Spawn specialized AI agents working in parallel
Phase 28: Background Agents	7	Persistent monitoring agents (Code Sentinel, Doc Keeper)
Phase 29: Semantic Response Cache	5	Embedding-based similarity caching for cost savings
Phase 30: Predictive Model Loading	3	Usage pattern analysis for model pre-warming
Phase 31: Conversation Archaeology	5	Deep search, decision extraction, timeline building
Phase 32: A/B Testing Framework	5	Model comparison experiments with statistical analysis
Phase 33: Cascade Execution	4	Confidence-based model escalation (fast→balanced→capable→expert)
Phase 34: Cost Intelligence	7	Token tracking, budget alerts, local vs cloud comparison
Phase 35: Persona Fusion	6	Dynamically combine personas for complex tasks

New Modules (v9.0.0)

Module	Purpose
`smart_router.py`	Intelligent task classification and model routing
`agent_swarm.py`	Multi-agent orchestration with parallel execution
`background_agents.py`	Long-running monitoring agents with alerts
`semantic_cache.py`	Embedding-based response caching
`predictive_loader.py`	Usage pattern learning and prediction
`conversation_archaeology.py`	Deep conversation search and analysis
`ab_testing.py`	A/B experiment framework
`cascade.py`	Tiered model execution with confidence
`cost_intelligence.py`	Cost tracking and optimization
`persona_fusion.py`	Dynamic persona combination
`server_extensions_v3.py`	Extension registration v3

Key Features

🤖 Agent Swarm - Spawn specialized agents (Code, Research, Writing, Analysis) that work in parallel and synthesize results:

swarm_spawn "Build a comprehensive analysis of this codebase"

🎯 Cascade Execution - Start with fast models, escalate to capable ones only when needed:

cascade_smart "Complex reasoning task requiring detailed analysis"

💰 Cost Intelligence - Track spending, compare local vs cloud, get optimization tips:

cost_compare_local_cloud  # Shows 95%+ savings using local models

🔮 Predictive Loading - Learn your usage patterns and pre-warm models:

predict_session_start  # "Based on history, you typically code at 9am"

What's in v8.0.0

36 New Tools Across 10 New Phases

Phase	Tools	Description
Phase 16: Shadow Personas	5	Multi-perspective conversation analysis
Phase 17: Workspaces	4	Workspace management and data isolation
Phase 18: Real-Time Web	3	Web search, URL fetch, YouTube transcripts
Phase 19: Chat Management	4	Export, clone, branch, merge conversations
Phase 20: Folder Organization	4	Conversation folder management
Phase 21: PII Scrubbing	3	13 PII patterns, GDPR/HIPAA compliance
Phase 22: Embedding Visualization	4	Document clustering and similarity
Phase 23: Health Dashboard	3	Service monitoring and alerts
Phase 24: Configuration Profiles	4	Save/load/compare configurations
Phase 25: Automated Maintenance	3	Cleanup, optimization, health scoring

New Modules (v8.0.0)

Module	Purpose
`shadow_personas.py`	Shadow persona integration
`workspaces.py`	Workspace management
`realtime_data.py`	Web/YouTube integration
`chat_management.py`	Chat operations
`folders.py`	Folder organization
`pii_tools.py`	PII detection and scrubbing
`embeddings.py`	Embedding visualization
`dashboard.py`	Health monitoring
`profiles.py`	Configuration profiles
`maintenance.py`	Automated maintenance
`server_extensions_v2.py`	Extension registration v2

Comprehensive Testing

130+ unit tests covering all modules
PII pattern detection validated
Cosine similarity mathematical tests
Maintenance dry-run verification

What's in v7.0.0

35 Tools Across 6 Phases

Phase	Tools	Description
Phase 10: Knowledge Stacks	5	RAG system management - list, search, analyze
Phase 11: Model Management	6	Download/delete models, find duplicates, storage analysis
Phase 12: Claude↔Local Bridge	5	Intelligent model delegation, multi-model consensus
Phase 13: Turnstile Workflows	7	5 built-in automation templates, dry-run execution
Phase 14: Live Context	5	Real-time system/datetime/Msty context for prompts
Phase 15: Conversation Analytics	5	Usage patterns, content analysis, session metrics

Enhanced Tagging System v2.0

Context length awareness: long_context (100K+), very_long_context (250K+), massive_context (500K+)
Quantization detection: fp16, 8bit, 6bit, 5bit, 4bit, 3bit
Architecture tags: moe, mlx, gguf
New size tier: massive (200B+ parameters)

Msty 2.4.0+ Service Support

Service	Port	Description
Local AI Service	11964	Ollama-compatible API
MLX Service	11973	Apple Silicon optimized models
LLaMA.cpp Service	11454	GGUF model support
Vibe CLI Proxy	8317	Unified proxy for all AI services

What is This?

Msty Admin MCP lets you manage your entire Msty Studio installation through Claude Desktop. Instead of clicking through menus or manually editing config files, just ask Claude:

"Show me my Msty personas and suggest improvements"

"Compare my local models on a coding task"

"What models do I have available across all services?"

"Benchmark my fastest model for coding tasks"

Claude handles the rest—querying databases, calling APIs, analysing results, and presenting actionable insights.

💻 Usage Examples

Check Service Status

You: What's the status of my Msty services?

Claude: All 4 services are running:
        ✅ Local AI Service (port 11964) - 2 models
        ✅ MLX Service (port 11973) - 11 models
        ✅ LLaMA.cpp Service (port 11454) - 10 models
        ✅ Vibe CLI Proxy (port 8317) - 36 models

        Total: 59 models available

Benchmark a Model

You: Benchmark my fastest coding model

Claude: Running benchmark on deepseek-coder-v2-lite...

        Results (3 runs each):
        | Context | Tokens/sec | Latency |
        |---------|------------|---------|
        | 50 tokens | 42.3 t/s | 1.2s |
        | 200 tokens | 38.7 t/s | 5.2s |
        | 500 tokens | 35.1 t/s | 14.3s |

        Average: 38.7 tokens/sec

Export Conversations

You: Export my last week's conversations to markdown

Claude: Exported 23 conversations from the last 7 days.

        File: conversations_2026-01-26.md
        Format: Markdown with headers per conversation
        Total messages: 156

Create Prompt Template

You: Create a code review template

Claude: Created template "code-review":

        Template: "Review this {{language}} code for {{focus}}:

                   ```{{language}}
                   {{code}}
                   ```

                   Provide specific suggestions."

        Variables: language, focus, code
        Category: coding

📚 Documentation

API Reference - Error codes, response formats, tool parameters
Development Guide - Contributing, testing, architecture
Changelog - Version history and migration notes

🔧 Technical Details

Available Tools (155 Total)

Phase 1: Installation & Health (7 tools)

Tool	Description
`detect_msty_installation`	Find Msty Studio, verify paths, check running status
`read_msty_database`	Query conversations, personas, prompts, tools
`list_configured_tools`	View MCP toolbox configuration
`get_model_providers`	List AI providers and local models
`analyse_msty_health`	Database integrity, storage, all 4 service status
`get_server_status`	MCP server info and capabilities
`scan_database_locations`	Find database files in common locations

Phase 2: Configuration Management (4 tools)

Tool	Description
`export_tool_config`	Export MCP configs for backup or sync
`import_tool_config`	Validate and prepare tools for Msty import
`generate_persona`	Create personas from templates (opus, coder, writer, minimal)
`sync_claude_preferences`	Convert Claude Desktop preferences to Msty persona

Phase 3: Local Model Integration (8 tools)

Tool	Description
`get_sidecar_status`	Check all 4 services (Local AI, MLX, LLaMA.cpp, Vibe Proxy)
`list_available_models`	Query models from ALL services with breakdown
`query_local_ai_service`	Direct low-level API access
`chat_with_local_model`	Send messages with automatic metric tracking
`recommend_model`	Hardware-aware model recommendations by use case
`list_model_tags`	Get available tags for smart model selection
`find_model_by_tag`	Find models matching specific tags
`get_cache_stats`	View response cache statistics
`clear_cache`	Clear cached responses

Phase 4: Intelligence & Analytics (5 tools)

Tool	Description
`get_model_performance_metrics`	Tokens/sec, latency, error rates over time
`analyse_conversation_patterns`	Privacy-respecting usage analytics
`compare_model_responses`	Same prompt to multiple models, compare quality/speed
`optimise_knowledge_stacks`	Analyse and recommend improvements
`suggest_persona_improvements`	AI-powered persona optimisation

Phase 5: Calibration & Workflow (4 tools)

Tool	Description
`run_calibration_test`	Test models across categories with quality scoring
`evaluate_response_quality`	Score any response using heuristic evaluation
`identify_handoff_triggers`	Track patterns that should escalate to Claude
`get_calibration_history`	Historical results with trends and statistics

Phase 6: Advanced Model Management (4 tools)

Tool	Description
`get_model_details`	Comprehensive model info (context length, parameters, tags, capabilities)
`benchmark_model`	Performance benchmarks at different context sizes (tokens/sec)
`list_local_model_files`	List MLX and GGUF model files on disk with sizes
`estimate_model_requirements`	Estimate memory/hardware requirements for a model

Phase 7: Conversation Management (3 tools)

Tool	Description
`export_conversations`	Export chat history in JSON, Markdown, or CSV format
`search_conversations`	Search through conversations by keyword or title
`get_conversation_stats`	Usage analytics: messages per day, model usage, session lengths

Phase 8: Prompt Templates & Automation (4 tools)

Tool	Description
`create_prompt_template`	Create reusable templates with `{{variable}}` placeholders
`list_prompt_templates`	List all templates, optionally filtered by category
`run_prompt_template`	Execute a template with variable substitutions
`smart_model_router`	Auto-select the best model for a given task description

Phase 9: Backup & System Management (3 tools)

Tool	Description
`backup_configuration`	Create comprehensive backup of personas, prompts, templates, tools
`restore_configuration`	Restore configuration from a backup file
`get_system_resources`	CPU, memory, and disk usage relevant to AI inference

Model Tagging System

Msty Admin MCP includes a smart model tagging system with 60+ model-specific overrides for accurate routing.

Available Tags

Category	Tags	Description
Size	`large`, `medium`, `small`	Model parameter count (70B+, 13-34B, <13B)
Speed	`fast`	Quick response models (Haiku, Flash, Mini, etc.)
Capability	`coding`, `reasoning`, `creative`, `vision`, `embedding`	Specialized capabilities
Context	`long_context`	Models with 128K+ context windows
Quality	`quality`	High-quality output models
General	`general`	General-purpose models

Finding Models by Tag

You: Find me a fast coding model

Claude: Using find_model_by_tag with tag="coding" and prefer_fast=true...

        Found 3 fast coding models:
        1. deepseek-coder-v2-lite (fast, coding, small)
        2. codestral-mini (fast, coding, small)
        3. starcoder2-3b (fast, coding, small)

Smart Model Router

You: What's the best model for writing a poem?

Claude: Using smart_model_router with task="writing a poem"...

        Recommended: claude-3-opus (tags: quality, creative, reasoning, large)
        Reasoning: Creative writing tasks benefit from models with
        the 'creative' tag and high quality output.

Environment Variables

Customize behavior with these environment variables:

Variable	Default	Description
`MSTY_SIDECAR_HOST`	`127.0.0.1`	Service host address
`MSTY_AI_PORT`	`11964`	Local AI Service port
`MSTY_MLX_PORT`	`11973`	MLX Service port
`MSTY_LLAMACPP_PORT`	`11454`	LLaMA.cpp Service port
`MSTY_VIBE_PORT`	`8317`	Vibe CLI Proxy port
`MSTY_TIMEOUT`	`10`	API request timeout (seconds)
`MSTY_DATABASE_PATH`	(auto-detect)	Override database path

Architecture

┌─────────────────────────────────────────────────────────────┐
│                      Claude Desktop                          │
│                           │                                  │
│                      MCP Protocol                            │
│                           │                                  │
│                ┌──────────┴──────────┐                      │
│                ▼                     ▼                      │
│      ┌─────────────────┐   ┌─────────────────┐             │
│      │ Msty Admin MCP  │   │  Other MCPs     │             │
│      │   (42 tools)    │   │                 │             │
│      └────────┬────────┘   └─────────────────┘             │
└───────────────┼─────────────────────────────────────────────┘
                │
     ┌──────────┴──────────────────────────────┐
     ▼                                         ▼
┌──────────┐                          ┌──────────────────┐
│  Msty    │                          │   Msty Studio    │
│ Database │                          │   2.4.0+ App     │
│ (SQLite) │                          └────────┬─────────┘
└──────────┘                                   │
                          ┌────────────────────┼────────────────────┐
                          ▼                    ▼                    ▼
                   ┌────────────┐      ┌────────────┐      ┌────────────┐
                   │ Local AI   │      │    MLX     │      │ LLaMA.cpp  │
                   │  :11964    │      │   :11973   │      │   :11454   │
                   └────────────┘      └────────────┘      └────────────┘
                          │                    │                    │
                          └────────────────────┼────────────────────┘
                                               ▼
                                        ┌────────────┐
                                        │ Vibe Proxy │
                                        │   :8317    │
                                        └────────────┘

Project Structure

msty-admin-mcp/
├── src/
│   ├── __init__.py         # Package exports
│   ├── constants.py        # Configuration constants
│   ├── models.py           # Data classes
│   ├── errors.py           # Standardized error handling
│   ├── paths.py            # Path resolution utilities
│   ├── database.py         # SQL operations (injection protected)
│   ├── network.py          # API request helpers
│   ├── cache.py            # Response caching
│   ├── tagging.py          # Model tagging system
│   ├── server.py           # Main MCP server (42 tools)
│   └── phase4_5_tools.py   # Metrics and calibration
├── tests/
│   ├── test_server.py      # Integration tests
│   ├── test_constants.py   # Constants tests
│   ├── test_paths.py       # Path utilities tests
│   ├── test_database.py    # Database tests (SQL injection)
│   ├── test_network.py     # Network tests
│   ├── test_cache.py       # Cache tests
│   └── test_tagging.py     # Tagging tests
├── docs/
│   ├── API.md              # API reference & error codes
│   └── DEVELOPMENT.md      # Development guide
├── run_msty_server.sh      # Shell script launcher (required!)
├── requirements.txt
├── pyproject.toml
├── CHANGELOG.md
├── LICENSE
└── README.md

📄 License

MIT License - see LICENSE for details.

Troubleshooting

"ModuleNotFoundError: No module named 'src'"

Claude Desktop isn't running from the correct directory. Make sure you're using the shell script launcher (run_msty_server.sh) instead of calling Python directly.

"No Local AI services are running"

Open Msty Studio
Go to Settings → Local AI / MLX / LLaMA.cpp
Make sure the services show "Running"

Claude doesn't see the msty-admin tools

Check your claude_desktop_config.json has the correct absolute path
Make sure run_msty_server.sh is executable (chmod +x)
Restart Claude Desktop completely (Cmd+Q, then reopen)

Only seeing 2 embedding models

The models shown depend on which service responds first. Use list_available_models to see ALL models from all services with the by_service breakdown.

Database not found

Run detect_msty_installation first to verify paths
Use scan_database_locations to find database files
Set MSTY_DATABASE_PATH environment variable if needed

Security

See docs/API.md for details on:

SQL Injection Protection - Table allowlists, parameterized queries
API Key Handling - Keys are never logged or returned
Network Security - All calls to localhost, configurable timeouts

Contributing

Contributions welcome! Please:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Run tests (pytest tests/ -v)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

See docs/DEVELOPMENT.md for detailed contribution guidelines.

Credits

Original Author: Pineapple - Created the original msty-admin-mcp
v5.0.0+ Fork: DigitalKredit - Msty 2.4.0+ compatibility, modular architecture

Acknowledgements

Msty Studio - The excellent local AI application this MCP administers
Anthropic - For Claude and the MCP protocol
Model Context Protocol - The foundation making this possible

ks_list_stacks

List all knowledge stacks and their metadata

ks_get_details

Get detailed information about a specific knowledge stack

Parameters

stack_id : str*

Description

Knowledge stack identifier

ks_search

Search within a knowledge stack

Parameters

stack_id : str*

Description

Knowledge stack to search

Parameters

query : str*

Description

Search query

Parameters

limit : int*

Description

Maximum number of results (default: 10)

ks_analyze

Analyze the quality and optimization of a knowledge stack

Parameters

stack_id : str*

Description

Knowledge stack to analyze

ks_statistics

Get aggregated statistical information for all knowledge stacks

model_inventory

Get a complete inventory of local AI models

model_delete

Delete a local model file

Parameters

model_path : str*

Description

Full path of the model file

Parameters

confirm : bool*

Description

Must be True to actually delete

model_find_duplicates

Find duplicate model files

model_check_hf

Check the HuggingFace model repository

Parameters

repo_id : str*

Description

HuggingFace repository ID (e.g., 'meta - llama/Llama - 2 - 7b')

model_download_guide

Get the download guide for a model

Parameters

repo_id : str*

Description

HuggingFace repository ID

Parameters

model_type : str*

Description

Model type (auto, mlx, gguf)

model_storage_analysis

Analyze model storage usage and recommend cleanup

bridge_select_model

Select the best local model for a task

Parameters

task_type : str*

Description

Task type (coding, reasoning, creative, general)

Parameters

prefer_speed : bool*

Description

Prioritize faster models

Parameters

prefer_quality : bool*

Description

Prioritize higher - quality models

Parameters

max_size : Optional[str]*

Description

Maximum model size (small, medium, large)

bridge_delegate

Delegate a task to a local model

Parameters

prompt : str*

Description

Prompt to send

Parameters

task_type : str*

Description

Task type for model selection

Parameters

model_id : Optional[str]*

Description

Specific model (optional)

Parameters

system_prompt : Optional[str]*

Description

System prompt (optional)

Parameters

temperature : float*

Description

Sampling temperature

Parameters

max_tokens : int*

Description

Maximum number of response tokens

bridge_consensus

Get consensus from multiple local models

Parameters

prompt : str*

Description

Prompt sent to all models

Parameters

models : Optional[List[str]]*

Description

Specific models to use (optional)

Parameters

num_models : int*

Description

Number of models to use if no models are specified

Parameters

voting_method : str*

Description

Method for determining consensus

bridge_draft_refine

Draft using a local model and prepare for optimization by Claude

Parameters

prompt : str*

Description

Content prompt

Parameters

draft_model : Optional[str]*

Description

Model for drafting (optional)

Parameters

refine_instructions : Optional[str]*

Description

Optimization instructions

Parameters

task_type : str*

Description

Content type

bridge_parallel_tasks

Process multiple tasks in parallel across models

Parameters

tasks : List[Dict[str, Any]]*

Description

List of task dictionaries, containing 'prompt' and optional 'task_type', 'model'

Parameters

max_concurrent : int*

Description

Maximum number of concurrent tasks

turnstile_list

List all Turnstile workflows

turnstile_details

Get detailed information about a specific turnstile

Parameters

turnstile_id : str*

Description

Turnstile identifier

turnstile_templates

List available turnstile templates

turnstile_get_template

Get a specific turnstile template

Parameters

template_id : str*

Description

Template identifier

turnstile_execute

Execute or preview a turnstile workflow

Parameters

template_id : str*

Description

Template to execute

Parameters

input_data : str*

Description

Input for the workflow

Parameters

variables : Optional[Dict[str, str]]*

Description

Additional variables

Parameters

dry_run : bool*

Description

Preview only (default: True)

turnstile_analyze

Analyze turnstile usage patterns

turnstile_suggest

Recommend a turnstile template for a task

Parameters

task_description : str*

Description

Task description

context_system

Get system context (CPU, memory, disk)

context_datetime

Get the current date - time context

context_msty

Get Msty - specific context

context_full

Get the complete aggregated real - time context

Parameters

include_system : bool*

Description

Include system information

Parameters

include_datetime : bool*

Description

Include date - time

Parameters

include_environment : bool*

Description

Include environment information

Parameters

include_processes : bool*

Description

Include process information

Parameters

include_msty : bool*

Description

Include Msty information

context_for_prompt

Get the context formatted for an AI prompt

Parameters

context_type : str*

Description

Context type (full, system, datetime, msty)

Parameters

style : str*

Description

Output style (markdown, text, json)

analytics_usage

Analyze conversation usage patterns

Parameters

days : int*

Description

Number of days to analyze

analytics_content

Analyze conversation content patterns (privacy - protected)

Parameters

conversation_id : Optional[str]*

Description

Specific conversation (optional)

Parameters

sample_size : int*

Description

Number of messages to sample

analytics_models

Analyze model performance across conversations

Parameters

days : int*

Description

Number of days to analyze

analytics_sessions

Analyze session patterns and behavior

Parameters

days : int*

Description

Number of days to analyze

analytics_report

Generate a comprehensive analysis report

Parameters

days : int*

Description

Number of days to analyze

Parameters

include_usage : bool*

Description

Include usage analysis

Parameters

include_content : bool*

Description

Include content analysis

Parameters

include_models : bool*

Description

Include model analysis

Parameters

include_sessions : bool*

Description

Include session analysis

Gitlab MCP Server

Certified

The GitLab MCP server is a project based on the Model Context Protocol that provides a comprehensive toolset for interacting with GitLab accounts, including code review, merge request management, CI/CD configuration, and other functions.

A Python-based MCP Server that provides advanced to-do list management and content organization functions through the Notion API, enabling seamless integration between AI models and Notion.

Python

20.4K

4.5 points

Duckduckgo MCP Server

Certified

The DuckDuckGo Search MCP Server provides web search and content scraping services for LLMs such as Claude.

Markdownify is a multi-functional file conversion service that supports converting multiple formats such as PDFs, images, audio, and web page content into Markdown format.

UnityMCP is a Unity editor plugin that implements the Model Context Protocol (MCP), providing seamless integration between Unity and AI assistants, including real - time state monitoring, remote command execution, and log functions.

31.1K

5 points

Figma Context MCP

Framelink Figma MCP Server is a server that provides access to Figma design data for AI programming tools (such as Cursor). By simplifying the Figma API response, it helps AI more accurately achieve one - click conversion from design to code.

A Gmail automatic authentication MCP server designed for Claude Desktop, supporting Gmail management through natural language interaction, including complete functions such as sending emails, label management, and batch operations.

Context7 MCP is a service that provides real-time, version-specific documentation and code examples for AI programming assistants. It is directly integrated into prompts through the Model Context Protocol to solve the problem of LLMs using outdated information.

TypeScript

96.8K

4.7 points

Zhiqi Future, Your AI Solution Think Tank

English 简体中文繁體中文にほんご

Msty Admin MCP

Overview

Installation

Tools List

Content Details

Alternatives

What is Msty Admin MCP?

How to use Msty Admin MCP?

Use cases

Main features

How to use

Usage examples

Frequently Asked Questions

Related resources

Installation

🚀 Msty Admin MCP

🚀 Quick Start

Prerequisites

Installation

Claude Desktop Configuration

✨ Features

About This Fork

What's New in v9.0.0

Advanced AI Orchestration - 42 New Tools Across 10 New Phases

New Modules (v9.0.0)

Key Features

What's in v8.0.0

36 New Tools Across 10 New Phases

New Modules (v8.0.0)

Comprehensive Testing

What's in v7.0.0

35 Tools Across 6 Phases

Enhanced Tagging System v2.0

Msty 2.4.0+ Service Support

What is This?

💻 Usage Examples

Check Service Status

Benchmark a Model

Export Conversations

Create Prompt Template

📚 Documentation

🔧 Technical Details

Available Tools (155 Total)

Phase 1: Installation & Health (7 tools)

Phase 2: Configuration Management (4 tools)

Phase 3: Local Model Integration (8 tools)

Phase 4: Intelligence & Analytics (5 tools)

Phase 5: Calibration & Workflow (4 tools)

Phase 6: Advanced Model Management (4 tools)

Phase 7: Conversation Management (3 tools)

Phase 8: Prompt Templates & Automation (4 tools)

Phase 9: Backup & System Management (3 tools)

Model Tagging System

Available Tags

Finding Models by Tag

Smart Model Router

Environment Variables

Architecture

Project Structure

📄 License

Troubleshooting

"ModuleNotFoundError: No module named 'src'"

"No Local AI services are running"

Claude doesn't see the msty-admin tools

Only seeing 2 embedding models

Database not found

Security

Contributing

Credits

Acknowledgements

Alternatives