Setting Up a AI-assisted Development Environment with VS Code Dev Containers

The modern software development landscape increasingly demands consistent, isolated, and reproducible environments to manage the complexities of projects and foster effective collaboration within teams. Visual Studio Code (VS Code), paired with the capabilities of Dev Containers, offers a robust solution to address these needs, particularly for Python development 1. Dev Containers are essentially Docker containers meticulously configured to serve as fully functional development environments 1. By encapsulating all the necessary tools, runtimes, and libraries required for a specific project, they ensure a uniform experience across different machines and among team members 3. This approach leverages the power of Docker to provide isolation and maintain reproducibility throughout the development lifecycle 1. The Remote Development Extension Pack in VS Code further facilitates seamless interaction with these containers, making the development process feel local even though the environment is containerized 3.

For Python development, the advantages of using Dev Containers are manifold. They provide dependency isolation, preventing conflicts that can arise from different Python versions or package dependencies across various projects 6. This ensures a consistent environment where every team member develops and tests the application using the exact same setup 3. The simplified setup process significantly speeds up onboarding for new developers, eliminating the often time-consuming and error-prone task of configuring local environments 3. Furthermore, Dev Containers allow for safe experimentation with different Python versions or tools without impacting the developer's local system, offering a sandbox for innovation 4. The configuration of these environments is primarily managed through key files. The .devcontainer directory, typically located at the root of the project, serves as the standard repository for all Dev Container configuration files 2. Within this directory, the devcontainer.json file acts as the central configuration, defining how VS Code should initiate the container and what actions to take upon connection 1. For more intricate container setups or when building custom images is required, developers can utilize an optional Dockerfile or docker-compose.yml file, also typically placed within the .devcontainer directory 1. The increasing adoption of Dev Containers signifies a notable trend in the software development industry toward standardized and isolated environments, a response to the growing complexity of modern software projects and the imperative for enhanced team collaboration. This trend is clearly supported by the extensive documentation and active community engagement surrounding this technology. Moreover, the availability of both pre-built images and the option for custom Dockerfile configurations offers developers a spectrum of control and customization. This caters to users seeking a rapid setup as well as those with highly specific environmental requirements, demonstrating a design that effectively addresses a diverse range of development scenarios 1.

Before embarking on setting up the development environment, certain prerequisites must be in place. The first and foremost is the installation and configuration of Docker. For users on Windows and macOS, Docker Desktop is the recommended choice, providing a user-friendly interface for managing Docker containers, images, and volumes 7. It is crucial to ensure that Docker Desktop is running, which can be verified by checking the system tray for the Docker whale icon 6. Linux users should follow the official installation instructions for Docker CE/EE specific to their distribution 7. After installation on Linux, a common post-installation step involves adding the user to the docker group to grant permissions for executing Docker commands without needing sudo 7. Windows users who opt for Docker Desktop are strongly advised to enable the WSL 2 based engine in the Docker Desktop settings. This backend offers improved performance and more efficient file sharing between the host system and the container 7. In cases where issues arise, particularly when working with sample containers, it is often beneficial to ensure that the Docker context is set to the default context 6.

The second prerequisite is the installation of Visual Studio Code itself. Users should download and install the latest stable version of Visual Studio Code, or the Insiders build for early access to new features, from the official VS Code website 7. Finally, the Dev Containers extension needs to be installed within VS Code. This can be done by opening VS Code, navigating to the Extensions view (using the shortcut Ctrl+Shift+X or Cmd+Shift+X), searching for "Dev Containers," and installing the extension provided by Microsoft 3. Alternatively, users can install the "Remote Development" extension pack, which conveniently bundles the Dev Containers extension along with other extensions that support remote development workflows 7. The strong recommendation for Docker Desktop on Windows and macOS highlights a commitment to providing a streamlined experience for developers on these platforms, effectively abstracting away some of the underlying complexities associated with Docker management. Furthermore, the specific emphasis on WSL 2 integration for Windows users underscores the significance of leveraging operating system-level features to achieve optimal performance within the containerized development environment.

