project-mcp-tools
Provides C++ development tools including parallel compilation with Clang, static analysis with cppcheck, code formatting verification, class and test scaffolding, and include dependency tree analysis.
Provides git operations including quick upload (pull, add, commit, push), discarding uncommitted changes and untracked files, and updating submodules to the latest remote commits.
Provides image generation and interpretation using Google's Gemini models, allowing creation of images from text descriptions and analysis of existing images.
Provides Python code analysis and formatting verification tools to check Python files against formatting rules and clean up cache directories.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@project-mcp-toolsCompile the C++ project"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
project-mcp-tools
A Python framework that exposes developer tools simultaneously through three protocols: MCP (Model Context Protocol), REST API, and CLI — all from a single, shared tool registry.
Overview
project-mcp-tools solves the problem of maintaining separate tool backends for different consumers. Write a tool once using the @tool() decorator, and it becomes instantly available to:
AI assistants via the MCP protocol (powered by FastMCP)
HTTP clients via a REST API (powered by FastAPI + uvicorn)
Terminal users via a CLI (powered by argparse)
The bundled tools cover C++ development (compile, static analysis, formatting, class/test scaffolding, include tree analysis), Python formatting verification, and git operations — all with process isolation through subprocess execution.
Installation
Requirements: Python 3.14+, uv package manager
# Clone the repository
git clone <repository-url>
cd project-mcp-tools
# Install dependencies
uv syncUsage
MCP Server
Starts a FastMCP server that AI assistants can connect to:
uv run mcp-serverConfigure your MCP client to use this server. For example, in opencode.json at the root of the host project (the project you want the tools to operate on, not the project-mcp-tools directory itself):
{
"mcp": {
"project-mcp-tools": {
"type": "local",
"command": ["uv", "--directory", "project-mcp-tools", "run", "mcp-server", "--target-project", "../my-host-project"]
}
}
}Important:
--directorytellsuvwhere to find theproject-mcp-toolspackage (pyproject.toml, dependencies, venv).--target-projectsets the working directory for the MCP process and all its subprocesses — this is the project the tools will actually operate on. The path is resolved relative toproject-mcp-tools/(sinceuv --directorychanges the working directory). Without this separation, git/cpp/python tools would operate insideproject-mcp-tools/instead of your host project.
REST API Server
Starts a FastAPI server on http://0.0.0.0:8000:
uv run api --target-project ../my-host-projectEach tool is exposed as POST /tools/<tool_name>. Query parameters from the tool's function signature become fields in the JSON request body.
Example request:
curl -X POST http://localhost:8000/tools/git_quick_upload \
-H "Content-Type: application/json" \
-d '{"message": "my commit"}'Swagger UI is available at http://localhost:8000/docs.
CLI
Invoke any tool from the terminal:
uv run cli --target-project ../my-host-project git_quick_upload --message "your commit message"--target-project must come before the tool name. Tools that don't reference the host project (e.g., get_random_number) can be called without --target-project.
Tool Catalog
General
Tool | Signature | Description |
|
| Generates an image using Gemini (model |
|
| Interprets an image from the target project using Gemini vision (fixed model |
|
| Returns environment debugging information (cwd, paths, env vars) |
|
| Returns a random number between start and end |
Git
Tool | Signature | Description |
|
| Discards all uncommitted changes and removes untracked files. Reverts to HEAD |
|
| Updates every submodule to the latest remote commit (requires clean submodules); the pointer bump is left uncommitted |
|
| Performs |
Python
Tool | Signature | Description |
|
| Applies |
|
| Removes all |
|
| Verifies Python formatting rules for specified files |
C++
Tool | Signature | Description |
|
| Applies formatting fixes on all |
|
| Verifies C++ formatting rules for specified files |
|
| Compiles the entire C++ project in parallel using Clang |
|
| Scaffolds a new C++ class from a hierarchy string (e.g., |
|
| Scaffolds a C++ test file |
|
| Displays the recursive include dependency tree of a C++ file. Defaults to the project main file |
|
| Generates |
Session
Tool | Signature | Description |
|
| Reports how much of the model context window the current opencode chat session is using ( |
Project Structure
project-mcp-tools/
├── main.py # Entry point — builds tool_manager, starts servers
├── pyproject.toml # Project config, dependencies, entry points
├── tools/ # Core engine package
│ ├── __init__.py
│ ├── tool_manager.py # Core orchestrator — shared registry, tool folder loading, subprocess dispatch, CLI/API/MCP exposure
│ ├── tool.py # @tool() decorator, ToolInfo/ParameterInfo models, response contract helpers
│ ├── path_manager.py # Project/target root resolution — injectable, no global state
│ └── folder_scanner.py # Auto-discovers @tool-decorated functions in directories
├── general/ # General-purpose tools (no host project dependency)
│ ├── create_image.py # Gemini image generation tool
│ ├── describe_image.py # Gemini image interpretation tool
│ ├── debug.py # Environment debugging tool
│ └── get_random_number.py # Random number generator
├── sak/
│ ├── common.py # Utilities (process creation, JSON, assertions)
│ └── fso/ # File system objects
├── lib/
│ ├── base_verifier.py # Abstract regex-based code formatter
│ ├── project_config.py # Global project configuration
│ ├── project_file.py # Abstract source file with license header management
│ └── template.py # Jinja-like template engine with imports and lists
├── cpp/
│ ├── analyze.py # C++ full analysis tool
│ ├── code_verifier.py # C++ formatting verification tool
│ ├── compile.py # C++ parallel compilation tool
│ ├── create_class.py # C++ class scaffolding tool
│ ├── create_test.py # C++ test scaffolding tool
│ ├── include_tree.py # C++ include dependency tree tool
│ └── cpp_lib/ # C++ domain library (compiler, model, verifier, build)
├── python/
│ ├── analyze.py # Python full analysis tool
│ ├── code_verifier.py # Python formatting verification tool
│ └── python_lib/ # Python domain library (model, verifier, config)
├── session/
│ ├── context_usage.py # opencode session context usage tool
│ └── session_lib/ # Session domain library (opencode database reader)
├── git/
│ ├── discard_changes.py # Git reset + clean tool
│ └── quick_upload.py # Git pull/add/commit/push tool
├── resources/
│ └── images/ # Generated images (from create_image tool)
├── .agents/
│ └── skills/ # AI assistant skills (compliance audit, uv package manager)
└── docs/
├── templates/ # Template files for class/test scaffolding (user zone)
├── example/ # Usage examples (e.g. google-genai.py) (user zone)
└── agent/ # AI-managed knowledge base (architecture, guides, workflows, status)
├── architecture.md # System architecture and design decisions
├── development/ # Tool development guide
├── style-guide/ # Coding style guides
├── workflow/ # Workflow documentation
└── status.md # Agent task statusArchitecture
The system is built around a central tool_manager object that holds the shared tool registry and handles all three transports (CLI, REST API, and MCP).
For a detailed breakdown of the system architecture, design decisions, and target project mechanism, see the System Architecture guide.
Adding a New Tool
To add a new tool, create a Python file in an existing tool folder (or a new one) and decorate your function with @tool().
For a step-by-step tutorial and guidelines on structuring the tool layer and domain libraries, see the Tool Development Guide.
Configuration
Global and domain-specific configurations are centralized in the codebase. For a complete list of configuration keys and values, see System Architecture - Centralized Configuration.
Coding Conventions
All code in this project must adhere to strict guidelines, including the exclusive use of snake_case for all identifiers and specific spacing rules. For the complete set of guidelines, see the Python Style Guide.
License
GNU General Public License v3.0 — see the license headers in source files for details.
This server cannot be installed
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Package intelligence MCP for AI agents — 22 tools, 19 ecosystems, AGPL SDK, free.
Free public MCP for AI agents — 193 tools, 44 workflows. No API key.
AI Reasoning Cache & Consensus Layer with 11 MCP tools via Streamable HTTP.
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/maxwellaguiarsilva/project-mcp-tools'
If you have feedback or need assistance with the MCP directory API, please join our Discord server