In the previous post, we learned about the concept of MCP and why it's used.

In this post, let's explore specific use cases for MCP. We will particularly focus on how combining Docker and MCP can enhance development productivity.

Docker

We will be using Docker in this post.

Therefore, basic knowledge of Docker is required. However, even without basic knowledge, you can read through the entire post and get a general idea of how it might be used.

Also, Docker and Docker Desktop must be installed on your local computer.

Please download the appropriate installation file for your OS from Docker.com and install it.

---

MCP server docker

There have been quite a few attempts to combine Docker and an MCP server. Among them, one that I found interesting and used is mcp-server-docker.

Using this MCP server, you can perform various Docker-related tasks based on natural language. Let's actually install and use the mcp-server-docker to see what Docker tasks can be done with natural language.

1. Clone the Github repo locally.

   Copy

   git clone https://github.com/ckreiling/mcp-server-docker

2. Navigate into the cloned directory and run the Docker build command.

   Copy

   docker build -t mcp-server-docker .

   • A docker image named mcp-server-docker should have been built.
3. Since we will use Claude desktop as the MCP client, add the following content to the claude_desktop_config.json file.
   claude_desktop_config.json

   Copy

   {
     "mcpServers": {
       "mcp-server-docker": {
         "command": "docker",
         "args": [
           "run",
           "-i",
           "--rm",
           "-v",
           "/var/run/docker.sock:/var/run/docker.sock",
           "mcp-server-docker:latest"
         ]
       }
     }
   }

4. Run Claude desktop. If it was already running, you need to quit and restart it.

If the setup is completed correctly up to this point, you should see a total of 19 Tools in Claude desktop.

Alright, all settings are done. Now let's perform Docker tasks using natural language. Let's get a feel for real-world examples through a few scenarios.

Example Scenario 1: Need to run a Redis server locally using version 7 based on Alpine Linux.

Let's start a Redis server. It should be version 7 based on Alpine Linux.

• A total of 3 Tools are used (pull_image, run_container, start_container).

• You can confirm that the redis-server container is running with the intended version.

Example Scenario 2: Need to run WordPress locally. MySQL must be connected as the DB, and WordPress should use port 9000.

deploy a WordPress container and a supporting MySQL container, exposing Wordpress on port 9000

This time, I recorded a video. Check out the results.

• At the beginning of the video, you can see Claude desktop on the left and Docker desktop on the right.
  • You can see the mcp-server-docker image running according to the claude_desktop_config.json file settings.
• When you type the natural language sentence above into the chat window and press Enter, Claude selects and calls the appropriate Tools from the registered MCP server (in this case, mcp-server-docker).
  • First, it calls the create_network tool. This creates a docker network to connect WordPress and MySQL. wordpress-network is created.
  • Next, it creates and runs the wordpress-db container using the mysql:8.0 image. It uses the wordpress-network created just before.
  • Then, it creates and runs the wordpress container using the wordpress:latest image. It also uses the wordpress-network.
• After all MCP server calls are finished, Claude kindly tells you how to test it (at 44 seconds in the video).
  • Open a browser and go to http://localhost:9000 to see the WordPress setup page.

Did you follow along well?

Do you get the idea of what it means to perform Docker tasks with natural language? The official Github repo for this project supports a total of 19 Tools (as of late March 2025). Besides the two examples presented in this post, it seems applicable to a wider variety of situations.

---

Docker desktop extension

This time, let's look at a project officially supported by Docker called labs-ai-tools-for-devs. The official Github address is here.

While the mcp-server-docker we just looked at was an MCP server that helps with Docker tasks like running containers, this labs-ai-tools-for-devs is a project that allows you to perform various other tasks using natural language, mediated by Docker.

The technical documentation here provides a clearer explanation.

The mcp/docker container is an mcp server that can be extended with new container-based tools, and prompts. Existing containers, like curl or ffmpeg, can now be exposed as MCP servers without having to wrap each tool in an mcp server.

