MCPgee
MCPgee
MCPgeeMCPgee

Shinzo.ts

v1.1.0•Monitoring & Observability•stable

TypeScript SDK for MCP server observability, built on OpenTelemetry. Gain insight into agent usage patterns, contextualize tool calls, and analyze server performance across platforms. Integrate with any OpenTelemetry ingest service including the Shin

aiai-agentsanalyticsframeworkinfrastructure
Share:
67
Stars
0
Downloads
0
Weekly
0/5
View on GitHub

What is Shinzo.ts?

Shinzo.ts is a Model Context Protocol (MCP) server that allows AI assistants like Claude, Cursor, and VS Code to typescript sdk for mcp server observability, built on opentelemetry. gain insight into agent usage patterns, contextualize tool calls, and analyze server performance across platforms. integrate with a...

TypeScript SDK for MCP server observability, built on OpenTelemetry. Gain insight into agent usage patterns, contextualize tool calls, and analyze server performance across platforms. Integrate with any OpenTelemetry ingest service including the Shin

This server falls under the Monitoring & Observability category on MCPgee, the world's largest MCP server directory with 33,000+ servers.

Features

  • TypeScript SDK for MCP server observability, built on OpenTe

Use Cases

MCP server observability with OpenTelemetry
Agent usage analytics and server performance tracking
shinzo-labs

Maintainer

LicenseMIT
Languagetypescript
Versionv1.1.0
UpdatedFeb 16, 2026
Statushealthy
Maintenanceactive

Works with

ClaudeOpenAIwindowsmacoslinux
View SourceBrowse All Servers

Installation

NPM

npx -y @shinzolabs/instrumentation-mcp

Manual Installation

npx -y @shinzolabs/instrumentation-mcp

Configuration

Configuration Details

Config File

claude_desktop_config.json

Performance

Response Metrics

Response Time< 200ms
ThroughputMedium

Resource Usage

Memory UsageLow
CPU UsageLow

How to Set Up and Use Shinzo.ts

Shinzo.ts is a TypeScript SDK that adds OpenTelemetry-compatible observability to any MCP server by wrapping it with a single function call. It automatically collects traces and metrics for every tool invocation, supports PII sanitization, flexible sampling, and can export telemetry to any OpenTelemetry-compatible backend including Jaeger, Grafana Tempo, Honeycomb, or the Shinzo cloud platform. Teams building and operating MCP servers use it to understand agent usage patterns, identify slow or failing tools, and debug multi-step agent workflows.

