@promptlayer/mcp-server 1.0.0

package/scripts/fetch-openapi-endpoints.ts

@@ -0,0 +1,150 @@
+/**
+ * Fetches the PromptLayer OpenAPI spec from GitHub and extracts a canonical
+ * list of endpoints with their parameters. Writes to scripts/openapi-endpoints.json.
+ *
+ * Usage: npx tsx scripts/fetch-openapi-endpoints.ts
+ */
+
+const OPENAPI_URL = "https://raw.githubusercontent.com/magnivorg/prompt-layer-docs/master/openapi.json";
+const OUTPUT_PATH = new URL("./openapi-endpoints.json", import.meta.url).pathname;
+
+type OpenAPIParam = {
+  name: string;
+  in: string;
+  required?: boolean;
+  schema?: { type?: string; enum?: string[]; default?: unknown; [k: string]: unknown };
+  [k: string]: unknown;
+};
+
+type OpenAPISchema = {
+  type?: string;
+  properties?: Record<string, { type?: string | unknown[]; enum?: string[]; [k: string]: unknown }>;
+  required?: string[];
+  $ref?: string;
+  [k: string]: unknown;
+};
+
+type CanonicalEndpoint = {
+  method: string;
+  path: string;
+  summary: string;
+  operationId: string;
+  pathParams: { name: string; type: string; required: boolean }[];
+  queryParams: { name: string; type: string; required: boolean; enum?: string[]; default?: unknown }[];
+  bodyFields: { name: string; type: string; required: boolean; enum?: string[] }[];
+};
+
+function resolveRef(ref: string, spec: Record<string, unknown>): Record<string, unknown> {
+  const parts = ref.replace("#/", "").split("/");
+  let obj: unknown = spec;
+  for (const p of parts) obj = (obj as Record<string, unknown>)[p];
+  return obj as Record<string, unknown>;
+}
+
+function resolveSchema(schema: OpenAPISchema, spec: Record<string, unknown>): OpenAPISchema {
+  if (schema.$ref) return resolveRef(schema.$ref, spec) as OpenAPISchema;
+  return schema;
+}
+
+function normalizeType(schema: { type?: string | unknown[]; anyOf?: unknown[]; oneOf?: unknown[]; [k: string]: unknown }): string {
+  if (typeof schema.type === "string") return schema.type;
+  if (Array.isArray(schema.type)) {
+    const nonNull = schema.type.filter((t) => t !== "null");
+    return nonNull.length === 1 ? String(nonNull[0]) : String(schema.type);
+  }
+  if (schema.anyOf) {
+    const types = (schema.anyOf as Array<{ type?: string }>).map((s) => s.type).filter((t) => t && t !== "null");
+    return types.length === 1 ? types[0]! : `union(${types.join(",")})`;
+  }
+  if (schema.oneOf) return "oneOf";
+  return "unknown";
+}
+
+async function main() {
+  console.error(`Fetching OpenAPI spec from ${OPENAPI_URL}...`);
+  const resp = await fetch(OPENAPI_URL);
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+  const spec = (await resp.json()) as Record<string, unknown>;
+  const paths = spec.paths as Record<string, Record<string, Record<string, unknown>>>;
+
+  const endpoints: CanonicalEndpoint[] = [];
+
+  for (const [path, methods] of Object.entries(paths).sort(([a], [b]) => a.localeCompare(b))) {
+    for (const method of ["get", "post", "put", "patch", "delete"]) {
+      const op = methods[method];
+      if (!op) continue;
+
+      const endpoint: CanonicalEndpoint = {
+        method: method.toUpperCase(),
+        path,
+        summary: (op.summary as string) || "",
+        operationId: (op.operationId as string) || "",
+        pathParams: [],
+        queryParams: [],
+        bodyFields: [],
+      };
+
+      // Parameters (path + query)
+      const params = (op.parameters || []) as OpenAPIParam[];
+      for (const p of params) {
+        const resolved = p.$ref ? (resolveRef(p.$ref as string, spec) as OpenAPIParam) : p;
+        if (resolved.in === "header") continue; // skip X-API-KEY
+        const schema = resolved.schema || {};
+        const entry = {
+          name: resolved.name,
+          type: normalizeType(schema),
+          required: resolved.required ?? false,
+          ...(schema.enum ? { enum: schema.enum } : {}),
+          ...(schema.default !== undefined ? { default: schema.default } : {}),
+        };
+        if (resolved.in === "path") endpoint.pathParams.push(entry);
+        else if (resolved.in === "query") endpoint.queryParams.push(entry);
+      }
+
+      // Request body
+      const reqBody = op.requestBody as { content?: Record<string, { schema?: OpenAPISchema }> } | undefined;
+      if (reqBody?.content) {
+        for (const ct of Object.values(reqBody.content)) {
+          let schema = ct.schema;
+          if (!schema) continue;
+          schema = resolveSchema(schema, spec);
+
+          // Handle anyOf/oneOf wrappers (e.g. anyOf: [$ref, null])
+          if (!schema.properties && (schema.anyOf || schema.oneOf)) {
+            const variants = (schema.anyOf || schema.oneOf) as OpenAPISchema[];
+            const nonNull = variants.filter((v) => v.type !== "null");
+            if (nonNull.length === 1) {
+              schema = resolveSchema(nonNull[0], spec);
+            }
+          }
+
+          if (schema.type === "object" && schema.properties) {
+            const required = new Set(schema.required || []);
+            for (const [name, propSchema] of Object.entries(schema.properties)) {
+              const resolved = propSchema.$ref
+                ? (resolveRef(propSchema.$ref as string, spec) as typeof propSchema)
+                : propSchema;
+              endpoint.bodyFields.push({
+                name,
+                type: normalizeType(resolved),
+                required: required.has(name),
+                ...(resolved.enum ? { enum: resolved.enum as string[] } : {}),
+              });
+            }
+          }
+        }
+      }
+
+      endpoints.push(endpoint);
+    }
+  }
+
+  const { writeFileSync } = await import("fs");
+  writeFileSync(OUTPUT_PATH, JSON.stringify(endpoints, null, 2) + "\n");
+  console.error(`Wrote ${endpoints.length} endpoints to ${OUTPUT_PATH}`);
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/scripts/show-descriptions.ts

@@ -0,0 +1,101 @@
+/**
+ * Pretty-prints all MCP tool names, descriptions, and annotations.
+ *
+ * Usage: npx tsx scripts/show-descriptions.ts
+ */
+
+import { TOOL_DEFINITIONS } from "../src/types.js";
+
+const CATEGORY_ORDER = [
+  "Prompt Templates",
+  "Tracking",
+  "Datasets",
+  "Evaluations",
+  "Agents / Workflows",
+  "Folders",
+];
+
+// Derive categories from the comment markers in TOOL_DEFINITIONS
+const TOOL_CATEGORIES: Record<string, string> = {
+  "get-prompt-template": "Prompt Templates",
+  "get-prompt-template-raw": "Prompt Templates",
+  "list-prompt-templates": "Prompt Templates",
+  "publish-prompt-template": "Prompt Templates",
+  "list-prompt-template-labels": "Prompt Templates",
+  "create-prompt-label": "Prompt Templates",
+  "move-prompt-label": "Prompt Templates",
+  "delete-prompt-label": "Prompt Templates",
+  "get-snippet-usage": "Prompt Templates",
+  "log-request": "Tracking",
+  "create-spans-bulk": "Tracking",
+  "list-datasets": "Datasets",
+  "create-dataset-group": "Datasets",
+  "create-dataset-version-from-file": "Datasets",
+  "create-dataset-version-from-filter-params": "Datasets",
+  "list-evaluations": "Evaluations",
+  "create-report": "Evaluations",
+  "run-report": "Evaluations",
+  "get-report": "Evaluations",
+  "get-report-score": "Evaluations",
+  "update-report-score-card": "Evaluations",
+  "delete-reports-by-name": "Evaluations",
+  "list-workflows": "Agents / Workflows",
+  "get-workflow": "Agents / Workflows",
+  "create-workflow": "Agents / Workflows",
+  "patch-workflow": "Agents / Workflows",
+  "run-workflow": "Agents / Workflows",
+  "get-workflow-version-execution-results": "Agents / Workflows",
+  "create-folder": "Folders",
+  "edit-folder": "Folders",
+  "get-folder-entities": "Folders",
+  "move-folder-entities": "Folders",
+  "delete-folder-entities": "Folders",
+  "resolve-folder-id": "Folders",
+};
+
+// Group tools by category
+const grouped = new Map<string, { name: string; description: string; readOnly: boolean }[]>();
+for (const cat of CATEGORY_ORDER) grouped.set(cat, []);
+
+for (const [name, def] of Object.entries(TOOL_DEFINITIONS)) {
+  const cat = TOOL_CATEGORIES[name] ?? "Other";
+  if (!grouped.has(cat)) grouped.set(cat, []);
+  grouped.get(cat)!.push({
+    name,
+    description: def.description,
+    readOnly: (def.annotations as { readOnlyHint?: boolean })?.readOnlyHint ?? false,
+  });
+}
+
+// Print
+const SEP = "─".repeat(80);
+
+for (const [category, tools] of grouped) {
+  if (tools.length === 0) continue;
+  console.log(`\n${"═".repeat(80)}`);
+  console.log(`  ${category.toUpperCase()} (${tools.length} tools)`);
+  console.log(`${"═".repeat(80)}`);
+
+  for (const tool of tools) {
+    const badge = tool.readOnly ? "📖 read" : "✏️  write";
+    console.log(`\n${SEP}`);
+    console.log(`  ${tool.name}  [${badge}]`);
+    console.log(SEP);
+    // Word-wrap description at ~76 chars
+    const words = tool.description.split(" ");
+    let line = "  ";
+    for (const word of words) {
+      if (line.length + word.length + 1 > 78) {
+        console.log(line);
+        line = "  " + word;
+      } else {
+        line += (line.length > 2 ? " " : "") + word;
+      }
+    }
+    if (line.trim()) console.log(line);
+  }
+}
+
+console.log(`\n${"═".repeat(80)}`);
+console.log(`  TOTAL: ${Object.keys(TOOL_DEFINITIONS).length} tools`);
+console.log(`${"═".repeat(80)}\n`);

package/src/client.ts

@@ -0,0 +1,92 @@
+import type { GetPromptTemplateParams, ListPromptTemplatesParams } from "./types.js";
+import { buildQueryParams, handleApiError } from "./utils.js";
+
+type Body = Record<string, unknown>;
+
+export class PromptLayerClient {
+  constructor(
+    private apiKey: string,
+    private baseUrl: string = "https://api.promptlayer.com"
+  ) {}
+
+  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-KEY": this.apiKey,
+        ...(options.headers as Record<string, string> | undefined),
+      },
+    });
+    if (!response.ok) throw await handleApiError(response);
+    return (await response.json()) as T;
+  }
+
+  private get<T = unknown>(path: string, params?: Body): Promise<T> {
+    return this.request<T>(`${path}${buildQueryParams(params)}`, { method: "GET" });
+  }
+
+  private post<T = unknown>(path: string, body?: Body): Promise<T> {
+    return this.request<T>(path, { method: "POST", body: JSON.stringify(body) });
+  }
+
+  private patch<T = unknown>(path: string, body?: Body): Promise<T> {
+    return this.request<T>(path, { method: "PATCH", body: JSON.stringify(body) });
+  }
+
+  private del<T = unknown>(path: string): Promise<T> {
+    return this.request<T>(path, { method: "DELETE" });
+  }
+
+  private enc(s: string): string {
+    return encodeURIComponent(s);
+  }
+
+  // Prompt Templates
+  getPromptTemplate(name: string, params?: GetPromptTemplateParams) {
+    return this.post(`/prompt-templates/${this.enc(name)}`, { api_key: this.apiKey, ...params });
+  }
+  getPromptTemplateRaw(id: string, params?: Body) { return this.get(`/prompt-templates/${this.enc(id)}`, params); }
+  listPromptTemplates(params?: ListPromptTemplatesParams) { return this.get("/prompt-templates", params); }
+  publishPromptTemplate(body: Body) { return this.post("/rest/prompt-templates", body); }
+  listPromptTemplateLabels(id: string) { return this.get(`/prompt-templates/${this.enc(id)}/labels`); }
+  createPromptLabel(promptId: number, body: Body) { return this.post(`/prompts/${promptId}/label`, body); }
+  movePromptLabel(labelId: number, body: Body) { return this.patch(`/prompt-labels/${labelId}`, body); }
+  deletePromptLabel(labelId: number) { return this.del(`/prompt-labels/${labelId}`); }
+  getSnippetUsage(id: string, params?: Body) { return this.get(`/prompt-templates/${this.enc(id)}/snippet-usage`, params); }
+
+  // Tracking
+  logRequest(body: Body) { return this.post("/log-request", body); }
+  createSpansBulk(body: Body) { return this.post("/spans-bulk", body); }
+
+  // Datasets
+  listDatasets(params?: Body) { return this.get("/api/public/v2/datasets", params); }
+  createDatasetGroup(body: Body) { return this.post("/api/public/v2/dataset-groups", body); }
+  createDatasetVersionFromFile(body: Body) { return this.post("/api/public/v2/dataset-versions/from-file", body); }
+  createDatasetVersionFromFilterParams(body: Body) { return this.post("/api/public/v2/dataset-versions/from-filter-params", body); }
+
+  // Evaluations
+  listEvaluations(params?: Body) { return this.get("/api/public/v2/evaluations", params); }
+  createReport(body: Body) { return this.post("/reports", body); }
+  runReport(id: number, body: Body) { return this.post(`/reports/${id}/run`, body); }
+  getReport(id: number) { return this.get(`/reports/${id}`); }
+  getReportScore(id: number) { return this.get(`/reports/${id}/score`); }
+  updateReportScoreCard(id: number, body: Body) { return this.patch(`/reports/${id}/score-card`, body); }
+  deleteReportsByName(name: string) { return this.del(`/reports/name/${this.enc(name)}`); }
+
+  // Agents
+  listWorkflows(params?: Body) { return this.get("/workflows", params); }
+  getWorkflow(idOrName: string) { return this.get(`/workflows/${this.enc(idOrName)}`); }
+  createWorkflow(body: Body) { return this.post("/rest/workflows", body); }
+  patchWorkflow(idOrName: string, body: Body) { return this.patch(`/rest/workflows/${this.enc(idOrName)}`, body); }
+  runWorkflow(name: string, body: Body) { return this.post(`/workflows/${this.enc(name)}/run`, body); }
+  getWorkflowVersionExecutionResults(params: Body) { return this.get("/workflow-version-execution-results", params); }
+
+  // Folders
+  createFolder(body: Body) { return this.post("/api/public/v2/folders", body); }
+  editFolder(folderId: number, body: Body) { return this.patch(`/api/public/v2/folders/${folderId}`, body); }
+  getFolderEntities(params: Body) { return this.get("/api/public/v2/folders/entities", params); }
+  moveFolderEntities(body: Body) { return this.post("/api/public/v2/folders/entities", body); }
+  deleteFolderEntities(body: Body) { return this.request("/api/public/v2/folders/entities", { method: "DELETE", body: JSON.stringify(body) }); }
+  resolveFolderId(params: Body) { return this.get("/api/public/v2/folders/resolve-id", params); }
+}

