🔌 Itential - MCP Server
About
An MCP server that connects LLMs to the Itential Platform, enabling AI assistants to manage network automations, orchestrate workflows, monitor platform health, and perform advanced network operations. It is designed for platform engineers and developers.
Details
- License
- GPL-3.0
Explore
- 56+ Automation Tools: Comprehensive toolkit across 10 tag categories for all network automation needs
- Advanced Tool Selection: Filter and control available tools using flexible tagging system
- Multiple Transport Methods: stdio, SSE, and HTTP transports with optional TLS encryption
- Dynamic Tool Discovery: Automatically discovers and registers tools without code modifications
- Flexible Authentication: Supports basic auth, OAuth 2.0, JWT, and role-based access for Itential Platform
- Comprehensive Configuration: CLI parameters, environment variables, or configuration files
- Role-Based Access: Tailored tool configurations for Platform Administrators, Network Engineers, and Developers
- Tagging System - Advanced tool filtering and selection strategies
- Workflow Execution - Execute and monitor Itential workflows
- Custom Tools Development - Create and integrate custom MCP tools
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
🔌 Itential - MCP ServerCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
The itential-mcp application can be installed using either PyPI or it can be
run directly from source.
To install it from PyPI, simply use pip:
pip install itential-mcp
uv run itential-mcp run --include-tags "system,devices" --exclude-tags "experimental"
docker run -p 8000:8000 \
--env ITENTIAL_MCP_SERVER_TRANSPORT=sse \
--env ITENTIAL_MCP_SERVER_HOST=0.0.0.0 \
--env ITENTIAL_MCP_SERVER_PORT=8000 \
--env ITENTIAL_MCP_PLATFORM_HOST=your-platform.example.com \
--env ITENTIAL_MCP_PLATFORM_CLIENT_ID=CLIENT_ID \
--env ITENTIAL_MCP_PLATFORM_CLIENT_SECRET=CLIENT_SECRET \
ghcr.io/itential/itential-mcp:latest
pip install itential-mcp
Set your Itential Platform credentials:
export ITENTIAL_MCP_PLATFORM_HOST="your-platform.example.com"
export ITENTIAL_MCP_PLATFORM_USER="your-username"
export ITENTIAL_MCP_PLATFORM_PASSWORD="your-password"
Follow the integration guide to connect Claude, Continue.dev, or other MCP clients.
Start the MCP server with default settings _(stdio transport)_:
itential-mcp run
Start with SSE transport:
itential-mcp run --transport sse --host 0.0.0.0 --port 8000
| Option | Description | Default |
|-----------------------------|-------------------------------------|-----------|
| --platform-host | Itential Platform hostname | localhost |
| --platform-port | Platform port (0 = auto-detect) | 0 |
| --platform-disable-tls | Disable TLS for platform connection | false |
| --platform-disable-verify | Disable certificate verification | false |
| --platform-timeout | Connection timeout | 30 |
| --platform-user | Username for authentication | admin |
| --platform-password | Password for authentication | admin |
| --platform-client-id | OAuth client ID | none |
| --platform-client-secret | OAuth client secret | none |
All command line options can also be set using environment variables prefixed with ITENTIAL_MCP_SERVER_. For example:
export ITENTIAL_MCP_SERVER_TRANSPORT=sse
export ITENTIAL_MCP_PLATFORM_HOST=platform.example.com
itential-mcp run # Will use the environment variables
The server configuration can also be specified using a configuration file. The
configuration file can be used to pass in all the configuration parameters. To
use a configuration file, simply pass in the --config <path> command line
argument where <path> points to the configuration file to load.
The format and values for the configuration file are documented
here
When configuration options are specified in multiple places the following
precedence for determinting the value to be used will be honored from highest
to lowest:
1. Environment variable
2. Command line option
3. Configuration file
4. Default value
The following role-based configurations provide tailored tool access based on specific job functions and responsibilities:
Platform Administrator:
System health monitoring, component management, platform operations
itential-mcp run --include-tags "health,adapters,applications,integrations"
Key Tools: Platform health monitoring, adapter/application lifecycle, integration management
Network Engineer:
Device management, configurations, compliance, network automation
itential-mcp run --include-tags "configuration_manager,automation_studio"
Key Tools: Device configuration, compliance plans, command templates, golden config management
Automation Developer:
Workflow building, performance analysis, platform extension
itential-mcp run --include-tags "operations_manager,workflow_engine,lifecycle_manager,gateway_manager"
Key Tools: Workflow execution, performance metrics, resource lifecycle, external service integration
Platform Operator:
Daily operations, job monitoring, report generation
itential-mcp run --include-tags "operations_manager,configuration_manager"
Key Tools: Workflow execution, job monitoring, device operations, compliance reporting
- MCP Client Integration - Configure Claude, Continue.dev, and other MCP clients
- TLS Configuration - Enable secure HTTPS connections with certificates
- JWT Authentication - JWT token authentication setup
- OAuth Authentication - OAuth 2.0 with multiple providers
- Configuration Examples - Complete configuration file reference
- Status Endpoints - Health monitoring for production deployments
Run the test suite with:
make test
For test coverage information:
make coverage
```
The Itential MCP server provides powerful tool filtering capabilities through a comprehensive tagging system. This allows you to customize which tools are available based on your specific needs and security requirements.
itential-mcp run --include-tags "health,configuration_manager"
itential-mcp run --exclude-tags "experimental,beta,lifecycle_manager"
The entire list of available tools can be found in the tools documentation along with detailed tag associations.
Adding a new tool is simple:
1. Create a new Python file in the src/itential_mcp/tools/ directory or add a function to an existing file
2. Define an async function with a Context parameter annotation:
from fastmcp import Context
async def my_new_tool(ctx: Context) -> dict:
"""
Description of what the tool does
Args:
ctx (Context): The FastMCP Context object
Returns:
dict: The response data
Raises:
None
"""
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"\ud83d\udd0c itential - mcp server": {
"itential-mcp": {
"command": "uv",
"args": [
"run",
"itential-mcp",
"run"
]
}
}
}
}McpServers
{
"itential-mcp": {
"command": "uv",
"args": [
"run",
"itential-mcp",
"run"
]
}
}A Model Context Protocol _(MCP)_ server that provides comprehensive tools for connecting LLMs to Itential Platform. Enable AI assistants to manage network automations, orchestrate workflows, monitor platform health, and perform advanced network operations.
🎯 Who This Is For
Platform Engineers
Manage infrastructure, monitor system health, configure devices, and orchestrate network operations through AI-powered automation.Developers
Build automation workflows, integrate with external systems, manage application lifecycles, and extend platform capabilities.📒 Key Features
Core Capabilities
- 56+ Automation Tools: Comprehensive toolkit across 10 tag categories for all network automation needs - Advanced Tool Selection: Filter and control available tools using flexible tagging system - Multiple Transport Methods: stdio, SSE, and HTTP transports with optional TLS encryption - Dynamic Tool Discovery: Automatically discovers and registers tools without code modifications - Flexible Authentication: Supports basic auth, OAuth 2.0, JWT, and role-based access for Itential Platform - Comprehensive Configuration: CLI parameters, environment variables, or configuration files - Role-Based Access: Tailored tool configurations for Platform Administrators, Network Engineers, and DevelopersNetwork Automation & Device Management
- Device Configuration: Apply configurations, backup device settings, and retrieve current configurations - Command Execution: Run single commands or command templates across multiple devices with rule validation - Device Groups: Create and manage logical device collections for streamlined operations - Compliance Management: Automated compliance plan execution and detailed reporting - Golden Configuration: Hierarchical template-based configuration management with version controlWorkflow & Orchestration
- Workflow Execution: Start workflows via API endpoints and monitor execution status - Job Management: Track workflow jobs with comprehensive status, metrics, and task details - Workflow Exposure: Convert workflows into REST API endpoints for external consumption - Template Management: Create, update, and execute Jinja2 and TextFSM templates - Performance Metrics: Detailed job and task execution metrics for workflow optimizationPlatform Operations & Monitoring
- Health Monitoring: Real-time platform health including system resources, applications, and adapters - Component Lifecycle: Start, stop, and restart applications and adapters with status monitoring - Integration Management: Create and manage OpenAPI-based integration models - Gateway Services: Execute external services (Ansible, Python scripts, OpenTofu) through Gateway ManagerLifecycle & Resource Management
- Resource Models: Define JSON Schema-based resource structures with lifecycle workflows - Instance Management: Full CRUD operations on resource instances with state tracking - Action Execution: Run lifecycle actions with comprehensive execution history - Data Validation: Schema-based validation for resource data and action parameters🔍 Requirements
- Python _3.10_ or higher - Access to an Itential Platform Instance - For _development_ -uv and make
Tested Python Versions
This project is automatically tested against the following Python versions: - Python 3.10 - Python 3.11 - Python 3.12 - Python 3.13🔧 Installation
Theitential-mcp application can be installed using either PyPI or it can be
run directly from source.
PyPI Installation
To install it from PyPI, simply usepip:
pip install itential-mcp
Local Development
The repository can also be clone the repository to your local environment to work with the MCP server. The project usesuv and make so both tools
would need to be installed and available in your environment.
The following commands can be used to get started.
git clone https://github.com/itential/itential-mcp
cd itential-mcp
make build
For development, you can run the server directly using uv:
```bash
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
