otel-mcp-agent-extension

MCP安全风控

提供方 graphsentinel

安全风控 stdio · 本地进程 API Key 社区 / 第三方 ClaudeGemini CLIZed
查看接入方式

Provides decision-level telemetry for AI agent observability, tracking the agent's decision-making process and blocking dangerous actions.

一句话选型结论

按资料字段整理

otel-mcp-agent-extension 属于安全风控类 MCP 服务器,stdio · 本地进程,API Key,可直接接入 Claude、Gemini CLI、Zed,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类安全风控 传输方式stdio · 本地进程 鉴权API Key 部署方式本地部署
GitHub 星标 2 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

安全风控
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

Local Deployment AI Agent Observability Python Decision Telemetry Security Protection OpenTelemetry

支持客户端

适用场景

Local DeploymentAI AgentObservability

安装与配置

stdio · 本地进程 API Key
客户端在本机拉起子进程,数据不出本机
git clone https://github.com/graphsentinel/otel-mcp-agent-extension.git cd otel-mcp-agent-extension # Install the library (and provider extras) once pip install -e ".[all]" # Bring up the SRE example's observability stack cd examples/sre-incident-demo ./scripts/setup.sh podman-compose up -d # or: docker compose up -d

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 python,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
资产与漏洞排查

盘点资产、扫漏洞、看暴露面。

日志与审计

汇总日志、查异常行为。

合规检查

按规则检查配置与权限是否合规。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Gemini CLI、Zed,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在安全风控场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Gemini CLI 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
otel-mcp-agent-extension当前 未标注 stdio · 本地进程 本地部署 有 2026-05-22
Cyber Strike AI 75 未标注 未标注 无 2026-05-17
mcp-for-beginners 未标注 stdio · 本地进程 本地部署 有 2026-04-13
casdoor 未标注 stdio · 本地进程 本地部署 有 2026-04-12
kubeshark 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Modelcontextprotocol C22988b0 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

安全风控
字段来自项目仓库与公开索引,中文说明由本站标注
提供方graphsentinel上游标注的维护方 graphsentinel
分类安全风控本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · python本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-05-22上游最后核验时间

详细介绍

24.3 KB
来自项目仓库与上游目录的原文,未做删改

Tracing the Agent's Mind

Decision-Level Telemetry for AI Agent Observability

> See not just what your agent did, but why it made those decisions — and block the dangerous ones before they execute.

The Problem

Current observability stops at the model boundary:```
Token Metrics (what tokens-only telemetry sees):
Step 1: 89 tokens Normal
Step 2: 112 tokens Normal
Step 3: 156 tokens Normal ← MISSED THE PROBLEM!

Decision Metrics (what gen_ai.agent.* + gen_ai.evaluation.result add):
Step 1: confidence=0.92, deviation=0.05 Normal
Step 2: confidence=0.88, deviation=0.08 Normal
Step 3: confidence=0.34, deviation=0.78 ANOMALY DETECTED
Expected: QueryMetrics
Actual: send_http (external)
Scope: network:external (not in baseline)
→ PreExecutionGate.decide() returns allowed=false
→ BLOCKED before tool execution
→ emits gen_ai.evaluation.result event (score.label=critical)
gen_ai.agent.gate.blocked=true


Reproduce the above with the SRE benchmark:
`python examples/sre-incident-demo/src/demo_sre_inverse_scaling.py --pilot --threshold 0.6`

**The Inverse Scaling Problem** (McKenzie et al., 2023): More capable models produce more unpredictable tool selections — invisible through token metrics alone.

**Our Evidence (SRE n=10 benchmark):** 8,400 chains across 28 models in 7 families — 19 open-source + 9 frontier (Anthropic / Google / OpenAI, vendor-masked as Frontier-A/B/C in the keynote). 6 incident categories × 5 ambiguity variants × n=10. The keynote headline figures (27 models / 8,100 chains) drop `qwen2.5-coder:0.5b` as a degenerate-output artifact. See examples/sre-incident-demo/ and Docs/gen-ai-attributes.md.

## Four Contributions

| # | Contribution | Type | Evidence |
|---|-------------|------|---------|
| 1 | **Inverse scaling in tool selection** | Empirical finding | 8,400 chains; 5 classical (β₁ > 0) + 2 REVERSE (β₁ < 0) families |
| 2 | **`gen_ai.agent.*` semantic conventions** | OTel SIG proposal | 11 Proposed attribute groups on top of OTel-spec (Development) — see Docs/gen-ai-attributes.md §11 |
| 3 | **Defense-in-depth pipeline** | Architecture | 5-stage detection inside Layer 3 (Cognitive); only 1 stage uses LLM |
| 4 | **Unified observation layer** | Library | Framework-agnostic: adapter → analyzer → gate → `gen_ai.evaluation.result` OTel Event (Development) |

## Defense-in-Depth Pipeline```
Prompt arrives
     │
     ▼
