### Configure pylsp

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Minimal setup for the Python language server.

```lua
require'lspconfig'.pylsp.setup {
  cmd = require'lspcontainers'.command('pylsp'),
  ...
}
```

--------------------------------

### Configure LSP Containers with Ensure Installed List

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Configures the `lspcontainers` plugin globally using `setup` to specify which language servers should be available. These can then be pulled using the `:LspImagesPull` command.

```lua
local lspcontainers = require('lspcontainers')

-- Configure which language servers should be available
lspcontainers.setup({
  ensure_installed = {
    "lua_ls",
    "tsserver",
    "gopls",
    "rust_analyzer",
    "pyright",
  }
})

-- After setup, run :LspImagesPull to download the configured images
```

--------------------------------

### Configure lua_ls

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Minimal setup for the Lua language server.

```lua
require'lspconfig'.lua_ls.setup {
  cmd = require'lspcontainers'.command('lua_ls'),
  ...
}
```

--------------------------------

### setup(options)

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Configures the lspcontainers plugin with global options, such as specifying language servers to be managed.

```APIDOC
## setup(options)

### Description
Configures the lspcontainers plugin with global options. Currently supports specifying language servers to ensure are installed.

### Parameters
- **options** (table) - Required - Configuration table containing 'ensure_installed' (a list of server names).

### Request Example
lspcontainers.setup({ ensure_installed = { "lua_ls", "gopls" } })
```

--------------------------------

### Configure lemminx

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Minimal setup for the XML language server.

```lua
require'lspconfig'.lemminx.setup {
  cmd = require'lspcontainers'.command('lemminx'),
  ...
}
```

--------------------------------

### Install lspcontainers via vim-plug

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Add the plugin to your vim-plug configuration.

```vim
Plug 'neovim/nvim-lspconfig'
Plug 'lspcontainers/lspcontainers.nvim'
```

--------------------------------

### Install lspcontainers via packer

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Add the plugin to your packer configuration.

```lua
use 'neovim/nvim-lspconfig'
use 'lspcontainers/lspcontainers.nvim'
```

--------------------------------

### Configure rust_analyzer

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Minimal setup for the Rust language server.

```lua
require'lspconfig'.rust_analyzer.setup {
  cmd = require'lspcontainers'.command('rust_analyzer'),
  ...
}
```

--------------------------------

### Configure LSP with lspcontainers

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/doc/lspcontainers.txt

Override the cmd property in lspconfig's setup function to use a Docker-based language server.

```lua
    local lspconfig = require('lspconfig')
    local lspcontainers = require('lspcontainers')

    lspconfig.my_language_server.setup({
      cmd = lspcontainers.command('my_language_server')
    })
```

```lua
    local lspconfig = require('lspconfig')
    local lspcontainers = require('lspcontainers')

    lspconfig.lua_ls.setup({
      cmd = lspcontainers.command('lua_ls')
    })
```

--------------------------------

### Configure solargraph

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Minimal setup for the Solargraph Ruby language server.

```lua
require'lspconfig'.solargraph.setup {
  cmd = require'lspcontainers'.command('solargraph'),
  ...
}
```

--------------------------------

### Configure pyright

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Sets up the Pyright language server with root directory detection.

```lua
require'lspconfig'.pyright.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('pyright'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure HTML Language Server with Custom Image and Command Builder

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Sets up the html language server with a custom Docker image and a `cmd_builder` function to define the container run command. This is useful for unsupported language servers. Ensure `lspconfig` and `lspcontainers` are required.

```lua
local lspconfig = require('lspconfig')
local lspcontainers = require('lspcontainers')

