DevToolkit MCP server
Commit Nov 10, 2026Provides AI assistants with tools for repository analysis, Python code explanation, error debugging, dependency checking, and test execution.
Also known as Prashil001/devtoolkit-mcp
- Stars
- 0
- Tools
- 9
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 10, 2026
- License
- MIT
What is DevToolkit MCP?
DevToolkit provides AI assistants with tools for repository analysis, Python code explanation, error debugging, dependency checking, and test execution. It exposes 9 tools, such as repository_path, max_files, code.
Summary generated from the project's README
About DevToolkit MCP server
Software developers can use DevToolkit MCP to provide AI assistants with specialized capabilities for managing Python projects. By connecting this server to an MCP-compatible client like Claude Desktop, an AI can directly interact with your local codebase to perform deep technical tasks. The server functions as a bridge that allows a model to inspect directory structures, parse code logic, and manage testing workflows.
Users can deploy the server locally using uv or pip. The toolkit includes specific tools such as analyze_repository for project inspection, explain_code for AST-based Python analysis, and analyze_error for processing tracebacks. It also features check_dependencies to identify outdated or vulnerable packages via PyPI and OSV, and run_tests to execute pytest or unittest suites. Because it is model-independent, it works with any client following the Model Context Protocol without requiring specific LLM provider credentials.
What you can do with it
- 1Map project architectureAsk your AI assistant to provide a detailed overview of your local directory structure and file types.
- 2Deconstruct Python logicHave an AI explain the specific classes, functions, and imports within a Python source file.
- 3Debug Python exceptionsProvide a traceback to the AI to identify the exact exception type and error message.
- 4Audit package securityInstruct the assistant to scan requirements.txt or pyproject.toml for known vulnerabilities.
- 5Automate test verificationRequest that the AI runs your existing test suites and reports the execution status.
Written from the project's README. Every use case is checked against a quote from it.
DevToolkit MCP tools 9
Detected from the READMErepository_pathmax_filescodefile_patherror_textproject_pathtimeoutpytestunittest
Automated checks
Ran Nov 15, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableprashil001/devtoolkit-mcp is public and reachablegithub.com/prashil001/devtoolkit-mcp ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-10github.com/prashil001/devtoolkit-mcp ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model9 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubDevToolkit MCP
A lightweight, model-independent MCP server that gives AI assistants practical software development tools.
DevToolkit MCP is an open-source Model Context Protocol (MCP) server that exposes essential software development utilities as tools that AI assistants can call.
It helps AI assistants inspect Python projects, understand code, analyze errors, check dependencies, and execute tests through a standardized MCP interface.
The server is designed to be simple, extensible, and independent of any specific AI model or provider.
Features
- Repository Analysis: Inspect project structure, file types, and configuration files.
- Code Explanation: Analyze Python code using Abstract Syntax Trees (AST).
- Error Analysis: Extract useful information from Python exceptions and tracebacks.
- Dependency Checking: Identify dependency versions and check for known vulnerabilities.
- Test Execution: Detect and execute pytest or unittest test suites.
- MCP Integration: Connect compatible AI assistants through the Model Context Protocol.
- Model Independent: Works with MCP-compatible clients without requiring a specific LLM provider.
Available Tools
DevToolkit MCP currently provides five tools.
1. analyze_repository
Analyzes a local project directory and returns information about its structure.
Parameters
| Parameter | Type | Default | Description |
|---|---|---|---|
repository_path |
string | Required | Path to the project directory |
max_files |
integer | 5000 | Maximum number of files to inspect |
Returns
- Project directory information
- File and directory statistics
- File extension distribution
- Detected languages and configuration files
- Project structure information
2. explain_code
Analyzes Python source code or a Python file using AST parsing.
Parameters
| Parameter | Type | Default | Description |
|---|---|---|---|
code |
string or null | None | Python source code |
file_path |
string or null | None | Path to a Python file |
Provide either code or file_path.
Returns
- Functions and classes
- Methods and imports
- Code structure and statistics
- Syntax errors, when present
3. analyze_error
Analyzes Python exceptions and traceback text.
Parameters
| Parameter | Type | Description |
|---|---|---|
error_text |
string | Python exception or traceback |
Returns
- Exception type
- Error message
- File and line information, when available
- Traceback details
- Structured error information
4. check_dependencies
Checks project dependencies and retrieves package information from external vulnerability and package registries.
Parameters
| Parameter | Type | Description |
|---|---|---|
project_path |
string | Path to the Python project |
Supported dependency files
requirements.txtpyproject.toml
Returns
- Detected dependencies
- Declared dependency versions
- Latest available versions from PyPI
- Known vulnerability information from OSV, when available
Network access is required for live PyPI and OSV checks. Network failures are handled without treating unavailable data as a clean security result.
5. run_tests
Automatically detects and executes Python test suites.
Parameters
| Parameter | Type | Default | Description |
|---|---|---|---|
project_path |
string | Required | Path to the project directory |
timeout |
integer | 120 | Maximum execution time in seconds (1–600) |
Supported frameworks
- pytest
- unittest
Returns
- Detected testing framework
- Test execution status
- Process exit code
- Test output
- Timeout or execution error information, when applicable
The tool prefers pytest when both frameworks are detected and uses the project's virtual environment when available.
Installation
Using uv (recommended)
uv tool install devtoolkit-mcp
Alternatively, run it without permanently installing:
uvx devtoolkit-mcp
Using pip
pip install devtoolkit-mcp
MCP Client Configuration
Add DevToolkit MCP to an MCP-compatible client.
Claude Desktop
Open your Claude Desktop configuration file and add:
{
"mcpServers": {
"devtoolkit-mcp": {
"command": "uvx",
"args": ["devtoolkit-mcp"]
}
}
}
Restart Claude Desktop after saving the configuration.
Other MCP-compatible clients
Use the following command to launch the server:
uvx devtoolkit-mcp
Configure your client to launch this command using its supported MCP transport configuration.
Example Use Cases
Once connected to an MCP-compatible AI assistant, you can ask it to:
- "Analyze the structure of my Python project."
- "Explain the classes and functions in this Python file."
- "Analyze this traceback and identify the exception."
- "Check my project's dependencies for outdated or vulnerable packages."
- "Run the tests in my project and show me the results."
The AI assistant decides when to invoke the available tools based on the user's request and the MCP client.
Architecture
AI Assistant
|
|
MCP-Compatible Client
|
|
DevToolkit MCP
|
+--------+--------+
| | |
v v v
Repository Code Error
Analysis Analysis Analysis
|
+----------------+
| |
v v
Dependency Test
Checking Execution
DevToolkit MCP uses the Model Context Protocol to expose development utilities through standardized tool interfaces.
Technology Stack
| Technology | Purpose |
|---|---|
| Python 3.11+ | Core implementation |
| FastMCP | MCP server and tool registration |
| AST | Python source code analysis |
| httpx | HTTP requests to external APIs |
| packaging | Python dependency version parsing |
| pytest | Automated testing |
| Ruff | Linting and formatting |
| uv | Python project and package management |
Project Structure
devtoolkit-mcp/
│
├── src/
│ └── devtoolkit_mcp/
│ ├── tools/
│ │ ├── repository.py
│ │ ├── explain_code.py
│ │ ├── analyze_error.py
│ │ ├── check_dependencies.py
│ │ └── run_tests.py
│ │
│ └── server.py
│
├── tests/
│
├── .github/
│ └── workflows/
│ └── publish.yml
│
├── LICENSE
├── README.md
├── pyproject.toml
└── uv.lock
Development Setup
1. Clone the repository
git clone https://github.com/Prashil001/devtoolkit-mcp.git
cd devtoolkit-mcp
2. Install dependencies
uv sync --dev
3. Run tests
uv run pytest -v
4. Run linting
uv run ruff check .
5. Check formatting
uv run ruff format --check .
6. Run the MCP server
uv run devtoolkit-mcp
Security Considerations
- Repository inspection is restricted to validated local project directories.
- Test execution uses subprocesses without shell command interpretation.
- Test execution has a configurable timeout.
- Dependency vulnerability checks use external public APIs.
- Tool execution should only be allowed on project directories the user trusts.
- Do not expose sensitive project files or credentials to AI clients unnecessarily.
Contributing
Contributions, bug reports, and feature suggestions are welcome.
- Fork the repository.
- Create a feature branch.
- Make your changes.
- Add or update tests.
- Run the test suite and Ruff checks.
- Submit a pull request.
Please keep contributions focused on improving the existing five tools unless the project scope is explicitly expanded.
License
This project is licensed under the MIT License.
See the LICENSE file for details.
Author
Prashil001
- GitHub: https://github.com/Prashil001
- Repository: https://github.com/Prashil001/devtoolkit-mcp
If you find DevToolkit MCP useful, consider giving the repository a ⭐ on GitHub.
Built to make AI-assisted software development more capable through MCP.
DevToolkit MCP questions
What tools does DevToolkit MCP provide?
It exposes 9 tools, including repository_path, max_files, code, file_path, error_text.
Can it check for security vulnerabilities in my dependencies?
Yes, it retrieves known vulnerability information from OSV when available.
Does it require internet access?
Network access is required for performing live PyPI and OSV dependency checks.