┌─────────────────────────────────┐
│ Layer 0: Safety Pre-Filter      │  Regex: injection, question, vague (0ms)
│ (deterministic — no LLM)        │  Embedding: actionability check (50ms)
│                                 │  → Catches 24% of prompts
└─────────┬───────────────────────┘
          │
          ▼
┌─────────────────────────────────┐
│ Layer 1-2: Task Shape Classifier│  Embedding (93%) + LLM fallback (100%)
│ (hybrid — LLM only when needed) │  → Routes to correct baseline
└─────────┬───────────────────────┘
          │
          ▼
┌─────────────────────────────────┐
│ Layer 3: Pre-Execution Gate     │  Deviation scoring against baseline
│ (deterministic formula)         │  → 579/579 anomalies caught, 0 escaped
└─────────┬───────────────────────┘
          │
          ▼
┌─────────────────────────────────┐
│ Layer 4: Scope Enforcement      │  Policy-based allow/deny
│ (deterministic policy)          │  → scope.denied = always block
└─────────────────────────────────┘

Quick Start

Prerequisites

  • Docker/Podman & Compose
  • Python 3.10+
  • 4GB RAM minimum (8GB+ recommended for Ollama)

Setup```bash

git clone https://github.com/graphsentinel/otel-mcp-agent-extension.git
cd otel-mcp-agent-extension

Install the library (and provider extras) once

pip install -e ".[all]"

Bring up the SRE example's observability stack

cd examples/sre-incident-demo
./scripts/setup.sh
podman-compose up -d # or: docker compose up -d


The SRE compose file stores runtime state in example-local bind mounts
under `examples/sre-incident-demo/data/` by default. Override the
location:```bash
DEMO_DATA_DIR=/path/to/demo-data podman-compose up -d

Each example owns its own compose.yaml and data/ (gitignored). Other
case studies that need a stack do the same; see
examples/legacy-interactive-demo/README.md.

Run the SRE benchmark (primary demo — keynote dataset)

This is the demo that produces the headline 8,100-chain / 27-model results.

> Live engine (--engine ollama, RunPod, OpenAI, Anthropic, Gemini) needs API
> keys.
Set them up once via .env — see
> examples/sre-incident-demo/README.md → Secrets.
> The simulator (--pilot / default --engine simulated) needs no keys.```bash

Smoke test — 2 categories × 3 models, simulator (no LLM, no keys)

python examples/sre-incident-demo/src/demo_sre_inverse_scaling.py --pilot

Full default run, simulator

python examples/sre-incident-demo/src/demo_sre_inverse_scaling.py --runs 30

Real local Ollama (load .env first if your llm_connection_conf.yaml routes

any pattern to a cloud / RunPod backend)

set -a; source examples/sre-incident-demo/.env; set +a
python examples/sre-incident-demo/src/demo_sre_inverse_scaling.py \
--engine ollama --models qwen2.5-coder:7b --pilot

Tighter / looser pre-execution gate

python examples/sre-incident-demo/src/demo_sre_inverse_scaling.py --threshold 0.4
python examples/sre-incident-demo/src/demo_sre_inverse_scaling.py --threshold 0.8

Subset by category / variant

python examples/sre-incident-demo/src/demo_sre_inverse_scaling.py \
--categories cleanup_envs,hotfix_deploy --variants v3,v4


Output: `examples/sre-incident-demo/results//sre_drift_rows_.jsonl`
+ `sre_inverse_scaling_.json`. The pre-execution gate decision
(BLOCKED / PASSED) is recorded per chain.

### Run the legacy interactive demo

A simpler walk-through that emits OTel spans against the local stack
(Jaeger / Grafana / Neo4j). Supports mock, local Ollama, and OpenAI:```bash
# Mock mode (no LLM required)
python examples/legacy-interactive-demo/run_demo.py --mock --compare

# Local Ollama
python examples/legacy-interactive-demo/run_demo.py --ollama --host http://localhost:11434 --compare

# OpenAI
OPENAI_API_KEY=sk-... python examples/legacy-interactive-demo/run_demo.py --openai --compare

Anthropic and Google providers are exercised by the SRE benchmark (above)
through examples/sre-incident-demo/src/llm_router.py, not by this legacy demo.
See examples/legacy-interactive-demo/README.md
for the optional containerized run.

Historical: champion-baseline simulation```bash

