RMGS MCP Server

An MCP (Model Context Protocol) server for Altair Graph Studio (AGS) that provides intelligent SPARQL query capabilities, ontology management, and graphmart construction tools — all accessible from AI coding assistants like GitHub Copilot, Claude Code, and other MCP-compatible clients.

Features

• SPARQL Query Execution — Run SPARQL queries against AGS graphmarts
• Knowledge Discovery — Explore ontologies, classes, and properties
• Ontology Management — Create, modify, and delete ontologies
• Graphmart Construction — Build and manage transformation layers and steps
• Agent Memory — Persistent and ephemeral memory for context retention
• Dual Modes — explore (read-only, 13 tools) and create (all 51 tools)
• Multiple Transports — stdio, SSE, and streamable-http

Installation

pip install siemens-graph-studio-mcp-server

Default setup (recommended)

Use this as the baseline setup when installing from PyPI.

1. Create a Python virtual environment:

python -m venv graph_mcp_env

1. Activate the environment:

source /.../howtomcp/graph_mcp_env/bin/activate

1. Install from PyPI:

pip install siemens-graph-studio-mcp-server

1. Start MCP as two separate servers (recommended):

siemens-graph-studio-mcp-server --config ags-config.json --mode explore --transport sse --port 8000
siemens-graph-studio-mcp-server --config ags-config.json --mode create --transport sse --port 8001

Note: This also installs rdflib, which adds rdfpipe and rdfgraphisomorphism executables to your environment. These are standard rdflib CLI utilities and can be safely ignored.

From Source

git clone <repository-url>
cd rmgs-mcp-server
pip install -e .

Quick AI Setup (Recommended)

Copy the prompt below and send it to your AI assistant (OpenCode, Claude Code, or GitHub Copilot). The AI will automatically handle the entire installation and configuration process.

Please install and configure the AGS MCP server from GitHub for me.

My AGS server info:
  Server: your-ags-server.example.com
  Port: 443 (or 8443)
  Username: your-username
  Password: ${AGS_PASSWORD}

Follow these steps. After each command, check the output for "Next:" guidance:
1. pip install https://github.com/engalar/siemens_graph_studio_mcp_server/archive/master.tar.gz
2. ags-mcp init --server your-ags-server.example.com --port <port> --username your-username
   Use --insecure for self-signed certificates
3. Follow the on-screen instructions until setup is complete

The AI will:

1. Install the package from GitHub
2. Run ags-mcp init to interactively set up server connection
3. Auto-discover available graphmarts and prompt for selection
4. Save configuration
5. Optionally configure OpenCode, Claude Code, and VS Code
6. Report back when ready

After setup, restart your AI assistant and ask: "What data is in the knowledge graph?"

Windows PATH note: After pip install, scripts are placed in %APPDATA%\Python\Python311\Scripts. If ags-mcp is not recognized, add this directory to your PATH or use python -m rmgs_mcp_server.cli <command> instead.

Quick verification

After installation, run this to verify everything works:

ags-mcp doctor

Or if ags-mcp is not on PATH:

python -m rmgs_mcp_server.cli doctor

ags-mcp Commands

| Command | Purpose | |---|---| | ags-mcp init | Interactive setup wizard (auto-discover graphmarts) | | ags-mcp doctor | Diagnose environment, config, and connectivity | | ags-mcp connect | Save AGS server credentials to central config (non-interactive) | | ags-mcp client setup --all | Configure OpenCode, Claude Code, and VS Code | | ags-mcp config list | Show configured servers | | ags-mcp config switch <name> | Switch default server | | ags-mcp config show | Show active configuration | | ags-mcp serve | Start MCP server (used by AI clients) | | ags-mcp self init | Initialize tarball-based version management | | ags-mcp self upgrade | Upgrade to latest version | | ags-mcp self rollback <tag> | Rollback to specific version | | ags-mcp self list | List local and available versions | | ags-mcp self check | Check GitHub for updates |

---

Quick Start

1. Create a config file

Save this as ags-config.json (e.g., in your home directory or project):

{
  "servers": {
    "my-server": {
      "host": "your-ags-server.example.com",
      "port": 443,
      "username": "your-username",
      "password": "${AGS_PASSWORD}",
      "graphmart_uri": "http://cambridgesemantics.com/Graphmart/your-graphmart-id",
      "default": true
    }
  }
}

Security: Use ${ENV_VAR} references for passwords — they are resolved from environment variables at startup. Never commit real passwords to config files.

