npm install @shinzolabs/instrumentation-mcp

pnpm add @shinzolabs/instrumentation-mcp

yarn add @shinzolabs/instrumentation-mcp

pip install shinzo

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
import { instrumentServer } from "@shinzolabs/instrumentation-mcp"

const server = new McpServer({
  name: "my-awesome-server",
  version: "1.0.0",
  description: "My MCP server with telemetry"
})

// Add this after creating your server
const telemetry = instrumentServer(server, {
  serverName: server.name,
  serverVersion: server.version,
  exporterEndpoint: "https://api.app.shinzo.ai/telemetry/ingest_http",
  exporterAuth: {
    type: "bearer",
    token: "your-ingest-token-here" // Replace with your actual token
  }
})

// Continue with your existing server setup
server.tool("example_tool", {
  description: "An example tool",
  inputSchema: {
    type: "object",
    properties: {
      message: { type: "string" }
    }
  }
}, async (args) => {
  return { content: `Hello, ${args.message}!` }
})

from mcp.server import Server
from shinzo import instrument_server

# Create your MCP server
server = Server("my-awesome-server")

# Instrument it with Shinzo
observability = instrument_server(
    server,
    config={
        "server_name": "my-awesome-server",
        "server_version": "1.0.0",
        "exporter_auth": {
            "type": "bearer",
            "token": "your-ingest-token-here"  # Replace with your actual token
        }
    }
)

# Define your tools
@server.call_tool()
async def example_tool(message: str) -> str:
    """An example tool."""
    return f"Hello, {message}!"

# Clean shutdown
async def shutdown():
    await observability.shutdown()

from mcp.server.fastmcp import FastMCP
from shinzo import instrument_server

# Create FastMCP server
mcp = FastMCP(name="my-awesome-server")

# Instrument it with Shinzo
observability = instrument_server(
    mcp,
    config={
        "server_name": "my-awesome-server",
        "server_version": "1.0.0",
        "exporter_auth": {
            "type": "bearer",
            "token": "your-ingest-token-here"  # Replace with your actual token
        }
    }
)

# Define your tools
@mcp.tool()
def example_tool(message: str) -> str:
    """An example tool."""
    return f"Hello, {message}!"

# Run the server
if __name__ == "__main__":
    mcp.run()

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
import { instrumentServer } from "@shinzolabs/instrumentation-mcp"

const server = new McpServer({
  name: "weather-server",
  version: "1.0.0",
  description: "Weather information MCP server"
})

// Instrument the server
const telemetry = instrumentServer(server, {
  serverName: "weather-server",
  serverVersion: "1.0.0",
  exporterEndpoint: "https://api.app.shinzo.ai/telemetry/ingest_http",
  exporterAuth: {
    type: "bearer",
    token: process.env.SHINZO_TOKEN
  }
})

// Add a weather tool
server.tool("get_weather", {
  description: "Get weather for a city",
  inputSchema: {
    type: "object",
    properties: {
      city: { type: "string" }
    },
    required: ["city"]
  }
}, async (args) => {
  // Simulate API call
  const weather = {
    city: args.city,
    temperature: Math.round(Math.random() * 30 + 10),
    condition: "sunny"
  }

  return {
    content: `Weather in ${weather.city}: ${weather.temperature}°C, ${weather.condition}`
  }
})

// Start the server
async function main() {
  const transport = new StdioServerTransport()
  await server.connect(transport)
}

main().catch(console.error)

import os
import random
import asyncio
from mcp.server import Server
from shinzo import instrument_server

# Create your MCP server
server = Server("weather-server")

# Instrument the server
observability = instrument_server(
    server,
    config={
        "server_name": "weather-server",
        "server_version": "1.0.0",
        "exporter_auth": {
            "type": "bearer",
            "token": os.getenv("SHINZO_TOKEN")
        }
    }
)

# Add a weather tool
@server.call_tool()
async def get_weather(city: str) -> str:
    """Get weather for a city."""
    # Simulate API call
    temperature = random.randint(10, 40)
    condition = "sunny"

    return f"Weather in {city}: {temperature}°C, {condition}"

# Run the server
async def main():
    # Your server setup and connection logic here
    try:
        # Server connection logic would go here
        await asyncio.sleep(60)  # Keep server running
    finally:
        await observability.shutdown()

if __name__ == "__main__":
    asyncio.run(main())

import os
import random
from mcp.server.fastmcp import FastMCP
from shinzo import instrument_server

# Create FastMCP server
mcp = FastMCP(name="weather-server")

# Instrument the server
observability = instrument_server(
    mcp,
    config={
        "server_name": "weather-server",
        "server_version": "1.0.0",
        "exporter_auth": {
            "type": "bearer",
            "token": os.getenv("SHINZO_TOKEN")
        }
    }
)

# Add a weather tool
@mcp.tool()
def get_weather(city: str) -> str:
    """Get weather for a city."""
    # Simulate API call
    temperature = random.randint(10, 40)
    condition = "sunny"

    return f"Weather in {city}: {temperature}°C, {condition}"

# Run the server
if __name__ == "__main__":
    mcp.run()