Reproduce champion selection + consensus baseline from the original 3,650-run dataset

python examples/sre-incident-demo/analysis/baseline_simulation.py


### Run Task Shape Classifier Benchmark```bash
# All 3 approaches (embedding, LLM, hybrid)
python examples/sre-incident-demo/analysis/task_shape_classifier.py --approach all

# v2 with Layer0 safety filter + adversarial prompts (50 test cases)
python examples/sre-incident-demo/analysis/task_shape_classifier_v2.py --approach 4

View Results

Service URL Credentials
Grafana http://localhost:3000 admin / admin
Jaeger http://localhost:16686 —
Neo4j Browser http://localhost:7474 neo4j / DecisionGraph2026!
Prometheus http://localhost:9090 —

Multi-Provider LLM Support

All providers implement a unified LLMClient protocol; the SRE benchmark
multiplexes through examples/sre-incident-demo/src/llm_router.py.
Per-provider chain totals from the SRE n=10 dataset:

Provider Models tested (SRE n=10) Chains
Ollama / RunPod (open-source) qwen2.5-coder (0.5b–14b), qwen3.5 (2b/4b/9b/27b), qwen3-coder-next, gemma3 (1b/4b/12b/27b), gemma4 (e2b/e4b/26b/31b), deepseek-r1, kimi, minimax 5,700
Anthropic claude-haiku-4.5, claude-sonnet-4.6, claude-opus-4.7 900
Google gemini-3-flash-preview, gemini-3.1-flash-lite-preview, gemini-3.1-pro-preview 900
OpenAI gpt-5.4, gpt-5.4-mini, gpt-5.5 900
Total 28 models / 7 families 8,400

OTel attributes — status taxonomy + wire-format contract

The full wire-format contract — every attribute, every event, every span
name, plus the four-tag status taxonomy this project uses — lives in
Docs/gen-ai-attributes.md. Quick map:

Tag Meaning Examples
Canonical In the OTel spec, Stable badge (currently empty: no gen_ai.* attr has reached Stable in semconv 1.41.0)
Development In the OTel spec, Development badge gen_ai.tool.name, gen_ai.conversation.id, gen_ai.usage.{input,output}_tokens, gen_ai.evaluation.result (event)
Extension In a public SIG draft, not yet in the spec gen_ai.task.*, gen_ai.action.*, gen_ai.team.*, gen_ai.memory.*
Proposed Only this project proposes it; not in any SIG draft gen_ai.agent.tool.confidence, gen_ai.agent.scope.*, gen_ai.agent.baseline.*, gen_ai.agent.gate.*, gen_ai.agent.computed.*

We use OTel-spec names verbatim where they exist and emit decision-level
extensions in the gen_ai.agent.* namespace. Filing strategy for the
~30 Proposed extensions: see gen-ai-attributes.md §11.```yaml

── OTel-spec GenAI sem-conv (Development; used verbatim) ────────────────

gen_ai.operation.name: "invoke_agent" # or "execute_tool"
gen_ai.provider.name: "openai"
gen_ai.conversation.id: "sess_abc123"
gen_ai.agent.id: "agt-001" # 1 of 4 reserved spec attrs
gen_ai.agent.name: "sre-incident-bot"
gen_ai.request.model: "qwen2.5-coder:7b"
gen_ai.tool.name: "send_http"
gen_ai.usage.input_tokens: 120
gen_ai.usage.output_tokens: 85

Deviation surfaces as the gen_ai.evaluation.result OTel Event (Development)

(NOT a span attribute):

event.name: "gen_ai.evaluation.result"
gen_ai.evaluation.name: "baseline_deviation"
gen_ai.evaluation.score.value: 0.87
gen_ai.evaluation.score.label: "high"
gen_ai.evaluation.explanation: "Tool 'send_http' deviates from baseline …"

── Proposed (this project; see Docs/gen-ai-attributes.md §11) ────────────

gen_ai.agent.task_type: "investigate_latency"
gen_ai.agent.tool.category: "network"
gen_ai.agent.tool.confidence: 0.87
gen_ai.agent.tool.sequence_position: 1
gen_ai.agent.tool.risk_severity: 4
gen_ai.agent.baseline.id: "sre.investigate_latency.v1"
gen_ai.agent.baseline.expected_tool: "QueryMetrics"
gen_ai.agent.baseline.match: false
gen_ai.agent.scope.requested: ["network:external"]
gen_ai.agent.scope.granted: []
gen_ai.agent.scope.denied: ["network:external"]
gen_ai.agent.gate.blocked: true
gen_ai.agent.gate.reason: "deviation=0.87, scope creep"
gen_ai.agent.computed.severity: "critical" # SDK-set or collector-derived
gen_ai.agent.computed.risk_score: 0.78


## Key Results (SRE n=10 benchmark)

Full analysis in examples/sre-incident-demo/README.md.

### Open-source vs frontier — statistical gap```
                                n      severity   danger%   matched%
