Simpletel vs Jaeger MCP — MCP Server Comparison | AllMCPs
Simpletel vs Jaeger MCP
A side-by-side look at the Simpletel and Jaeger MCP MCP servers: transport, auth, tools, quality signals, and the config to install either one in Claude, Cursor, Windsurf or VS Code.
Verdict: choose Simpletel for monitoring work; choose Jaeger MCP for monitoring as a local process. You can also run both side by side in one mcpServers block.
Which MCP server should you choose?
S
Choose Simpletel when
You need dedicated capabilities in the Monitoring domain.
You have the keys it needs: SIMPLETEL_ENDPOINT, SIMPLETEL_TEAM, SIMPLETEL_ADMIN_TOKEN, SIMPLETEL_TOKEN, SIMPLETEL_CONFIG.
You want tools like get_traces, get_trace, verify.
get_tracesLists this team's traces newest-first. The JSON document `simpletel get traces --format json` produces. Use it to find a failing or slow request.
get_traceFetches one trace in full — spans, span events, and correlated log records. The JSON document `simpletel get trace <id> --format json` produces.
verifyRuns the `simpletel verify` onboarding check: polls until `service` has a fresh trace carrying spans from a library instrumentation. Returns the rung report and the exit status (`0` verified, `1` deadline miss). A deadline miss is a completed check, not a tool error.
usageShows the account's plan, month-to-date records, allowance, and spend cap. The JSON document `simpletel usage --format json` produces. Account-scoped (needs a logged-in user token).
Jaeger MCP tools 15
jaeger_list_servicesList all services that Jaeger has observed traces for.
Wraps ``GET /api/services``. Jaeger returns all services at once — no
pagination. Output is capped at 500 services with a truncation hint.
Use this first to discover valid service names before calling
``jaeger_list_operations`` or ``jaeger_search_traces``.
Examples:
- Use when: "What services does Jaeger know about?"
→ call with no parameters; read the ``services`` list.
- Use when: "Is `payment-service` instrumented?"
→ check if `payment-service` appears in the services list.
- Use when: Starting a debugging session — list services first,
then pick one for ``jaeger_list_operations`` or
``jaeger_search_traces``.
- Don't use when: You already know the service name and want to
search its traces (call ``jaeger_search_traces`` directly).
- Don't use when: You want the dependency graph between services
(call ``jaeger_get_dependencies``).
Returns:
dict with keys ``services_count`` / ``truncated`` / ``services``.
jaeger_list_operationsList all operation names Jaeger has seen for a given service.
Wraps ``GET /api/services/{service}/operations``. Useful for discovering
which operation names to pass as filters to ``jaeger_search_traces``.
Output is capped at 500 operations.
Examples:
- Use when: "What HTTP endpoints does `order-service` expose in tracing?"
→ ``service='order-service'``.
- Use when: You want to search for a specific slow operation but need
the exact name — list operations first, then pass it to
``jaeger_search_traces``.
- Use when: Auditing which gRPC methods a service traces.
- Don't use when: You don't have a specific service — start with
``jaeger_list_services`` first.
- Don't use when: You want to search traces immediately (skip this
step if you already know the operation name).
Returns:
dict with ``service`` / ``operations_count`` / ``truncated`` /
``operations`` (sorted alphabetically).
Ready-to-paste client configs
Paste either block (or both) into your client config, e.g. claude_desktop_config.json or ~/.cursor/mcp.json. We only show a config when the install command is confirmed.
Simpletel
No confirmed install command for Simpletel yet — follow the setup steps linked from its listing page rather than a guessed package name.
Simpletel is categorized under Monitoring and uses an install path we have not confirmed yet. Jaeger MCP belongs to Monitoring and uses a local stdio subprocess. Pick Simpletel for monitoring work and Jaeger MCP for monitoring.
Copy the mcpServers block from the config section on this page into your client's config (for example claude_desktop_config.json or ~/.cursor/mcp.json), then fully restart the client. Simpletel has no confirmed install command yet — follow its own setup instructions.
Simpletel has no declared pricing — check the project's own site. Jaeger MCP is listed as free. Auth: other. If a server needs environment variables such as API keys, define them under the env key in your client's MCP config.
Yes. MCP clients support multiple servers: add simpletel and mshegolev-jaeger-mcp as separate keys in the same mcpServers object, and your assistant will call tools from either one.
On AllMCPs, Simpletel has a quality signal of 45/100 (Fair) with 0 views, 0 installs and 0 GitHub stars. Jaeger MCP has 57/100 (Good) with 2 views, 0 installs and 2 GitHub stars.
jaeger_search_tracesSearch Jaeger traces with rich filters.
Wraps ``GET /api/traces``. Returns a list of trace summaries — use
``jaeger_get_trace`` to drill into a specific trace for span details.
The ``tags`` parameter accepts a JSON string so the LLM can construct
arbitrary tag filters. Durations (``min_duration``/``max_duration``) are
forwarded as-is to Jaeger (e.g. ``'100ms'``, ``'1.5s'``).
Examples:
- Use when: "Show me recent 500 errors in `order-service`"
→ ``service='order-service'``, ``tags='{"http.status_code":"500"}'``.
- Use when: "Find slow traces (>1s) for `checkout` endpoint"
→ ``service='checkout'``, ``operation='POST /checkout'``,
``min_duration='1s'``.
- Use when: "Give me the last 5 traces in the last hour"
→ ``limit=5``, set ``start`` to (now - 3600s) in microseconds.
- Don't use when: You already have a traceID and want full details
(call ``jaeger_get_trace`` directly — one fewer round trip).
- Don't use when: You want service dependency topology
(call ``jaeger_get_dependencies``).
Returns:
dict with ``service`` / ``operation`` / ``returned`` / ``truncated`` /
``traces`` (list of :class:`TraceSummary`).
jaeger_get_traceRetrieve full trace detail with all spans, service breakdown, and execution tree.
Wraps ``GET /api/traces/{traceID}``. Returns every span in the trace,
per-service statistics, and a flat execution tree (each node lists its
child span IDs) that summarises the call hierarchy.
Error spans are identified by ``tags["error"] = "true"``.
Examples:
- Use when: "Why is trace `abc123...` slow — show me the span breakdown"
→ ``trace_id='abc123...'``; inspect ``services`` for the heaviest service
and ``execution_tree`` for the call hierarchy.
- Use when: "Which service caused the error in trace `xyz...`?"
→ check ``spans`` where ``is_error=true``.
- Use when: You found a slow/failed trace in ``jaeger_search_traces``
and need full detail.
- Don't use when: You don't have a specific traceID — use
``jaeger_search_traces`` to find one first.
- Don't use when: You only want aggregate data across many traces
(use ``jaeger_search_traces`` with filters instead).
Returns:
dict with ``trace_id`` / ``span_count`` / ``service_count`` /
``root_operation`` / ``root_service`` / ``start_time_us`` /
``total_duration_us`` / ``errors_count`` / ``services`` (per-service stats) /
``spans`` (all spans) / ``execution_tree``.
jaeger_get_dependenciesRetrieve the service-to-service call graph from Jaeger.
Wraps ``GET /api/dependencies``. Returns directed edges (parent → child)
with ``call_count`` — the number of spans where parent called child in
the lookback window.
Use this to understand service topology, find high fan-out services, or
verify that a new service is connected as expected.
Examples:
- Use when: "What services does `order-service` call?"
→ check edges where ``parent='order-service'``.
- Use when: "Map the full service dependency graph for the last 7 days"
→ ``lookback_hours=168``.
- Use when: "Which services are called most frequently?"
→ sort edges by ``call_count`` descending.
- Don't use when: You want detailed span timings (use
``jaeger_search_traces`` + ``jaeger_get_trace`` instead).
- Don't use when: You need real-time data — Jaeger's dependency graph
is aggregated and may lag by minutes.
Returns:
dict with ``end_ts_us`` / ``lookback_hours`` / ``edge_count`` /
``edges`` (list of ``{parent, child, call_count}``).
jaeger_compare_tracesCompare two traces structurally — find added, removed, and changed spans.
Fetches both traces from Jaeger and performs a structural diff by matching
spans on ``(operationName, serviceName, parentOperation)`` — not span IDs,
which differ across traces. Reports duration deltas and tag differences for
changed spans.
Examples:
- Use when: "What changed between a fast and slow request?"
→ pass the trace IDs of both requests; inspect ``changed_spans``
for duration deltas.
- Use when: "Did a deployment add new service calls?"
→ compare a pre-deploy trace with a post-deploy trace; check
``added_spans`` for new operations.
- Use when: "Are these two traces structurally identical?"
→ if ``added_spans``, ``removed_spans``, and ``changed_spans``
are all empty, the traces have the same structure.
- Don't use when: You want aggregate statistics across many traces
(use ``jaeger_span_statistics`` instead, once available).
- Don't use when: You only have one trace — use ``jaeger_get_trace``
for single-trace inspection.
Returns:
dict with ``trace_id_a`` / ``trace_id_b`` / ``added_spans`` /
``removed_spans`` / ``changed_spans`` (with duration + tag deltas) /
``unchanged_count``.
jaeger_span_statisticsCompute per-operation latency percentiles and error rates across recent traces.
Fetches up to ``limit`` traces for the given service (optionally filtered
by operation), then aggregates all spans by operation name. For each
operation reports: span count, p50/p95/p99 duration in microseconds,
error count, and error rate.
Duration values are in microseconds (integer). Error rate is
``error_count / span_count`` (float, 0.0–1.0).
Examples:
- Use when: "What are the p95 latencies for each endpoint in `order-service`?"
→ ``service='order-service'``; inspect each operation's ``p95_duration_us``.
- Use when: "How often does the `POST /checkout` endpoint error?"
→ ``service='checkout-svc'``, ``operation='POST /checkout'``; check
``error_rate`` in the stats.
- Use when: "Compare latency distributions across operations"
→ look at p50 vs p99 spread to identify high-variance operations.
- Use when: "Get a larger sample for more accurate stats"
→ ``limit=100`` for higher confidence percentiles.
- Don't use when: You want to compare two specific traces
(use ``jaeger_compare_traces`` instead).
- Don't use when: You want full span detail for a single trace
(use ``jaeger_get_trace`` instead).
Returns:
dict with ``service`` / ``operation`` / ``trace_count`` /
``stats`` (list of per-operation stats with count, p50/p95/p99
duration_us, error_count, error_rate).
jaeger_critical_pathIdentify the critical path and top bottlenecks in a trace.
Finds the longest-duration span chain (critical path) from root to leaf,
and ranks spans by self-time to find actual performance bottlenecks.
Examples:
- Use when: "Why is this trace so slow?"
→ call with the slow trace ID; examine the critical_path_duration_us
and critical_path_percentage to see how much of the total time is
spent on the longest path.
- Use when: "Which operations are consuming the most CPU/self-time?"
→ check the bottlenecks list sorted by self_time_us descending.
- Use when: Debugging performance regressions — compare critical path
percentages before/after changes.
- Don't use when: You want aggregate statistics across many traces
(use jaeger_span_statistics for that).
- Don't use when: You need to compare two traces structurally
(use jaeger_compare_traces for that).
Returns:
dict with trace metadata, critical path spans, and bottleneck ranking.
jaeger_compare_windowsCompare aggregate trace behavior between two time periods for a service.
Fetches traces from both time windows, aggregates span statistics per operation,
then compares the aggregate behavior to detect performance changes.
Examples:
- Use when: "Did our latest deployment affect performance?"
→ compare pre-deploy and post-deploy time windows for the service.
- Use when: "Which operations got slower after the database upgrade?"
→ check the comparison_p95_us and p95_delta_pct columns for increases.
- Use when: "Are we seeing new error patterns?"
→ look for operations with increased error_rate_delta.
- Use when: "Did we add or remove any API endpoints?"
→ check added_count and removed_count in the summary.
- Don't use when: You want to compare two specific traces
(use jaeger_compare_traces instead).
- Don't use when: You want full span detail for a single trace
(use jaeger_get_trace instead).
Returns:
WindowComparisonOutput with per-operation diffs and summary statistics.
jaeger_detect_anomaliesDetect latency and error-rate anomalies for a service by comparing recent behavior to historical baseline.
Fetches traces from a historical baseline window and a recent observation window,
computes per-operation statistics for both, then identifies statistically significant
deviations that may indicate performance issues or reliability problems.
Examples:
- Use when: "Are there any new performance issues in `order-service`?"
→ `service='order-service'` (uses default 60-minute baseline, 5-minute current).
- Use when: "Be more sensitive to subtle changes"
→ set `sensitivity=1.5` (lower threshold).
- Use when: "Check for issues over the last 24 hours against previous week"
→ `baseline_duration_minutes=10080`, `current_duration_minutes=1440`.
- Don't use when: You want to compare two specific time periods
(use jaeger_compare_windows instead).
- Don't use when: You want full span detail for a single trace
(use jaeger_get_trace instead).
Returns:
AnomalyDetectionOutput with flagged operations and severity scores.
jaeger_find_test_tracesFind Jaeger traces matching the supplied tag query.
Accepts any tag key-value schema (Allure, pytest, custom) without
normalization. When service is omitted, searches all known services
concurrently (capped at 20). Results are sorted newest-first.
jaeger_regression_diffCompare two Jaeger time windows and classify per-operation regressions.
Fetches traces from the baseline and comparison windows, then classifies
each operation as regressed, recovered, appeared, or removed. Results are
sorted by severity score (0-100) descending for easy triage.
Choose Jaeger MCP when