2. Connect your MCP client

Choose your client below.

---

VS Code — GitHub Copilot (Agent Mode)

Setup

1. Create .vscode/mcp.json in your workspace:

{
  "servers": {
    "ags-sparql-agent": {
      "type": "stdio",
      "command": "siemens-graph-studio-mcp-server",
      "args": ["--config", "/absolute/path/to/ags-config.json"],
      "env": {
        "AGS_PASSWORD": "your-password-here"
      }
    }
  }
}

1. Reload VS Code (Cmd+Shift+P → "Developer: Reload Window").
2. Open Copilot Chat and switch to Agent mode (click the mode selector at the top of the chat panel).
3. The AGS tools will appear in the tool list (click the 🔧 icon to verify).

Usage

Type natural language prompts in Copilot Chat (Agent mode):

What ontologies are available in this graphmart?
Show me all classes in the equipment ontology
Run a SPARQL query to count all products
Create a new transformation layer for data linking

Copilot will automatically select and call the appropriate MCP tools.

Running from source (without pip install)

If you prefer to run directly from the cloned repo:

{
  "servers": {
    "ags-sparql-agent": {
      "type": "stdio",
      "command": "python",
      "args": [
        "/absolute/path/to/rmgs_mcp_server/ags_sparql_agent.py",
        "--config", "/absolute/path/to/ags-config.json"
      ],
      "env": {
        "AGS_PASSWORD": "your-password-here"
      }
    }
  }
}

---

Claude Code

Setup

Add to your project's .mcp.json (or ~/.claude.json for global config):

{
  "mcpServers": {
    "ags-sparql-agent": {
      "command": "siemens-graph-studio-mcp-server",
      "args": ["--config", "/absolute/path/to/ags-config.json"],
      "env": {
        "AGS_PASSWORD": "your-password-here"
      }
    }
  }
}

Usage

In Claude Code, the MCP tools are automatically available. Use natural language:

What data is in this knowledge graph?
Show me all properties of the Customer class
Create a linking ontology between orders and products

Claude Code will call the appropriate MCP tools to interact with your AGS graphmart.

---

Advanced Configuration

Multiple servers

{
  "servers": {
    "production": {
      "host": "prod-ags.example.com",
      "port": 443,
      "username": "your-username",
      "password": "${PROD_PASSWORD}",
      "graphmart_uri": "http://cambridgesemantics.com/Graphmart/prod-id",
      "default": true
    },
    "staging": {
      "host": "staging-ags.example.com",
      "port": 8443,
      "username": "your-username",
      "password": "${STAGING_PASSWORD}"
    }
  }
}

The server marked "default": true is automatically selected at startup. Switch at runtime using select_server and select_graphmart tools.

Agent configuration

{
  "servers": { "...": "..." },
  "agent_config": {
    "max_iterations": 3,
    "query_timeout": 30,
    "cache_ontologies": true,
    "ontology_cache_ttl": 86400
  }
}

Transport options

# SSE (default)
siemens-graph-studio-mcp-server --config ags-config.json --transport sse --port 8000

# stdio (used by VS Code and Claude Code)
siemens-graph-studio-mcp-server --config ags-config.json

# Streamable HTTP
siemens-graph-studio-mcp-server --config ags-config.json --transport streamable-http --port 8000

Modes

# Explore mode — read-only tools only (safe for browsing)
siemens-graph-studio-mcp-server --config ags-config.json --mode explore

# Create mode — all tools including write operations (default)
siemens-graph-studio-mcp-server --config ags-config.json --mode create

Explore mode tools (13): list_servers, select_server, list_graphmarts, select_graphmart, execute_sparql_query, discover_knowledge_overview, discover_available_ontologies, discover_ontology_classes, discover_class_data_properties, discover_class_object_properties, list_ontology_imports, initialize_agent_memory, read_agent_memory

Create mode includes all 51 tools (explore + write operations).

Legacy: Direct ANZO_* environment variables (without a config file) are still supported but deprecated.

---

Tool Categories

System & Monitoring

| Tool | Description | |---|---| | test_system_connection | Test MCP server and AGS agent status | | get_session_logs | Get session logs and interaction history | | list_servers | List all configured AGS servers | | select_server | Switch to a different AGS server at runtime | | list_graphmarts | List all graphmarts on the active server | | select_graphmart | Switch to a different graphmart at runtime |

