IC-CAP MCP Server

IC-CAP MCP Server exposes the Keysight IC-CAP Python API through the Model Context Protocol. An MCP-compatible agent can inspect and modify the active IC-CAP project, run simulations and transforms, configure parameter extraction, and retrieve plots and data through a consistent tool interface.

Features

• 114 tools covering IC-CAP models, DUTs, setups, inputs, outputs, variables, parameters, transforms, plots, macros, and project-level operations.

• Fine-grained read, build, execute, and display operations instead of one opaque extraction command.

• Packaged operational and extraction-strategy skills exposed as MCP resources.

• In-process SSE server for access to the active IC-CAP session.

• Serialized IC-CAP API calls and configurable call timeouts.

• Plot capture and numerical data access for result inspection.

The full tool catalog is defined in src/mcp_iccap_server/tools/all_tools.py.

Tool coverage

Related MCP server: COMSOL MCP Server

Architecture

The launcher runs inside IC-CAP and starts the MCP server in a background thread. Tool definitions validate MCP requests, handlers translate those requests into IC-CAP Python API calls, and skill resources provide operational and model-family extraction guidance.

MCP client
    |
    | SSE: http://127.0.0.1:8765/sse
    v
IC-CAP MCP server
    |-- tool definitions
    |-- IC-CAP API handlers
    `-- skill resources
             |
             v
       active IC-CAP session

Requirements

• Windows 11

• Keysight IC-CAP 2025 with an IC-CAP-compatible Python environment configured according to the installed Python Installation documentation

• Python 3.12

• A licensed IC-CAP installation

• An MCP client that supports SSE connections

The current release has been developed against IC-CAP 2025 on Windows 11 with Python 3.12. Other IC-CAP and Python versions have not yet been validated. The proprietary iccap and IC-CAP-compatible PySide2 modules are supplied with the product and are therefore not installed by this package.

The server must use the same Python environment selected by IC-CAP through ICCAP_PYTHONHOME. Installing its dependencies into a system Python, Conda environment, or unrelated virtual environment does not make them available to the IC-CAP process and can introduce incompatible package versions.

Installation

1. Prepare the IC-CAP Python environment

Follow the Keysight documentation installed with IC-CAP:

iccap2025/icappydoc/Python_Installation

Use the corresponding page for your installed IC-CAP update when its documentation path differs. For Windows, the documented procedure creates a compatible Python 3.12 installation, installs the pre-built wheels and package requirements provided under ICCAP_ROOT, and sets ICCAP_PYTHONHOME to that installation. Use the exact Python patch release and product files specified by the documentation shipped with your IC-CAP version.

Set ICCAP_PYTHONHOME before starting IC-CAP, then restart IC-CAP so that the process inherits the setting. In PowerShell, confirm the selected interpreter:

$iccapPython = Join-Path $env:ICCAP_PYTHONHOME "python.exe"
& $iccapPython -c "import sys; print(sys.executable); print(sys.prefix)"

If ICCAP_PYTHONHOME is empty or this command fails, finish the Keysight Python Installation procedure before installing this server.

2. Install the server into that environment

Clone the repository and use the same interpreter for installation:

git clone https://github.com/Solitario119/iccap-mcp-server.git
cd iccap-mcp-server
$iccapPython = Join-Path $env:ICCAP_PYTHONHOME "python.exe"
& $iccapPython -m pip install -e .

Do not substitute another Python executable. This command adds the MCP runtime dependencies to the environment already prepared for IC-CAP; it does not install or modify IC-CAP itself. Keep the cloned repository after installation: the editable package and iccap_launcher.py are loaded from this checkout.

3. Verify the Python dependencies

Check the dependencies with the same interpreter:

& $iccapPython -c "import mcp, pydantic, starlette, typing_extensions, uvicorn; print('dependencies available')"

Run inside IC-CAP

1. Open IC-CAP after setting ICCAP_PYTHONHOME, then load the project to be accessed.

2. Load or paste iccap_launcher.py into an IC-CAP Python Macro and execute it. This in-process launch is the supported way to give the server access to the active IC-CAP session.

3. If imports fail, print sys.prefix from an IC-CAP Python Macro and confirm that it matches ICCAP_PYTHONHOME.

4. Wait for the IC-CAP console to report:

   MCP-ICCAP server READY on http://127.0.0.1:8765/sse

5. Configure an MCP-compatible client to connect to:

   http://127.0.0.1:8765/sse

The launcher is persistent for the current IC-CAP process. Running it again while the server is active reports the existing connection instead of starting a second server.

Verify the connection

After connecting the MCP client:

1. Request the tool list and confirm that 114 tools are returned.

2. Call main_get_models to read the models in the active project.

3. Call object_exist with the path of a known IC-CAP object.

4. Request the resource list and read skill://skills/iccap-operation/SKILL.md.

These checks confirm the MCP connection, IC-CAP API access, and packaged skill resources. When validating another IC-CAP release, also use a temporary project to check object creation, value updates, simulation, plot capture, save, and deletion.

Skill resources

The MCP tools define what an agent can do in IC-CAP. The skill resources describe how to organize those operations into a safe and technically coherent device-modeling workflow. They are Markdown resources packaged with the server, not hard-coded prompts or client-specific configuration.

Operational skills

Extraction-strategy skills

An MCP client can discover all 15 files through resources/list. A typical agent workflow is:

1. Read skill://skills/iccap-operation/SKILL.md.

2. Read the operational file needed for the current action.

3. Read skill://skills/iccap-extraction/SKILL.md for an extraction task.

4. Read the relevant model-family strategy.

5. Use the tool schemas and inspect the active project before applying the documented procedure.

Resource loading depends on the MCP client. A client that does not automatically expose resources must explicitly list and read these URIs before the agent can use their contents.

Configuration

The launcher and server accept the following environment variables:

Safety

This server can create, modify, execute, save, and delete objects in the active IC-CAP project. Work on a project copy until the intended tool sequence has been verified, and save before operations that may change a large part of the project.

The SSE transport does not provide authentication or transport encryption. The server binds to 127.0.0.1 by default and rejects non-loopback addresses unless ICCAP_MCP_ALLOW_REMOTE=1 is set. Do not expose it directly to the public internet. A remote deployment requires a trusted network boundary, authentication, encryption, and access controls appropriate to the environment.

Use GitHub private vulnerability reporting for suspected vulnerabilities. Do not include proprietary IC-CAP projects, measurement data, credentials, or licensed Keysight materials in a public issue.

Limitations

• IC-CAP API calls are serialized because the underlying application state is not designed for concurrent mutation.

• Long simulations and optimization transforms can exceed the default timeout.

• Measurement operations require correctly configured instruments and drivers.

• Tool availability does not replace model-specific extraction judgment; use the relevant skill resource and inspect intermediate results.

• Compatibility outside the tested environment is not yet established.

Development

The source tree uses a standard src layout:

src/mcp_iccap_server/server.py             MCP transports and dispatch
src/mcp_iccap_server/tools/all_tools.py    tool schemas
src/mcp_iccap_server/handlers/all_handlers.py
                                           IC-CAP API handlers
src/mcp_iccap_server/skills/               packaged skill resources
iccap_launcher.py                          in-process IC-CAP launcher

This repository does not include IC-CAP projects, measurement data, vendor documentation, or licensed software. Functional validation must be performed in a licensed IC-CAP environment.

License and trademarks

The project is released under the MIT License.

This is an independent open-source project. It is not affiliated with, endorsed by, or sponsored by Keysight Technologies. IC-CAP and Keysight are trademarks of their respective owner.