With the prerequisites in place, the next step is to set up the Dev Container. This process begins with creating the .devcontainer folder and the devcontainer.json file within your project. Start by opening your project folder in VS Code, or create a new project folder if necessary. Then, access the Command Palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on macOS). Type "Dev Containers: Add Dev Container Configuration Files..." and select this option 1. You will be prompted to "Create a new configuration" 2. Choose a predefined configuration that aligns with your project's primary language, which in this case is Python 3. You might see an option specifically labeled "Python 3" or perhaps a more specific version. Alternatively, you can select "Show All Definitions" to explore a broader range of available base configurations 2. Once you have made your selection, VS Code will automatically create a .devcontainer folder in the root of your project and populate it with a devcontainer.json file 7. This guided approach within VS Code for adding Dev Container configuration files significantly simplifies the initial setup, allowing developers to quickly establish their container environment without needing to manually create and configure these files from scratch.

The next step involves configuring the base Python environment within the devcontainer.json file. Open the newly created .devcontainer/devcontainer.json file. Examine the "image" property. This property specifies the base Docker image that will be used as the foundation for your container. For a Python 3 environment, this might be something like "mcr.microsoft.com/devcontainers/python:3" or a more specific version such as "mcr.microsoft.com/devcontainers/python:3.9" 10. You can explore the range of available Python images on Docker Hub under the microsoft/devcontainers-python repository 10. When selecting an image, it is generally advisable to consider using a non-breaking, actively supported version (e.g., 1-3.x) to ensure you receive necessary security patches 10. For developers who require more granular control over their base environment, the "image" property can be replaced with a "build" property. This "build" property then references a "dockerfile" (e.g., "build": { "dockerfile": "Dockerfile" }) located within the .devcontainer folder. This approach allows you to define the precise base image and any additional steps for installing software or configuring the environment within a Dockerfile 1. This flexibility to choose between a pre-configured image and a custom Dockerfile provides developers with the ability to tailor their base environment precisely to the specific needs of their project, striking a balance between ease of initial setup and the capacity for detailed customization.

To integrate Node.js and NVM into the Dev Container, there are two primary methods: using Dev Container Features, which is generally the recommended approach, or using the postCreateCommand property.

Using Features:

In your devcontainer.json file, locate the "features" section. If it doesn't exist, you can add it as a top-level property. To install Node.js via NVM, add the following feature reference: "ghcr.io/devcontainers/features/node:1": {} 8. If you need a specific version of Node.js, you can specify it within the feature configuration using the "version" property. For example, to install Node.js version 18, the configuration would look like this: "ghcr.io/devcontainers/features/node:1": { "version": "18" } 11. For a comprehensive list of available features and their configuration options, you can refer to the official Dev Container Features documentation 12.

Using postCreateCommand:

As an alternative, you can add a "postCreateCommand" property to your devcontainer.json file. The command specified in this property will be executed automatically after the container is created 1. To install NVM and a specific Node.js version using this method, you can use a command similar to the following: "postCreateCommand": "bash -i -c 'curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.[39](#ref39).7/install.sh | bash' && source ~/.nvm/nvm.sh && nvm install --lts'". The -i flag in the bash command ensures an interactive shell, which is often necessary for the NVM installation script to execute correctly 1. Leveraging Dev Container Features for installing common development tools like Node.js and NVM offers the advantage of simplifying the devcontainer.json file and promoting the reuse of standardized configuration snippets. When choosing the manual installation approach via postCreateCommand, it is important to understand the intricacies of shell interaction, such as the requirement for an interactive shell for NVM installation, to ensure a successful setup.

To automatically install the RooCode extension within the Dev Container, you need to configure the "customizations" section in your devcontainer.json file. If this section doesn't exist, add it as a top-level property. Within "customizations", add a "vscode" section. Inside the "vscode" section, add an "extensions" array and include the identifier for the RooCode extension. Based on available information, the identifier is likely "RooVeterinaryInc.roo-cline" 14. Your complete devcontainer.json file might then resemble the following structure:

{
    "image": "mcr.microsoft.com/devcontainers/python:[3](#ref3).9",
    "features": {
        "ghcr.io/devcontainers/features/node:1": {
            "version": "18"
        }
    },
    "customizations": {
        "vscode": {
            "extensions":
        }
    }
}