SPARQL Query Execution

| Tool | Description | |---|---| | execute_sparql_query | Execute SPARQL directly against graphmart | | query_ags_configuration | Query graphmart metadata (local volume) | | update_ags_configuration | Update graphmart metadata with SPARQL |

Knowledge Discovery

| Tool | Description | |---|---| | discover_knowledge_overview | Get overview of available knowledge | | discover_available_ontologies | List all available ontologies | | discover_ontology_classes | List classes in a specific ontology | | discover_class_data_properties | List data properties for a class | | discover_class_object_properties | List object properties for a class |

Ontology Management

| Tool | Description | |---|---| | create_ontology | Create a new ontology | | delete_ontology | Delete an ontology | | register_ontology | Register ontology with graphmart | | load_ontology_from_file | Load TTL files into named graphs | | add_ontology_class | Add a class to an ontology | | remove_ontology_class | Remove a class from an ontology | | add_ontology_property | Add a property to an ontology | | remove_ontology_property | Remove a property from an ontology | | add_ontology_import | Add an import to an ontology | | remove_ontology_import | Remove an import from an ontology | | list_ontology_imports | List imports of an ontology | | list_ontology_structure_classes | List classes in ontology structure | | list_ontology_structure_properties | List properties in ontology structure | | get_ontology_cache_status | Get ontology cache status | | clear_ontology_cache | Clear ontology caches | | refresh_ontology_cache | Force cache refresh |

Graphmart Construction & Management

| Tool | Description | |---|---| | create_transformation_layer | Create transformation layers | | update_transformation_layer | Update layer properties | | delete_transformation_layer | Delete transformation layers | | list_transformation_layers | List all transformation layers | | add_transformation_step | Add transformation steps to layers | | update_transformation_step | Update transformation step properties | | delete_transformation_step | Delete transformation steps | | list_transformation_steps | List steps within a layer | | add_direct_load_step | Add direct data loading steps | | update_direct_load_step | Update direct load step properties | | add_bookmark_query | Add a SPARQL query bookmark to graphmart | | delete_bookmark_query | Delete a single bookmark from a graphmart | | delete_all_bookmark_queries | Delete all bookmarks from a graphmart | | refresh_graphmart | Lightweight refresh of changed layers | | reload_graphmart | Complete reprocessing of all layers | | get_layer_status | Comprehensive layer and step error info | | get_step_status | Specific step debugging |

Agent Memory

| Tool | Description | |---|---| | initialize_agent_memory | Initialize memory for the agent | | write_permanent_memory | Write to persistent memory | | write_ephemeral_memory | Write to session-scoped memory | | promote_ephemeral_memory | Promote ephemeral to permanent memory | | clear_agent_memory | Clear agent memory | | read_agent_memory | Read from agent memory |

---

Development

# Install in development mode
pip install -e ".[dev]"

# Run tests
pytest

# Build package
python -m build

Bump Version

Update the version in both:

• pyproject.toml → version = "x.y.z"
• rmgs_mcp_server/__init__.py → __version__ = "x.y.z"

Publish to PyPI

pip install build twine
python -m build
twine upload dist/*

Project Structure

rmgs-mcp-server/
├── rmgs_mcp_server/           # Main package
│   ├── __init__.py            # Package init with version
│   ├── ags_sparql_agent.py    # MCP server entry point
│   ├── models.py              # Data models
│   ├── server_registry.py     # Multi-server configuration manager
│   ├── sparql_agent_core.py   # Core SPARQL agent logic
│   ├── sparql_query_engine.py # SPARQL query engine
│   ├── ontology_cache.py      # Ontology caching
│   ├── ontology_discovery.py  # Ontology discovery
│   ├── interaction_logger.py  # Logging utilities
│   ├── tools/                 # MCP tool implementations
│   │   ├── base_tool.py       # Base tool class
│   │   ├── system/            # System, server & graphmart tools
│   │   ├── query/             # SPARQL query tools
│   │   ├── discovery/         # Knowledge discovery tools
│   │   ├── ontology/          # Ontology management tools
│   │   ├── graphmart/         # Graphmart construction tools
│   │   └── memory/            # Agent memory tools
│   └── utils/                 # Shared utilities
├── prompts/                   # Agent prompt templates
├── skills/                    # Best practices guides
├── pyproject.toml             # Package metadata & build config
├── LICENSE                    # MIT License
└── README.md                  # This file

License

MIT