-- With custom image for unsupported language server
lspconfig.html.setup {
  cmd = lspcontainers.command('html', {
    image = "lspcontainers/html-language-server:1.4.0",
    cmd_builder = function(runtime, workdir, image, network)
      return {
        runtime,
        "container",
        "run",
        "--interactive",
        "--rm",
        "--network=" .. network,
        "--workdir=" .. workdir,
        "--volume=" .. workdir .. ":" .. workdir .. ":z",
        image
      }
    end,
  }),
  root_dir = require('lspconfig/util').root_pattern(".git", vim.fn.getcwd()),
}
```

--------------------------------

### Configure tsserver

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Sets up the TypeScript language server with root directory detection.

```lua
require'lspconfig'.tsserver.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('tsserver'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure svelte

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Sets up the Svelte language server with root directory detection.

```lua
require'lspconfig'.svelte.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('svelte'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure vuels

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Sets up the Vue language server with root directory detection.

```lua
require'lspconfig'.vuels.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('vuels'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure yamlls

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Sets up the YAML language server with root directory detection.

```lua
require'lspconfig'.yamlls.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('yamlls'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure powershell_es

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Sets up the PowerShell language server with a custom on_new_config handler.

```lua
require'lspconfig'.powershell_es.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  on_new_config = function(new_config, new_root_dir)
    new_config.cmd = require'lspcontainers'.command(server, {root_dir = new_root_dir})
  end,
  cmd = require'lspcontainers'.command(server),
  filetypes = {"ps1", "psm1", "psd1"},
  ...
}
```

--------------------------------

### Configure Multiple Language Servers

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Sets up multiple language servers by distinguishing between those that require processId modification and those that do not. Requires lspconfig and lspcontainers plugins.

```lua
local lspconfig = require('lspconfig')
local lspcontainers = require('lspcontainers')

-- Helper function for common on_attach keymaps
local function on_attach(client, bufnr)
  local opts = { noremap = true, silent = true, buffer = bufnr }
  vim.keymap.set('n', 'gd', vim.lsp.buf.definition, opts)
  vim.keymap.set('n', 'K', vim.lsp.buf.hover, opts)
  vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, opts)
  vim.keymap.set('n', 'gr', vim.lsp.buf.references, opts)
  vim.keymap.set('n', '<space>rn', vim.lsp.buf.rename, opts)
  vim.keymap.set('n', '<space>ca', vim.lsp.buf.code_action, opts)
end

-- Setup lspcontainers with servers to ensure are installed
lspcontainers.setup({
  ensure_installed = { "lua_ls", "tsserver", "gopls", "rust_analyzer" }
})

-- Servers that work without processId modification
local simple_servers = { "clangd", "gopls", "pylsp", "rust_analyzer", "solargraph", "lemminx", "lua_ls", "terraformls" }

for _, server in ipairs(simple_servers) do
  lspconfig[server].setup {
    on_attach = on_attach,
    cmd = lspcontainers.command(server),
  }
end

-- Servers requiring processId = nil
local nil_pid_servers = { "bashls", "denols", "dockerls", "graphql", "html", "intelephense", "jsonls", "prismals", "pyright", "svelte", "tailwindcss", "tsserver", "vuels", "yamlls" }

for _, server in ipairs(nil_pid_servers) do
  lspconfig[server].setup {
    on_attach = on_attach,
    before_init = function(params)
      params.processId = vim.NIL
    end,
    cmd = lspcontainers.command(server),
    root_dir = require('lspconfig/util').root_pattern(".git", vim.fn.getcwd()),
  }
end
```

--------------------------------

### Configure Go Language Server with Custom Podman Options

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Configures the gopls language server using `lspcontainers.command` with custom options for Podman runtime, network bridge, and a specific image tag. Ensure `lspconfig` and `lspcontainers` are required.

```lua
local lspconfig = require('lspconfig')
local lspcontainers = require('lspcontainers')

-- With custom options
lspconfig.gopls.setup {
  cmd = lspcontainers.command('gopls', {
    container_runtime = "podman",  -- Use podman instead of docker
    network = "bridge",            -- Enable network access (default is "none")
    image = "docker.io/lspcontainers/gopls:latest",  -- Custom image tag
  }),
  root_dir = require('lspconfig/util').root_pattern("go.mod", ".git"),
}
```

--------------------------------

### Configure terraformls

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Sets up the Terraform language server with explicit filetype definitions.

```lua
require'lspconfig'.terraformls.setup {
  cmd = require'lspcontainers'.command('terraformls'),
  filetypes = { "hcl", "tf", "terraform", "tfvars" },
  ...
}
```

--------------------------------

### Configure volume mounting

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Set up persistent Docker volumes or direct host directory mounts for language servers requiring access to project files.

```lua
local lspconfig = require('lspconfig')
local lspcontainers = require('lspcontainers')