This declarative method of listing extensions in the devcontainer.json file ensures that the development environment is automatically provisioned with the necessary IDE tools each time a new container instance is created, promoting consistency across the team and reducing the need for manual extension installation.

Once the devcontainer.json file is configured, save the file. VS Code will automatically detect the changes and prompt you to rebuild the container. Click the "Rebuild now" button in the pop-up notification that appears in the bottom-right corner of the window 2. Alternatively, you can manually trigger the rebuild process by opening the Command Palette and selecting "Dev Containers: Rebuild and Reopen in Container" 1. The initial build of the container might take some time as the base Docker image is downloaded and the specified features and extensions are installed 7. However, subsequent rebuilds will generally be much faster. You can monitor the progress of the build process in the "Dev Containers" output panel within VS Code, which can be accessed via View > Output > Dev Containers. After the build is successfully completed, VS Code will automatically connect to the container. A green indicator labeled "Remote - Containers" will appear in the bottom-left corner of the VS Code window, signifying that you are now working within the containerized development environment 1. To verify that the setup is correct, open a new terminal within VS Code by navigating to Terminal > New Terminal and run the commands python --version, node --version, and nvm --version. These commands should confirm that Python 3, Node.js, and NVM have been installed correctly within the container. The automated rebuild process, triggered by modifications to the devcontainer.json file, offers a streamlined way to update the development environment configuration and ensures that the container consistently reflects the desired setup. Furthermore, the visual cues provided by VS Code, such as the rebuild prompt and the remote indicator, offer clear feedback to the user regarding the status of their Dev Container environment.

Starting a new project using templates within the Dev Container can be achieved through several methods. One effective approach is to use the "Clone Repository in Container Volume" command. Open the Command Palette and type "Dev Containers: Clone Repository in Container Volume..." and select the command 1. You will then be prompted to enter the URL of the Git repository that contains the project template you wish to use. VS Code will proceed to clone the repository directly into a Docker volume and will then ask if you want to reopen the folder within the container. Click "Reopen in Container" to continue working in the newly cloned project environment. If the template repository includes a .devcontainer folder with a devcontainer.json file, that specific configuration will be automatically used to build the development environment for your new project. If the repository does not contain a devcontainer.json file, VS Code will prompt you to select a starting point for the Dev Container configuration, allowing you to customize the environment for your new project 1.

For users working with GitHub Codespaces, a similar workflow exists for leveraging template repositories. You can create a new codespace directly from a template repository either through the GitHub website or within VS Code. Template repositories can be set up with pre-configured .devcontainer configurations, providing a ready-to-use development environment as soon as the codespace is created 2. Additionally, VS Code offers a convenient way to explore sample Dev Container configurations that can serve as excellent starting points for new projects. Open the Command Palette and use the command "Dev Containers: Try a Dev Container Sample..." 7. You can then select a sample that aligns with the type of project you want to start (for example, a Python-based sample). VS Code will guide you through the process of opening the selected sample project within a container. The ability to clone repositories directly into a container volume significantly streamlines the process of initiating new projects from templates. This ensures that both the project's codebase and the necessary development environment are set up in a single, integrated step. Furthermore, the tight integration with GitHub Codespaces extends the benefits of Dev Containers to cloud-based development, providing a consistent environment provisioning experience regardless of the chosen development platform.

To further enhance the capabilities of your development environment, particularly when working with the RooCode extension, you can add and configure MCP (Model Context Protocol) servers. MCP is a standardized protocol that enables AI agents, such as RooCode, to interact with a wide array of external tools, APIs, and data sources 14. MCP servers act as intermediaries, translating the AI's requests into specific actions that external systems can understand and executing those actions on behalf of the AI 17. This allows RooCode to extend its functionality beyond its core programming assistance, enabling tasks such as browser automation, file system management, and integration with various online services 14.