package/src/handlers.ts

@@ -0,0 +1,116 @@
+import type { GetPromptTemplateParams, ListPromptTemplatesParams } from "./types.js";
+import { TOOL_DEFINITIONS } from "./types.js";
+import { createToolHandler } from "./utils.js";
+
+type Args = Record<string, unknown> & { api_key?: string };
+function body(args: Args) { const { api_key: _, ...rest } = args; return rest; }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerAllTools(server: any) {
+  const t = TOOL_DEFINITIONS;
+
+  function reg(def: (typeof t)[keyof typeof t], call: Parameters<typeof createToolHandler>[0], msg: Parameters<typeof createToolHandler>[1]) {
+    server.tool(def.name, def.description, def.inputSchema.shape, createToolHandler(call, msg));
+  }
+
+  // Prompt Templates
+  reg(t["get-prompt-template"],
+    (c, a) => { const { api_key: _, prompt_name, ...p } = a as { prompt_name: string; api_key?: string } & GetPromptTemplateParams; return c.getPromptTemplate(prompt_name, p); },
+    (r) => { const { prompt_name, version } = r as { prompt_name: string; version: number }; return `Retrieved "${prompt_name}" v${version}`; });
+
+  reg(t["get-prompt-template-raw"],
+    (c, a) => { const { api_key: _, identifier, ...p } = a as { identifier: string; api_key?: string } & Args; return c.getPromptTemplateRaw(identifier, p); },
+    (r) => `Retrieved raw template "${(r as { prompt_name?: string }).prompt_name ?? ""}"`);
+
+  reg(t["list-prompt-templates"],
+    (c, a) => c.listPromptTemplates(body(a) as ListPromptTemplatesParams),
+    (r) => { const { items, page, pages, total } = r as { items: unknown[]; page: number; pages: number; total: number }; return `${items.length} template(s) (page ${page}/${pages}, total ${total})`; });
+
+  reg(t["publish-prompt-template"],
+    (c, a) => c.publishPromptTemplate(body(a)),
+    () => "Published");
+
+  reg(t["list-prompt-template-labels"],
+    (c, a) => c.listPromptTemplateLabels((a as { identifier: string }).identifier),
+    (r) => `${Array.isArray(r) ? r.length : 0} label(s)`);
+
+  reg(t["create-prompt-label"],
+    (c, a) => { const { api_key: _, prompt_id, prompt_version_number, name } = a as { prompt_id: number; prompt_version_number: number; name: string; api_key?: string }; return c.createPromptLabel(prompt_id, { prompt_version_number, name }); },
+    () => "Label created");
+
+  reg(t["move-prompt-label"],
+    (c, a) => { const { api_key: _, prompt_label_id, prompt_version_number } = a as { prompt_label_id: number; prompt_version_number: number; api_key?: string }; return c.movePromptLabel(prompt_label_id, { prompt_version_number }); },
+    () => "Label moved");
+
+  reg(t["delete-prompt-label"],
+    (c, a) => c.deletePromptLabel((a as { prompt_label_id: number }).prompt_label_id),
+    () => "Label deleted");
+
+  reg(t["get-snippet-usage"],
+    (c, a) => { const { api_key: _, identifier, ...p } = a as { identifier: string; api_key?: string } & Args; return c.getSnippetUsage(identifier, p); },
+    (r) => `${Array.isArray(r) ? r.length : 0} prompt(s) using snippet`);
+
+  // Tracking
+  reg(t["log-request"], (c, a) => c.logRequest(body(a)),
+    (r) => { const id = (r as { request_id?: unknown }).request_id; return id ? `Logged (ID: ${id})` : "Logged"; });
+  reg(t["create-spans-bulk"], (c, a) => c.createSpansBulk(body(a)),
+    (r) => `Created ${(r as { spans?: unknown[] }).spans?.length ?? 0} span(s)`);
+
+  // Datasets
+  reg(t["list-datasets"], (c, a) => c.listDatasets(body(a)),
+    (r) => { const { datasets, total } = r as { datasets?: unknown[]; total?: number }; return `${datasets?.length ?? 0} dataset(s) (total: ${total ?? "?"})`; });
+  reg(t["create-dataset-group"], (c, a) => c.createDatasetGroup(body(a)), () => "Dataset group created");
+  reg(t["create-dataset-version-from-file"], (c, a) => c.createDatasetVersionFromFile(body(a)), () => "Dataset version from file initiated");
+  reg(t["create-dataset-version-from-filter-params"], (c, a) => c.createDatasetVersionFromFilterParams(body(a)), () => "Dataset version from history initiated");
+
+  // Evaluations
+  reg(t["list-evaluations"], (c, a) => c.listEvaluations(body(a)),
+    (r) => { const { items, total } = r as { items?: unknown[]; total?: number }; return `${items?.length ?? 0} evaluation(s) (total: ${total ?? "?"})`; });
+  reg(t["create-report"], (c, a) => c.createReport(body(a)),
+    (r) => { const id = (r as { report_id?: number }).report_id; return id ? `Pipeline created (ID: ${id})` : "Pipeline created"; });
+  reg(t["run-report"],
+    (c, a) => { const { api_key: _, report_id, ...b } = a as { report_id: number; api_key?: string } & Args; return c.runReport(report_id, b); },
+    () => "Evaluation run started");
+  reg(t["get-report"],
+    (c, a) => c.getReport((a as { report_id: number }).report_id),
+    () => "Evaluation retrieved");
+  reg(t["get-report-score"],
+    (c, a) => c.getReportScore((a as { report_id: number }).report_id),
+    (r) => { const s = (r as { score?: number }).score; return s !== undefined ? `Score: ${s}` : "Score retrieved"; });
+  reg(t["update-report-score-card"],
+    (c, a) => { const { api_key: _, report_id, ...b } = a as { report_id: number; api_key?: string } & Args; return c.updateReportScoreCard(report_id, b); },
+    () => "Score card updated");
+  reg(t["delete-reports-by-name"],
+    (c, a) => c.deleteReportsByName((a as { report_name: string }).report_name),
+    () => "Reports archived");
+
+  // Agents
+  reg(t["list-workflows"], (c, a) => c.listWorkflows(body(a)), () => "Agents listed");
+  reg(t["create-workflow"], (c, a) => c.createWorkflow(body(a)), () => "Agent created");
+  reg(t["patch-workflow"],
+    (c, a) => { const { api_key: _, workflow_id_or_name, ...b } = a as { workflow_id_or_name: string; api_key?: string } & Args; return c.patchWorkflow(workflow_id_or_name, b); },
+    () => "Agent updated");
+  reg(t["run-workflow"],
+    (c, a) => { const { api_key: _, workflow_name, ...b } = a as { workflow_name: string; api_key?: string } & Args; return c.runWorkflow(workflow_name, b); },
+    (r) => { const id = (r as { workflow_version_execution_id?: number }).workflow_version_execution_id; return id ? `Agent run started (ID: ${id})` : "Agent run started"; });
+  reg(t["get-workflow-version-execution-results"],
+    (c, a) => c.getWorkflowVersionExecutionResults(body(a)),
+    () => "Execution results retrieved");
+  reg(t["get-workflow"],
+    (c, a) => c.getWorkflow((a as { workflow_id_or_name: string }).workflow_id_or_name),
+    (r) => { const w = r as { workflow?: { name?: string } }; return `Agent "${w.workflow?.name ?? ""}" retrieved`; });
+
+  // Folders
+  reg(t["create-folder"], (c, a) => c.createFolder(body(a)), () => "Folder created");
+  reg(t["edit-folder"],
+    (c, a) => { const { api_key: _, folder_id, ...b } = a as { folder_id: number; api_key?: string } & Args; return c.editFolder(folder_id, b); },
+    () => "Folder renamed");
+  reg(t["get-folder-entities"], (c, a) => c.getFolderEntities(body(a)),
+    (r) => { const e = (r as { entities?: unknown[] }).entities; return `${e?.length ?? 0} entity/entities`; });
+  reg(t["move-folder-entities"], (c, a) => c.moveFolderEntities(body(a)),
+    (r) => { const c_ = (r as { moved_count?: number }).moved_count; return `Moved ${c_ ?? 0} entity/entities`; });
+  reg(t["delete-folder-entities"], (c, a) => c.deleteFolderEntities(body(a)),
+    (r) => { const c_ = (r as { moved_count?: number }).moved_count; return `Deleted ${c_ ?? 0} entity/entities`; });
+  reg(t["resolve-folder-id"], (c, a) => c.resolveFolderId(body(a)),
+    (r) => { const id = (r as { id?: number }).id; return id ? `Folder ID: ${id}` : "Folder not found"; });
+}