-- Mount a Docker volume for persistent storage
lspconfig.omnisharp.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = lspcontainers.command('omnisharp', {
    workdir = "/projects",
    docker_volume = "persistent_volume_projects",
  }),
  root_dir = require('lspconfig/util').root_pattern("*.sln", vim.fn.getcwd()),
}

-- Mount host directory directly
lspconfig.omnisharp.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = lspcontainers.command('omnisharp', {
    workdir = "/home/user/projects",  -- Same as host path for direct mount
  }),
  root_dir = require('lspconfig/util').root_pattern("*.sln", vim.fn.getcwd()),
}
```

--------------------------------

### Configure html

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the HTML language server.

```lua
require'lspconfig'.html.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('html'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure graphql

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the GraphQL language server.

```lua
require'lspconfig'.graphql.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('graphql'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure custom language server image

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Define a custom Docker image and command structure for a language server.

```lua
lspconfig.html.setup {
  on_attach = on_attach,
  capabilities = capabilities,
  cmd = lspcontainers.command('html', {
	image = "lspcontainers/html-language-server:1.4.0",
	cmd = function (runtime, volume, image)
      return {
        runtime,
        "container",
        "run",
        "--interactive",
        "--rm",
        "--volume",
        volume,
        image
      }
    end,
  }),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
}
```

--------------------------------

### Sync root directory dynamically

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Use on_new_config to update the container command with the root directory detected by lspconfig.

```lua
local lspconfig = require('lspconfig')
local lspcontainers = require('lspcontainers')

local server = "lua_ls"

lspconfig[server].setup {
  on_new_config = function(new_config, new_root_dir)
    -- Dynamically update the command with the detected root directory
    new_config.cmd = lspcontainers.command(server, {
      root_dir = new_root_dir
    })
  end,
  root_dir = require('lspconfig/util').root_pattern(".luarc.json", ".git"),
}
```

--------------------------------

### Mount host directory as volume

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configure a language server to mount a specific host path.

```lua
require'lspconfig'.omnisharp.setup {
  capabilities = capabilities,
  before_init = before_init_process_id_nil,
  cmd = require'lspcontainers'.command(
      'omnisharp',
      {
          workdir = /home/[UserName]/projects
      }
  ),
  on_new_config = on_new_config,
  on_attach = on_attach,
  root_dir = require'lspconfig/util'.root_pattern("*.sln", vim.fn.getcwd()),
}
```

--------------------------------

### Sync root directory with container volume

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Use on_new_config to ensure the container volume mount matches the LSP root directory.

```lua
local server = "lua_ls"
require'lspconfig'[server].setup{
  on_new_config = function(new_config, new_root_dir)
    new_config.cmd = require'lspcontainers'.command(server, { root_dir = new_root_dir })
  end
}
```

--------------------------------

### Configure intelephense

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the Intelephense language server.

```lua
require'lspconfig'.intelephense.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('intelephense'),
  root_dir = require'lspconfig/util'.root_pattern("composer.json", ".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### command(server, user_opts)

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Generates the container command array required to run a language server in Docker or Podman.

```APIDOC
## command(server, user_opts)

### Description
Generates the container command array to run a language server in Docker or Podman. This is the primary function used to configure language servers with nvim-lspconfig.

### Parameters
- **server** (string) - Required - The name of the language server.
- **user_opts** (table) - Optional - Configuration overrides for container_runtime, image, network, volume mounts, or a custom cmd_builder function.

### Request Example
local cmd = lspcontainers.command('gopls', { container_runtime = "podman", network = "bridge" })
```

--------------------------------

### Configure bashls

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the bash language server.

```lua
require'lspconfig'.bashls.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('bashls'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure gopls

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the Go language server.

```lua
require'lspconfig'.gopls.setup {
  cmd = require'lspcontainers'.command('gopls'),
  ...
}
```

--------------------------------

### Configure Podman as container runtime

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Specify podman as the container runtime for the language server.

```lua
lspconfig.gopls.setup {
  on_attach = on_attach,
  capabilities = capabilities,
  cmd = lspcontainers.command('gopls', {
    container_runtime = "podman",
  }),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
}
```

--------------------------------

### Configure clangd

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the clangd language server.

```lua
require'lspconfig'.clangd.setup {
  cmd = require'lspcontainers'.command('clangd'),
  ...
}
```

--------------------------------

### Configure Lua Language Server with LSP Containers

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Basic usage of `lspcontainers.command` to set up the lua_ls language server with default container settings. Ensure `lspconfig` and `lspcontainers` are required.

```lua
local lspconfig = require('lspconfig')
local lspcontainers = require('lspcontainers')

-- Basic usage with default settings
lspconfig.lua_ls.setup {
  cmd = lspcontainers.command('lua_ls'),
  root_dir = require('lspconfig/util').root_pattern(".git", vim.fn.getcwd()),
}
```

--------------------------------

### Configure dockerls

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the Docker language server.

```lua
require'lspconfig'.dockerls.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('dockerls'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure jsonls

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the JSON language server.

```lua
require'lspconfig'.jsonls.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('jsonls'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Configure prismals

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configures the Prisma language server with a root pattern utility.

```lua
require'lspconfig'.prismals.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('prismals'),
  root_dir = require'lspconfig/util'.root_pattern(".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### List supported language servers

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Iterate through the supported_languages table to view pre-configured language servers and their associated Docker images.

```lua
local lspcontainers = require('lspcontainers')

-- List all supported language servers
for server_name, config in pairs(lspcontainers.supported_languages) do
  print(server_name .. ": " .. config.image)
end

-- Output includes:
-- bashls: docker.io/lspcontainers/bash-language-server
-- clangd: docker.io/lspcontainers/clangd-language-server
-- denols: docker.io/lspcontainers/denols
-- dockerls: docker.io/lspcontainers/docker-language-server
-- gopls: docker.io/lspcontainers/gopls
-- graphql: docker.io/lspcontainers/graphql-language-service-cli
-- html: docker.io/lspcontainers/html-language-server
-- intelephense: docker.io/lspcontainers/intelephense
-- jsonls: docker.io/lspcontainers/json-language-server
-- lua_ls: docker.io/lspcontainers/lua-language-server
-- omnisharp: docker.io/lspcontainers/omnisharp
-- powershell_es: docker.io/lspcontainers/powershell-language-server
-- prismals: docker.io/lspcontainers/prisma-language-server
-- pylsp: docker.io/lspcontainers/python-lsp-server
-- pyright: docker.io/lspcontainers/pyright-langserver
-- rust_analyzer: docker.io/lspcontainers/rust-analyzer
-- solargraph: docker.io/lspcontainers/solargraph
-- lemminx: docker.io/lspcontainers/lemminx
-- svelte: docker.io/lspcontainers/svelte-language-server
-- tailwindcss: docker.io/lspcontainers/tailwindcss-language-server
-- terraformls: docker.io/lspcontainers/terraform-ls
-- tsserver: docker.io/lspcontainers/typescript-language-server
-- vuels: docker.io/lspcontainers/vue-language-server
-- yamlls: docker.io/lspcontainers/yaml-language-server
```

--------------------------------

### Configure denols

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the Deno language server.

```lua
require'lspconfig'.denols.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('denols'),
  root_dir = require'lspconfig/util'.root_pattern("deno.json", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Mount persistent Docker volume

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configure a language server to use a persistent Docker volume.

```lua
require'lspconfig'.omnisharp.setup {
  capabilities = capabilities,
  before_init = before_init_process_id_nil,
  cmd = require'lspcontainers'.command(
      'omnisharp',
      {
          workdir = /projects
          docker_volume = 'persistent_volume_projects',
      }
  ),
  on_new_config = on_new_config,
  on_attach = on_attach,
  root_dir = require'lspconfig/util'.root_pattern("*.sln", vim.fn.getcwd()),
}
```

--------------------------------

### Configure omnisharp

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configuration for the OmniSharp language server.

```lua
require'lspconfig'.omnisharp.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('omnisharp'),
  root_dir = require'lspconfig/util'.root_pattern("*.sln", "*.csproj", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Enable network access for container

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Override the default network settings to allow bridge network access.

```lua
cmd = lspcontainers.command('mylsp', {
  -- ...
  network = "bridge",
}),
```

--------------------------------

### images_pull(runtime)

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Pulls Docker/Podman images for all language servers specified in ensure_installed.

```APIDOC
## images_pull(runtime)

### Description
Pulls Docker/Podman images for all language servers specified in ensure_installed. Runs asynchronously.

### Parameters
- **runtime** (string) - Optional - The container runtime to use (e.g., "docker" or "podman"). Defaults to "docker".
```

--------------------------------

### Disable Process ID Detection

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Use this before_init function to prevent containerized language servers from exiting due to host-container process ID mismatches.

```lua
require'lspconfig'.bashls.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('bashls'),
}
```

--------------------------------

### Pull Language Server Images Programmatically

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Pulls Docker/Podman images for language servers specified in `ensure_installed` using `lspcontainers.images_pull()`. This function runs asynchronously. The default runtime is Docker.

```lua
local lspcontainers = require('lspcontainers')

-- First configure which servers you want
lspcontainers.setup({
  ensure_installed = { "lua_ls", "tsserver", "gopls" }
})

-- Pull images programmatically (default uses docker)
lspcontainers.images_pull()

-- Or use podman as the runtime
lspcontainers.images_pull("podman")

-- Alternatively, use the Vim command
-- :LspImagesPull
```

--------------------------------

### Create persistent Docker volume

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Command to create a named Docker volume for persistent storage.

```bash
docker create volume persistent_volume_projects
```

--------------------------------

### Handle process ID for containers

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Disable process ID detection for containerized language servers to prevent namespace conflicts.

```lua
local lspconfig = require('lspconfig')
local lspcontainers = require('lspcontainers')

-- Disable process ID for servers that require it
lspconfig.bashls.setup {
  before_init = function(params)
    params.processId = vim.NIL
  end,
  cmd = lspcontainers.command('bashls'),
  root_dir = require('lspconfig/util').root_pattern(".git", vim.fn.getcwd()),
}

-- This is required for: bashls, denols, dockerls, graphql, html,
-- intelephense, jsonls, omnisharp, powershell_es, prismals,
-- pyright, svelte, tailwindcss, tsserver, vuels, yamlls
```

--------------------------------

### Configure tailwindcss

Source: https://github.com/lspcontainers/lspcontainers.nvim/blob/main/README.md

Configures the Tailwind CSS language server with extensive filetype support and specific root patterns.

```lua
require'lspconfig'.tailwindcss.setup {
  before_init = function(params)
  	params.processId = vim.NIL
  end,
  cmd = require'lspcontainers'.command('tailwindcss'),
  filetypes = { "django-html", "htmldjango", "gohtml", "html", "markdown", "php", "css", "postcss", "sass", "scss", "stylus", "javascript", "javascriptreact", "rescript", "typescript", "typescriptreact", "vue", "svelte" },
  root_dir = require'lspconfig/util'.root_pattern("tailwind.config.js", "tailwind.config.ts", "postcss.config.js", "postcss.config.ts", "package.json", "node_modules", ".git", vim.fn.getcwd()),
  ...
}
```

--------------------------------

### Remove Language Server Images Programmatically

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Removes all `lspcontainers` Docker/Podman images from the system using `lspcontainers.images_remove()`. This function runs asynchronously. The default runtime is Docker.

```lua
local lspcontainers = require('lspcontainers')

-- Remove all language server images (default uses docker)
lspcontainers.images_remove()

-- Or use podman as the runtime
lspcontainers.images_remove("podman")

-- Alternatively, use the Vim command
-- :LspImagesRemove
```

--------------------------------

### images_remove(runtime)

Source: https://context7.com/lspcontainers/lspcontainers.nvim/llms.txt

Removes all lspcontainers Docker/Podman images from the system.

```APIDOC
## images_remove(runtime)

### Description
Removes all lspcontainers Docker/Podman images from the system. Runs asynchronously.

### Parameters
- **runtime** (string) - Optional - The container runtime to use (e.g., "docker" or "podman"). Defaults to "docker".
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.