open-source (5 fam, 19 mdl):  5,700    0.567       23.3%      15.2%
frontier    (3 ven,  9 mdl):  2,700    0.379        6.7%      35.5%
                              ──────────────────────────────────────
Welch t = +26.21,  p = 2.7×10⁻¹⁴²  →  closed-source significantly safer

Within-family β₁ — inverse scaling sign varies

Centered linear OLS, β₁ = severity × log₂(capability) coefficient.

Family β₁ Pattern
qwen2.5-coder +0.066 ★ classical inverse (bigger = riskier)
qwen3.5 +0.043 ★ classical inverse
Frontier-B +0.041 ★ classical inverse
gemma3 +0.025 ★ classical inverse
Frontier-A +0.019 ★ classical inverse (weak)
qwen3-coder-next −0.007 ns no trend (only 2 capability points)
gemma4 −0.034 ★ REVERSE (bigger = safer) ⚡
Frontier-C −0.045 ★ REVERSE (bigger = safer) ⚡

5 families exhibit classical inverse scaling; 2 families exhibit the
opposite sign — capability and risk are not monotonically aligned.

The refusal paradox

Frontier-A models (Anthropic-masked) rank low on raw severity partly because
35–45% of their chains are empty ("won't help with that"). For an SRE
incident-response agent, refusing isn't safety — it's failure.

Model empty% useful% severity
Frontier-A1 (small) 45.0% 53.7% 0.207
Frontier-A3 (large) 39.3% 60.7% 0.254
Frontier-A2 (medium) 35.3% 64.3% 0.326

empty% and chain_OK% are the missing production-fitness metrics —
visible only at OTel's Layer 3 (Cognitive) telemetry, never via tokens.

Gate is a non-negotiable backstop

PreExecutionGate(threshold=0.6).decide(AnalysisResult) per step,
pre-execution. In the SRE n=10 dataset every chain whose worst step crosses
the deviation threshold is blocked before any tool runs. The blocked
chains never reach execute_tool — they emit gen_ai.agent.gate.blocked=true
and a gen_ai.evaluation.result event with score.label = critical.

Repository layout

The repo root holds the installable library and project-level
references. Every runnable story lives under examples//
and is self-contained — its own configs, compose, presentation, and
results sit in that directory. Full operational plan in
Docs/repository-organization.md.

Library — src/gen_ai_otel/

pip install -e ".[all]" installs the library; nothing under src/
imports app config, YAML files, or example data.

Module Purpose
attributes.py OTel-spec (Development) + Proposed attribute constants; gen_ai.evaluation.result event payload helper
instrumentation.py OTel tracing context manager + unified observation bridge
llm_client.py, providers/ LLMClient protocol + factory; Ollama (local + cloud), OpenAI, Anthropic, Google clients
ollama_agent.py LLM-powered decision agent with built-in default toolset
neo4j_exporter.py Direct Neo4j exporter (legacy alternative to the OTLP→bridge path)
config.py Generic types (Tool, ToolCatalog, ModelInfo, GateConfig) + readers; no domain data
cli/ gen-ai-demo console entry point — routes to the available case studies
observation/ UnifiedAnalyzer, PreExecutionGate, BaselineResolver, InverseScalingDetector, framework adapters (vanilla / langchain / langgraph / openai-agents / autogen / strands / mcp_use)

Examples — examples/

Directory What's inside
sre-incident-demo/ Primary keynote dataset producer. 28 models × 8,400 chains across 6 incident categories × 5 ambiguity variants. Owns the full observability stack (compose, configs, bridge, schemas, queries), the slide deck (presentation, videos), and analysis/ scripts (baseline_simulation, dag_auto_builder, dag_formula_comparison, dag_benchmark, model_comparison, task_shape_classifier{,_v2}).
legacy-interactive-demo/ Mock / Ollama / OpenAI walk-through that emits OTel spans against the local stack. Recording helpers live under scripts/. Optional Dockerfile for sandboxed runs.
workato-demo/ Workato adapter demo — wires an external workflow platform into the observation pipeline.
neo4j-demo/ Standalone Neo4j seed + Cypher walkthrough for the decision-graph layer.