To configure MCP servers for RooCode, you first need to locate the MCP settings file. This file is typically named cline_mcp_settings.json and resides within the VS Code global storage directory. On Windows, the path is typically %APPDATA%\Code\User\globalStorage\rooveterinaryinc.roo-cline\settings\ 15, and on macOS, it is usually located at ~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/ 19. Open the cline_mcp_settings.json file in VS Code. It should contain a JSON object with a top-level key named "mcpServers" 18. To add a new MCP server, you need to add a new entry under the "mcpServers" object. The key for this new entry will be the name you want to assign to the server (for example, "browser", "github", or "brave-search"). Each server configuration within this object requires at least two properties: "command" and "args". The "command" property specifies the executable that should be run to start the MCP server (this is often node for JavaScript-based servers or python for Python-based servers), and the "args" property is an array of command-line arguments that will be passed to the server when it is executed 18. Optionally, you can also include an "env" property, which is an object containing environment variables that the MCP server might require, such as API keys or specific configuration settings 18. Here is an example configuration for a browser MCP server, assuming the server is a Node.js application:

{
    "mcpServers": {
        "browser": {
            "command": "node",
            "args": ["/path/to/browser-server/build/index.js"],
            "disabled": false,
            "alwaysAllow":
        }
    }
}

Make sure to replace /path/to/browser-server/build/index.js with the actual path to the main entry point of the browser MCP server. After adding the configuration for your desired MCP servers, save the cline_mcp_settings.json file. You might need to restart VS Code entirely for the changes to be fully applied and recognized by RooCode 21. The configuration of MCP servers involves specifying the execution command and any necessary arguments, indicating that these servers are typically run as separate processes that RooCode communicates with to extend its functionalities. The use of environment variables within the MCP server configuration provides a secure and flexible way to pass sensitive information like API keys without directly embedding them in the configuration file.

There is a wide range of useful MCP servers available that can significantly enhance your development workflow with RooCode. A Browser Automation Server allows RooCode to control web browsers, enabling tasks such as interacting with web applications for testing or scraping data from websites 16. A File System Server grants RooCode the ability to read, write, create, and manage files and directories within specified, often sandboxed, paths on your local file system 22. Configuration examples for the file system server often include using NPX or Docker 28. A GitHub Server allows RooCode to interact with the GitHub API, facilitating tasks like managing repositories, creating issues, and submitting pull requests 22. This server typically requires a GitHub personal access token for authentication. The Brave Search Server integrates the Brave Search engine into RooCode, enabling it to perform web searches and retrieve information based on your queries 22. This server usually requires a Brave Search API key. A Docker MCP Server provides control over Docker itself, allowing RooCode to manage containers, images, and even Docker Compose stacks through natural language commands 22. Configuration for this server can often involve using Docker Compose 41. Notably, there is also a Modes MCP Server specifically designed for RooCode (and its predecessor Cline). This server allows for programmatic control over custom operational modes within the AI agent, enabling fine-grained adjustments to its behavior and capabilities for different tasks 18. For a more comprehensive list of available MCP servers, you can explore online registries such as glama.ai/mcp/servers and mcpservers.org/ 22. These registries often categorize servers based on their functionality, including those for databases, cloud services, and various other integrations 22. The availability of such a wide range of MCP servers significantly expands the potential use cases for RooCode, transforming it from a tool primarily focused on code assistance to a more versatile AI assistant capable of interacting with various aspects of the development workflow and beyond. The existence of these servers, particularly those tailored for common developer tasks like file system access, Git integration, and Docker management, directly addresses frequent needs and can substantially enhance productivity. Furthermore, the Modes MCP Server indicates a deep level of customizability within RooCode itself, allowing users to define and manage specialized operational modes for different types of tasks.

