Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@plc-mcp-server What are the current alarm statuses on the main line?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server for industrial PLC integration. Enables AI assistants to read tags, monitor alarms, and interact with Allen-Bradley ControlLogix PLCs using natural language.
🏭 Tag Operations - Read/write PLC tags
🚨 Alarm Management - View and acknowledge alarms
📊 Diagnostics - PLC status, I/O health, connection info
🔒 Safety First - Read-only by default, write whitelist, audit logging
🔌 MCP Standard - Works with Claude Desktop, Cursor, and any MCP client
Related MCP server: ignition-mcp
# Install dependencies
pip install -r requirements.txt
# Configure your PLC connection
cp config.example.yaml config.yaml
# Edit config.yaml with your PLC IP and settings
# Run the server (stdio mode for MCP)
python -m plc_mcp_server
# Or run in HTTP/SSE mode
python -m plc_mcp_server --transport sse --port 8080Add to claude_desktop_config.json:
{
"mcpServers": {
"plc": {
"command": "python",
"args": ["-m", "plc_mcp_server"],
"cwd": "/path/to/plc-mcp-server"
}
}
}plc-mcp-server/
├── plc_mcp_server/
│ ├── __init__.py
│ ├── __main__.py # Entry point
│ ├── server.py # MCP server implementation
│ ├── plc/
│ │ ├── __init__.py
│ │ ├── client.py # PLC connection manager
│ │ ├── allen_bradley.py # ControlLogix driver
│ │ ├── siemens.py # S7 driver (future)
│ │ └── modbus.py # Modbus driver (future)
│ ├── tools/
│ │ ├── __init__.py
│ │ ├── tags.py # Tag read/write tools
│ │ ├── alarms.py # Alarm tools
│ │ └── diagnostics.py # Status/diagnostic tools
│ ├── resources/
│ │ ├── __init__.py
│ │ └── tag_database.py # Tag list resource
│ └── safety/
│ ├── __init__.py
│ ├── whitelist.py # Write permission control
│ └── audit.py # Audit logging
├── config.example.yaml
├── requirements.txt
├── pyproject.toml
└── tests/
└── ...This server controls industrial equipment. Safety is paramount.
Read-only mode by default (allow_writes: false)
Tag whitelist for write operations
All operations logged to audit trail
Confirmation required for writes (via MCP confirmation flow)
MIT
Acknowledge an active alarm.
| Name | Required | Description | Default |
|---|---|---|---|
| alarm_id | Yes | ID of the alarm to acknowledge |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must fully disclose behavior. It only says 'Acknowledge an active alarm' without explaining side effects (e.g., state change, notification triggers, reversibility, or error cases).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short, but it lacks essential detail. Conciseness is not beneficial if it sacrifices clarity and completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (one parameter, no output schema), the description should still explain the outcome of acknowledgment and any assumptions. It fails to do so, leaving the agent underinformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the parameter 'alarm_id' is clearly described in the schema. The description adds no additional meaning beyond what the schema provides, so baseline score is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('acknowledge') and the resource ('an active alarm'). It distinguishes from sibling tools like 'get_alarms' which reads alarms, but does not elaborate on the exact meaning of acknowledgment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no prerequisites (e.g., alarm must be active), and no exclusions or context provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get active alarms from the PLC.
| Name | Required | Description | Default |
|---|---|---|---|
| include_acknowledged | No | Include already acknowledged alarms |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It says 'active alarms' but does not define 'active' (default excludes acknowledged ones). Basic transparency but lacks detail on behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence. It is appropriately sized for a simple tool, though no structured formatting is used.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema is provided, and the description does not explain what the tool returns (e.g., list of alarm objects, fields). For a tool that reads data, this is a significant gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the description adds no extra meaning beyond the schema's parameter description. Baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states it retrieves active alarms from the PLC, which is a specific verb and resource. It is distinct from sibling tools like acknowledge_alarm (modification) and tag-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives like acknowledge_alarm or read_tag. Usage context is only implied by the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get connection information and statistics.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits. It indicates a read operation ('Get') but does not explicitly state read-only nature, side effects, or permissions. Minimal behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words. It is concise and front-loaded with the verb and resource, but could be slightly more descriptive.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (no parameters, no output schema), the description provides a basic understanding but lacks detail on what constitutes 'connection information and statistics.' It is adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, and schema description coverage is 100%. The description adds no parameter info, which is acceptable here. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves connection information and statistics. However, it does not differentiate from sibling tools like 'get_alarms' or 'get_plc_status' that also get data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description lacks any context about appropriate usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get I/O module status and health.
| Name | Required | Description | Default |
|---|---|---|---|
| module | No | Specific module to check (optional, all if not specified) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description only says 'status and health' without explaining what that entails (e.g., return format, side effects). Lacks details on read-only nature or performance implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no fluff. Efficient but could be slightly expanded for clarity without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional param and no output schema, the description is minimally sufficient but lacks return format and relation to other tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. Description adds no additional meaning beyond the schema's parameter description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'Get' and resource 'I/O module status and health', which distinguishes it from siblings like get_plc_status or get_alarms. However, it does not explicitly differentiate itself from other 'get' tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs siblings such as get_plc_status. Does not mention prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get PLC status including CPU state, mode, and faults.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states it gets status, which is implied by the name. There is no mention of side effects, permissions, rate limits, or other behaviors beyond the basic read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no unnecessary words. Front-loaded with 'Get PLC status' which captures the core purpose immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description partially explains return values by listing CPU state, mode, and faults. It does not describe format or structure, but for a simple read tool, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, and the schema coverage is 100% (trivially). Per guidelines, baseline for 0 parameters is 4. The description does not add parameter info but none is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verb 'Get' and resource 'PLC status', and lists specific components (CPU state, mode, faults). It clearly distinguishes from sibling tools like get_alarms, get_io_status, and get_connection_info, which cover other aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description does not mention when to prefer it over get_io_status or get_alarms, nor does it provide any conditions or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available tags in the PLC. Can filter by pattern.
| Name | Required | Description | Default |
|---|---|---|---|
| pattern | No | Optional filter pattern (e.g., 'Motor*', '*_Level') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It only states listing and filtering, with no mention of side effects (presumably read-only), performance, pagination, or pattern matching semantics (regex vs glob, case sensitivity). This is insufficient for a tool with no annotation safety net.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, front-loaded sentences. First sentence states the main action, second adds optional filtering. No wasted words, perfectly sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema or return format is specified. For a list tool, the description should indicate what fields are returned (e.g., tag names, IDs?). Given the simplicity and lack of annotations, more detail is needed to be fully useful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (the pattern parameter has examples in the schema). The description merely repeats that filtering is available, adding no extra meaning beyond the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List all available tags in the PLC', which is a specific verb and resource. It distinguishes from sibling tools like read_tag (which reads a single tag value) or write_tag, making it easy to understand what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for discovering tags and optionally filtering, but it does not explicitly state when to use this tool versus siblings (e.g., for reading values use read_tag). No when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a PLC tag value. Returns the current value of the specified tag.
| Name | Required | Description | Default |
|---|---|---|---|
| tag_name | Yes | Name of the tag to read (e.g., 'Motor1_Running', 'Tank_Level') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must stand alone. It discloses a read operation and return value, but is minimal—no mention of side effects, permissions, or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences with no wasted words. Information is front-loaded, covering purpose and output immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description provides sufficient context: what it does (read tag) and what it returns (value).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter description including examples. The tool description adds nothing beyond the schema: 'specified tag' is redundant. Baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads a PLC tag value and returns its current value. It uses specific verb and resource, distinguishing it from siblings like 'write_tag' and 'list_tags'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool over alternatives like 'read_tags' for multiple tags. The name implies single-tag use, but no when-not-to-use or alternative mentions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read multiple PLC tags at once. More efficient than multiple single reads.
| Name | Required | Description | Default |
|---|---|---|---|
| tag_names | Yes | List of tag names to read |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must bear full burden. It describes the core read behavior but does not mention non-destructive nature or other traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with two front-loaded sentences that convey purpose and benefit without extraneous content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool with no output schema, the description is adequate but lacks details on return format, limits, or error behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the description adds little beyond what the schema already conveys about the tag_names parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads multiple PLC tags at once, distinguishing it from the sibling single-read tool, read_tag.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly notes efficiency over multiple single reads, providing a reason to use this tool, though it does not explicitly state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Write a value to a PLC tag. Requires write permissions and tag must be in whitelist.
| Name | Required | Description | Default |
|---|---|---|---|
| value | Yes | Value to write (type depends on tag) | |
| tag_name | Yes | Name of the tag to write |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries the burden. It mentions required permissions and whitelist, but does not disclose response format, error handling, or side effects beyond mutation. Adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no fluff. The core action is front-loaded. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter write tool with no output schema and no annotations, the description covers the action and prerequisites. It could mention that the tag must exist or error handling, but it is sufficiently complete for typical usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%: both parameters have descriptions in the schema. The tool description adds no additional parameter semantics beyond what the schema already provides. Baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Write a value to a PLC tag', using a specific verb and resource. It distinguishes itself from sibling tools like read_tag and list_tags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes prerequisites: 'Requires write permissions and tag must be in whitelist.' It does not explicitly compare to alternatives or state when-not-to-use, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0acknowledge_alarmget_alarmsget_connection_infoget_io_statusget_plc_statuslist_tagsread_tagread_tagswrite_tagEach tool targets a distinct action: reading/writing tags, listing tags, managing alarms, or retrieving status info. No overlap in purpose.
All tools follow a consistent verb_noun pattern using snake_case (e.g., read_tag, write_tag, acknowledge_alarm).
9 tools cover the essential PLC operations without unnecessary bloat; the count is well-scoped for the domain.
Core operations (read/write tags, list tags, alarms, status) are present; missing a bulk write or subscription feature, but these are minor gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
Self-hosted MCP gateway: turn any API, database or MCP server into AI connectors — no code.
Cloud-hosted MCP server for secure AI access to enterprise data sources via CData Connect AI.
Hosted MCP server connecting AI assistants to 9,000+ apps and 40,000+ actions via Zapier.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/OlubunmiAde/plc-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