In other words, while existing tools like curl and ffmpeg previously required special wrappers to become MCP servers, this project eliminates that need, allowing them to be turned directly into MCP servers.

Docker's advantage lies in the vast array of programs already created (and yet to be created) by countless developers. What if all of these could be turned into MCP servers and connected to an LLM? This could be said to be the very reason this project exists.

Now, let's install and use it ourselves.

1. First, you need to install the Docker desktop extension.

   

   • Click this link Docker Labs AI Tools for Devs to install it.

   

   • If the extension you just installed appears correctly under Docker desktop's Extensions > Manage menu, the installation was successful.

2. Next, you need to connect the newly installed extension to Claude desktop.

   

   • Click on AI Tool Catalog and wait a moment. A page similar to the image above will appear. Click the gear icon on the right.

   

   • In the MCP Clients menu, click the Connect button for the Claude Desktop item.

   

   • After clicking the Connect button, wait a moment, and the status will change to CONNECTED.
   • This action automatically modifies the claude_desktop_config.json file.

If you've proceeded without issues up to this point, the installation and setup are complete. Now, let's test it out. We will look specifically at how it can be used through two example scenarios.

Example Scenario 1: Need to summarize a specific technical documentation web page.

We'll try summarizing the official Github README.md web page for the project we're currently testing. First, let's see what happens when we query Claude with natural language purely without any Tools.

• Without any Tools, Claude cannot access the web page, so it refuses to answer.
• This is because the Claude LLM itself has no way to access web pages.

Now let's see what happens when we use a Tool.

• In Docker desktop's Tool Catalog menu, you can see dozens of registered Tools. For now, let's activate and use Curl. Click the toggle button.

• When you run Claude desktop, you can see that 2 Tools have been registered: curl and curl-manual.

• If you make the same natural language query, Claude uses the curl tool to read the web page document and then outputs a summary.
• Not only can it summarize long documents, but it also enables document-based Q&A.
• It's also possible to read multiple web pages, compare them, and analyze similarities and differences.

Through this example, we can easily read technical documentation from web pages. Additionally, since it's possible to translate documents written in English into Korean or Japanese instantly, this can significantly reduce the time spent reading and understanding technical documentation.

Now let's move on to the next scenario.

Example Scenario 2: Connecting to a local or remote Database to query table information and perform performance analysis.

This is a situation developers frequently encounter. Usually, database connection extensions in IDEs (IntelliJ, Visual Studio Code) are used to check which tables exist and what their schemas look like. Let's see if this task can be done with the Claude + MCP server (Tool) combination.

• In the Tool Catalog menu, search for postgres. You'll see 2 Tools. Activate Postgres here.

• If you restart Claude desktop, you will see a total of 22 postgres-related Tools.

• I provided the path to a PostgreSQL DB hosted on Supabase and requested it to print the entire table schema.
• Claude desktop uses the get_schema_info Tool to organize and output the schemas of a total of 5 tables.

Now that we've checked the table schema, it would be good to perform a performance analysis. (Let's analyze the above tables from a performance perspective.)

• Since the conversation continues within the same session, Claude already knows the DB information. So, it proceeds with the performance analysis for the same DB.
• This time, Claude uses the monitor_database Tool to perform performance analysis on the tables and the DB.
• Developers no longer need to worry about which postgres commands to run or how to interpret the command results. They just need to read and understand the text.

So far, we've used curl and postgres.

Both curl and postgres are used via labs-ai-tools-for-devs, based on their respective docker images.

Through this project, you can also create and register your own Tools. Since the project is still in its early stages, only the 33 currently registered Tools can be used. It's expected that more Tools will likely be added over time.

---

we have looked at actual examples of using Docker and MCP servers. Particularly from a developer's perspective, Docker could be utilized in two different ways:

1. Perform Docker tasks themselves using natural language.
2. Utilize Docker images to perform other general tasks using natural language.

In the next post, I plan to share how to combine Cursor IDE and MCP servers to increase development productivity.

Thank you for reading!