Beyond setting up a development environment with VS Code and Dev Containers along with the RooCode extension, it is also worth exploring alternative development environment options. Cursor is an AI-first code editor that leverages large language models for tasks such as code completion, generation, and refactoring 47. Importantly, Cursor also supports the Model Context Protocol (MCP), enabling it to integrate with the same external tools and data sources as Cline and RooCode 27. Cursor features a "Composer" mode that is specifically designed for agentic workflows involving AI assistants 27. It has been noted that Cursor can utilize MCP servers that were originally configured for Claude Desktop or Cline/RooCode, suggesting a degree of compatibility across these platforms 39. Claude Code is Anthropic's own AI coding assistant, integrated directly into the Claude platform 47. It harnesses the power of Claude's advanced language models to assist with code generation, debugging, and explanation. Similar to Cursor and Cline/RooCode, Claude Code also supports the Model Context Protocol, allowing it to interact with external tools and data through MCP servers 15. Claude Code is accessible within the Claude web interface and may also be available through a dedicated desktop application. Cline is another AI-powered autonomous coding agent specifically designed for VS Code 14. As mentioned earlier, RooCode is actually a fork of Cline, meaning they share a common foundation and many core functionalities 46. Cline has deep integration with the Model Context Protocol and is notable for its ability to not only use existing MCP servers but also to autonomously build new ones by reading and understanding documentation 17. The configuration of MCP servers for Cline is managed through the same cline_mcp_settings.json file that RooCode uses 15. Information regarding Aider and bolt.diy would require further external research to provide detailed descriptions and functionalities. The increasing prevalence of AI-powered code editors and assistants signifies a substantial shift in the software development landscape, with artificial intelligence becoming an increasingly integral component of the coding process, offering capabilities that extend far beyond those of traditional integrated development environments. The shared support for the Model Context Protocol among these alternative tools underscores the growing importance of this standard in facilitating seamless integration between AI agents and the broader development ecosystem. Furthermore, the relationship between Cline and RooCode as a fork suggests a common underlying architecture and potentially similar functionalities, with RooCode possibly representing a more advanced or specialized iteration.

The following table provides a concise comparison of the alternative development tools discussed:

Tool Name	Description	Key Features	MCP Support	Relationship to RooCode/Cline
Cursor	AI-first code editor	AI code completion, generation, refactoring, Composer mode for agentic workflows	Yes	N/A
Aider	(Information to be added based on external research)	(Information to be added based on external research)	Unknown	Unknown
Claude Code	Anthropic's AI coding assistant	AI code generation, debugging, explanation	Yes	N/A
Cline	AI-powered autonomous coding agent for VS Code	Autonomous coding, natural language communication, file system access, terminal commands, browser automation, deep MCP integration, tool building	Yes	RooCode is a fork
bolt.diy	(Information to be added based on external research)	(Information to be added based on external research)	Unknown	Unknown

In conclusion, setting up a robust Python development environment using VS Code and Dev Containers offers significant advantages in terms of consistency, isolation, and reproducibility. By integrating Node.js and NVM into this containerized environment, developers can seamlessly work on projects that involve both Python and JavaScript technologies. The RooCode extension, with its AI-powered automation capabilities and its support for Model Context Protocol servers, further enhances the development experience by providing intelligent assistance and the ability to interact with a wide range of external tools and services. Exploring alternative AI-powered development tools such as Cursor, Claude Code, and Cline reveals a clear trend towards more intelligent and automated coding workflows, with MCP playing a vital role in enabling these tools to interact effectively with the broader development ecosystem. While the ultimate choice of development environment depends on individual preferences and the specific requirements of a project, the combination of VS Code Dev Containers and AI-powered assistants like RooCode provides a powerful and efficient solution for tackling the complexities of modern software development. The synergy between robust environment management provided by Dev Containers and the intelligent assistance offered by AI-powered tools like RooCode represents a potent approach to enhancing productivity and streamlining the software development process.

Works cited

