aris-mcp 0.1.0__tar.gz

aris_mcp-0.1.0/LICENSE

@@ -0,0 +1 @@
+MIT License

aris_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: aris-mcp
+Version: 0.1.0
+Summary: Software AG ARIS REST API + MCP Server + A2A Server for Agentic AI!
+Author-email: Audel Rouhi <knucklessg1@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: <3.15,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agent-utilities>=0.50.0
+Requires-Dist: requests>=2.31.0
+Provides-Extra: mcp
+Requires-Dist: agent-utilities[mcp]>=0.50.0; extra == "mcp"
+Provides-Extra: agent
+Requires-Dist: agent-utilities[agent,logfire]>=0.50.0; extra == "agent"
+Provides-Extra: all
+Requires-Dist: agent-utilities[agent,logfire,mcp]>=0.50.0; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest-xdist>=3.6.0; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# aris-mcp
+
+Software AG **ARIS** REST API + MCP Server + A2A Server for Agentic AI.
+
+`aris-mcp` connects the agent ecosystem to an ARIS tenant (ARIS Connect / ARIS
+Enterprise / ARIS Cloud). It is the inbound *and* outbound bridge for the
+agent-utilities Knowledge Graph's Camunda + ARIS ↔ KG integration:
+
+- **Inbound** — the KG ARIS extractor (`enrichment/extractors/aris.py`) consumes
+  this client to lift ARIS models + their EPC structure (functions → BusinessTask,
+  rule operators → gateways, events collapsed, connections → FLOWS_TO) into the
+  canonical ArchiMate ontology, where they reconcile with Camunda/Egeria via
+  `ALIGNED_WITH` and are reasoned over in OWL/RDF.
+- **Outbound** — the KG process-intelligence writeback (`enrichment/process_writeback.py`)
+  uses `set_model_attributes` to write a `kg_intelligence` attribute back onto
+  ARIS models (gated by `ARIS_ENABLE_WRITE`).
+
+## Available MCP Tools
+
+The table below is auto-generated from the live server — do not edit by hand.
+
+<!-- MCP-TOOLS-TABLE:START -->
+
+| MCP Tool | Toggle Env Var | Description |
+|----------|----------------|-------------|
+| `aris_model` | `ARISTOOL` | Work with ARIS models and their EPC structure. |
+| `aris_object` | `ARISTOOL` | Write attributes on a single ARIS object. |
+
+_2 action-routed tools (default `MCP_TOOL_MODE=condensed`). Each is enabled unless its toggle is set false; set `MCP_TOOL_MODE=verbose` (or `both`) for the 1:1 per-operation surface. Auto-generated — do not edit._
+<!-- MCP-TOOLS-TABLE:END -->
+
+> Writes require `ARIS_ENABLE_WRITE=True`.
+
+## Environment Variables
+
+Every variable the server reads, grouped by concern.
+
+### Connection & Credentials
+| Variable | Purpose | Default |
+|----------|---------|---------|
+| `ARIS_API_BASE` | ARIS REST base URL (tenant API root) | `http://localhost/abs/api` |
+| `ARIS_SSL_VERIFY` | verify TLS | `True` |
+| `ARIS_OAUTH_URL` / `ARIS_CLIENT_ID` / `ARIS_CLIENT_SECRET` / `ARIS_TENANT` | OAuth2 client-credentials (preferred) | — |
+| `ARIS_TOKEN` | static bearer token (alt to OAuth) | — |
+| `ARIS_USERNAME` / `ARIS_PASSWORD` | HTTP basic (alt) | — |
+| `ARIS_PATHS_JSON` | JSON overriding REST path templates per tenant | — |
+| `ARIS_ENABLE_WRITE` | allow attribute writes | `False` |
+
+> **Tenant differences.** ARIS deployments vary (Connect ABS portal vs the public
+> ARIS API; on-prem vs Cloud). The defaults follow the common ARIS Connect ABS
+> REST layout. If your tenant's paths differ, set `ARIS_PATHS_JSON`, e.g.
+> `{"models":"v2/repository/models","model_objects":"v2/models/{model_id}/objects"}`.
+
+### MCP server / transport
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `TRANSPORT` | `stdio`, `streamable-http`, or `sse` | `stdio` |
+| `HOST` | Bind host (HTTP transports) | `0.0.0.0` |
+| `PORT` | Bind port (HTTP transports) | `8000` |
+| `MCP_TOOL_MODE` | Tool surface: `condensed`, `verbose`, or `both` | `condensed` |
+| `MCP_ENABLED_TOOLS` / `MCP_DISABLED_TOOLS` | Comma-separated tool allow/deny list | — |
+| `MCP_ENABLED_TAGS` / `MCP_DISABLED_TAGS` | Comma-separated tag allow/deny list | — |
+| `DEBUG` | Verbose logging | `False` |
+| `PYTHONUNBUFFERED` | Unbuffered stdout (recommended in containers) | `1` |
+
+### Tool toggles
+The action-routed tools can be disabled via their toggle env var (set to `false`):
+`ARISTOOL` (see the [Available MCP Tools](#available-mcp-tools) table above).
+
+### Telemetry & governance
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ENABLE_OTEL` | Enable OpenTelemetry export | `True` |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP collector endpoint | — |
+| `OTEL_EXPORTER_OTLP_PUBLIC_KEY` / `OTEL_EXPORTER_OTLP_SECRET_KEY` | OTLP auth keys | — |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | OTLP protocol (e.g. `http/protobuf`) | — |
+| `EUNOMIA_TYPE` | Authorization mode: `none`, `embedded`, `remote` | `none` |
+| `EUNOMIA_POLICY_FILE` | Embedded policy file | `mcp_policies.json` |
+| `EUNOMIA_REMOTE_URL` | Remote Eunomia server URL | — |
+
+### Agent CLI (full `[agent]` runtime only)
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `MCP_URL` | URL of the MCP server the agent connects to | `http://localhost:8000/mcp` |
+| `PROVIDER` | LLM provider (e.g. `openai`) | `openai` |
+| `MODEL_ID` | Model id (e.g. `gpt-4o`) | `gpt-4o` |
+| `ENABLE_WEB_UI` | Serve the AG-UI web interface | `True` |
+
+## Installation
+
+> **Install the slim `[mcp]` extra.** Install `aris-mcp[mcp]` — the MCP-server extra
+> that pulls only the FastMCP / FastAPI tooling (`agent-utilities[mcp]`). It deliberately
+> **excludes** the heavy agent runtime (the epistemic-graph engine, `pydantic-ai`,
+> `dspy`, `llama-index`, `tree-sitter`), so `uvx`/container installs are dramatically
+> smaller and faster. Use the full `[agent]` extra only when you need the integrated
+> Pydantic AI agent.
+
+Pick the extra that matches what you want to run:
+
+| Extra | Installs | Use when |
+|-------|----------|----------|
+| `aris-mcp[mcp]` | Slim MCP server only (`agent-utilities[mcp]` — FastMCP/FastAPI) | You only run the **MCP server** (smallest install / image) |
+| `aris-mcp[agent]` | Full agent runtime (`agent-utilities[agent,logfire]` — Pydantic AI + the epistemic-graph engine) | You run the **integrated agent** |
+| `aris-mcp[all]` | Everything (`mcp` + `agent` + `logfire`) | Development / both surfaces |
+
+```bash
+# MCP server only (recommended for tool hosting — slim deps)
+uv pip install "aris-mcp[mcp]"
+
+# Full agent runtime (Pydantic AI + epistemic-graph engine)
+uv pip install "aris-mcp[agent]"
+
+# Everything (development)
+uv pip install "aris-mcp[all]"      # or: python -m pip install "aris-mcp[all]"
+```
+
+### Container images (`:mcp` vs `:agent`)
+
+One multi-stage `docker/Dockerfile` builds two right-sized images, selected by `--target`:
+
+| Image tag | Build target | Contents | Entrypoint |
+|-----------|--------------|----------|------------|
+| `knucklessg1/aris-mcp:mcp` | `--target mcp` | `aris-mcp[mcp]` — **slim**, no engine/`pydantic-ai`/`dspy`/`llama-index`/`tree-sitter` | `aris-mcp` |
+| `knucklessg1/aris-mcp:latest` | `--target agent` (default) | `aris-mcp[agent]` — **full** agent runtime + epistemic-graph engine | `aris-agent` |
+
+```bash
+docker build --target mcp   -t knucklessg1/aris-mcp:mcp    docker/   # slim MCP server
+docker build --target agent -t knucklessg1/aris-mcp:latest docker/   # full agent
+```
+
+`docker/mcp.compose.yml` runs the slim `:mcp` server; `docker/agent.compose.yml` runs the
+agent (`:latest`) with a co-located `:mcp` sidecar.
+
+### Knowledge-graph database (`epistemic-graph`)
+
+The **full agent** (`[agent]` / `:latest`) embeds the **epistemic-graph** engine (pulled in
+transitively via `agent-utilities[agent]`). For production — or to share one knowledge graph
+across multiple agents — run **epistemic-graph as its own database container** and point the
+agent at it instead of embedding it. Deployment recipes (single-node + Raft HA), connection
+config, and the full database architecture (with diagrams) are documented in the
+[epistemic-graph deployment guide](https://knuckles-team.github.io/epistemic-graph/deployment/).
+The slim `[mcp]` server does **not** require the database.
+
+## Run
+
+```bash
+aris-mcp                       # stdio (default)
+aris-mcp --transport streamable-http --host 0.0.0.0 --port 8000
+```
+
+## Deployment
+
+1. **stdio** — `uv run aris-mcp` (see `mcp_config.json`).
+2. **streamable-http** — `aris-mcp --transport streamable-http --port 8000`.
+3. **local container** — build from `docker/` and run with the env above.
+4. **remote** — point your client at `http://aris-mcp.arpa/mcp`.
+
+
+<!-- BEGIN agent-os-genesis-deploy (generated; do not edit between markers) -->
+
+## Deploy with `agent-os-genesis`
+
+This package can be provisioned for you — skill-guided — by the **`agent-os-genesis`**
+universal skill (its *single-package deploy mode*): it picks your install method, seeds
+secrets to OpenBao/Vault (or `.env`), trusts your enterprise CA, registers the MCP
+server, and verifies it — the same machinery that stands up the whole Agent OS, narrowed
+to just this package. Ask your agent to **"deploy `aris-mcp` with agent-os-genesis"**.
+
+| Install mode | Command |
+|------|---------|
+| Bare-metal, prod (PyPI) | `uvx aris-mcp` · or `uv tool install aris-mcp` |
+| Bare-metal, dev (editable) | `uv pip install -e ".[all]"` · or `pip install -e ".[all]"` |
+| Container, prod | deploy `knucklessg1/aris-mcp:latest` via docker-compose / swarm / podman / podman-compose / kubernetes |
+| Container, dev (editable) | deploy `docker/compose.dev.yml` (source-mounted at `/src`; edits live on restart) |
+
+Secrets are read-existing + seeded via `vault_sync` — you are only prompted for what's missing.
+
+<!-- END agent-os-genesis-deploy -->

aris_mcp-0.1.0/README.md

@@ -0,0 +1,178 @@
+# aris-mcp
+
+Software AG **ARIS** REST API + MCP Server + A2A Server for Agentic AI.
+
+`aris-mcp` connects the agent ecosystem to an ARIS tenant (ARIS Connect / ARIS
+Enterprise / ARIS Cloud). It is the inbound *and* outbound bridge for the
+agent-utilities Knowledge Graph's Camunda + ARIS ↔ KG integration:
+
+- **Inbound** — the KG ARIS extractor (`enrichment/extractors/aris.py`) consumes
+  this client to lift ARIS models + their EPC structure (functions → BusinessTask,
+  rule operators → gateways, events collapsed, connections → FLOWS_TO) into the
+  canonical ArchiMate ontology, where they reconcile with Camunda/Egeria via
+  `ALIGNED_WITH` and are reasoned over in OWL/RDF.
+- **Outbound** — the KG process-intelligence writeback (`enrichment/process_writeback.py`)
+  uses `set_model_attributes` to write a `kg_intelligence` attribute back onto
+  ARIS models (gated by `ARIS_ENABLE_WRITE`).
+
+## Available MCP Tools
+
+The table below is auto-generated from the live server — do not edit by hand.
+
+<!-- MCP-TOOLS-TABLE:START -->
+
+| MCP Tool | Toggle Env Var | Description |
+|----------|----------------|-------------|
+| `aris_model` | `ARISTOOL` | Work with ARIS models and their EPC structure. |
+| `aris_object` | `ARISTOOL` | Write attributes on a single ARIS object. |
+
+_2 action-routed tools (default `MCP_TOOL_MODE=condensed`). Each is enabled unless its toggle is set false; set `MCP_TOOL_MODE=verbose` (or `both`) for the 1:1 per-operation surface. Auto-generated — do not edit._
+<!-- MCP-TOOLS-TABLE:END -->
+
+> Writes require `ARIS_ENABLE_WRITE=True`.
+
+## Environment Variables
+
+Every variable the server reads, grouped by concern.
+
+### Connection & Credentials
+| Variable | Purpose | Default |
+|----------|---------|---------|
+| `ARIS_API_BASE` | ARIS REST base URL (tenant API root) | `http://localhost/abs/api` |
+| `ARIS_SSL_VERIFY` | verify TLS | `True` |
+| `ARIS_OAUTH_URL` / `ARIS_CLIENT_ID` / `ARIS_CLIENT_SECRET` / `ARIS_TENANT` | OAuth2 client-credentials (preferred) | — |
+| `ARIS_TOKEN` | static bearer token (alt to OAuth) | — |
+| `ARIS_USERNAME` / `ARIS_PASSWORD` | HTTP basic (alt) | — |
+| `ARIS_PATHS_JSON` | JSON overriding REST path templates per tenant | — |
+| `ARIS_ENABLE_WRITE` | allow attribute writes | `False` |
+
+> **Tenant differences.** ARIS deployments vary (Connect ABS portal vs the public
+> ARIS API; on-prem vs Cloud). The defaults follow the common ARIS Connect ABS
+> REST layout. If your tenant's paths differ, set `ARIS_PATHS_JSON`, e.g.
+> `{"models":"v2/repository/models","model_objects":"v2/models/{model_id}/objects"}`.
+
+### MCP server / transport
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `TRANSPORT` | `stdio`, `streamable-http`, or `sse` | `stdio` |
+| `HOST` | Bind host (HTTP transports) | `0.0.0.0` |
+| `PORT` | Bind port (HTTP transports) | `8000` |
+| `MCP_TOOL_MODE` | Tool surface: `condensed`, `verbose`, or `both` | `condensed` |
+| `MCP_ENABLED_TOOLS` / `MCP_DISABLED_TOOLS` | Comma-separated tool allow/deny list | — |
+| `MCP_ENABLED_TAGS` / `MCP_DISABLED_TAGS` | Comma-separated tag allow/deny list | — |
+| `DEBUG` | Verbose logging | `False` |
+| `PYTHONUNBUFFERED` | Unbuffered stdout (recommended in containers) | `1` |
+
+### Tool toggles
+The action-routed tools can be disabled via their toggle env var (set to `false`):
+`ARISTOOL` (see the [Available MCP Tools](#available-mcp-tools) table above).
+
+### Telemetry & governance
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ENABLE_OTEL` | Enable OpenTelemetry export | `True` |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP collector endpoint | — |
+| `OTEL_EXPORTER_OTLP_PUBLIC_KEY` / `OTEL_EXPORTER_OTLP_SECRET_KEY` | OTLP auth keys | — |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | OTLP protocol (e.g. `http/protobuf`) | — |
+| `EUNOMIA_TYPE` | Authorization mode: `none`, `embedded`, `remote` | `none` |
+| `EUNOMIA_POLICY_FILE` | Embedded policy file | `mcp_policies.json` |
+| `EUNOMIA_REMOTE_URL` | Remote Eunomia server URL | — |
+
+### Agent CLI (full `[agent]` runtime only)
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `MCP_URL` | URL of the MCP server the agent connects to | `http://localhost:8000/mcp` |
+| `PROVIDER` | LLM provider (e.g. `openai`) | `openai` |
+| `MODEL_ID` | Model id (e.g. `gpt-4o`) | `gpt-4o` |
+| `ENABLE_WEB_UI` | Serve the AG-UI web interface | `True` |
+
+## Installation
+
+> **Install the slim `[mcp]` extra.** Install `aris-mcp[mcp]` — the MCP-server extra
+> that pulls only the FastMCP / FastAPI tooling (`agent-utilities[mcp]`). It deliberately
+> **excludes** the heavy agent runtime (the epistemic-graph engine, `pydantic-ai`,
+> `dspy`, `llama-index`, `tree-sitter`), so `uvx`/container installs are dramatically
+> smaller and faster. Use the full `[agent]` extra only when you need the integrated
+> Pydantic AI agent.
+
+Pick the extra that matches what you want to run:
+
+| Extra | Installs | Use when |
+|-------|----------|----------|
+| `aris-mcp[mcp]` | Slim MCP server only (`agent-utilities[mcp]` — FastMCP/FastAPI) | You only run the **MCP server** (smallest install / image) |
+| `aris-mcp[agent]` | Full agent runtime (`agent-utilities[agent,logfire]` — Pydantic AI + the epistemic-graph engine) | You run the **integrated agent** |
+| `aris-mcp[all]` | Everything (`mcp` + `agent` + `logfire`) | Development / both surfaces |
+
+```bash
+# MCP server only (recommended for tool hosting — slim deps)
+uv pip install "aris-mcp[mcp]"
+
+# Full agent runtime (Pydantic AI + epistemic-graph engine)
+uv pip install "aris-mcp[agent]"
+
+# Everything (development)
+uv pip install "aris-mcp[all]"      # or: python -m pip install "aris-mcp[all]"
+```
+
+### Container images (`:mcp` vs `:agent`)
+
+One multi-stage `docker/Dockerfile` builds two right-sized images, selected by `--target`:
+
+| Image tag | Build target | Contents | Entrypoint |
+|-----------|--------------|----------|------------|
+| `knucklessg1/aris-mcp:mcp` | `--target mcp` | `aris-mcp[mcp]` — **slim**, no engine/`pydantic-ai`/`dspy`/`llama-index`/`tree-sitter` | `aris-mcp` |
+| `knucklessg1/aris-mcp:latest` | `--target agent` (default) | `aris-mcp[agent]` — **full** agent runtime + epistemic-graph engine | `aris-agent` |
+
+```bash
+docker build --target mcp   -t knucklessg1/aris-mcp:mcp    docker/   # slim MCP server
+docker build --target agent -t knucklessg1/aris-mcp:latest docker/   # full agent
+```
+
+`docker/mcp.compose.yml` runs the slim `:mcp` server; `docker/agent.compose.yml` runs the
+agent (`:latest`) with a co-located `:mcp` sidecar.
+
+### Knowledge-graph database (`epistemic-graph`)
+
+The **full agent** (`[agent]` / `:latest`) embeds the **epistemic-graph** engine (pulled in
+transitively via `agent-utilities[agent]`). For production — or to share one knowledge graph
+across multiple agents — run **epistemic-graph as its own database container** and point the
+agent at it instead of embedding it. Deployment recipes (single-node + Raft HA), connection
+config, and the full database architecture (with diagrams) are documented in the
+[epistemic-graph deployment guide](https://knuckles-team.github.io/epistemic-graph/deployment/).
+The slim `[mcp]` server does **not** require the database.
+
+## Run
+
+```bash
+aris-mcp                       # stdio (default)
+aris-mcp --transport streamable-http --host 0.0.0.0 --port 8000
+```
+
+## Deployment
+
+1. **stdio** — `uv run aris-mcp` (see `mcp_config.json`).
+2. **streamable-http** — `aris-mcp --transport streamable-http --port 8000`.
+3. **local container** — build from `docker/` and run with the env above.
+4. **remote** — point your client at `http://aris-mcp.arpa/mcp`.
+
+
+<!-- BEGIN agent-os-genesis-deploy (generated; do not edit between markers) -->
+
+## Deploy with `agent-os-genesis`
+
+This package can be provisioned for you — skill-guided — by the **`agent-os-genesis`**
+universal skill (its *single-package deploy mode*): it picks your install method, seeds
+secrets to OpenBao/Vault (or `.env`), trusts your enterprise CA, registers the MCP
+server, and verifies it — the same machinery that stands up the whole Agent OS, narrowed
+to just this package. Ask your agent to **"deploy `aris-mcp` with agent-os-genesis"**.
+
+| Install mode | Command |
+|------|---------|
+| Bare-metal, prod (PyPI) | `uvx aris-mcp` · or `uv tool install aris-mcp` |
+| Bare-metal, dev (editable) | `uv pip install -e ".[all]"` · or `pip install -e ".[all]"` |
+| Container, prod | deploy `knucklessg1/aris-mcp:latest` via docker-compose / swarm / podman / podman-compose / kubernetes |
+| Container, dev (editable) | deploy `docker/compose.dev.yml` (source-mounted at `/src`; edits live on restart) |
+
+Secrets are read-existing + seeded via `vault_sync` — you are only prompted for what's missing.
+
+<!-- END agent-os-genesis-deploy -->

aris_mcp-0.1.0/aris_mcp/__init__.py

@@ -0,0 +1,64 @@
+"""aris-mcp: Software AG ARIS REST API + MCP Server + A2A Server."""
+
+import importlib
+import inspect
+from typing import Any
+
+__version__ = "0.1.0"
+__all__: list[str] = []
+
+CORE_MODULES = ["aris_mcp.api_client"]
+OPTIONAL_MODULES = {
+    "aris_mcp.agent_server": "agent",
+    "aris_mcp.mcp_server": "mcp",
+}
+
+
+def _expose_members(module):
+    for name, obj in inspect.getmembers(module):
+        if (inspect.isclass(obj) or inspect.isfunction(obj)) and not name.startswith(
+            "_"
+        ):
+            globals()[name] = obj
+            if name not in __all__:
+                __all__.append(name)
+
+
+for module_name in CORE_MODULES:
+    module = importlib.import_module(module_name)
+    _expose_members(module)
+
+_loaded_optional_modules: dict[str, Any] = {}
+
+
+def _import_module_safely(module_name: str):
+    try:
+        return importlib.import_module(module_name)
+    except ImportError:
+        return None
+
+
+def __getattr__(name: str) -> Any:
+    if name == "_MCP_AVAILABLE":
+        mcp_key = next((k for k in OPTIONAL_MODULES if "mcp_server" in k), None)
+        return _import_module_safely(mcp_key) is not None if mcp_key else False
+    if name == "_AGENT_AVAILABLE":
+        agent_key = next((k for k in OPTIONAL_MODULES if "agent_server" in k), None)
+        return _import_module_safely(agent_key) is not None if agent_key else False
+
+    for module_name in OPTIONAL_MODULES:
+        if module_name not in _loaded_optional_modules:
+            module = _import_module_safely(module_name)
+            if module is not None:
+                _loaded_optional_modules[module_name] = module
+                _expose_members(module)
+
+        module = _loaded_optional_modules.get(module_name)
+        if module is not None and hasattr(module, name):
+            return getattr(module, name)
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals().keys()) + __all__)

aris_mcp-0.1.0/aris_mcp/__main__.py

@@ -0,0 +1,4 @@
+from aris_mcp.agent_server import agent_server
+
+if __name__ == "__main__":
+    agent_server()

aris_mcp-0.1.0/aris_mcp/agent_server.py

@@ -0,0 +1,75 @@
+"""Graph-based Pydantic AI agent server entry point for aris-mcp."""
+
+import logging
+import os
+import sys
+import warnings
+
+__version__ = "0.1.0"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+DEFAULT_AGENT_NAME = None
+DEFAULT_AGENT_DESCRIPTION = None
+DEFAULT_AGENT_SYSTEM_PROMPT = None
+
+
+def agent_server():
+    """Start the graph-based Pydantic AI agent server for ARIS."""
+    from agent_utilities import (
+        build_system_prompt_from_workspace,
+        create_agent_parser,
+        create_agent_server,
+        initialize_workspace,
+        load_identity,
+    )
+
+    global DEFAULT_AGENT_NAME, DEFAULT_AGENT_DESCRIPTION, DEFAULT_AGENT_SYSTEM_PROMPT
+    initialize_workspace()
+    meta = load_identity()
+    DEFAULT_AGENT_NAME = os.getenv("DEFAULT_AGENT_NAME", meta.get("name", "ARIS Agent"))
+    DEFAULT_AGENT_DESCRIPTION = os.getenv(
+        "AGENT_DESCRIPTION",
+        meta.get("description", "AI agent for Software AG ARIS operations."),
+    )
+    DEFAULT_AGENT_SYSTEM_PROMPT = os.getenv(
+        "AGENT_SYSTEM_PROMPT",
+        meta.get("content") or build_system_prompt_from_workspace(),
+    )
+
+    warnings.filterwarnings("ignore", message=".*urllib3.*")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module="fastmcp")
+
+    print(f"{DEFAULT_AGENT_NAME} v{__version__}", file=sys.stderr)
+    parser = create_agent_parser()
+    args = parser.parse_args()
+
+    create_agent_server(
+        mcp_url=args.mcp_url,
+        mcp_config=args.mcp_config or "mcp_config.json",
+        host=args.host,
+        port=args.port,
+        provider=args.provider,
+        model_id=args.model_id,
+        router_model=args.model_id,
+        agent_model=args.model_id,
+        base_url=args.base_url,
+        api_key=args.api_key,
+        custom_skills_directory=args.custom_skills_directory,
+        enable_web_ui=args.web,
+        enable_otel=args.otel,
+        otel_endpoint=args.otel_endpoint,
+        otel_headers=args.otel_headers,
+        otel_public_key=args.otel_public_key,
+        otel_secret_key=args.otel_secret_key,
+        otel_protocol=args.otel_protocol,
+        debug=args.debug,
+    )
+
+
+if __name__ == "__main__":
+    agent_server()

aris_mcp-0.1.0/aris_mcp/api/api_client_aris.py

@@ -0,0 +1,96 @@
+"""Software AG ARIS REST API wrapper.
+
+Client for the ARIS REST API (ARIS Connect / ARIS Enterprise / ARIS Cloud)
+covering the surface the agent-utilities KG ARIS extractor and the outbound
+process-intelligence writeback consume:
+
+* **read** — model inventory, per-model EPC objects (functions/events/rules) and
+  their control-flow connections, and attribute read-back.
+* **write** — model / object attribute writes (the outbound ``kg_intelligence``
+  enrichment); gated at the MCP-tool layer by ``ARIS_ENABLE_WRITE``.
+
+ARIS deployments differ (Connect ABS portal vs the public ARIS API; on-prem vs
+Cloud), so the **endpoint path templates are configurable** — pass overrides
+(or set the matching env vars in :mod:`aris_mcp.auth`) to match your tenant.
+The defaults follow the common ARIS Connect ABS REST layout
+(``{base}/models``, ``{base}/models/{id}/objects`` …). Method names are stable;
+only the paths move.
+"""
+
+from typing import Any
+
+from aris_mcp.api.api_client_base import ApiClientBase
+
+# Default ARIS Connect ABS REST path templates. Override per tenant if needed.
+DEFAULT_PATHS = {
+    "models": "models",
+    "model": "models/{model_id}",
+    "model_objects": "models/{model_id}/objects",
+    "model_connections": "models/{model_id}/connections",
+    "model_attributes": "models/{model_id}/attributes",
+    "object_attributes": "objects/{object_id}/attributes",
+}
+
+
+class ArisApi(ApiClientBase):
+    """Read/write client for an ARIS REST API tenant."""
+
+    def __init__(
+        self,
+        base_url: str,
+        token: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        verify: bool = True,
+        paths: dict[str, str] | None = None,
+    ):
+        super().__init__(
+            base_url, token=token, username=username, password=password, verify=verify
+        )
+        self.paths = {**DEFAULT_PATHS, **(paths or {})}
+
+    # ── reads (consumed by the KG ARIS extractor) ──────────────────────────
+    def list_models(self, params: dict[str, Any] | None = None) -> Any:
+        """List models in the tenant/database (process + architecture)."""
+        return self.request("GET", self.paths["models"], params=params)
+
+    def get_model(self, model_id: str) -> Any:
+        """Get a single model's metadata (including its attributes)."""
+        return self.request("GET", self.paths["model"].format(model_id=model_id))
+
+    def list_model_objects(self, model_id: str) -> Any:
+        """List the EPC objects (functions/events/rule operators) of a model."""
+        return self.request(
+            "GET", self.paths["model_objects"].format(model_id=model_id)
+        )
+
+    def list_model_connections(self, model_id: str) -> Any:
+        """List the directed control-flow connections between a model's objects."""
+        return self.request(
+            "GET", self.paths["model_connections"].format(model_id=model_id)
+        )
+
+    def list_model_attributes(self, model_id: str) -> Any:
+        """Get a model's attributes (used for writeback idempotency read-back)."""
+        return self.request(
+            "GET", self.paths["model_attributes"].format(model_id=model_id)
+        )
+
+    # ── writes (outbound enrichment; gated by ARIS_ENABLE_WRITE at the tool) ─
+    def set_model_attributes(self, model_id: str, attributes: dict[str, Any]) -> Any:
+        """Write/update attributes on a model (e.g. the ``kg_intelligence`` blob)."""
+        return self.request(
+            "PUT",
+            self.paths["model_attributes"].format(model_id=model_id),
+            json={"attributes": attributes},
+            content_type="application/json",
+        )
+
+    def set_object_attributes(self, object_id: str, attributes: dict[str, Any]) -> Any:
+        """Write/update attributes on a single object."""
+        return self.request(
+            "PUT",
+            self.paths["object_attributes"].format(object_id=object_id),
+            json={"attributes": attributes},
+            content_type="application/json",
+        )