@agenthippo-ai/agenthippo 0.1.0

package/out/base-prompts/mcp-servers/langfuse-analytics/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "langfuse-analytics-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for querying Langfuse analytics (costs, latencies, errors)",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "node scripts/test-server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "langfuse": "^3.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}
+

package/out/base-prompts/mcp-servers/langfuse-analytics/scripts/run-with-env.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+#
+# Copyright (c) AgentHippo.ai. All rights reserved.
+#
+# Run the MCP server with Langfuse credentials from .env.local
+
+export LANGFUSE_SECRET_KEY="sk-lf-427333f6-80ca-440e-bb6b-6cfaaa02c8d3"
+export LANGFUSE_PUBLIC_KEY="pk-lf-80ec7ea4-03a5-46b2-aed1-d8f2812101bc"
+export LANGFUSE_BASE_URL="http://localhost:3001"
+
+exec node "$(dirname "$0")/../dist/index.js"
+

package/out/base-prompts/mcp-servers/langfuse-analytics/scripts/sdk-test.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Test using MCP SDK Client
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const serverPath = join(__dirname, "..", "dist", "index.js");
+
+async function main() {
+  console.log("🚀 Testing Langfuse MCP Server with SDK Client\n");
+
+  // Create client transport
+  const transport = new StdioClientTransport({
+    command: "node",
+    args: [serverPath],
+    env: {
+      ...process.env,
+      LANGFUSE_BASE_URL: process.env.LANGFUSE_BASE_URL || "http://localhost:3001",
+      LANGFUSE_SECRET_KEY: process.env.LANGFUSE_SECRET_KEY || "",
+      LANGFUSE_PUBLIC_KEY: process.env.LANGFUSE_PUBLIC_KEY || "",
+    },
+  });
+
+  // Create client
+  const client = new Client({
+    name: "test-client",
+    version: "1.0.0",
+  });
+
+  console.log("📡 Connecting to server...");
+  await client.connect(transport);
+  console.log("✅ Connected!\n");
+
+  // List tools
+  console.log("📋 Listing available tools...");
+  const tools = await client.listTools();
+  console.log(`Found ${tools.tools.length} tools:`);
+  for (const tool of tools.tools) {
+    console.log(`  - ${tool.name}: ${tool.description?.slice(0, 60)}...`);
+  }
+
+  // Call cost summary
+  console.log("\n💰 Calling langfuse_cost_summary...");
+  try {
+    const costResult = await client.callTool({
+      name: "langfuse_cost_summary",
+      arguments: { groupBy: "model", limit: 5 },
+    });
+    console.log("Result:");
+    if (costResult.content?.[0]?.type === "text") {
+      const data = JSON.parse(costResult.content[0].text);
+      console.log(`  Total cost: $${data.totalCost?.toFixed(4) || "N/A"}`);
+      console.log(`  Total tokens: ${data.totalTokens || "N/A"}`);
+      console.log(`  Groups: ${data.summary?.length || 0}`);
+      if (data.summary?.length > 0) {
+        console.log("  Top models:");
+        for (const item of data.summary.slice(0, 3)) {
+          console.log(`    - ${item.key}: $${item.estimatedCost?.toFixed(4)} (${item.totalTokens} tokens)`);
+        }
+      }
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+
+  // Call list traces
+  console.log("\n📜 Calling langfuse_list_traces...");
+  try {
+    const tracesResult = await client.callTool({
+      name: "langfuse_list_traces",
+      arguments: { limit: 3 },
+    });
+    if (tracesResult.content?.[0]?.type === "text") {
+      const data = JSON.parse(tracesResult.content[0].text);
+      console.log(`  Found ${data.data?.length || 0} traces`);
+      if (data.data?.length > 0) {
+        for (const trace of data.data.slice(0, 3)) {
+          console.log(`    - ${trace.id.slice(0, 8)}... (${trace.name || "unnamed"})`);
+        }
+      }
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+
+  // Cleanup
+  console.log("\n🛑 Closing connection...");
+  await client.close();
+
+  console.log("\n✅ Test complete!");
+}
+
+main().catch((e) => {
+  console.error("❌ Test failed:", e);
+  process.exit(1);
+});
+

package/out/base-prompts/mcp-servers/langfuse-analytics/scripts/simple-test.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * Simple MCP server test - sends JSON-RPC messages and reads responses
+ */
+
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const serverPath = join(__dirname, "..", "dist", "index.js");
+
+let messageId = 1;
+
+function createMessage(method, params = {}) {
+  const msg = {
+    jsonrpc: "2.0",
+    id: messageId++,
+    method,
+    params,
+  };
+  const json = JSON.stringify(msg);
+  return `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`;
+}
+
+async function main() {
+  console.log("🚀 Starting Langfuse MCP Server Test\n");
+
+  const server = spawn("node", [serverPath], {
+    env: {
+      ...process.env,
+      LANGFUSE_BASE_URL: process.env.LANGFUSE_BASE_URL || "http://localhost:3001",
+      LANGFUSE_SECRET_KEY: process.env.LANGFUSE_SECRET_KEY || "",
+      LANGFUSE_PUBLIC_KEY: process.env.LANGFUSE_PUBLIC_KEY || "",
+    },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  server.stderr.on("data", (d) => console.log(`[stderr] ${d.toString().trim()}`));
+
+  // Collect responses
+  let buffer = "";
+  const responses = [];
+
+  server.stdout.on("data", (data) => {
+    buffer += data.toString();
+    // Parse Content-Length messages
+    while (true) {
+      const headerEnd = buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+
+      const header = buffer.slice(0, headerEnd);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) break;
+
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      if (buffer.length < bodyStart + contentLength) break;
+
+      const body = buffer.slice(bodyStart, bodyStart + contentLength);
+      buffer = buffer.slice(bodyStart + contentLength);
+
+      try {
+        const parsed = JSON.parse(body);
+        responses.push(parsed);
+        console.log(`\n📥 Response ${parsed.id}:`);
+        console.log(JSON.stringify(parsed, null, 2));
+      } catch (e) {
+        console.log(`[parse error] ${e.message}`);
+      }
+    }
+  });
+
+  // Wait for server to start
+  await new Promise((r) => setTimeout(r, 500));
+
+  // 1. Initialize
+  console.log("\n📤 [1] initialize");
+  server.stdin.write(
+    createMessage("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "test", version: "1.0.0" },
+    })
+  );
+
+  await new Promise((r) => setTimeout(r, 500));
+
+  // 2. initialized notification
+  console.log("\n📤 [2] initialized (notification)");
+  server.stdin.write(
+    `Content-Length: ${Buffer.byteLength('{"jsonrpc":"2.0","method":"notifications/initialized"}')}\r\n\r\n{"jsonrpc":"2.0","method":"notifications/initialized"}`
+  );
+
+  await new Promise((r) => setTimeout(r, 200));
+
+  // 3. List tools
+  console.log("\n📤 [3] tools/list");
+  server.stdin.write(createMessage("tools/list", {}));
+
+  await new Promise((r) => setTimeout(r, 500));
+
+  // 4. Call cost summary tool
+  console.log("\n📤 [4] tools/call (langfuse_cost_summary)");
+  server.stdin.write(
+    createMessage("tools/call", {
+      name: "langfuse_cost_summary",
+      arguments: { groupBy: "model", limit: 10 },
+    })
+  );
+
+  await new Promise((r) => setTimeout(r, 2000));
+
+  // 5. Call list traces tool
+  console.log("\n📤 [5] tools/call (langfuse_list_traces)");
+  server.stdin.write(
+    createMessage("tools/call", {
+      name: "langfuse_list_traces",
+      arguments: { limit: 3 },
+    })
+  );
+
+  await new Promise((r) => setTimeout(r, 2000));
+
+  console.log("\n" + "=".repeat(60));
+  console.log(`✅ Test complete! Received ${responses.length} responses`);
+  console.log("=".repeat(60));
+
+  server.kill("SIGTERM");
+  process.exit(0);
+}
+
+main().catch((e) => {
+  console.error("❌ Test failed:", e);
+  process.exit(1);
+});
+

package/out/base-prompts/mcp-servers/langfuse-analytics/scripts/test-client.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Simple test client for Langfuse API (without MCP)
+ *
+ * Tests direct connection to Langfuse to verify credentials and connectivity.
+ *
+ * Usage:
+ *   export LANGFUSE_BASE_URL=http://localhost:3000
+ *   export LANGFUSE_SECRET_KEY=sk-lf-xxx
+ *   export LANGFUSE_PUBLIC_KEY=pk-lf-xxx
+ *   node scripts/test-client.js
+ */
+
+const host = process.env.LANGFUSE_BASE_URL || "http://localhost:3000";
+const secretKey = process.env.LANGFUSE_SECRET_KEY || "";
+const publicKey = process.env.LANGFUSE_PUBLIC_KEY || "";
+
+async function main() {
+	console.log("🧪 Testing Langfuse API Connection\n");
+
+	console.log(`📍 Host: ${host}`);
+	console.log(`🔑 Public Key: ${publicKey ? publicKey.slice(0, 10) + "..." : "(not set)"}`);
+	console.log(`🔑 Secret Key: ${secretKey ? secretKey.slice(0, 10) + "..." : "(not set)"}`);
+	console.log("");
+
+	if (!secretKey || !publicKey) {
+		console.error("❌ Please set LANGFUSE_SECRET_KEY and LANGFUSE_PUBLIC_KEY");
+		process.exit(1);
+	}
+
+	const credentials = Buffer.from(`${publicKey}:${secretKey}`).toString("base64");
+	const authHeader = `Basic ${credentials}`;
+
+	// Test 1: Health check (if available)
+	console.log("1️⃣ Testing health endpoint...");
+	try {
+		const healthResp = await fetch(`${host}/api/public/health`, {
+			headers: { Authorization: authHeader },
+		});
+		if (healthResp.ok) {
+			const health = await healthResp.json();
+			console.log(`   ✅ Health: ${JSON.stringify(health)}`);
+		} else {
+			console.log(`   ⚠️ Health endpoint returned ${healthResp.status} (may not exist)`);
+		}
+	} catch (e) {
+		console.log(`   ⚠️ Health check failed: ${e.message}`);
+	}
+
+	// Test 2: List traces
+	console.log("\n2️⃣ Fetching traces (limit=5)...");
+	try {
+		const tracesResp = await fetch(`${host}/api/public/traces?limit=5`, {
+			headers: { Authorization: authHeader },
+		});
+		if (!tracesResp.ok) {
+			const errorText = await tracesResp.text();
+			console.log(`   ❌ Error ${tracesResp.status}: ${errorText}`);
+		} else {
+			const traces = await tracesResp.json();
+			console.log(`   ✅ Found ${traces.data?.length || 0} traces`);
+			if (traces.data?.length > 0) {
+				console.log(`   📋 First trace: ${traces.data[0].id} (${traces.data[0].name || "unnamed"})`);
+			}
+		}
+	} catch (e) {
+		console.log(`   ❌ Failed: ${e.message}`);
+	}
+
+	// Test 3: List sessions
+	console.log("\n3️⃣ Fetching sessions (limit=5)...");
+	try {
+		const sessionsResp = await fetch(`${host}/api/public/sessions?limit=5`, {
+			headers: { Authorization: authHeader },
+		});
+		if (!sessionsResp.ok) {
+			const errorText = await sessionsResp.text();
+			console.log(`   ❌ Error ${sessionsResp.status}: ${errorText}`);
+		} else {
+			const sessions = await sessionsResp.json();
+			console.log(`   ✅ Found ${sessions.sessions?.length || sessions.data?.length || 0} sessions`);
+		}
+	} catch (e) {
+		console.log(`   ❌ Failed: ${e.message}`);
+	}
+
+	// Test 4: List observations (generations)
+	console.log("\n4️⃣ Fetching observations (limit=5, type=GENERATION)...");
+	try {
+		const obsResp = await fetch(`${host}/api/public/observations?limit=5&type=GENERATION`, {
+			headers: { Authorization: authHeader },
+		});
+		if (!obsResp.ok) {
+			const errorText = await obsResp.text();
+			console.log(`   ❌ Error ${obsResp.status}: ${errorText}`);
+		} else {
+			const obs = await obsResp.json();
+			console.log(`   ✅ Found ${obs.data?.length || 0} observations`);
+			if (obs.data?.length > 0) {
+				const first = obs.data[0];
+				console.log(`   📋 First observation:`);
+				console.log(`      Model: ${first.model || "unknown"}`);
+				console.log(`      Tokens: ${first.usage?.totalTokens || 0}`);
+				console.log(`      Cost: $${first.calculatedTotalCost?.toFixed(4) || "?"}`);
+			}
+		}
+	} catch (e) {
+		console.log(`   ❌ Failed: ${e.message}`);
+	}
+
+	console.log("\n✅ Connection test complete!");
+}
+
+main().catch((e) => {
+	console.error("❌ Test failed:", e);
+	process.exit(1);
+});
+

package/out/base-prompts/mcp-servers/langfuse-analytics/scripts/test-server.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+/**
+ * Test script for Langfuse Analytics MCP Server
+ *
+ * This script spawns the MCP server and sends test requests via stdio.
+ *
+ * Usage:
+ *   # Set environment variables first:
+ *   export LANGFUSE_BASE_URL=http://localhost:3000
+ *   export LANGFUSE_SECRET_KEY=sk-lf-xxx
+ *   export LANGFUSE_PUBLIC_KEY=pk-lf-xxx
+ *
+ *   # Run test:
+ *   node scripts/test-server.js
+ */
+
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const serverPath = join(__dirname, "..", "dist", "index.js");
+
+// MCP JSON-RPC message helpers
+let messageId = 1;
+
+function createRequest(method, params = {}) {
+  return {
+    jsonrpc: "2.0",
+    id: messageId++,
+    method,
+    params,
+  };
+}
+
+function sendMessage(proc, message) {
+  const json = JSON.stringify(message);
+  const content = `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`;
+  proc.stdin.write(content);
+}
+
+async function readResponse(rl) {
+  return new Promise((resolve, reject) => {
+    let headers = "";
+    let contentLength = 0;
+    let body = "";
+    let readingHeaders = true;
+
+    const onLine = (line) => {
+      if (readingHeaders) {
+        if (line === "") {
+          readingHeaders = false;
+          // Now read body
+          const match = headers.match(/Content-Length:\s*(\d+)/i);
+          if (match) {
+            contentLength = parseInt(match[1], 10);
+          }
+        } else {
+          headers += line + "\n";
+        }
+      }
+    };
+
+    rl.on("line", onLine);
+
+    // For simplicity, just wait a bit and read what's available
+    setTimeout(() => {
+      rl.off("line", onLine);
+      resolve(null);
+    }, 2000);
+  });
+}
+
+async function main() {
+  console.log("🚀 Starting Langfuse Analytics MCP Server test...\n");
+
+  // Check environment
+  const host = process.env.LANGFUSE_BASE_URL || "http://localhost:3000";
+  const hasSecretKey = !!process.env.LANGFUSE_SECRET_KEY;
+  const hasPublicKey = !!process.env.LANGFUSE_PUBLIC_KEY;
+
+  console.log(`📍 Langfuse Host: ${host}`);
+  console.log(`🔑 Secret Key: ${hasSecretKey ? "✓ set" : "✗ missing"}`);
+  console.log(`🔑 Public Key: ${hasPublicKey ? "✓ set" : "✗ missing"}`);
+  console.log("");
+
+  if (!hasSecretKey || !hasPublicKey) {
+    console.error("❌ Please set LANGFUSE_SECRET_KEY and LANGFUSE_PUBLIC_KEY");
+    console.error("");
+    console.error("Example:");
+    console.error("  export LANGFUSE_BASE_URL=http://localhost:3000");
+    console.error("  export LANGFUSE_SECRET_KEY=sk-lf-xxx");
+    console.error("  export LANGFUSE_PUBLIC_KEY=pk-lf-xxx");
+    process.exit(1);
+  }
+
+  // Spawn the server
+  console.log(`📦 Starting server: node ${serverPath}`);
+  const server = spawn("node", [serverPath], {
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  // Collect stderr (server logs)
+  let stderrOutput = "";
+  server.stderr.on("data", (data) => {
+    stderrOutput += data.toString();
+    // Print server logs in real-time
+    process.stderr.write(`[server] ${data}`);
+  });
+
+  // Wait for server to start
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  if (server.exitCode !== null) {
+    console.error("❌ Server exited prematurely");
+    console.error(stderrOutput);
+    process.exit(1);
+  }
+
+  console.log("\n✓ Server started\n");
+
+  // Create readline for reading responses
+  const rl = createInterface({
+    input: server.stdout,
+    crlfDelay: Infinity,
+  });
+
+  // Collect all stdout data
+  let responseData = "";
+  server.stdout.on("data", (chunk) => {
+    responseData += chunk.toString();
+  });
+
+  // Test 1: Initialize
+  console.log("📤 Sending: initialize");
+  sendMessage(server, createRequest("initialize", {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "test-client", version: "1.0.0" },
+  }));
+
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
+  // Test 2: List tools
+  console.log("📤 Sending: tools/list");
+  sendMessage(server, createRequest("tools/list", {}));
+
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
+  // Test 3: Call langfuse_list_traces
+  console.log("📤 Sending: tools/call (langfuse_list_traces)");
+  sendMessage(server, createRequest("tools/call", {
+    name: "langfuse_list_traces",
+    arguments: { limit: 5 },
+  }));
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  // Test 4: Call langfuse_cost_summary
+  console.log("📤 Sending: tools/call (langfuse_cost_summary)");
+  sendMessage(server, createRequest("tools/call", {
+    name: "langfuse_cost_summary",
+    arguments: { groupBy: "model", limit: 10 },
+  }));
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  // Print collected responses
+  console.log("\n" + "=".repeat(60));
+  console.log("📥 Responses received:");
+  console.log("=".repeat(60) + "\n");
+
+  // Parse and pretty-print responses
+  const lines = responseData.split("\r\n\r\n");
+  for (const line of lines) {
+    if (line.trim() && !line.startsWith("Content-Length:")) {
+      try {
+        // Find JSON in the line
+        const jsonMatch = line.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          const parsed = JSON.parse(jsonMatch[0]);
+          console.log(JSON.stringify(parsed, null, 2));
+          console.log("");
+        }
+      } catch {
+        // Not JSON, print as-is
+        if (line.trim()) {
+          console.log(line);
+        }
+      }
+    }
+  }
+
+  // Cleanup
+  console.log("\n🛑 Stopping server...");
+  server.kill("SIGTERM");
+
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
+  console.log("✅ Test complete!");
+}
+
+main().catch((error) => {
+  console.error("❌ Test failed:", error);
+  process.exit(1);
+});
+