@langwatch/mcp-server 0.3.2 → 0.4.0

package/src/tools/search-traces.ts

@@ -0,0 +1,91 @@
+import { searchTraces as apiSearchTraces } from "../langwatch-api.js";
+import { parseRelativeDate } from "../utils/date-parsing.js";
+
+/**
+ * Handles the search_traces MCP tool invocation.
+ *
+ * Searches LangWatch traces with optional filters, text query, and date range.
+ * In digest mode (default), returns AI-readable formatted digests per trace.
+ * In json mode, returns the full raw JSON.
+ */
+export async function handleSearchTraces(params: {
+  query?: string;
+  filters?: Record<string, string[]>;
+  startDate?: string;
+  endDate?: string;
+  pageSize?: number;
+  scrollId?: string;
+  format?: "digest" | "json";
+}): Promise<string> {
+  const now = Date.now();
+  const startDate = params.startDate
+    ? parseRelativeDate(params.startDate)
+    : now - 86400000;
+  const endDate = params.endDate ? parseRelativeDate(params.endDate) : now;
+  const format = params.format ?? "digest";
+
+  const result = await apiSearchTraces({
+    query: params.query,
+    filters: params.filters,
+    startDate,
+    endDate,
+    pageSize: params.pageSize ?? 25,
+    scrollId: params.scrollId,
+    format,
+  });
+
+  const traces = result.traces ?? [];
+  if (traces.length === 0) {
+    return "No traces found matching your query.";
+  }
+
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+
+  const lines: string[] = [];
+  lines.push(
+    `Found ${result.pagination?.totalHits ?? traces.length} traces:\n`
+  );
+
+  for (const trace of traces) {
+    lines.push(`### Trace: ${trace.trace_id}`);
+
+    if (trace.formatted_trace) {
+      lines.push(trace.formatted_trace);
+    } else {
+      const inputStr = trace.input?.value
+        ? String(trace.input.value)
+        : "N/A";
+      const outputStr = trace.output?.value
+        ? String(trace.output.value)
+        : "N/A";
+      lines.push(
+        `- **Input**: ${inputStr.slice(0, 100)}${inputStr.length > 100 ? "..." : ""}`
+      );
+      lines.push(
+        `- **Output**: ${outputStr.slice(0, 100)}${outputStr.length > 100 ? "..." : ""}`
+      );
+    }
+
+    if (trace.timestamps) {
+      lines.push(`- **Time**: ${trace.timestamps.started_at || "N/A"}`);
+    }
+    if (trace.error) {
+      lines.push(`- **Error**: ${JSON.stringify(trace.error)}`);
+    }
+    lines.push("");
+  }
+
+  if (result.pagination?.scrollId) {
+    lines.push(
+      `\n**More results available.** Use scrollId: "${result.pagination.scrollId}" to get next page.`
+    );
+  }
+
+  lines.push(
+    '\n> Tip: Use `get_trace` with a trace_id for full details. Use `search_traces` with `format: "json"` for raw data. Use `discover_schema` to see available filter fields.'
+  );
+
+  return lines.join("\n");
+}

package/src/tools/update-prompt.ts

@@ -0,0 +1,44 @@
+import {
+  updatePrompt as apiUpdatePrompt,
+  createPromptVersion as apiCreateVersion,
+} from "../langwatch-api.js";
+import type { PromptMutationResponse } from "../langwatch-api.js";
+
+/**
+ * Handles the update_prompt MCP tool invocation.
+ *
+ * Updates an existing prompt or creates a new version, depending on the
+ * `createVersion` flag. Returns a confirmation with the updated details.
+ */
+export async function handleUpdatePrompt(params: {
+  idOrHandle: string;
+  messages?: Array<{ role: string; content: string }>;
+  model?: string;
+  modelProvider?: string;
+  commitMessage?: string;
+  createVersion?: boolean;
+}): Promise<string> {
+  const { idOrHandle, createVersion, ...data } = params;
+
+  let result: PromptMutationResponse;
+  if (createVersion) {
+    result = await apiCreateVersion(idOrHandle, data);
+  } else {
+    result = await apiUpdatePrompt(idOrHandle, data);
+  }
+
+  const lines: string[] = [];
+  lines.push(
+    createVersion
+      ? "New version created successfully!\n"
+      : "Prompt updated successfully!\n"
+  );
+  if (result.id) lines.push(`**ID**: ${result.id}`);
+  if (result.handle) lines.push(`**Handle**: ${result.handle}`);
+  if (result.latestVersionNumber != null)
+    lines.push(`**Version**: v${result.latestVersionNumber}`);
+  if (params.commitMessage)
+    lines.push(`**Commit**: ${params.commitMessage}`);
+
+  return lines.join("\n");
+}

package/src/utils/date-parsing.ts

@@ -0,0 +1,31 @@
+const RELATIVE_UNITS: Record<string, number> = {
+  h: 3600000,
+  d: 86400000,
+  w: 604800000,
+  m: 2592000000,
+};
+
+/**
+ * Parses a date string that can be either a relative duration (e.g. "24h", "7d")
+ * or an ISO date string. Throws on invalid input rather than silently falling back.
+ *
+ * @returns epoch milliseconds
+ * @throws Error if the input is not a valid relative duration or parseable date string
+ */
+export function parseRelativeDate(input: string): number {
+  if (input === "now") return Date.now();
+
+  const match = input.match(/^(\d+)(h|d|w|m)$/);
+  if (match) {
+    const [, amount, unit] = match;
+    return Date.now() - parseInt(amount!) * (RELATIVE_UNITS[unit!] ?? 86400000);
+  }
+
+  const parsed = Date.parse(input);
+  if (Number.isNaN(parsed)) {
+    throw new Error(
+      `Invalid date: "${input}". Use a relative duration (e.g. "24h", "7d", "4w") or an ISO date string.`
+    );
+  }
+  return parsed;
+}