[1]. Create a Dev Container - Visual Studio Code, accessed March 14, 2025, https://code.visualstudio.com/docs/devcontainers/create-dev-container
[2]. Introduction to dev containers - Codespaces - GitHub Docs, accessed March 14, 2025, https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/adding-a-dev-container-configuration/introduction-to-dev-containers
[3]. Dev Containers: Getting Started - Engineering Fundamentals Playbook, accessed March 14, 2025, https://microsoft.github.io/code-with-engineering-playbook/developer-experience/devcontainers-getting-started/
[4]. Ultimate Guide to Dev Containers - Daytona.io, accessed March 14, 2025, https://www.daytona.io/dotfiles/ultimate-guide-to-dev-containers
[5]. Where do you run your code? - an intro to devcontainers - The Red Guild, accessed March 14, 2025, https://blog.theredguild.org/where-do-you-run-your-code/
[6]. Dev Containers tutorial - Visual Studio Code, accessed March 14, 2025, https://code.visualstudio.com/docs/devcontainers/tutorial
[7]. Developing inside a Container - Visual Studio Code, accessed March 14, 2025, https://code.visualstudio.com/docs/devcontainers/containers
[8]. Introduction to Dev Containers - Medium, accessed March 14, 2025, https://medium.com/versent-tech-blog/introduction-to-dev-containers-4c01cb1752a0
[9]. Dev Containers Tips and Tricks - Visual Studio Code, accessed March 14, 2025, https://code.visualstudio.com/docs/devcontainers/tips-and-tricks
[10]. microsoft/devcontainers-python - Docker Image, accessed March 14, 2025, https://hub.docker.com/r/microsoft/devcontainers-python
[11]. microsoft/vscode-remote-try-python: Python sample project for trying out Dev Containers, accessed March 14, 2025, https://github.com/microsoft/vscode-remote-try-python
[12]. Available Dev Container Features, accessed March 14, 2025, https://containers.dev/features
[13]. How to install nvm in docker? - node.js - Stack Overflow, accessed March 14, 2025, https://stackoverflow.com/questions/25899912/how-to-install-nvm-in-docker
[14]. Roo Code (prev. Roo Cline) - Visual Studio Marketplace, accessed March 14, 2025, https://marketplace.visualstudio.com/items?itemName=RooVeterinaryInc.roo-cline
[15]. Automating a Data Science Project with RooCode and GitHub Copilot: Step-by-Step Guide, accessed March 14, 2025, https://www.tanyongsheng.com/blog/automating-a-data-science-project-with-roocode-and-github-copilot-step-by-step-guide/
[16]. Browser Automation MCP Server - Glama, accessed March 14, 2025, https://glama.ai/mcp/servers/3o1j64rc1q
[17]. MCP Servers Explained: What They Are, How They Work, and Why Cline is Revolutionizing AI Tools - Cline Blog, accessed March 14, 2025, https://cline.bot/blog/mcp-servers-explained-what-they-are-how-they-work-and-why-cline-is-revolutionizing-ai-tools
[18]. MCP server for managing Roo's custom operational modes - GitHub, accessed March 14, 2025, https://github.com/ccc0168/modes-mcp-server
[19]. MCP Client Configuration Server - Glama, accessed March 14, 2025, https://glama.ai/mcp/servers/aa10ltj5b6
[20]. I deleted by mistake the MCP configuration file : r/RooCode - Reddit, accessed March 14, 2025, https://www.reddit.com/r/RooCode/comments/1iuzxzq/i_deleted_by_mistake_the_mcp_configuration_file/
[21]. Changing the MCP Server settings causes an erroneous error message box to appear in the side bar. · Issue #527 · RooVetGit/Roo-Code - GitHub, accessed March 14, 2025, https://github.com/RooVetGit/Roo-Code/issues/527
[22]. Awesome MCP Servers, accessed March 14, 2025, https://mcpservers.org/
[23]. Top 10 MCP Servers: Your Ultimate Guide to Boosting Productivity in 2025 - Apidog, accessed March 14, 2025, https://apidog.com/blog/top-10-mcp-servers
[24]. Top 5 MCP Servers to Automate Daily Tasks and Workflows with Prompts | by Pedro Aquino, accessed March 14, 2025, https://medium.com/@pedro.aquino.se/top-5-mcp-servers-to-automate-daily-tasks-and-workflows-with-prompts-039fe50570fd
[25]. For Claude Desktop Users - Model Context Protocol, accessed March 14, 2025, https://modelcontextprotocol.io/quickstart/user
[26]. Setting up Claude Filesystem MCP - Medium, accessed March 14, 2025, https://medium.com/@richardhightower/setting-up-claude-filesystem-mcp-80e48a1d3def
[27]. Filesystem - MCP Server - Cursor Directory, accessed March 14, 2025, https://cursor.directory/mcp/filesystem
[28]. Filesystem MCP Server - Glama, accessed March 14, 2025, https://glama.ai/mcp/servers/s4jc7g4hn2
[29]. MCP Servers Object Structure - LibreChat, accessed March 14, 2025, https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/mcp_servers
[30]. GitHub MCP Server - Glama, accessed March 14, 2025, https://glama.ai/mcp/servers/782x50kvuh
[31]. A Model Context Protocol (MCP) server to provide git tools for LLM Agents - GitHub, accessed March 14, 2025, https://github.com/cyanheads/git-mcp-server
[32]. appcypher/awesome-mcp-servers - GitHub, accessed March 14, 2025, https://github.com/appcypher/awesome-mcp-servers
[33]. MCP_SERVER_CONFIG.md - GitHub Gist, accessed March 14, 2025, https://gist.github.com/davidteren/80c1b3e1ee092113f6d3fe8a1b7572d7
[34]. Github - MCP Server - Cursor Directory, accessed March 14, 2025, https://cursor.directory/mcp/github
[35]. Using MCP Tools with Claude and Cline - Scott Spence, accessed March 14, 2025, https://scottspence.com/posts/using-mcp-tools-with-claude-and-cline
[36]. Brave Search | Model Context Protocol Server Directory - Claude MCP, accessed March 14, 2025, https://www.claudemcp.com/servers/brave-search
[37]. MCP Integration: How Brave Search and Claude Desktop Enhance AI Assistant Agentic Capabilities | by Rick Hightower | Medium, accessed March 14, 2025, https://medium.com/@richardhightower/mcp-integration-how-brave-search-and-claude-desktop-enhance-ai-assistant-agentic-capabilities-c840590fa100
[38]. Brave Search - MCP Server - Cursor Directory, accessed March 14, 2025, https://cursor.directory/mcp/brave-search
[39]. How do I get Cursor to use my configured MCP Servers?, accessed March 14, 2025, https://forum.cursor.com/t/how-do-i-get-cursor-to-use-my-configured-mcp-servers/50042
[40]. Could not start MCP server for Brave Search in Computer Use and Claude Desktop, accessed March 14, 2025, https://stackoverflow.com/questions/79262030/could-not-start-mcp-server-for-brave-search-in-computer-use-and-claude-desktop
[41]. Docker AI Agent and Model Context Protocol (MCP) Server - Working Together, accessed March 14, 2025, https://dev.to/ajeetraina/docker-ai-agent-and-model-context-protocol-mcp-server-working-together-4c4l
[42]. MCP - Docker Docs, accessed March 14, 2025, https://docs.docker.com/desktop/features/gordon/mcp/
[43]. A docker MCP Server (modelcontextprotocol) - GitHub, accessed March 14, 2025, https://github.com/QuantGeekDev/docker-mcp
[44]. Docker MCP Server - Glama, accessed March 14, 2025, https://glama.ai/mcp/servers/dmna3tblnr
[45]. Information or Source Code for Roo Programming Language or Tool - Glama, accessed March 14, 2025, https://glama.ai/mcp/servers/search/information-or-source-code-for-roo-programming-language-or-tool
[46]. mcp servers with RooCode - Reddit, accessed March 14, 2025, https://www.reddit.com/r/RooCode/comments/1io354m/mcp_servers_with_roocode/
[47]. Roo Code + MCPs (best MCP configs) : r/RooCode - Reddit, accessed March 14, 2025, https://www.reddit.com/r/RooCode/comments/1ijgk2x/roo_code_mcps_best_mcp_configs/
[48]. Open-Source MCP servers - Glama, accessed March 14, 2025, https://glama.ai/mcp/servers
[49]. Top 10 MCP servers - Portkey, accessed March 14, 2025, https://portkey.ai/blog/top-10-mcp-servers
[50]. How to Use DeepSeek R1 for Free in Visual Studio Code with Cline or Roo Code, accessed March 14, 2025, https://dev.to/dwtoledo/how-to-use-deepseek-r1-for-free-in-visual-studio-code-with-cline-or-roo-code-3an9
[51]. Enhance Your Roo Code VSCode Extension with GPT API Integration! - Reddit, accessed March 14, 2025, https://www.reddit.com/r/RooCode/comments/1ifwglt/enhance_your_roo_code_vscode_extension_with_gpt/
[52]. Can someone please share Memory Bank extension for VScode : r/RooCode - Reddit, accessed March 14, 2025, https://www.reddit.com/r/RooCode/comments/1j8lmud/can_someone_please_share_memory_bank_extension/