package/src/index.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAllTools } from "./handlers.js";
+
+const INSTRUCTIONS = `
+PromptLayer is a prompt management and observability platform. This MCP server lets you manage PromptLayer resources.
+
+## Key entities and naming
+
+- **Prompt template**: A versioned prompt in the registry. Each version has a prompt_template (the content) and metadata. Versions are immutable — publishing always creates a new version.
+- **Snippet**: A reusable prompt fragment referenced inside prompt templates with @@@snippet_name@@@ markers. Snippets are themselves prompt templates (with type "completion"). When a prompt is fetched, snippets are expanded inline by default.
+- **Release label**: A pointer (e.g. "prod", "staging") attached to a specific prompt version. Move labels between versions for deployment.
+- **Agent** (backend name: workflow): A multi-step pipeline of nodes. Each node has a type, configuration, and dependencies. Agents are versioned like prompts.
+- **Evaluation pipeline** (backend name: report): Runs evaluation columns against a dataset and produces scores. Columns can be LLM assertions, code execution, comparisons, etc.
+- **Dataset**: A versioned collection of test rows. Belongs to a dataset group. Versions can be created from CSV/JSON files or by filtering request log history.
+- **Folder**: Organizes prompts, agents, datasets, evaluations, and other entities into a hierarchy.
+
+## Working with prompts and snippets
+
+When editing a prompt that may contain snippets, always use get-prompt-template-raw with resolve_snippets=false. This preserves the raw @@@snippet_name@@@ references so they are not lost on re-publish. The response also includes a "snippets" array listing every snippet used.
+
+When publishing back, keep @@@snippet_name@@@ markers intact in the prompt_template content. Do not inline snippet text — this breaks the snippet reference and future snippet updates will no longer propagate.
+
+Use get-prompt-template (the POST variant) only when you need a fully rendered prompt ready to send to an LLM, with input_variables filled in and provider-specific formatting applied.
+
+## Working with evaluations
+
+The recommended way to create an evaluation pipeline is with LLM assertion columns — these use a language model to score each dataset row. For details on all available column types (LLM assertion, code execution, comparison, etc.), search the PromptLayer docs or see https://docs.promptlayer.com/features/evaluations/column-types.
+
+## Additional documentation
+
+For deeper questions about PromptLayer features, configuration, or API details, the PromptLayer docs site has an MCP server you can use for search. See https://docs.promptlayer.com/mcp for setup.
+`.trim();
+
+const server = new McpServer(
+  { name: "promptlayer-server", version: "1.0.0" },
+  { instructions: INSTRUCTIONS },
+);
+registerAllTools(server);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("PromptLayer MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});