MCP Server installation on Linux via Docker
Overview
This guide covers the installation of CAST Imaging MCP Server on Linux via Docker. It’s intended for:
- Direct installation on Linux, via Docker
- new installations (i.e. from scratch)
- in-place updates to a new release
The installation package com.castsoftware.imaging.mcpserver.docker includes an installation script and configuration files. All Docker images are pulled direct from https://hub.docker.com during the installation.
Requirements
MCP Server is a standalone component and can therefore be installed wherever convenient in your local environment, e.g. on a dedicated machine, or on a machine already used by other CAST Imaging components.
When using a dedicated machine, CAST recommends following the general hardware and software requirements but note that the component does not require:
- a Java JRE/JDK
Other requirements:
- MCP Server runs as a Docker container on TCP port 8282 although you can change this in the
.env
file (see below). You may therefore need to adjust firewall rules to allow incoming and outgoing connections to this port - see software requirements for more information about supported Linux OS, Docker Engine and Docker Compose
- a minimum of 2GB free disk space
- CAST Imaging ≥ 3.4.1 installed and functioning (MCP Server interacts with the
imaging-services
component) in your network - an MCP-aware client such as GitHub Copilot (Visual Studio Code)
- a CAST Imaging API key, see Generating an API key
What’s new?
See the release notes.
Installation process
Step 1 - Verify connection to CAST Imaging
Before proceeding, ensure you can access CAST Imaging (the imaging-services
component) from the machine where you intend to install MCP Server by running the following (tailored to your own environment):
curl -H "x-api-key: <your-imaging-api-key>" http://<your_imaging_public_URL>:8090/rest/ready
The expected output is true
.
Step 2 - Download the installation media
Download the installer using curl
:
curl -# -O -J "https://extend.castsoftware.com/#/extension?id=com.castsoftware.imaging.mcpserver.docker/<version>?platform=linux_x64" -H "x-nuget-apikey: <api-key>" -H "accept: application/octet-stream"
Where:
-#
: enables a download progress bar.-O
: (--remote-name
) ensures the file is downloaded and saved to the current folder using the same name as the remote file.-J
: (--remote-header-name
) ensures the-O
option uses the server-specified Content-Disposition filename instead of extracting a filename from the URL. If the server-provided filename contains a path, that is stripped off before the filename is used.<version>
: uselatest
to download the most recent release, or specify the specific release, e.g.,1.0.1-funcrel
.-H
: (--header
) defines the additional header to include in information sent.<api-key>
: your CAST Extend API key (obtain this from https://extend.castsoftware.com/#/profile/settings )
Example for latest release:
curl -# -O -J "https://extend.castsoftware.com/#/extension?id=com.castsoftware.imaging.mcpserver.docker/latest?platform=linux_x64" -H "x-nuget-apikey: a9999a9a-c999-999d-999b" -H "accept: application/octet-stream"
Unzip the resulting ZIP file anywhere on your local disk. The following files/folders will be created:
com.castsoftware.imaging.mcpserver.docker.<version>/
├── config/
│ └── app.config
├── nginx/
│ └── nginx.conf
├── .env # Hidden file (use `ls -a` to view)
├── copilot-instructions.md
├── docker-compose.https.yml
├── docker-compose.yml
├── README.md
└── run.sh
Step 3 - Configure your installation
app.config
Locate the config/app.config
file at the root of the unzipped installation media. Open the file with a text editor and update the installation variables to match your environment:
HOSTNAME_CONTROL_PANEL="imaging-services machine" # Required: IP address/hostname/FQDN of the machine on which the "imaging-services" component is installed. You can use localhost if MCP Server is installed on the same machine as the "imaging-services" component.
PORT_CONTROL_PANEL=8098 # Default port on which the CAST Imaging Control Panel service (part of the "imaging-services" component) is running - unless you have changed this during the CAST Imaging installation, leave it as is
IMAGING_PAGE_SIZE=1000 # Sets the number of records the MCP server fetches per request (internal batching).
IMAGING_DISPLAY_PAGE_SIZE=20 # Sets how many records are shown per page in the user-facing response
IMAGING_CODE=False # Defines whether the application source code is accessible to the MCP Server or not: when it is set to False source code (from the Imaging analysis results) cannot be accessed by the MCP Server and therefore source code will not figure in any results returned by MCP server
HTTPS_ENABLED=false # Enable HTTPS between MCP-aware client and MCP Server (requires appropriate certificates). Forces the use of the docker-compose.https.yml file instead of docker-compose.yml
.env
Locate the .env
file at the root of the unzipped installation media. Open the file with a text editor and set the MCP server listening port (the default is set to 8282
):
MCP_SERVER_PORT=8282 # Default port
Optional: establishing a HTTPS connection between the MCP-aware client and the MCP Server
If you need to establish a secure HTTPS connection between the MCP-aware client and MCP server, follow these steps:
- Locate the
config/app.config
file at the root of the unzipped installation media. Open the file with a text editor and update theHTTPS_ENABLED
variable to true:
HTTPS_ENABLED=true
- Create a folder named
certificates
in the root of the unzipped installation media folder. Inside this folder, add your certificate and private key files with the following names:
certificate.pem
– the secure certificateprivate_key.pem
– the corresponding private key
- Creating the key file pair is beyond the scope of this documentation.
- The MCP Server will be automatically set to listen on port
8443
.
Step 4 - Run the installation
Run the following commands:
chmod +x run.sh # makes the installation script executable
./run.sh
Verify the installation by checking Docker containers (you should see one Docker container hosting the MCP Server):
docker ps
Step 5 - Configure your MCP-Aware client (GitHub Copilot for Visual Studio Code)
Install GitHub Copilot extension
Install the GitHub Copilot extension (see https://marketplace.visualstudio.com/items?itemName=GitHub.copilot ) in Visual Studio Code, ensure you are signed in to GitHub and clone the repository you need to work with.
Create mcp.json file
Create an mcp.json
configuration file and place it in the .vscode/
folder for your Visual Studio Code workspace. The mcp.json
must use the following template:
{
"inputs": [
{
"id": "imaging-key",
"type": "promptString",
"description": "CAST Imaging API Key"
}
],
"servers": {
"imaging": {
"type": "http",
"url": "http://<your-mcp-server-host:port>/mcp/",
"headers": {
"x-api-key": "${input:imaging-key}"
}
}
}
}
where:
"type"
is set tohttp
orhttps
depending on whether the MCP Server is set to run in secure HTTPS mode or not"url"
is the IP address/hostname/FQDN and port number (8282
by default) of the machine hosting the MCP Server.
Manage copilot-instructions.md file
Locate the copilot-instructions.md
file at the root of the unzipped installation media and copy it into a folder called .github
located at the root of the repository you are working with. This file provides provide chat responses that are tailored to CAST Imaging: the additional information is not displayed in the chat, but is available to Copilot to allow it to generate higher quality responses.
Alternative manual registration flow
If Visual Studio Code does not auto‑pick the MCP server:
- Open Copilot Chat → gear icon → Select tools that are available to chat
- + Add More Tools… → + Add MCP Server… → choose HTTP
- Enter
http(s)://<your-mcp-server-host:port>/mcp/
and confirm - Visual Studio Code will then create
.vscode/copilot/mcp.json
→ add the header block:
"my-mcp-server-xxxx": {
"url": "http://<your-mcp-server-host:port>/mcp/",
"headers": {
"x-api-key": "${input:imaging-key}"
}
}
Step 6 - Test your MCP-Aware client
- Launch your MCP-aware client
- Enter your CAST Imaging API key when prompted
- Run a test query, for example:
List all applications
List 5 transactions for application <YourApp>
List available applications datagraphs
List applications insights
If successful (see below), you’re ready to use your MCP Client with your MCP Server.
Success indicators
✅ Connection successful if you receive:
- Valid application listings
- Architectural insights
- Suggested analysis queries
❌ Check configuration if you see:
- Connection errors
- Authentication failures
- Empty responses
Example queries
Basic application information
List all applications
Transaction analysis
List all applications transactions
Show 10 transactions for application <YourApp>
Data flow analysis
List available applications datagraphs
Show data graphs for application <YourApp>
Quality insights
List applications insights
Show quality issues for application <YourApp>
Architectural analysis
Analyze the architecture of <YourApp>
Show dependencies for <YourApp>
Available Toolsets
Toolset | Description |
---|---|
Portfolio Tools |
Portfolio‑level exploration: list applications, compare metrics, scan hotspots across systems. |
Applications Tools |
Application‑level analysis: transactions, quality issues, datagraphs, architecture. |
Objects Tools |
Object element exploration: locate objects, references, callers/callees. |
Tools
Portfolio
- applications - List the available applications in CAST Imaging
- applications_transactions - Get transactions from all applications with filtering support
- applications_data_graphs - Data entity interaction networks (data graphs) from all applications
- applications_dependencies - Inter-dependencies between all applications
- applications_quality_insights - Quality insights including CVE, cloud detection patterns, and green detection patterns
Applications
- application_database_explorer - Explore database tables and columns in an application
- stats - Get basic statistical information for an application
- architectural_graph - Get architectural graph data (nodes/links) at specific levels (layer, component, sub-component, technology-category, element-type)
- architectural_graph_focus - Get focused architectural graph data for specific areas
- quality_insights - Get quality-related insights (CVE, cloud patterns, green patterns, structural flaws, ISO-5055)
- quality_insight_occurrences - Get specific occurrences of quality insights by ID
- packages - Get package information and dependencies
- package_interactions - Get interactions with specific packages by component and version
- transactions - Get transactions with optional filtering by name, fullname, or type
- transaction_objects_with_insights - Get objects with insights within specific transactions
- transaction_complex_objects - Get complex objects within specific transactions
- transaction_documents - Get documents for specific transactions
- add_transaction_document - Add documentation to specific transactions
- transaction_graph - Get transaction graph data (nodes/links) at different granularity levels
- transaction_graph_focus - Get focused transaction graph data concentrating on complex objects
- data_graphs - Get data entity interaction networks (data graphs) with optional filtering
- data_graph_objects_with_insights - Get objects with insights within specific data graphs
- data_graph_complex_objects - Get complex objects within specific data graphs
- data_graph_documents - Get documents for specific data graphs
- add_datagraph_document - Add documentation to specific data graphs
- data_graph_graph - Get data graph structure (nodes/links) at different granularity levels
- data_graph_graph_focus - Get focused data graph structure concentrating on complex objects
- documents - Find documents about code elements and graphs matching search text (requires IMAGING_CODE=True)
- inter_applications_dependencies - Get inward and outward inter-application dependencies
- inter_app_detailed_dependencies - Get detailed dependencies between two specific applications
Objects
- objects - Get objects in an application matching identification criteria (name, fullname, mangling, type, filepath)
- object_details - Get comprehensive details for objects including properties, relationships, code snippets, and usage statistics
- add_object_document - Add documentation text to a specific object identified by ID
- source_files - Find source files that define code objects matching file path criteria
- source_file_details - Get detailed information about source files and their code elements (inventory, intra, inward, outward, testing)
- transactions_using_object - Get transactions that use objects matching specified criteria
- data_graphs_involving_object - Get data entity interaction networks (data graphs) that involve specific objects
Troubleshooting
- Check the MCP Server container is running:
docker ps | grep imaging-mcp
- Check MCP Server logs:
docker logs <mcp-container-id>
- Test connectivity to CAST Imaging API:
curl -H "x-api-key: <your-imaging-api-key>" http://<your_imaging_public_URL>:8090/rest/ready
- Validate configuration files:
- Check
config/app.config
- Check
.env
file for correct port configuration - Ensure
"url"
parameter in the clientmcp.json
points to correct URL
- Regenerate API key in CAST Imaging profile if necessary.
Uninstall process
To remove only MCP Server related items:
- run the following Docker commands
- delete the installer ZIP file
- delete the unzipped installation files/folder
# Stop imaging-services containers
cd /<unzipped-install-files>
docker compose down
# Remove images
docker images | grep $servicename | awk '{print $3}' | xargs -I {} docker rmi -f {}
docker image prune