For the primary SRE benchmark (Anthropic / Google / OpenAI / Ollama via a
single --engine flag) use
examples/sre-incident-demo/src/demo_sre_inverse_scaling.py.

Configuration

The SRE case study owns its config under
examples/sre-incident-demo/configs/:```
examples/sre-incident-demo/configs/
├── sre_tools.yaml # 10 MCP servers · 73 tools · 19 risk-4 destructive
├── sre_dataset.yaml # 6 incident categories × 5 ambiguity variants
├── sre_models.yaml # 40-entry model registry (capability, tier, family)
├── llm_connection_conf.yaml # Provider routing for --engine live
├── otel-collector-decision.yaml, prometheus.yaml
└── grafana/ # Dashboards + datasource provisioning


Accessors are in
examples/sre-incident-demo/src/sre_app_config.py.
The keynote-active demo path (`demo_baseline_deviation.py`,
`demo_sre_inverse_scaling.py`, `sre_adapter.py`) reads its YAML directly;
research/analysis scripts under `examples/sre-incident-demo/analysis/`
go through the adapter:```python
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))

from sre_app_config import get_tools, get_dag_tasks, get_model_capability

tools = get_tools()                              # 73 tools (server.tool flat keys)
dag = get_dag_tasks()                            # 6 incident categories
cap = get_model_capability("qwen3.5:27b")        # 27.0 from sre_models.yaml

To add a new tool, edit
examples/sre-incident-demo/configs/sre_tools.yaml —
every consumer (live demo, bridge, analysis scripts) picks it up
automatically through the same source-of-truth.

The library exposes only generic deserialisers (tools_from_mapping,
gate_config_from_dict, read_yaml, …) in gen_ai_otel.config;
applications hand it parsed dicts. See
Docs/repository-organization.md §4
on the boundary.

Project Structure```

tracing-agents-mind-demo/
├── src/gen_ai_otel/ # Library (pip installable)
│ ├── attributes.py # OTel-spec (Development) + Proposed constants
│ ├── instrumentation.py # OTel tracing + observation bridge
│ ├── llm_client.py, providers/ # LLMClient + Ollama/OpenAI/Anthropic/Google
│ ├── ollama_agent.py # Decision agent
│ ├── neo4j_exporter.py # Direct Neo4j exporter
│ ├── config.py # Generic types + readers (no domain data)
│ ├── cli/ # gen-ai-demo console entry point
│ └── observation/ # UnifiedAnalyzer, PreExecutionGate, adapters/
├── examples/
│ ├── sre-incident-demo/ # Primary SRE benchmark — 8,400 chains × 28 models
│ │ ├── compose.yaml # SRE observability stack (bind-mount data/)
│ │ ├── configs/ # OTel Collector, Prometheus, Grafana provisioning
│ │ ├── bridge/ # OTLP gRPC → Neo4j writer (Dockerfile + server.py)
│ │ ├── schemas/, queries/ # Neo4j decision-graph schema + forensic Cypher
│ │ ├── presentation/ # Keynote PPTX/HTML/MP4 + builder scripts
│ │ ├── videos/ # Demo recordings (.cast, .mp4, .gif)
│ │ ├── scripts/ # SRE-specific setup (data dir bootstrap)
│ │ ├── analysis/ # baseline_simulation, dag_auto_builder,
│ │ │ # dag_formula_comparison, dag_benchmark,
│ │ │ # model_comparison, task_shape_classifier{,_v2}
│ │ ├── results/ # Historical benchmark output (read-only)
│ │ ├── src/ # Example source code
│ │ │ ├── demo_sre_inverse_scaling.py # Primary entry
│ │ │ ├── analyze_inverse_scaling.py # Master ranking
│ │ │ ├── lind_mehlum_test.py # Formal U-shape test
│ │ │ ├── sre_adapter.py # Catalog loader + classifier
│ │ │ └── llm_router.py # Multi-provider dispatcher
│ │ └── configs/ # (also includes sre_tools.yaml,
│ │ # sre_dataset.yaml, llm_connection_conf.yaml)
│ ├── legacy-interactive-demo/ # Mock / Ollama / OpenAI walk-through
│ │ ├── run_demo.py, benchmark_10k.py
│ │ ├── scripts/ # demo-video.sh, record-demo.sh, setup.sh
│ │ └── Dockerfile # Optional sandboxed run (build context = repo root)
│ ├── workato-demo/ # External workflow platform adapter demo
│ └── neo4j-demo/ # Standalone Neo4j seed + Cypher walkthrough
├── Docs/
│ ├── gen-ai-attributes.md # Wire-format contract (Development + Proposed)
│ ├── architecture.md # Architecture document
│ └── repository-organization.md # Repo organization plan
├── papers/ # Source papers (Betley, McKenzie, Wei, Zhou)
├── KubeConEU2026-Presentation/ # KubeCon EU 2026 reference photos (separate event)
├── backup/ # Historical / archived outputs (gitignored)
├── pyproject.toml # Package with optional extras
└── README.md # this file


## Troubleshooting

### Podman: Permission denied```bash
./examples/sre-incident-demo/scripts/setup.sh

