Provides information about installed Arduino SDKs and connected Arduino devices through serial ports.
Detects and reports on installed Bazel build system configuration and usage in the development environment.
Identifies CMake installations and provides information about CMake-based build configurations.
Reports on installed DigitalOcean SDK and configuration settings for cloud development.
Provides information about running Docker containers and Docker installation details.
Detects ESLint installations and configuration files for code linting information.
Reports on Git configuration, remote origins, and repository details.
Provides information about GitHub Codespaces configuration and integration.
Detects and reports on Gitpod remote code execution environment configurations.
Identifies installed Haskell compiler (ghc) and development tools.
Lists Homebrew installed packages and provides version information on macOS and Linux.
Detects Jest testing framework installations and configuration.
Reports on installed JetBrains IDEs and their configuration settings.
Provides information about installed Jupyter kernels and notebook environments.
Reports on local Kubernetes configuration and kubectl installation details.
Provides detailed system information for Linux operating systems, including WSL configurations.
Provides detailed system information for macOS including hardware details and configurations.
Identifies Make build tool installations and detects Makefiles in projects.
Reports on Neovim editor installation and configuration details.
Provides information about installed Node.js versions and environments.
Lists globally installed NPM packages and reports on NPM configuration.
Reports on NVIDIA GPU installations and provides detailed GPU information.
Detects Node Version Manager installations and configured Node.js versions.
Identifies installed Perl interpreter and development environment details.
Reports on PHP installation details and configuration information.
Provides information about Podman container installations and running containers.
Detects Poetry Python package manager installation and managed environments.
Identifies Prettier code formatter installations and configuration settings.
Reports on Pulumi infrastructure as code tool installations and configurations.
Detects Python pytest testing framework installations and configuration.
Provides comprehensive information about Python installations, packages, and environments.
Reports on PyTorch installations and GPU availability for machine learning development.
Identifies Raspberry Pi development tools and connected Pi devices.
Reports on Ruby interpreter installations and environment configurations.
Provides information about Rust toolchain installations and cargo packages.
Reports on available shells, shell configurations, aliases, and functions.
Detects TensorFlow installations and reports on GPU availability for AI development.
Identifies Terraform installation and infrastructure configuration files.
Reports on Vagrant virtual development environment installations and configurations.
Provides information about Vim editor installations and configuration settings.
Detects VirtualBox installations and reports on configured virtual machines.
Identifies VMware installations and reports on configured virtual machines.
Lists globally installed Yarn packages and provides Yarn configuration information.
Reports on Zsh shell installation, configuration files, and customizations.
DevEnvInfoServer - Cursor MCP Server for Development Environment Information
This project implements a Cursor Model Context Protocol (MCP) server that provides detailed information about your development environment to the Cursor code editor. By leveraging this server, Cursor's intelligent agent can gain a deeper understanding of your system's configuration, installed tools, and running processes, enabling more context-aware and helpful assistance.
Features
This MCP server provides the following information categories about your development environment:
- System Information:
- Operating System Version and Platform Details
- Hardware Details (Processor, Machine, System Architecture)
- Python Versions and Locations
- Installed Package Managers (brew, npm, pip, yarn, uv, conda) and their versions
- Virtual Environment Information (detected environments and active environment)
- System Locale and Timezone
- Top 20 Environment Variables
- Available Shells (bash, zsh, fish, sh, powershell, cmd.exe)
- Simplified Firewall and Network Configurations (OS-dependent)
- Development Environment Details:
- Installed Compilers and Interpreters (gcc, clang, javac, node, ruby, perl, php, ghc, rustc, go)
- Jupyter Kernels and Running Containers (Docker, Podman)
- Virtual Machines (Hyper-V, VMware, VirtualBox)
- GPU and CUDA Information (NVIDIA GPUs and CUDA Compiler Version)
- Top Running Development Processes and Services
- Python Specific Information:
- Installed Python Packages (pip, conda, poetry, pyenv)
- Python Site-Packages Locations
- Active Python Environments
- Package Manager Details:
- Homebrew Installed Packages (macOS and Linux)
- Global Packages (npm, yarn, Rust toolchain, Go environment)
- Configuration and Dotfiles:
- Shell Configuration Files (.bashrc, .zshrc, .profile, .bash_profile, .config/fish/config.fish)
- Git, NPM, and Editor Configurations (VSCode, JetBrains, Neovim)
- Shell Aliases, Functions, and Custom Scripts (from shell config files)
- Installed Applications:
- Installed IDEs and Extensions (VSCode, JetBrains, Vim, Emacs)
- System Installed Applications (Simplified List)
- System and Hardware Performance (Simplified Metrics):
- CPU Load Average
- Battery and Power Management Configurations
- Temperature Sensors and Fan Speeds
- Network and Security (Simplified):
- Running Network Services and Open Ports
- VPN and Proxy Settings
- SSH Keys and Active Connections
- Simplified Firewall Logs and Rules
- Containerization and Virtualization:
- WSL (Windows Subsystem for Linux)
- Docker and Kubernetes (kubectl)
- Vagrant
- Virtual Machines (Hyper-V, VMware, VirtualBox)
- Development Tools and Languages:
- Installed Development Languages (Rust, Node.js, Perl, Ruby, PHP, Haskell)
- Version Management Tools (nvm, rbenv, rustup, pyenv)
- Debugging and Performance Monitoring:
- Load Averages, Memory Usage, IO Bottlenecks, GPU Utilization
- Available Debugger Tools (lldb, gdb, strace, dtrace)
- Version Control and CI/CD:
- Git Configuration and Remote Origins
- CI/CD Pipeline Configuration Files (Common types)
- Cloud and Remote Development:
- SSH Configurations and Active Remote Sessions
- Cloud SDKs (AWS, GCP, Azure, DigitalOcean)
- Remote Code Execution Environments (GitHub Codespaces, Gitpod)
- Code Execution and Debugging:
- Active Debugger Sessions (Basic check)
- Installed Debugging Tools (lldb, gdb, xdebug, pdb)
- Build Systems and Dependency Management:
- Installed Build Tools (Make, CMake, Bazel, Ninja)
- Detected Dependency Files (requirements.txt, package.json, Cargo.toml, etc.)
- Installed Compilers (gcc, clang, javac)
- Infrastructure and DevOps Tools:
- Local Kubernetes Configuration
- DevOps Tools (Terraform, Pulumi)
- Local Databases and Running Services (Simplified check for common DB services)
- Testing and Quality Assurance:
- Installed Testing Frameworks (pytest, Jest, Mocha)
- Code Linters and Formatters (flake8, pylint, eslint, prettier)
- Machine Learning and AI Development:
- GPU and CUDA Information
- PyTorch and TensorFlow Status (Installation and GPU availability)
- Embedded Development / IoT:
- Installed Embedded SDKs (Arduino, ESP-IDF, Raspberry Pi Tools)
- Connected Devices and Serial Ports (Simplified list of serial ports)
- Productivity and Workflow Enhancements:
- Shell Aliases, Functions, and Custom Scripts
- Shell History Analysis (Basic - last 20 lines of history)
- Background Automation and Task Scheduling (Simplified check for cron/Scheduled Tasks)
How it Works
This server is built using the Model Context Protocol (MCP) and operates as follows:
- MCP Protocol: It implements the MCP server protocol, allowing Cursor to communicate with it to discover and utilize its capabilities.
- Stdio Transport: The server uses the
stdio
transport, meaning it communicates with Cursor through standard input and output streams. - Information Gathering: When Cursor's Agent requests information, this server executes various system commands (using
subprocess
) and Python libraries (platform
,os
,sys
,psutil
,pyserial
, etc.) to collect data about your development environment. - Tool-Based Access: Each information category is exposed as a tool within the MCP server. Cursor's Agent can then call these tools to retrieve specific pieces of information.
- Markdown Output (Optional): The server can optionally generate a Markdown file (
development_environment_info.md
) containing all the collected information for easier review and debugging. - Cursor Integration: Cursor, acting as an MCP client, can connect to this server and automatically utilize the provided tools to enhance its understanding of your development context.
Installation
To install and run this MCP server, follow these steps:
- Clone the Repository:
- Create a Python Virtual Environment (Recommended):
- Activate the Virtual Environment:
- On Linux/macOS:
- On Windows:
- On Linux/macOS:
- Install Dependencies:
Configuration for Cursor
To connect this MCP server to Cursor, you need to configure it within Cursor's settings:
- Open Cursor Settings: Go to
Cursor Settings
>Features
>MCP
. - Add New MCP Server: Click on the
+ Add New MCP Server
button. - Configure Server: Fill in the form with the following details:
- Type:
stdio
- Name:
DevEnvInfoServer
(or any name you prefer) - Command: Enter the command to run the server. If you are in the
system_information_mcp
directory and have activated the virtual environment, you can use:Note: Ifpython
is not in your system's PATH or you are using a specific Python executable, you may need to provide the full path to your Python interpreter followed by the path toclaudemcp.py
. For example:
- Type:
- Add Server: Click the "Add Server" button.
- Refresh Tool List (Optional): You might need to manually press the refresh button in the top right corner of the MCP server list in Cursor to populate the tool list.
The server DevEnvInfoServer
should now appear in your list of MCP servers in Cursor, and its tools should be available to the Agent in Composer.
Usage in Cursor
Once configured, Cursor's Agent will automatically leverage the tools provided by DevEnvInfoServer
when it deems them relevant to your requests.
- Automatic Tool Usage: When you interact with Cursor's Agent in Composer, it will intelligently decide if information about your development environment is needed to answer your questions or fulfill your requests. If so, it will automatically use the tools provided by this server in the background.
- Intentional Tool Prompting: You can also explicitly instruct the Agent to use these tools by referring to them by name or description in your prompts. For example, you could ask:
- "What Python packages are installed in my current environment?"
- "List the available shells on my system using the DevEnvInfoServer tools."
- Tool Approval: By default, Cursor will ask for your approval before executing any MCP tool. You can review the tool call arguments before approving.
- YOLO Mode (Optional): If you prefer automatic tool execution without approval prompts, you can enable "YOLO Mode" in Cursor's MCP settings. Use this mode with caution, as it allows automatic execution of MCP tools.
Cursor will display the responses from the DevEnvInfoServer
tools directly in the chat, providing you with the requested development environment information.
This server cannot be installed
local-only server
The server can only run on the client's local machine because it depends on local resources.
An MCP server that provides detailed information about your development environment to the Cursor code editor, enabling more context-aware assistance.
Related Resources
Related MCP Servers
- AsecurityAlicenseAqualityA template for creating custom tools for Cursor IDE using Model Context Protocol (MCP), allowing developers to extend Cursor's functionality with their own server-based tools.Last updated -112PythonMIT License
- -securityAlicense-qualityA Model Context Protocol (MCP) server for Cursor IDE that simplifies the installation and configuration of other MCP servers.Last updated -88223JavaScriptMIT License
- AsecurityAlicenseAqualitySimple MCP Server to enable a human-in-the-loop workflow in tools like Cline and Cursor. This is especially useful for developing desktop applications that require complex user interactions to test.Last updated -113PythonMIT License
- -securityAlicense-qualityAn MCP server that analyzes codebases and generates contextual prompts, making it easier for AI assistants to understand and work with code repositories.Last updated -10PythonMIT License