wip

Author: afstanton

README.md

@@ -1,6 +1,8 @@
-# DockerMCP
+# RubyLLM Docker Tools
 
-A Model Context Protocol (MCP) server that provides comprehensive Docker management capabilities through a standardized interface. This tool enables AI assistants and other MCP clients to interact with Docker containers, images, networks, and volumes programmatically.
+A comprehensive Ruby gem that provides Docker management capabilities through [RubyLLM](https://github.com/afstanton/ruby_llm) tools. This library enables AI assistants and chatbots to interact with Docker containers, images, networks, and volumes programmatically using natural language.
+
+**Note:** This gem is a port of the [DockerMCP](https://github.com/afstanton/docker_mcp) gem, adapted to work directly with RubyLLM tools instead of requiring an external MCP server.
 
 ## ⚠️ Security Warning
 
@@ -16,105 +18,130 @@ A Model Context Protocol (MCP) server that provides comprehensive Docker managem
 - Ensure proper Docker daemon security configuration
 - Consider running with restricted Docker permissions
 - Monitor and audit all container operations
-- Be cautious when exposing this tool to external or untrusted MCP clients
+- Be cautious when exposing these tools in production environments
 
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
 ```bash
-bundle add docker_mcp
+bundle add ruby_llm-docker
 ```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
 ```bash
-gem install docker_mcp
+gem install ruby_llm-docker
 ```
 
 ## Prerequisites
 
 - Docker Engine installed and running
 - Ruby 3.2+
-- Docker permissions for the user running the MCP server
+- Docker permissions for the user running the application
+- RubyLLM gem
 
 ## Usage
 
-### MCP Client Configuration
-
-Add this to your MCP client configuration after installing the gem:
-
-```json
-{
-  "docker_mcp": {
-    "command": "bash",
-    "args": [
-      "-l",
-      "-c",
-      "docker_mcp"
-    ]
-  }
-}
+### Basic Setup
+
+```ruby
+require 'ruby_llm/docker'
+
+# Create a new chat instance
+chat = RubyLLM::Chat.new(
+  api_key: 'your-openai-api-key',
+  model: 'gpt-4'
+)
+
+# Add all Docker tools to the chat
+RubyLLM::Docker.add_all_tools_to_chat(chat)
+
+# Or add individual tools
+chat.tools << RubyLLM::Docker::ListContainers.new
+chat.tools << RubyLLM::Docker::RunContainer.new
+# ... etc
 ```
 
-### Example Usage
+### Interactive Command Line Tool
 
-Once configured, you can use the tools through your MCP client:
+This gem includes a ready-to-use interactive command line tool:
 
+```bash
+# Set your OpenAI API key
+export OPENAI_API_KEY='your-key-here'
+
+# Run the interactive Docker chat
+ruby -r 'ruby_llm/docker' -e "
+require_relative 'examples/docker_chat.rb'
+DockerChat.new.start
+"
+```
+
+Or use the included example script:
+
+```bash
+ruby examples/docker_chat.rb
 ```
+
+### Example Usage
+
+Once configured, you can interact with Docker using natural language:
+
+```ruby
 # List all containers
-list_containers
+response = chat.ask("How many containers are currently running?")
 
 # Create and run a new container
-run_container image="nginx:latest" name="my-web-server"
+response = chat.ask("Create a new nginx container named 'my-web-server' and expose port 8080")
 
 # Execute commands in a container
-exec_container id="my-web-server" cmd="nginx -v"
+response = chat.ask("Check the nginx version in the my-web-server container")
 
 # Copy files to a container
-copy_to_container id="my-web-server" source_path="/local/file.txt" destination_path="/var/www/html/"
+response = chat.ask("Copy my local config.txt file to /etc/nginx/ in the web server container")
 
 # View container logs
-fetch_container_logs id="my-web-server"
+response = chat.ask("Show me the logs for the my-web-server container")
 ```
 
-## 🔨 Tools
+## 🔨 Available Tools
 
-This MCP server provides 22 comprehensive Docker management tools organized by functionality:
+This gem provides 22 comprehensive Docker management tools organized by functionality:
 
 ### Container Management
 
-- **`list_containers`** - List all Docker containers (running and stopped) with detailed information
-- **`create_container`** - Create a new container from an image without starting it
-- **`run_container`** - Create and immediately start a container from an image
-- **`start_container`** - Start an existing stopped container
-- **`stop_container`** - Stop a running container gracefully
-- **`remove_container`** - Delete a container (must be stopped first unless forced)
-- **`recreate_container`** - Stop, remove, and recreate a container with the same configuration
-- **`exec_container`** ⚠️ - Execute arbitrary commands inside a running container
-- **`fetch_container_logs`** - Retrieve stdout/stderr logs from a container
-- **`copy_to_container`** ⚠️ - Copy files or directories from host to container
+- **`ListContainers`** - List all Docker containers (running and stopped) with detailed information
+- **`CreateContainer`** - Create a new container from an image without starting it
+- **`RunContainer`** - Create and immediately start a container from an image
+- **`StartContainer`** - Start an existing stopped container
+- **`StopContainer`** - Stop a running container gracefully
+- **`RemoveContainer`** - Delete a container (must be stopped first unless forced)
+- **`RecreateContainer`** - Stop, remove, and recreate a container with the same configuration
+- **`ExecContainer`** ⚠️ - Execute arbitrary commands inside a running container
+- **`FetchContainerLogs`** - Retrieve stdout/stderr logs from a container
+- **`CopyToContainer`** ⚠️ - Copy files or directories from host to container
 
 ### Image Management
 
-- **`list_images`** - List all Docker images available locally
-- **`pull_image`** - Download an image from a Docker registry
-- **`push_image`** - Upload an image to a Docker registry
-- **`build_image`** - Build a new image from a Dockerfile
-- **`tag_image`** - Create a new tag for an existing image
-- **`remove_image`** - Delete an image from local storage
+- **`ListImages`** - List all Docker images available locally
+- **`PullImage`** - Download an image from a Docker registry
+- **`PushImage`** - Upload an image to a Docker registry
+- **`BuildImage`** - Build a new image from a Dockerfile
+- **`TagImage`** - Create a new tag for an existing image
+- **`RemoveImage`** - Delete an image from local storage
 
 ### Network Management
 
-- **`list_networks`** - List all Docker networks
-- **`create_network`** - Create a new Docker network
-- **`remove_network`** - Delete a Docker network
+- **`ListNetworks`** - List all Docker networks
+- **`CreateNetwork`** - Create a new Docker network
+- **`RemoveNetwork`** - Delete a Docker network
 
 ### Volume Management
 
-- **`list_volumes`** - List all Docker volumes
-- **`create_volume`** - Create a new Docker volume for persistent data
-- **`remove_volume`** - Delete a Docker volume
+- **`ListVolumes`** - List all Docker volumes
+- **`CreateVolume`** - Create a new Docker volume for persistent data
+- **`RemoveVolume`** - Delete a Docker volume
 
 ### Tool Parameters
 
@@ -123,54 +150,40 @@ Most tools accept standard Docker parameters:
 - **Image**: Specify images using `name:tag` format (e.g., `nginx:latest`, `ubuntu:22.04`)
 - **Ports**: Use Docker port mapping syntax (e.g., `"8080:80"`)
 - **Volumes**: Use Docker volume mount syntax (e.g., `"/host/path:/container/path"`)
-- **Environment**: Set environment variables as `KEY=VALUE` pairs
+- **Environment**: Set environment variables as comma-separated `KEY=VALUE` pairs (e.g., `"NODE_ENV=production,PORT=3000"`)
 
 ## Common Use Cases
 
 ### Development Environment Setup
-```bash
-# Pull development image
-pull_image from_image="node:18-alpine"
-
-# Create development container with volume mounts
-run_container image="node:18-alpine" name="dev-env" \
-  host_config='{"PortBindings":{"3000/tcp":[{"HostPort":"3000"}]},"Binds":["/local/project:/app"]}'
-
-# Execute development commands
-exec_container id="dev-env" cmd="npm install"
-exec_container id="dev-env" cmd="npm start"
+```ruby
+# Ask the AI to set up a development environment
+response = chat.ask("Pull the node:18-alpine image and create a development container
+  named 'dev-env' with port 3000 exposed and my current directory mounted as /app")
+
+# Install dependencies and start the application
+response = chat.ask("Run 'npm install' in the dev-env container")
+response = chat.ask("Start the application with 'npm start' in the dev-env container")
 ```
 
 ### Container Debugging
-```bash
-# Check container status
-list_containers
-
-# View container logs
-fetch_container_logs id="problematic-container"
-
-# Execute diagnostic commands
-exec_container id="problematic-container" cmd="ps aux"
-exec_container id="problematic-container" cmd="df -h"
-exec_container id="problematic-container" cmd="netstat -tlnp"
+```ruby
+# Check container status and debug issues
+response = chat.ask("Show me all containers and their current status")
+response = chat.ask("Get the logs for the problematic-container")
+response = chat.ask("Check the running processes in the problematic-container")
+response = chat.ask("Show disk usage in the problematic-container")
 ```
 
 ### File Management
-```bash
-# Copy configuration files to container
-copy_to_container id="web-server" \
-  source_path="/local/nginx.conf" \
-  destination_path="/etc/nginx/"
-
-# Copy application code
-copy_to_container id="app-container" \
-  source_path="/local/src" \
-  destination_path="/app/"
+```ruby
+# Copy files to containers using natural language
+response = chat.ask("Copy my local nginx.conf file to /etc/nginx/ in the web-server container")
+response = chat.ask("Copy the entire src directory to /app/ in the app-container")
 ```
 
 ## Error Handling
 
-The server provides detailed error messages for common issues:
+The tools provide detailed error messages for common issues:
 
 - **Container Not Found**: When referencing non-existent containers
 - **Image Not Available**: When trying to use images that aren't pulled locally
@@ -189,17 +202,15 @@ docker info
 
 # Verify Docker permissions
 docker ps
-
-# Check MCP server logs for connection errors
 ```
 
 ### Container Operation Failures
-- Ensure container IDs/names are correct (use `list_containers` to verify)
+- Ensure container IDs/names are correct (ask the AI to list containers)
 - Check if containers are in the expected state (running/stopped)
-- Verify image availability with `list_images`
+- Verify image availability (ask the AI to list available images)
 
 ### Permission Issues
-- Ensure the user running the MCP server has Docker permissions
+- Ensure the user running the application has Docker permissions
 - Consider adding user to the `docker` group: `sudo usermod -aG docker $USER`
 - Verify Docker socket permissions: `ls -la /var/run/docker.sock`
 
@@ -239,8 +250,8 @@ bundle exec rake spec COVERAGE=true
 ### Local Development Setup
 ```bash
 # Clone the repository
-git clone https://github.com/afstanton/docker_mcp.git
-cd docker_mcp
+git clone https://github.com/afstanton/ruby_llm-docker.git
+cd ruby_llm-docker
 
 # Install dependencies
 bin/setup
@@ -255,13 +266,14 @@ bundle exec rake build
 bundle exec rake install
 ```
 
-### Testing with MCP Client
+### Testing with RubyLLM
 ```bash
-# Start the MCP server locally
-bundle exec exe/docker_mcp
+# Test the interactive chat tool
+export OPENAI_API_KEY='your-key-here'
+ruby examples/docker_chat.rb
 
-# Configure your MCP client to use local development server
-# Use file path instead of installed gem command
+# Test tool loading without API calls
+ruby examples/test_chat.rb
 ```
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).

examples/docker_chat.rb

@@ -1,10 +1,16 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Docker Chat - Interactive command line tool
-# A comprehensive chat interface with all Docker tools available
+# Docker Chat - Interactive command line tool for RubyLLM
+# A comprehensive chat interface with all Docker management tools available
+# through natural language interaction powered by OpenAI and RubyLLM
+#
+# Prerequisites:
+#   - Set OPENAI_API_KEY environment variable
+#   - Docker daemon running and accessible
 #
 # Usage:
+#   export OPENAI_API_KEY='your-key-here'
 #   ruby examples/docker_chat.rb
 #
 # Commands:

examples/test_chat.rb

@@ -1,8 +1,9 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Test script for docker_chat.rb
-# This verifies the basic functionality without requiring OpenAI API
+# Test script for RubyLLM Docker Tools
+# This verifies that all Docker tools load correctly and the chat system works
+# without requiring an OpenAI API key or active Docker daemon
 
 require_relative '../lib/ruby_llm/docker'
 

lib/ruby_llm/docker/build_image.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Docker
-    # MCP tool for building Docker images from Dockerfile content.
+    # RubyLLM tool for building Docker images from Dockerfile content.
     #
     # This tool provides the ability to build Docker images by providing Dockerfile
     # content as a string. It supports optional tagging of the resulting image for
@@ -65,7 +65,7 @@ class BuildImage < RubyLLM::Tool
       # can be tagged with a custom name for easy reference.
       #
       # @param dockerfile [String] the complete Dockerfile content as a string
-      # @param server_context [Object] MCP server context (unused but required)
+      # @param server_context [Object] RubyLLM context (unused but required)
       # @param tag [String, nil] optional tag to apply to the built image
       #
       # @return [RubyLLM::Tool::Response] build results including image ID and tag info

lib/ruby_llm/docker/copy_to_container.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Docker
-    # MCP tool for copying files and directories from host to Docker containers.
+    # RubyLLM tool for copying files and directories from host to Docker containers.
     #
     # This tool provides the ability to copy files or entire directory trees from
     # the host filesystem into running Docker containers. It uses Docker's archive
@@ -74,13 +74,13 @@ class CopyToContainer < RubyLLM::Tool
       # changed after the copy operation completes.
       #
       # The source path must exist on the host filesystem and be readable by the
-      # process running the MCP server. The destination path must be a valid path
+      # process running the application. The destination path must be a valid path
       # within the container.
       #
       # @param id [String] container ID or name to copy files into
       # @param source_path [String] path to file/directory on host filesystem
       # @param destination_path [String] destination path inside container
-      # @param server_context [Object] MCP server context (unused but required)
+      # @param server_context [Object] RubyLLM context (unused but required)
       # @param owner [String, nil] ownership specification (e.g., "user:group", "1000:1000")
       #
       # @return [RubyLLM::Tool::Response] success/failure message with operation details