Prerequisites

  • Node.js 18+ and npm, pnpm, or yarn
  • An existing MCP server written in TypeScript that you want to instrument
  • An OpenTelemetry-compatible backend or collector endpoint (e.g., Jaeger at http://localhost:4318, Honeycomb, Grafana Cloud)
  • An MCP-compatible client such as Claude Desktop for testing
1

Install the instrumentation package

Add @shinzolabs/instrumentation-mcp to your existing TypeScript MCP server project using your preferred package manager.

pnpm add @shinzolabs/instrumentation-mcp
# or
npm install @shinzolabs/instrumentation-mcp
2

Wrap your MCP server with instrumentServer()

Import instrumentServer from the package and call it with your existing MCP server instance and a TelemetryConfig object. The function wraps every tool handler automatically without requiring changes to individual tools.

import { instrumentServer } from '@shinzolabs/instrumentation-mcp';

const telemetry = instrumentServer(server, {
  serverName: 'my-mcp-server',
  serverVersion: '1.0.0',
  exporterEndpoint: 'http://localhost:4318/v1',
  exporterType: 'otlp-http',
  samplingRate: 1.0,
  enablePIISanitization: true,
  enableTracing: true,
  enableMetrics: true
});
3

Configure authentication for remote collectors

If your OpenTelemetry backend requires authentication (e.g., Honeycomb or Grafana Cloud), add the exporterAuth block to your TelemetryConfig with the appropriate auth type.

const telemetry = instrumentServer(server, {
  serverName: 'my-mcp-server',
  serverVersion: '1.0.0',
  exporterEndpoint: 'https://api.honeycomb.io/v1',
  exporterAuth: {
    type: 'apiKey',
    apiKey: process.env.HONEYCOMB_API_KEY
  }
});
4

Use console exporter for local development

During development, use the console exporter to see traces and metrics printed to stdout without needing a running collector.

const telemetry = instrumentServer(server, {
  serverName: 'my-mcp-server',
  serverVersion: '1.0.0',
  exporterType: 'console',
  exporterEndpoint: 'http://localhost:4318/v1'
});
5

Build and run your instrumented server

Compile your TypeScript project and start the server. Telemetry will be emitted automatically for every MCP tool call. Configure your MCP client to use the instrumented server as it normally would.

npx tsc
node dist/index.js

Shinzo.ts Examples

Client configuration

Claude Desktop config using an instrumented MCP server. The Shinzo SDK is transparent to the client — no config changes needed on the client side.

{
  "mcpServers": {
    "my-instrumented-server": {
      "command": "node",
      "args": ["/path/to/my-mcp-server/dist/index.js"]
    }
  }
}

Prompts to try

The Shinzo SDK is a developer library, not a standalone MCP server with prompts. These are developer workflow steps for using it effectively.

- Install @shinzolabs/instrumentation-mcp in your MCP server project
- Call instrumentServer(server, config) before server.listen()
- Set exporterType: 'console' to see traces during local development
- Query your OTLP backend to see tool call latency and error rates
- Use samplingRate: 0.1 in production to reduce telemetry volume

Troubleshooting Shinzo.ts

No traces appearing in the OpenTelemetry backend

First test with exporterType: 'console' to confirm instrumentation is working. Then verify the exporterEndpoint URL is reachable from your server and includes the correct path (e.g., /v1 for OTLP HTTP). Check that your collector is configured to accept OTLP over HTTP or gRPC depending on your exporterType setting.

TypeScript compilation errors after adding the package

Ensure your tsconfig.json targets ES2020 or later and has 'moduleResolution': 'node16' or 'bundler'. The package ships with type definitions, so @types packages are not needed.

PII appearing in traces despite enablePIISanitization being true

The built-in PII sanitizer covers common patterns like emails and credit card numbers. For domain-specific sensitive fields, add a custom dataProcessor function that redacts those fields before they are exported.

Frequently Asked Questions about Shinzo.ts

What is Shinzo.ts?

Shinzo.ts is a Model Context Protocol (MCP) server that typescript sdk for mcp server observability, built on opentelemetry. gain insight into agent usage patterns, contextualize tool calls, and analyze server performance across platforms. integrate with any opentelemetry ingest service including the shin It connects AI assistants to external tools and data sources through a standardized interface.

How do I install Shinzo.ts?

Install via npm with the command: npx -y @shinzolabs/instrumentation-mcp. Then add the server configuration to your AI client's JSON config file (e.g., claude_desktop_config.json or .cursor/mcp.json).

Which AI clients work with Shinzo.ts?

Shinzo.ts works with all major MCP-compatible AI clients including Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), Windsurf, and Cline.

Is Shinzo.ts free to use?

Yes, Shinzo.ts is open source and available under the MIT license. You can use it freely in both personal and commercial projects.

Learn More About MCP Servers

Getting Started with MCP

Set up your first MCP server in minutes

MCP Setup Guide

Configure MCP in Claude, Cursor & VS Code

All MCP Tutorials

18+ hands-on guides for developers

MCP FAQ

40+ answers about Model Context Protocol

Shinzo.ts Alternatives — Similar Monitoring & Observability Servers

Looking for alternatives to Shinzo.ts? Here are other popular monitoring & observability servers you can use with Claude, Cursor, and VS Code.

Netdata

★ 78.9k

Real-time infrastructure monitoring with metrics, logs, alerts, and ML-based anomaly detection.

Kubeshark

★ 11.9k

eBPF-powered network observability for Kubernetes. Indexes L4/L7 traffic with full K8s context, decrypts TLS without keys. Queryable by AI agents via MCP and humans via dashboard.

Mission Control

★ 4.9k

Self-hosted AI agent orchestration platform: dispatch tasks, run multi-agent workflows, monitor spend, and govern operations from one mission control dashboard.

Grafana

★ 3.0k

This MCP server enables natural-language querying of Grafana logs by automatically detecting log sources and service labels. It provides read-only access to log data with intelligent caching for efficient repeat queries.

Sentrux

★ 2.4k

Real-time architectural sensor that helps AI agents close the feedback loop, enabling recursive self-improvement of code quality. Pure Rust.

OpenInference

★ 986

OpenTelemetry Instrumentation for AI Observability

Browse More Monitoring & Observability MCP Servers

Explore all monitoring & observability servers available in the MCPgee directory. Each server includes setup guides for Claude, Cursor, and VS Code.

Monitoring & ObservabilityBrowse All Servers

Quick Config Preview

{ "mcpServers": { "shinzo-ts": { "command": "npx", "args": ["-y", "@shinzolabs/instrumentation-mcp"] } } }

Add this to your claude_desktop_config.json or .cursor/mcp.json

Read the full setup guide →

Ready to use Shinzo.ts?

Browse our complete directory of 33,000+ MCP servers, read setup guides for your editor, and start building with the Model Context Protocol.

33,000+ ServersFree & Open SourceStep-by-Step Guides
Explore All ServersRead Our Guides