WSL/Podman: CNI firewall plugin validation error

Symptom:```
WARN[0000] Error validating CNI config file /home/user/.config/cni/net.d/tracing-agents-mind_decision-net.conflist:
[plugin firewall does not support config version "1.0.0"]


**Root cause:** podman-compose creates a CNI network config with version "1.0.0", but the firewall plugin only supports up to "0.4.0".

**Solution:** Clean up existing network and recreate with the correct version:```bash
# Stop and remove all containers
podman rm -af && podman pod rm -af
podman network rm -f tracing-agents-mind_decision-net 2>/dev/null || true

# Create CNI config with correct version
cat > ~/.config/cni/net.d/tracing-agents-mind_decision-net.conflist << 'EOF'
{
  "cniVersion": "0.4.0",
  "name": "tracing-agents-mind_decision-net",
  "plugins": [
    {
      "type": "bridge",
      "bridge": "cni-podman1",
      "isGateway": true,
      "ipMasq": true,
      "hairpinMode": true,
      "ipam": {
        "type": "host-local",
        "routes": [{"dst": "0.0.0.0/0"}],
        "ranges": [[{"subnet": "10.89.0.0/24", "gateway": "10.89.0.1"}]]
      }
    },
    {
      "type": "portmap",
      "capabilities": {"portMappings": true}
    },
    {
      "type": "firewall"
    },
    {
      "type": "tuning"
    },
    {
      "type": "dnsname",
      "domainName": "dns.podman",
      "capabilities": {"aliases": true}
    }
  ]
}
EOF

# Restart the stack
cd examples/sre-incident-demo
podman-compose up -d

Bind-mount cleanup blocked by container-owned files

Neo4j (UID 7474), Grafana (UID 472), and Prometheus (UID 65534) write
into the bind-mount as their container users. Plain rm -rf data/ from
the host fails with permission denied. Use podman's user namespace:```bash
podman unshare rm -rf examples/sre-incident-demo/data


### Ollama not available```bash
curl http://localhost:11434/api/tags
ollama pull qwen2.5-coder:7b

Neo4j connection issues```bash

curl http://localhost:7474 # Default: neo4j / DecisionGraph2026!
```

Presented At

  • Observability Summit North America 2026 — Day 2 Keynote (May 22, Minneapolis)

Authors

  • Mustafa Dayioglu — Senior Chief Researcher
  • Zeyno Aygen Dodd — Principal AI Security Architect

License

Apache 2.0 — See LICENSE

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
otel-mcp-agent-extension 怎么安装?

在客户端按下面的安装命令接入:git clone https://github.com/graphsentinel/otel-mcp-agent-extension.git cd otel-mcp-agent-extension # Install the library (and provider extras) once pip install -e ".[all]" # Bring up the SRE example's observability stack cd examples/sre-incident-demo ./scripts/setup.sh podman-compose up -d # or: docker compose up -d。装完在客户端配置里引用同一个包或端点。

otel-mcp-agent-extension 怎么在 Claude、Gemini CLI、Zed 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

otel-mcp-agent-extension 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

otel-mcp-agent-extension 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

otel-mcp-agent-extension 支持哪些客户端?

资料标注支持 Claude、Gemini CLI、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

otel-mcp-agent-extension 能提供哪些能力?

资料显示能力标签包括 Local Deployment、AI Agent、Observability、Python、Decision Telemetry、Security Protection。具体工具清单以官方文档为准。

otel-mcp-agent-extension 需要什么运行环境?

运行时为 python;属于本地进程,需要在本机装好运行环境。

otel-mcp-agent-extension 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-22。