# Langfuse MCP Servers

Generated at 2026-08-10T23:20:44.210Z.

Connect MCP clients to Langfuse Cloud for project-scoped prompt management and to Langfuse Docs for public documentation search and retrieval.

This is an hourly regenerated snapshot. It documents configured MCP servers, connection variants, setup snippets, and discovered tools while serving cached output between regenerations.

## Servers

### Langfuse Cloud MCP

> ⚠️ **API stability**:
> This MCP server is self-describing. Clients should dynamically inspect available tools and schemas rather than assuming a static interface.
> Tool availability and schemas may evolve over time, including the addition, removal, or modification of tools and fields. Clients are expected to tolerate schema changes and refresh capabilities dynamically.

Authenticated project-scoped MCP server for Langfuse Cloud projects.

- Server ID: `langfuse-cloud`
- Canonical endpoint: `https://cloud.langfuse.com/api/public/mcp`
- Authentication: Basic Auth using LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY
- Discovered tools: 79

#### Connection Variants

| Variant | URL |
| --- | --- |
| Cloud EU | `https://cloud.langfuse.com/api/public/mcp` |
| Cloud US | `https://us.cloud.langfuse.com/api/public/mcp` |
| Cloud Japan | `https://jp.cloud.langfuse.com/api/public/mcp` |
| HIPAA US | `https://hipaa.cloud.langfuse.com/api/public/mcp` |
| Self-Hosted | `https://your-domain.com/api/public/mcp` |
| Local Development | `http://localhost:3000/api/public/mcp` |

#### Client Setup

##### Cursor: Cursor mcp.json

```json
{
  "mcpServers": {
    "langfuse-cloud": {
      "url": "https://cloud.langfuse.com/api/public/mcp",
      "headers": {
        "Authorization": "Basic <base64(LANGFUSE_PUBLIC_KEY:LANGFUSE_SECRET_KEY)>"
      }
    }
  }
}
```

##### Claude Code: Claude Code CLI

```bash
export LANGFUSE_PUBLIC_KEY=pk-lf-your-public-key
export LANGFUSE_SECRET_KEY=sk-lf-your-secret-key
claude mcp add --transport http langfuse-cloud https://cloud.langfuse.com/api/public/mcp \
  --header "Authorization: Basic $(printf '%s:%s' "$LANGFUSE_PUBLIC_KEY" "$LANGFUSE_SECRET_KEY" | base64)"
```

##### Generic MCP client: Streamable HTTP JSON

```json
{
  "servers": {
    "langfuse-cloud": {
      "transport": {
        "type": "streamable-http",
        "url": "https://cloud.langfuse.com/api/public/mcp",
        "headers": {
          "Authorization": "Basic <base64(LANGFUSE_PUBLIC_KEY:LANGFUSE_SECRET_KEY)>"
        }
      }
    }
  }
}
```

#### Tools

##### `getPrompt`

Fetch a specific prompt by name with optional label or version parameter.

Retrieval options:
- label: Get prompt with specific label (e.g., 'production', 'staging')
- version: Get specific version number (e.g., 1, 2, 3)
- neither: Returns 'latest' version by default

Note: label and version are mutually exclusive. Returns full prompt content with resolved dependencies.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "The name of the prompt"
    },
    "label": {
      "description": "Label to retrieve (e.g., \"production\", \"staging\"). Defaults to \"latest\".",
      "type": "string",
      "minLength": 1,
      "maxLength": 36,
      "pattern": "^[a-z0-9_\\-.]+$"
    },
    "version": {
      "description": "Specific version number to retrieve (e.g., 1, 2, 3)",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getPrompt",
    "arguments": {
      "name": "string",
      "label": "string",
      "version": 1
    }
  }
}
```

##### `getPromptUnresolved`

Fetch a specific prompt by name with optional label or version parameter WITHOUT resolving dependencies.

Returns the raw prompt content with dependency tags intact. Useful for:
- Understanding prompt composition/stacking before resolution
- Debugging prompt dependencies
- Analyzing the dependency graph structure

Retrieval options:
- label: Get prompt with specific label (e.g., 'production', 'staging')
- version: Get specific version number (e.g., 1, 2, 3)
- neither: Returns 'latest' version by default

Note: label and version are mutually exclusive. To get resolved prompts, use the 'getPrompt' tool instead.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "The name of the prompt"
    },
    "label": {
      "description": "Label to retrieve (e.g., \"production\", \"staging\"). Defaults to \"latest\".",
      "type": "string",
      "minLength": 1,
      "maxLength": 36,
      "pattern": "^[a-z0-9_\\-.]+$"
    },
    "version": {
      "description": "Specific version number to retrieve (e.g., 1, 2, 3)",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getPromptUnresolved",
    "arguments": {
      "name": "string",
      "label": "string",
      "version": 1
    }
  }
}
```

##### `listPrompts`

List and filter prompts in the project. Returns metadata including versions, labels, tags, last updated timestamp, and prompt type.

Optional filters:
- name: Filter by exact prompt name
- label: Filter by label on any version
- tag: Filter by tag
- fromUpdatedAt: Filter prompts updated at or after this timestamp
- toUpdatedAt: Filter prompts updated at or before this timestamp

Pagination: page (default: 1), limit (default: 50, max: 100)

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "description": "Filter by exact prompt name match",
      "type": "string",
      "minLength": 1,
      "maxLength": 255
    },
    "label": {
      "description": "Filter by label (e.g., 'production', 'staging')",
      "type": "string",
      "minLength": 1,
      "maxLength": 36,
      "pattern": "^[a-z0-9_\\-.]+$"
    },
    "tag": {
      "description": "Filter by tag (e.g., 'experimental', 'v1')",
      "type": "string"
    },
    "fromUpdatedAt": {
      "description": "Filter prompts updated at or after this timestamp (ISO 8601 with timezone, e.g. 2026-02-02T00:00:00Z)",
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "toUpdatedAt": {
      "description": "Filter prompts updated at or before this timestamp (ISO 8601 with timezone, e.g. 2026-02-02T00:00:00Z)",
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "page": {
      "default": 1,
      "description": "Page number for pagination (default: 1)",
      "type": "integer",
      "minimum": 1,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "description": "Number of items to return (1-100, default: 50)",
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listPrompts",
    "arguments": {
      "limit": 50,
      "page": 1,
      "fromUpdatedAt": "2026-05-15T12:00:00.000Z",
      "label": "string",
      "name": "string",
      "tag": "string",
      "toUpdatedAt": "2026-05-15T12:00:00.000Z"
    }
  }
}
```

##### `createTextPrompt`

Create a new text prompt version in Langfuse.

Important:
- Prompts are immutable - cannot modify existing versions
- To update content, create a new version
- New prompt versions receive the 'latest' label automatically
- Cannot assign the 'production' label during creation
- To promote to production, use updatePromptLabels only when the user explicitly requests it
- Labels are unique across versions
- Use {{variable_name}} syntax for dynamic content

Accepts: name, prompt (string), optional labels, config, tags, commitMessage

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "The name of the prompt"
    },
    "prompt": {
      "type": "string",
      "description": "The prompt text content (supports {{variables}})"
    },
    "labels": {
      "description": "Optional labels to assign, excluding 'production'. New prompt versions receive the 'latest' label automatically.",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "config": {
      "description": "Optional JSON config (e.g., {model: 'gpt-4', temperature: 0.7})",
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "tags": {
      "description": "Optional tags for organization (e.g., ['experimental', 'v2'])",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "commitMessage": {
      "description": "Optional commit message describing the changes",
      "type": "string"
    }
  },
  "required": [
    "name",
    "prompt"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createTextPrompt",
    "arguments": {
      "name": "string",
      "prompt": "string",
      "commitMessage": "string",
      "config": {
        "property": {}
      },
      "labels": [
        "string"
      ],
      "tags": [
        "string"
      ]
    }
  }
}
```

##### `createChatPrompt`

Create a new chat prompt version in Langfuse. Chat prompts are arrays of messages with roles and content.

Important:
- Prompts are immutable - cannot modify existing versions
- To update content, create a new version
- New prompt versions receive the 'latest' label automatically
- Cannot assign the 'production' label during creation
- To promote to production, use updatePromptLabels only when the user explicitly requests it
- Labels are unique across versions

Message roles: system (instructions), user (input, can contain {{variables}}), assistant (examples)
Accepts: name, prompt (array of {role, content}), optional labels, config, tags, commitMessage

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "The name of the prompt"
    },
    "prompt": {
      "minItems": 1,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "role": {
            "type": "string",
            "description": "The role (e.g., 'system', 'user', 'assistant')"
          },
          "content": {
            "type": "string",
            "description": "The message content"
          }
        },
        "required": [
          "role",
          "content"
        ],
        "additionalProperties": false
      },
      "description": "Array of chat messages with role and content"
    },
    "labels": {
      "description": "Optional labels to assign, excluding 'production'. New prompt versions receive the 'latest' label automatically.",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "config": {
      "description": "Optional JSON config (e.g., {model: 'gpt-4', temperature: 0.7})",
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "tags": {
      "description": "Optional tags for organization (e.g., ['experimental', 'v2'])",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "commitMessage": {
      "description": "Optional commit message describing the changes",
      "type": "string"
    }
  },
  "required": [
    "name",
    "prompt"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createChatPrompt",
    "arguments": {
      "name": "string",
      "prompt": [
        {
          "content": "string",
          "role": "string"
        }
      ],
      "commitMessage": "string",
      "config": {
        "property": {}
      },
      "labels": [
        "string"
      ],
      "tags": [
        "string"
      ]
    }
  }
}
```

##### `updatePromptLabels`

Update labels for a specific prompt version.

Important:
- ONLY way to modify existing prompts (labels only)
- Specified labels are added to the version (preserving others not mentioned)
- Labels are unique across versions - setting a label on one version automatically removes it from others
- 'latest' label is auto-managed and cannot be set manually
- Only add the 'production' label when the user explicitly asks to promote this prompt version to production
- Cannot modify prompt content, type, or tags - use createTextPrompt or createChatPrompt for new versions

Accepts: name, version (required), newLabels (array, can be empty to remove all labels)

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "The name of the prompt"
    },
    "version": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991,
      "description": "The version number to update (required)"
    },
    "newLabels": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Array of new labels to assign to the prompt version (can be empty to remove all labels). The 'latest' label is auto-managed and cannot be supplied."
    }
  },
  "required": [
    "name",
    "version",
    "newLabels"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "updatePromptLabels",
    "arguments": {
      "name": "string",
      "newLabels": [
        "string"
      ],
      "version": 1
    }
  }
}
```

##### `listObservations`

[Requires v4](https://langfuse.com/docs/v4)

Find and review observations in the current Langfuse project, such as generations, spans, events, agent steps, and tool calls.
Traces consist of observations. Use this tool when the user asks to inspect traces: pass traceId to page through the observations for a specific trace; those observation records are the trace data returned by the API.
Use filters to narrow results by trace, name, type, level, environment, time range, or advanced filter conditions. Results are paginated with an opaque cursor.
For metadata filters, first inspect metadata on selectively scoped observations by passing traceId, an exact id filter, or both fromStartTime and toStartTime with fields: ["id", "metadata"]. Then use a discovered key in a stringObject filter.

By default this returns compact summary fields. Use fields: ["*"] for the full observation, or pass specific field names to limit the response size.
Important: if you request metadata explicitly, for example fields: ["id", "metadata"], metadata values are truncated to 200 UTF-8 characters per key unless you also pass expandMetadataKeys with the keys that may need full values.
Requests that project or filter input, output, or metadata must include traceId, an id filter, or both fromStartTime and toStartTime.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "fields": {
      "description": "Observation fields to include in the response. Omit for compact defaults, use [\"*\"] for all available fields, or pass specific field names to keep responses small. Call getObservationFieldSchema to list accepted fields.",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "expandMetadataKeys": {
      "description": "Metadata keys that may need full values. Metadata values are truncated to 200 UTF-8 characters per key by default when metadata is projected without this option.",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "limit": {
      "default": 50,
      "description": "Number of observations to return (1-100, default: 50)",
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "cursor": {
      "description": "Cursor returned by a previous listObservations call",
      "type": "string"
    },
    "type": {
      "type": "string",
      "enum": [
        "SPAN",
        "EVENT",
        "GENERATION",
        "AGENT",
        "TOOL",
        "CHAIN",
        "RETRIEVER",
        "EVALUATOR",
        "EMBEDDING",
        "GUARDRAIL"
      ]
    },
    "name": {
      "type": "string"
    },
    "userId": {
      "type": "string"
    },
    "level": {
      "type": "string",
      "enum": [
        "DEBUG",
        "DEFAULT",
        "WARNING",
        "ERROR"
      ]
    },
    "traceId": {
      "type": "string"
    },
    "version": {
      "type": "string"
    },
    "parentObservationId": {
      "description": "Physical parent observation ID to match exactly.",
      "type": "string"
    },
    "isRootObservation": {
      "description": "Filter by logical root status. App-root observations can match true while retaining a non-null parentObservationId.",
      "type": "boolean"
    },
    "environment": {
      "description": "Environment to filter by. Multiple environments are temporarily unsupported until the public observations API applies allow-multiple environment filters correctly.",
      "type": "string"
    },
    "fromStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "toStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "filter": {
      "description": "Advanced filters. Each item must be an object with column, operator, value, optional type, and optional key. Type is inferred from getObservationFilterSchema columns when omitted. Use key for metadata filters.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "value": {},
          "type": {
            "type": "string"
          },
          "key": {
            "description": "Metadata/object key to filter on. Required when column is metadata.",
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "value"
        ],
        "additionalProperties": false,
        "description": "Advanced observation filter object. Example: {\"column\":\"totalCost\",\"operator\":\">\",\"value\":0.0029}. The explicit form {\"type\":\"number\",\"column\":\"totalCost\",\"operator\":\">\",\"value\":0.0029} is also accepted."
      }
    }
  },
  "required": [
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listObservations",
    "arguments": {
      "limit": 50,
      "cursor": "string",
      "environment": "string",
      "expandMetadataKeys": [
        "string"
      ],
      "fields": [
        "string"
      ],
      "filter": [
        {
          "column": "string",
          "operator": "string",
          "value": {},
          "key": "string",
          "type": "string"
        }
      ],
      "fromStartTime": "2026-05-15T12:00:00.000Z",
      "isRootObservation": true,
      "level": "DEBUG",
      "name": "string",
      "parentObservationId": "string",
      "toStartTime": "2026-05-15T12:00:00.000Z",
      "traceId": "string",
      "type": "SPAN",
      "userId": "string",
      "version": "string"
    }
  }
}
```

##### `getObservation`

[Requires v4](https://langfuse.com/docs/v4)

Get the details for a single observation in the current Langfuse project by observation ID.
Use this when you already know the observation ID and want to inspect its timing, model, status, payload, metadata, usage, cost, or prompt fields.

By default this returns compact summary fields. Use fields: ["*"] for the full observation, or pass specific field names to limit the response size.
Important: if you request metadata explicitly, for example fields: ["id", "metadata"], metadata values are truncated to 200 UTF-8 characters per key unless you also pass expandMetadataKeys with the keys that may need full values.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "observationId": {
      "type": "string",
      "minLength": 1
    },
    "fields": {
      "description": "Observation fields to include in the response. Omit for compact defaults, use [\"*\"] for all available fields, or pass specific field names to keep responses small. Call getObservationFieldSchema to list accepted fields.",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "expandMetadataKeys": {
      "description": "Metadata keys that may need full values. Metadata values are truncated to 200 UTF-8 characters per key by default when metadata is projected without this option.",
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "observationId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getObservation",
    "arguments": {
      "observationId": "string",
      "expandMetadataKeys": [
        "string"
      ],
      "fields": [
        "string"
      ]
    }
  }
}
```

##### `getObservationFieldSchema`

[Requires v4](https://langfuse.com/docs/v4)

Show which observation fields can be requested from listObservations and getObservation. The response marks default fields and fields that may be large or contain sensitive application data.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getObservationFieldSchema",
    "arguments": {}
  }
}
```

##### `getObservationFilterSchema`

[Requires v4](https://langfuse.com/docs/v4)

Show which observation fields can be used in listObservations filters, including the supported operators for each field.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getObservationFilterSchema",
    "arguments": {}
  }
}
```

##### `getObservationFilterValues`

[Requires v4](https://langfuse.com/docs/v4)

List example values for a string or boolean observation filter field, such as names, types, levels, environments, model names, tags, users, or sessions. For numeric metric fields, returns a range with min, max, avg, and count. Use the returned cursor to page through long value lists.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "column": {
      "type": "string",
      "enum": [
        "name",
        "type",
        "environment",
        "version",
        "userId",
        "sessionId",
        "traceName",
        "level",
        "promptName",
        "promptVersion",
        "modelId",
        "providedModelName",
        "totalCost",
        "totalTokens",
        "latency",
        "timeToFirstToken",
        "tags",
        "isRootObservation",
        "hasParentObservation"
      ]
    },
    "fromStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "toStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "observationType": {
      "type": "string",
      "enum": [
        "SPAN",
        "EVENT",
        "GENERATION",
        "AGENT",
        "TOOL",
        "CHAIN",
        "RETRIEVER",
        "EVALUATOR",
        "EMBEDDING",
        "GUARDRAIL"
      ]
    },
    "isRootObservation": {
      "type": "boolean"
    },
    "hasParentObservation": {
      "type": "boolean"
    },
    "limit": {
      "default": 50,
      "description": "Number of observations to return (1-100, default: 50)",
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "cursor": {
      "type": "string"
    }
  },
  "required": [
    "column",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getObservationFilterValues",
    "arguments": {
      "column": "name",
      "limit": 50,
      "cursor": "string",
      "fromStartTime": "2026-05-15T12:00:00.000Z",
      "hasParentObservation": true,
      "isRootObservation": true,
      "observationType": "SPAN",
      "toStartTime": "2026-05-15T12:00:00.000Z"
    }
  }
}
```

##### `listAnnotationQueues`

List annotation queues, worklists that collect trace or observation items for human review and scoring, with pagination.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listAnnotationQueues",
    "arguments": {
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `createAnnotationQueue`

Create an annotation queue, a worklist that collects trace or observation items for human review and scoring.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "scoreConfigIds": {
      "minItems": 1,
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "name",
    "scoreConfigIds"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createAnnotationQueue",
    "arguments": {
      "name": "string",
      "scoreConfigIds": [
        "string"
      ],
      "description": "string"
    }
  }
}
```

##### `getAnnotationQueue`

Get an annotation queue, a worklist of trace or observation items for human review and scoring, by ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "queueId": {
      "type": "string"
    }
  },
  "required": [
    "queueId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getAnnotationQueue",
    "arguments": {
      "queueId": "string"
    }
  }
}
```

##### `listAnnotationQueueItems`

List annotation queue items, each linking one trace or observation to a queue with a review status, with optional status filtering.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "queueId": {
      "type": "string"
    },
    "status": {
      "type": "string",
      "enum": [
        "PENDING",
        "COMPLETED"
      ]
    }
  },
  "required": [
    "page",
    "limit",
    "queueId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listAnnotationQueueItems",
    "arguments": {
      "limit": 50,
      "page": 1,
      "queueId": "string",
      "status": "PENDING"
    }
  }
}
```

##### `getAnnotationQueueItem`

Get an annotation queue item, one queued trace or observation with review status, by queue ID and item ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "queueId": {
      "type": "string"
    },
    "itemId": {
      "type": "string"
    }
  },
  "required": [
    "queueId",
    "itemId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getAnnotationQueueItem",
    "arguments": {
      "itemId": "string",
      "queueId": "string"
    }
  }
}
```

##### `createAnnotationQueueItem`

Add an annotation queue item, one trace or observation to review, to a queue.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "queueId": {
      "type": "string"
    },
    "objectId": {
      "type": "string"
    },
    "objectType": {
      "type": "string",
      "enum": [
        "TRACE",
        "OBSERVATION",
        "SESSION"
      ]
    },
    "status": {
      "default": "PENDING",
      "type": "string",
      "enum": [
        "PENDING",
        "COMPLETED"
      ]
    }
  },
  "required": [
    "queueId",
    "objectId",
    "objectType",
    "status"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createAnnotationQueueItem",
    "arguments": {
      "objectId": "string",
      "objectType": "TRACE",
      "queueId": "string",
      "status": "PENDING"
    }
  }
}
```

##### `updateAnnotationQueueItem`

Update an annotation queue item's review status, such as pending or completed.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "queueId": {
      "type": "string"
    },
    "itemId": {
      "type": "string"
    },
    "status": {
      "type": "string",
      "enum": [
        "PENDING",
        "COMPLETED"
      ]
    }
  },
  "required": [
    "queueId",
    "itemId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "updateAnnotationQueueItem",
    "arguments": {
      "itemId": "string",
      "queueId": "string",
      "status": "PENDING"
    }
  }
}
```

##### `deleteAnnotationQueueItem`

Remove an annotation queue item, the queued trace or observation, from a queue.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "queueId": {
      "type": "string"
    },
    "itemId": {
      "type": "string"
    }
  },
  "required": [
    "queueId",
    "itemId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteAnnotationQueueItem",
    "arguments": {
      "itemId": "string",
      "queueId": "string"
    }
  }
}
```

##### `createAnnotationQueueAssignment`

Assign a project user to an annotation queue so they can work through its review items.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "queueId": {
      "type": "string"
    },
    "userId": {
      "type": "string"
    }
  },
  "required": [
    "queueId",
    "userId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createAnnotationQueueAssignment",
    "arguments": {
      "queueId": "string",
      "userId": "string"
    }
  }
}
```

##### `deleteAnnotationQueueAssignment`

Remove a project user's assignment from an annotation queue.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "queueId": {
      "type": "string"
    },
    "userId": {
      "type": "string"
    }
  },
  "required": [
    "queueId",
    "userId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteAnnotationQueueAssignment",
    "arguments": {
      "queueId": "string",
      "userId": "string"
    }
  }
}
```

##### `createComment`

Create a comment on a trace, observation, session, or prompt.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "content": {
      "type": "string",
      "minLength": 1,
      "maxLength": 5000
    },
    "objectId": {
      "type": "string"
    },
    "objectType": {
      "type": "string",
      "enum": [
        "TRACE",
        "OBSERVATION",
        "SESSION",
        "PROMPT"
      ]
    },
    "authorUserId": {
      "type": "string"
    }
  },
  "required": [
    "content",
    "objectId",
    "objectType"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createComment",
    "arguments": {
      "content": "string",
      "objectId": "string",
      "objectType": "TRACE",
      "authorUserId": "string"
    }
  }
}
```

##### `listComments`

List comments in the current Langfuse project, optionally filtered by object or author.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "objectType": {
      "type": "string",
      "enum": [
        "TRACE",
        "OBSERVATION",
        "SESSION",
        "PROMPT"
      ]
    },
    "objectId": {
      "type": "string"
    },
    "authorUserId": {
      "type": "string"
    },
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listComments",
    "arguments": {
      "limit": 50,
      "page": 1,
      "authorUserId": "string",
      "objectId": "string",
      "objectType": "TRACE"
    }
  }
}
```

##### `getComment`

Get a comment by ID from the current Langfuse project.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "commentId": {
      "type": "string"
    }
  },
  "required": [
    "commentId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getComment",
    "arguments": {
      "commentId": "string"
    }
  }
}
```

##### `upsertDataset`

Upsert a dataset, a named collection of input and optional expected-output examples for experiments and evaluations.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "minLength": 1
    },
    "name": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "metadata": {},
    "inputSchema": {},
    "expectedOutputSchema": {}
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "upsertDataset",
    "arguments": {
      "name": "string",
      "description": "string",
      "expectedOutputSchema": {},
      "id": "string",
      "inputSchema": {},
      "metadata": {}
    }
  }
}
```

##### `listDatasets`

List datasets, named collections of input and optional expected-output examples for experiments and evaluations. Optionally filter by dataset name to find a dataset ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listDatasets",
    "arguments": {
      "limit": 50,
      "page": 1,
      "name": "string"
    }
  }
}
```

##### `getDataset`

Get a dataset, a named collection of input and optional expected-output examples for experiments and evaluations, by ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    }
  },
  "required": [
    "datasetId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getDataset",
    "arguments": {
      "datasetId": "string"
    }
  }
}
```

##### `upsertDatasetItem`

Upsert a dataset item (one example in a dataset) by dataset ID. Item IDs are unique per project across all datasets, so an ID used in one dataset cannot be reused in another.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    },
    "input": {},
    "expectedOutput": {},
    "metadata": {},
    "id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255
    },
    "sourceTraceId": {
      "type": "string"
    },
    "sourceObservationId": {
      "type": "string"
    },
    "status": {
      "type": "string",
      "enum": [
        "ACTIVE",
        "ARCHIVED"
      ]
    }
  },
  "required": [
    "datasetId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "upsertDatasetItem",
    "arguments": {
      "datasetId": "string",
      "expectedOutput": {},
      "id": "string",
      "input": {},
      "metadata": {},
      "sourceObservationId": "string",
      "sourceTraceId": "string",
      "status": "ACTIVE"
    }
  }
}
```

##### `listDatasetItems`

List dataset items, individual examples with input and optional expected output, optionally filtered by dataset ID, source trace, source observation, or version.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    },
    "sourceTraceId": {
      "type": "string"
    },
    "sourceObservationId": {
      "type": "string"
    },
    "version": {
      "type": "string"
    },
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listDatasetItems",
    "arguments": {
      "limit": 50,
      "page": 1,
      "datasetId": "string",
      "sourceObservationId": "string",
      "sourceTraceId": "string",
      "version": "string"
    }
  }
}
```

##### `getDatasetItem`

Get a dataset item, one example in a dataset with input and optional expected output, by ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetItemId": {
      "type": "string"
    }
  },
  "required": [
    "datasetItemId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getDatasetItem",
    "arguments": {
      "datasetItemId": "string"
    }
  }
}
```

##### `deleteDatasetItem`

Delete a dataset item, one example in a dataset, and all its run items.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetItemId": {
      "type": "string"
    }
  },
  "required": [
    "datasetItemId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteDatasetItem",
    "arguments": {
      "datasetItemId": "string"
    }
  }
}
```

##### `createDatasetRunItem`

Create a dataset run item, a result that links one dataset item to a trace or observation in a dataset run.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "runName": {
      "type": "string"
    },
    "runDescription": {
      "type": "string"
    },
    "metadata": {},
    "datasetItemId": {
      "type": "string"
    },
    "observationId": {
      "description": "Observation ID linked to this run item. Provide this or traceId.",
      "type": "string"
    },
    "traceId": {
      "description": "Trace ID linked to this run item. Provide this or observationId.",
      "type": "string"
    },
    "datasetVersion": {
      "type": "string"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    }
  },
  "required": [
    "runName",
    "datasetItemId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createDatasetRunItem",
    "arguments": {
      "datasetItemId": "string",
      "runName": "string",
      "createdAt": "2026-05-15T12:00:00.000Z",
      "datasetVersion": "string",
      "metadata": {},
      "observationId": "string",
      "runDescription": "string",
      "traceId": "string"
    }
  }
}
```

##### `listDatasetRunItems`

List dataset run items, each linking one dataset item to a trace or observation within a dataset run, by dataset ID and run ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    },
    "datasetRunId": {
      "type": "string"
    },
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "datasetId",
    "datasetRunId",
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listDatasetRunItems",
    "arguments": {
      "datasetId": "string",
      "datasetRunId": "string",
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `listDatasetRuns`

List dataset runs, each experiment or evaluation execution over a dataset, by dataset ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    },
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "datasetId",
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listDatasetRuns",
    "arguments": {
      "datasetId": "string",
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `getDatasetRun`

Get a dataset run, one experiment or evaluation execution over a dataset, and its run items by dataset ID and run ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    },
    "datasetRunId": {
      "type": "string"
    }
  },
  "required": [
    "datasetId",
    "datasetRunId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getDatasetRun",
    "arguments": {
      "datasetId": "string",
      "datasetRunId": "string"
    }
  }
}
```

##### `deleteDatasetRun`

Delete a dataset run by dataset ID and run ID, and enqueue deletion of its run items.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    },
    "datasetRunId": {
      "type": "string"
    }
  },
  "required": [
    "datasetId",
    "datasetRunId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteDatasetRun",
    "arguments": {
      "datasetId": "string",
      "datasetRunId": "string"
    }
  }
}
```

##### `getHealth`

Check Langfuse API health. Optionally verify database availability and recent trace/observation ingestion.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "failIfDatabaseUnavailable": {
      "default": false,
      "type": "boolean"
    },
    "failIfNoRecentEvents": {
      "default": false,
      "type": "boolean"
    }
  },
  "required": [
    "failIfDatabaseUnavailable",
    "failIfNoRecentEvents"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getHealth",
    "arguments": {
      "failIfDatabaseUnavailable": false,
      "failIfNoRecentEvents": false
    }
  }
}
```

##### `listScores`

Find scores in Langfuse.
Use this to review quality, evaluation, or feedback scores for traces, observations, sessions, and experiments (dataset runs).
Each score carries a polymorphic value matching its dataType (number, boolean, or string) and a subject describing what it scores: { kind: trace | observation | session | experiment, id }.
Results are paginated with an opaque cursor: pass meta.cursor from the previous response to fetch the next page; a response without meta.cursor is the last page.
Filtering by trace user or trace tags is not supported. To find scores for a specific user, first resolve the user's trace IDs (e.g. via listObservations with userId), then filter scores by traceId.
Score reads are eventually consistent: a score created with createScore may not appear in listScores immediately. If a newly created score is missing, wait briefly and retry.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "cursor": {
      "type": "string"
    },
    "scoreIds": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "name": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "source": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "API",
          "EVAL",
          "ANNOTATION"
        ]
      }
    },
    "dataType": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "NUMERIC",
          "CATEGORICAL",
          "BOOLEAN",
          "CORRECTION",
          "TEXT"
        ]
      }
    },
    "environment": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "configId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "queueId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "authorUserId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "value": {
      "description": "string-encoded, requires a single dataType (NUMERIC, BOOLEAN, or CATEGORICAL)",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "valueMin": {
      "description": "inclusive, requires dataType: [\"NUMERIC\"]",
      "type": "number"
    },
    "valueMax": {
      "description": "inclusive, requires dataType: [\"NUMERIC\"]",
      "type": "number"
    },
    "traceId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "sessionId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "observationId": {
      "description": "requires traceId",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "experimentId": {
      "description": "same ID as datasetRunId in createScore",
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "fromTimestamp": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "toTimestamp": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    }
  },
  "required": [
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listScores",
    "arguments": {
      "limit": 50,
      "authorUserId": [
        "string"
      ],
      "configId": [
        "string"
      ],
      "cursor": "string",
      "dataType": [
        "NUMERIC"
      ],
      "environment": [
        "string"
      ],
      "experimentId": [
        "string"
      ],
      "fromTimestamp": "2026-05-15T12:00:00.000Z",
      "name": [
        "string"
      ],
      "observationId": [
        "string"
      ],
      "queueId": [
        "string"
      ],
      "scoreIds": [
        "string"
      ],
      "sessionId": [
        "string"
      ],
      "source": [
        "API"
      ],
      "toTimestamp": "2026-05-15T12:00:00.000Z",
      "traceId": [
        "string"
      ],
      "value": [
        "string"
      ],
      "valueMax": 1.23,
      "valueMin": 1.23
    }
  }
}
```

##### `getScore`

Fetch one score by ID from the current Langfuse project.
The score carries a polymorphic value matching its dataType (number, boolean, or string) and a subject describing what it scores: { kind: trace | observation | session | experiment, id }.
Score reads are eventually consistent: a score created with createScore may not be returned by getScore immediately. If a newly created score is not found, wait briefly and retry.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "scoreId": {
      "type": "string"
    }
  },
  "required": [
    "scoreId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getScore",
    "arguments": {
      "scoreId": "string"
    }
  }
}
```

##### `createScore`

Create one score in the current Langfuse project.
Score reads are eventually consistent: after creation, getScore and listScores may not return the new score immediately. Wait briefly and retry reads when confirming creation.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "minLength": 1
    },
    "traceId": {
      "description": "Target trace ID.",
      "type": "string"
    },
    "sessionId": {
      "description": "Target session ID.",
      "type": "string"
    },
    "datasetRunId": {
      "description": "Target dataset run ID.",
      "type": "string"
    },
    "observationId": {
      "description": "Optional observation ID for trace-scoped scores.",
      "type": "string"
    },
    "comment": {
      "type": "string"
    },
    "metadata": {},
    "environment": {
      "type": "string"
    },
    "queueId": {
      "type": "string"
    },
    "source": {
      "type": "string",
      "enum": [
        "API",
        "ANNOTATION"
      ]
    },
    "value": {
      "description": "Score value. Must be a JSON number for NUMERIC and BOOLEAN scores; numeric strings like \"0.92\" are invalid. Use a string for CATEGORICAL, TEXT, and CORRECTION scores."
    },
    "dataType": {
      "description": "Score data type. When omitted, legacy scoring accepts string or number values.",
      "type": "string",
      "enum": [
        "NUMERIC",
        "CATEGORICAL",
        "BOOLEAN",
        "CORRECTION",
        "TEXT"
      ]
    },
    "configId": {
      "type": "string"
    }
  },
  "required": [
    "name",
    "value"
  ],
  "additionalProperties": false,
  "description": "Create score request. Provide exactly one of traceId, sessionId, or datasetRunId. observationId may only be provided together with traceId."
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createScore",
    "arguments": {
      "name": "string",
      "value": {},
      "comment": "string",
      "configId": "string",
      "datasetRunId": "string",
      "dataType": "NUMERIC",
      "environment": "string",
      "id": "string",
      "metadata": {},
      "observationId": "string",
      "queueId": "string",
      "sessionId": "string",
      "source": "API",
      "traceId": "string"
    }
  }
}
```

##### `listScoreConfigs`

List score configurations. Returns exactly data and meta at the top level.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listScoreConfigs",
    "arguments": {
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `getScoreConfig`

Fetch one score configuration by ID from the current Langfuse project. Returns the public score config object directly.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "configId": {
      "type": "string"
    }
  },
  "required": [
    "configId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getScoreConfig",
    "arguments": {
      "configId": "string"
    }
  }
}
```

##### `createScoreConfig`

Create a score configuration. Supports numeric, categorical, boolean, and text configs. Boolean configs automatically receive True and False categories.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 35,
      "description": "Allowed characters: letters, numbers, spaces, underscores, periods, parentheses, and hyphens."
    },
    "description": {
      "type": "string"
    },
    "dataType": {
      "type": "string",
      "enum": [
        "NUMERIC",
        "CATEGORICAL",
        "BOOLEAN",
        "TEXT"
      ],
      "description": "Score config type. Numeric range fields only apply to NUMERIC configs; categorical categories only apply to CATEGORICAL configs."
    },
    "numericMinValue": {
      "description": "Minimum allowed value for NUMERIC score configs.",
      "type": "number"
    },
    "numericMaxValue": {
      "description": "Maximum allowed value for NUMERIC score configs.",
      "type": "number"
    },
    "categoricalCategories": {
      "description": "Allowed categories for CATEGORICAL score configs as an array of { label, value } objects."
    }
  },
  "required": [
    "name",
    "dataType"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createScoreConfig",
    "arguments": {
      "dataType": "NUMERIC",
      "name": "string",
      "categoricalCategories": {},
      "description": "string",
      "numericMaxValue": 1.23,
      "numericMinValue": 1.23
    }
  }
}
```

##### `updateScoreConfig`

Update a score configuration. Use this to rename, describe, or adjust allowed numeric/category fields.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "configId": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 35,
      "description": "Allowed characters: letters, numbers, spaces, underscores, periods, parentheses, and hyphens."
    },
    "numericMinValue": {
      "description": "Minimum allowed value for NUMERIC score configs.",
      "type": "number"
    },
    "numericMaxValue": {
      "description": "Maximum allowed value for NUMERIC score configs.",
      "type": "number"
    },
    "categoricalCategories": {
      "description": "Allowed categories for CATEGORICAL score configs as an array of { label, value } objects."
    },
    "description": {
      "type": "string"
    }
  },
  "required": [
    "configId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "updateScoreConfig",
    "arguments": {
      "configId": "string",
      "categoricalCategories": {},
      "description": "string",
      "name": "string",
      "numericMaxValue": 1.23,
      "numericMinValue": 1.23
    }
  }
}
```

##### `deleteScoreConfig`

Delete a score configuration from the current Langfuse project by archiving it.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "configId": {
      "type": "string"
    }
  },
  "required": [
    "configId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteScoreConfig",
    "arguments": {
      "configId": "string"
    }
  }
}
```

##### `queryMetrics`

[Requires v4](https://langfuse.com/docs/v4)

Answer analytics questions about the current Langfuse project, such as usage over time, model costs, latency, errors, scores, or grouped breakdowns by environment, trace, observation, model, user, session, tag, or score name.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "view": {
      "type": "string",
      "enum": [
        "observations",
        "scores-numeric",
        "scores-categorical",
        "scores-boolean"
      ]
    },
    "dimensions": {
      "default": [],
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string"
          }
        },
        "required": [
          "field"
        ],
        "additionalProperties": false
      }
    },
    "metrics": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "measure": {
            "type": "string"
          },
          "aggregation": {
            "type": "string",
            "enum": [
              "sum",
              "avg",
              "count",
              "max",
              "min",
              "p50",
              "p75",
              "p90",
              "p95",
              "p99",
              "histogram",
              "uniq"
            ]
          }
        },
        "required": [
          "measure",
          "aggregation"
        ],
        "additionalProperties": false
      }
    },
    "filters": {
      "default": [],
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "value": {},
          "type": {
            "type": "string"
          },
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "value",
          "type"
        ],
        "additionalProperties": false
      }
    },
    "timeDimension": {
      "type": "object",
      "properties": {
        "granularity": {
          "type": "string",
          "enum": [
            "auto",
            "minute",
            "hour",
            "day",
            "week",
            "month"
          ]
        }
      },
      "required": [
        "granularity"
      ],
      "additionalProperties": false
    },
    "fromTimestamp": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "toTimestamp": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "orderBy": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string"
          },
          "direction": {
            "type": "string",
            "enum": [
              "asc",
              "desc"
            ]
          }
        },
        "required": [
          "field",
          "direction"
        ],
        "additionalProperties": false
      }
    },
    "config": {
      "type": "object",
      "properties": {
        "bins": {
          "type": "integer",
          "minimum": 1,
          "maximum": 100
        },
        "row_limit": {
          "type": "integer",
          "exclusiveMinimum": 0,
          "maximum": 1000
        }
      },
      "additionalProperties": false
    }
  },
  "required": [
    "view",
    "dimensions",
    "metrics",
    "filters",
    "fromTimestamp",
    "toTimestamp"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "queryMetrics",
    "arguments": {
      "dimensions": [],
      "filters": [],
      "fromTimestamp": "2026-05-15T12:00:00.000Z",
      "metrics": [
        {
          "aggregation": "sum",
          "measure": "string"
        }
      ],
      "toTimestamp": "2026-05-15T12:00:00.000Z",
      "view": "observations",
      "config": {
        "bins": 1,
        "row_limit": 1
      },
      "orderBy": [
        {
          "direction": "asc",
          "field": "string"
        }
      ],
      "timeDimension": {
        "granularity": "auto"
      }
    }
  }
}
```

##### `getMetricsSchema`

[Requires v4](https://langfuse.com/docs/v4)

Discover which Langfuse metrics can be analyzed and how to group, filter, aggregate, and time-bucket them before calling queryMetrics.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "view": {
      "description": "Limit the response to one v2 metrics view",
      "type": "string",
      "enum": [
        "observations",
        "scores-numeric",
        "scores-categorical",
        "scores-boolean"
      ]
    }
  },
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getMetricsSchema",
    "arguments": {
      "view": "observations"
    }
  }
}
```

##### `listModels`

List custom and Langfuse-managed model definitions visible to the current project.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listModels",
    "arguments": {
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `createModel`

Create a custom model definition for cost tracking/tokenization in the current project.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "modelName": {
      "type": "string"
    },
    "matchPattern": {
      "type": "string"
    },
    "startDate": {
      "type": "string"
    },
    "inputPrice": {
      "type": "number",
      "minimum": 0
    },
    "outputPrice": {
      "type": "number",
      "minimum": 0
    },
    "totalPrice": {
      "type": "number",
      "minimum": 0
    },
    "unit": {
      "type": "string",
      "enum": [
        "TOKENS",
        "CHARACTERS",
        "MILLISECONDS",
        "SECONDS",
        "REQUESTS",
        "IMAGES"
      ]
    },
    "tokenizerId": {
      "type": "string",
      "enum": [
        "openai",
        "claude"
      ]
    },
    "tokenizerConfig": {},
    "pricingTiers": {
      "type": "array",
      "items": {}
    }
  },
  "required": [
    "modelName",
    "matchPattern",
    "unit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createModel",
    "arguments": {
      "matchPattern": "string",
      "modelName": "string",
      "unit": "TOKENS",
      "inputPrice": 1.23,
      "outputPrice": 1.23,
      "pricingTiers": [
        {}
      ],
      "startDate": "string",
      "tokenizerConfig": {},
      "tokenizerId": "openai",
      "totalPrice": 1.23
    }
  }
}
```

##### `getModel`

Get a model definition by ID from the current project scope.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "modelId": {
      "type": "string"
    }
  },
  "required": [
    "modelId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getModel",
    "arguments": {
      "modelId": "string"
    }
  }
}
```

##### `deleteModel`

Delete a custom model definition from the current project. Built-in models cannot be deleted.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "modelId": {
      "type": "string"
    }
  },
  "required": [
    "modelId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteModel",
    "arguments": {
      "modelId": "string"
    }
  }
}
```

##### `getMedia`

Fetch metadata and a signed download URL for one media asset.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "mediaId": {
      "type": "string"
    }
  },
  "required": [
    "mediaId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getMedia",
    "arguments": {
      "mediaId": "string"
    }
  }
}
```

##### `listEvaluators`

List evaluators (llm_as_judge and code) defined in the current Langfuse project. Results are paginated.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listEvaluators",
    "arguments": {
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `getEvaluator`

Fetch a single evaluator by id, including its prompt or source code, output definition, and how many evaluation rules reference it.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "evaluatorId": {
      "type": "string"
    }
  },
  "required": [
    "evaluatorId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getEvaluator",
    "arguments": {
      "evaluatorId": "string"
    }
  }
}
```

##### `upsertEvaluator`

Create an evaluator, or add a new version to an existing one in the current project. Set type to `llm_as_judge` (default) and provide prompt + outputDefinition (modelConfig optional), or set type to `code` and provide sourceCode + sourceCodeLanguage. Reusing an existing evaluator name adds a new version and migrates evaluation rules that reference it.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "type": {
      "description": "Evaluator type. Defaults to `llm_as_judge` when omitted.",
      "type": "string",
      "enum": [
        "llm_as_judge",
        "code"
      ]
    },
    "prompt": {
      "type": "string",
      "minLength": 1
    },
    "outputDefinition": {
      "type": "object",
      "properties": {
        "dataType": {
          "type": "string",
          "enum": [
            "NUMERIC",
            "BOOLEAN",
            "CATEGORICAL"
          ]
        },
        "reasoning": {
          "type": "object",
          "properties": {
            "description": {
              "type": "string",
              "minLength": 1
            }
          },
          "required": [
            "description"
          ],
          "additionalProperties": false
        },
        "score": {
          "type": "object",
          "properties": {
            "description": {
              "type": "string",
              "minLength": 1
            },
            "categories": {
              "minItems": 2,
              "type": "array",
              "items": {
                "type": "string",
                "minLength": 1
              }
            },
            "shouldAllowMultipleMatches": {
              "type": "boolean"
            }
          },
          "required": [
            "description"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "dataType",
        "reasoning",
        "score"
      ],
      "additionalProperties": false,
      "description": "Score output definition. Required when type is `llm_as_judge`; omit for `code` evaluators."
    },
    "modelConfig": {
      "type": "object",
      "properties": {
        "provider": {
          "type": "string",
          "minLength": 1
        },
        "model": {
          "type": "string",
          "minLength": 1
        }
      },
      "required": [
        "provider",
        "model"
      ],
      "additionalProperties": false,
      "description": "Model used for `llm_as_judge` evaluation. Optional; falls back to the project default eval model."
    },
    "sourceCode": {
      "type": "string",
      "minLength": 1
    },
    "sourceCodeLanguage": {
      "type": "string",
      "enum": [
        "PYTHON",
        "TYPESCRIPT"
      ]
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "upsertEvaluator",
    "arguments": {
      "name": "string",
      "modelConfig": {
        "model": "string",
        "provider": "string"
      },
      "outputDefinition": {
        "dataType": "NUMERIC",
        "reasoning": {
          "description": "string"
        },
        "score": {
          "description": "string",
          "categories": [
            "string"
          ],
          "shouldAllowMultipleMatches": true
        }
      },
      "prompt": "string",
      "sourceCode": "string",
      "sourceCodeLanguage": "PYTHON",
      "type": "llm_as_judge"
    }
  }
}
```

##### `deleteEvaluator`

Delete a project evaluator by id, including all of its versions. Fails while evaluation rules still reference the evaluator; delete those first. Langfuse-managed evaluators cannot be deleted. This cannot be undone.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "evaluatorId": {
      "type": "string"
    }
  },
  "required": [
    "evaluatorId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteEvaluator",
    "arguments": {
      "evaluatorId": "string"
    }
  }
}
```

##### `listEvaluationRules`

List evaluation rules in the current Langfuse project. Each rule attaches an evaluator to incoming observations or experiment items. Results are paginated.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listEvaluationRules",
    "arguments": {
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `getEvaluationRule`

Fetch a single evaluation rule by id, including its evaluator reference, target, filter, variable mapping, sampling, and status.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "evaluationRuleId": {
      "type": "string"
    }
  },
  "required": [
    "evaluationRuleId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getEvaluationRule",
    "arguments": {
      "evaluationRuleId": "string"
    }
  }
}
```

##### `createEvaluationRule`

Create an evaluation rule that runs an evaluator on new observations or experiment items. Set target to `observation` or `experiment`. For `llm_as_judge` evaluators provide a variable mapping; for `code` evaluators omit mapping (Langfuse manages it).

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "evaluator": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "minLength": 1
        },
        "scope": {
          "type": "string",
          "enum": [
            "project",
            "managed"
          ]
        },
        "type": {
          "default": "llm_as_judge",
          "type": "string",
          "enum": [
            "llm_as_judge",
            "code"
          ]
        }
      },
      "required": [
        "name",
        "scope",
        "type"
      ],
      "additionalProperties": false
    },
    "enabled": {
      "type": "boolean"
    },
    "sampling": {
      "default": 1,
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1
    },
    "target": {
      "type": "string",
      "enum": [
        "observation",
        "experiment"
      ]
    },
    "filter": {
      "description": "Conditions selecting which items the rule runs on.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "value": {},
          "type": {
            "type": "string"
          },
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "value",
          "type"
        ],
        "additionalProperties": false,
        "description": "Filter condition, e.g. {\"column\":\"version\",\"operator\":\"=\",\"value\":\"1.0.0\",\"type\":\"string\"}. Use `key` for object columns such as `metadata`. `observation` rules filter on trace/observation columns; `experiment` rules filter on `datasetId`."
      }
    },
    "mapping": {
      "description": "Variable mapping. Required for `llm_as_judge` evaluators; omit for `code` evaluators.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "variable": {
            "type": "string",
            "minLength": 1
          },
          "source": {
            "type": "string",
            "enum": [
              "input",
              "output",
              "metadata",
              "tool_calls",
              "expected_output",
              "experiment_item_metadata"
            ]
          },
          "jsonPath": {
            "type": "string",
            "minLength": 1
          }
        },
        "required": [
          "variable",
          "source"
        ],
        "additionalProperties": false,
        "description": "Maps an evaluator variable to a data source. `observation` rules use `input`, `output`, `metadata`, `tool_calls`; `experiment` rules also allow `expected_output` and `experiment_item_metadata`. Required for `llm_as_judge` evaluators; omit for `code` evaluators (Langfuse manages their mapping)."
      }
    }
  },
  "required": [
    "name",
    "evaluator",
    "enabled",
    "sampling",
    "target"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createEvaluationRule",
    "arguments": {
      "enabled": true,
      "evaluator": {
        "name": "string",
        "scope": "project",
        "type": "llm_as_judge"
      },
      "name": "string",
      "sampling": 1,
      "target": "observation",
      "filter": [
        {
          "column": "string",
          "operator": "string",
          "type": "string",
          "value": {},
          "key": "string"
        }
      ],
      "mapping": [
        {
          "source": "input",
          "variable": "string",
          "jsonPath": "string"
        }
      ]
    }
  }
}
```

##### `updateEvaluationRule`

Update an existing evaluation rule. Provide evaluationRuleId plus at least one field to change. When updating filter or mapping, also pass the matching target. The evaluator type cannot be changed.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "evaluationRuleId": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "minLength": 1
    },
    "evaluator": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "minLength": 1
        },
        "scope": {
          "type": "string",
          "enum": [
            "project",
            "managed"
          ]
        }
      },
      "required": [
        "name",
        "scope"
      ],
      "additionalProperties": false
    },
    "enabled": {
      "type": "boolean"
    },
    "sampling": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1
    },
    "target": {
      "description": "Provide together with filter/mapping when changing them; must match the rule's target.",
      "type": "string",
      "enum": [
        "observation",
        "experiment"
      ]
    },
    "filter": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "value": {},
          "type": {
            "type": "string"
          },
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "value",
          "type"
        ],
        "additionalProperties": false,
        "description": "Filter condition, e.g. {\"column\":\"version\",\"operator\":\"=\",\"value\":\"1.0.0\",\"type\":\"string\"}. Use `key` for object columns such as `metadata`. `observation` rules filter on trace/observation columns; `experiment` rules filter on `datasetId`."
      }
    },
    "mapping": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "variable": {
            "type": "string",
            "minLength": 1
          },
          "source": {
            "type": "string",
            "enum": [
              "input",
              "output",
              "metadata",
              "tool_calls",
              "expected_output",
              "experiment_item_metadata"
            ]
          },
          "jsonPath": {
            "type": "string",
            "minLength": 1
          }
        },
        "required": [
          "variable",
          "source"
        ],
        "additionalProperties": false,
        "description": "Maps an evaluator variable to a data source. `observation` rules use `input`, `output`, `metadata`, `tool_calls`; `experiment` rules also allow `expected_output` and `experiment_item_metadata`. Required for `llm_as_judge` evaluators; omit for `code` evaluators (Langfuse manages their mapping)."
      }
    }
  },
  "required": [
    "evaluationRuleId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "updateEvaluationRule",
    "arguments": {
      "evaluationRuleId": "string",
      "enabled": true,
      "evaluator": {
        "name": "string",
        "scope": "project"
      },
      "filter": [
        {
          "column": "string",
          "operator": "string",
          "type": "string",
          "value": {},
          "key": "string"
        }
      ],
      "mapping": [
        {
          "source": "input",
          "variable": "string",
          "jsonPath": "string"
        }
      ],
      "name": "string",
      "sampling": 1.23,
      "target": "observation"
    }
  }
}
```

##### `deleteEvaluationRule`

Delete an evaluation rule by id. This stops the rule from evaluating new items and cannot be undone.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "evaluationRuleId": {
      "type": "string"
    }
  },
  "required": [
    "evaluationRuleId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteEvaluationRule",
    "arguments": {
      "evaluationRuleId": "string"
    }
  }
}
```

##### `listDashboardWidgets`

List dashboard widgets in the current project.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listDashboardWidgets",
    "arguments": {
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `createDashboardWidget`

Create a dashboard widget (a standalone chart definition you place on any dashboard). Widgets are useful to visualize Langfuse project data and give informative breakdowns to the user. This creates the widget only; place it on a dashboard with the addDashboardPlacement tool. The result includes a url field; use it to link to the created widget.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "description": "Human-readable widget name."
    },
    "description": {
      "description": "Human-readable widget description. Defaults to empty.",
      "type": "string"
    },
    "view": {
      "type": "string",
      "enum": [
        "observations",
        "scores-numeric",
        "scores-boolean",
        "scores-categorical"
      ],
      "description": "Data view for the widget. Traces widgets are not supported by this unstable API."
    },
    "dimensions": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1
          }
        },
        "required": [
          "field"
        ],
        "additionalProperties": false
      },
      "description": "Breakdown dimensions. Non-pivot charts support at most one dimension."
    },
    "metrics": {
      "minItems": 1,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "measure": {
            "type": "string",
            "minLength": 1
          },
          "agg": {
            "type": "string",
            "enum": [
              "sum",
              "avg",
              "count",
              "max",
              "min",
              "p50",
              "p75",
              "p90",
              "p95",
              "p99",
              "histogram",
              "uniq"
            ]
          }
        },
        "required": [
          "measure",
          "agg"
        ],
        "additionalProperties": false
      },
      "description": "Measures and aggregations to plot."
    },
    "filters": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "type": {
            "type": "string"
          },
          "value": {},
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "type"
        ],
        "additionalProperties": {}
      },
      "description": "Widget filters in the same shape as exported dashboard widget JSON."
    },
    "chartType": {
      "type": "string",
      "enum": [
        "LINE_TIME_SERIES",
        "AREA_TIME_SERIES",
        "BAR_TIME_SERIES",
        "HORIZONTAL_BAR",
        "VERTICAL_BAR",
        "PIE",
        "NUMBER",
        "HISTOGRAM",
        "PIVOT_TABLE"
      ]
    },
    "chartConfig": {
      "description": "Chart-specific config. Optional; type defaults to chartType and must match it when given.",
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "LINE_TIME_SERIES",
            "AREA_TIME_SERIES",
            "BAR_TIME_SERIES",
            "HORIZONTAL_BAR",
            "VERTICAL_BAR",
            "PIE",
            "NUMBER",
            "HISTOGRAM",
            "PIVOT_TABLE"
          ]
        },
        "row_limit": {
          "type": "integer",
          "exclusiveMinimum": 0,
          "maximum": 1000
        },
        "show_value_labels": {
          "type": "boolean"
        },
        "bins": {
          "type": "integer",
          "minimum": 1,
          "maximum": 100
        },
        "defaultSort": {
          "type": "object",
          "properties": {
            "column": {
              "type": "string"
            },
            "order": {
              "type": "string",
              "enum": [
                "ASC",
                "DESC"
              ]
            }
          },
          "required": [
            "column",
            "order"
          ],
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    }
  },
  "required": [
    "name",
    "view",
    "dimensions",
    "metrics",
    "filters",
    "chartType"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createDashboardWidget",
    "arguments": {
      "chartType": "LINE_TIME_SERIES",
      "dimensions": [
        {
          "field": "string"
        }
      ],
      "filters": [
        {
          "column": "string",
          "operator": "string",
          "type": "string",
          "key": "string",
          "value": {}
        }
      ],
      "metrics": [
        {
          "agg": "sum",
          "measure": "string"
        }
      ],
      "name": "string",
      "view": "observations",
      "chartConfig": {
        "bins": 1,
        "defaultSort": {
          "column": "string",
          "order": "ASC"
        },
        "row_limit": 1,
        "show_value_labels": true,
        "type": "LINE_TIME_SERIES"
      },
      "description": "string"
    }
  }
}
```

##### `getDashboardWidget`

Get a dashboard widget by ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "widgetId": {
      "type": "string"
    }
  },
  "required": [
    "widgetId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getDashboardWidget",
    "arguments": {
      "widgetId": "string"
    }
  }
}
```

##### `updateDashboardWidget`

Partially update a dashboard widget.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "widgetId": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "minLength": 1
    },
    "description": {
      "type": "string"
    },
    "view": {
      "type": "string",
      "enum": [
        "observations",
        "scores-numeric",
        "scores-boolean",
        "scores-categorical"
      ]
    },
    "dimensions": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string"
          }
        },
        "required": [
          "field"
        ],
        "additionalProperties": false
      }
    },
    "metrics": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "measure": {
            "type": "string"
          },
          "agg": {
            "type": "string",
            "enum": [
              "sum",
              "avg",
              "count",
              "max",
              "min",
              "p50",
              "p75",
              "p90",
              "p95",
              "p99",
              "histogram",
              "uniq"
            ]
          }
        },
        "required": [
          "measure",
          "agg"
        ],
        "additionalProperties": false
      }
    },
    "filters": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "type": {
            "type": "string"
          },
          "value": {},
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "type"
        ],
        "additionalProperties": {}
      }
    },
    "chartType": {
      "type": "string",
      "enum": [
        "LINE_TIME_SERIES",
        "AREA_TIME_SERIES",
        "BAR_TIME_SERIES",
        "HORIZONTAL_BAR",
        "VERTICAL_BAR",
        "PIE",
        "NUMBER",
        "HISTOGRAM",
        "PIVOT_TABLE"
      ]
    },
    "chartConfig": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "LINE_TIME_SERIES",
            "AREA_TIME_SERIES",
            "BAR_TIME_SERIES",
            "HORIZONTAL_BAR",
            "VERTICAL_BAR",
            "PIE",
            "NUMBER",
            "HISTOGRAM",
            "PIVOT_TABLE"
          ]
        },
        "row_limit": {
          "type": "integer",
          "exclusiveMinimum": 0,
          "maximum": 1000
        },
        "show_value_labels": {
          "type": "boolean"
        },
        "bins": {
          "type": "integer",
          "minimum": 1,
          "maximum": 100
        },
        "defaultSort": {
          "type": "object",
          "properties": {
            "column": {
              "type": "string"
            },
            "order": {
              "type": "string",
              "enum": [
                "ASC",
                "DESC"
              ]
            }
          },
          "required": [
            "column",
            "order"
          ],
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    }
  },
  "required": [
    "widgetId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "updateDashboardWidget",
    "arguments": {
      "widgetId": "string",
      "chartConfig": {
        "bins": 1,
        "defaultSort": {
          "column": "string",
          "order": "ASC"
        },
        "row_limit": 1,
        "show_value_labels": true,
        "type": "LINE_TIME_SERIES"
      },
      "chartType": "LINE_TIME_SERIES",
      "description": "string",
      "dimensions": [
        {
          "field": "string"
        }
      ],
      "filters": [
        {
          "column": "string",
          "operator": "string",
          "type": "string",
          "key": "string",
          "value": {}
        }
      ],
      "metrics": [
        {
          "agg": "sum",
          "measure": "string"
        }
      ],
      "name": "string",
      "view": "observations"
    }
  }
}
```

##### `deleteDashboardWidget`

Delete a dashboard widget. It must first be removed from every dashboard placement.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "widgetId": {
      "type": "string"
    }
  },
  "required": [
    "widgetId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteDashboardWidget",
    "arguments": {
      "widgetId": "string"
    }
  }
}
```

##### `listDashboards`

List editable dashboards in the current project.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 100
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listDashboards",
    "arguments": {
      "limit": 50,
      "page": 1
    }
  }
}
```

##### `getDashboard`

Get an editable dashboard by ID, including its current layout: definition.widgets lists every placement with 12-column-grid coordinates (x/y top-left cell, width/height in cells).

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "dashboardId": {
      "type": "string"
    }
  },
  "required": [
    "dashboardId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getDashboard",
    "arguments": {
      "dashboardId": "string"
    }
  }
}
```

##### `createDashboard`

Create an editable dashboard.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "description": {
      "type": "string"
    },
    "filters": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {},
        "additionalProperties": {}
      }
    },
    "definition": {
      "type": "object",
      "properties": {
        "widgets": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {},
            "additionalProperties": {}
          }
        }
      },
      "required": [
        "widgets"
      ],
      "additionalProperties": false
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "createDashboard",
    "arguments": {
      "name": "string",
      "definition": {
        "widgets": [
          {
            "property": {}
          }
        ]
      },
      "description": "string",
      "filters": [
        {
          "property": {}
        }
      ]
    }
  }
}
```

##### `updateDashboard`

Partially update dashboard metadata, filters, or its complete definition.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "dashboardId": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "minLength": 1
    },
    "description": {
      "type": "string"
    },
    "filters": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {},
        "additionalProperties": {}
      }
    },
    "definition": {
      "type": "object",
      "properties": {
        "widgets": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {},
            "additionalProperties": {}
          }
        }
      },
      "required": [
        "widgets"
      ],
      "additionalProperties": false
    }
  },
  "required": [
    "dashboardId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "updateDashboard",
    "arguments": {
      "dashboardId": "string",
      "definition": {
        "widgets": [
          {
            "property": {}
          }
        ]
      },
      "description": "string",
      "filters": [
        {
          "property": {}
        }
      ],
      "name": "string"
    }
  }
}
```

##### `deleteDashboard`

Delete an editable dashboard.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "dashboardId": {
      "type": "string"
    }
  },
  "required": [
    "dashboardId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteDashboard",
    "arguments": {
      "dashboardId": "string"
    }
  }
}
```

##### `addDashboardPlacement`

Add a widget or preset placement to a dashboard's 12-column grid. Prefer omitting id and position: the server generates an id and appends the tile below existing ones at the default 6x6 size. Explicit positions are not checked for overlap. After adding, call getDashboard to verify the full grid arrangement; use updateDashboardPlacement to move or resize the new tile when needed. Returns the created placement.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "dashboardId": {
      "type": "string"
    },
    "type": {
      "type": "string",
      "enum": [
        "widget",
        "preset"
      ]
    },
    "id": {
      "type": "string"
    },
    "widgetId": {
      "type": "string"
    },
    "presetId": {
      "type": "string"
    },
    "x": {
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "y": {
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "width": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "height": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "dashboardId",
    "type"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "addDashboardPlacement",
    "arguments": {
      "dashboardId": "string",
      "type": "widget",
      "height": 1,
      "id": "string",
      "presetId": "string",
      "widgetId": "string",
      "width": 1,
      "x": 1,
      "y": 1
    }
  }
}
```

##### `updateDashboardPlacement`

Move or resize an existing dashboard placement on the 12-column grid. Pass any of x, y (top-left cell), width, height (in cells); omitted fields keep their current value. The placement's content and id cannot change. Use getDashboard to read the current layout first. Overlaps are not checked. Returns the updated placement.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "dashboardId": {
      "type": "string"
    },
    "placementId": {
      "type": "string"
    },
    "x": {
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "y": {
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "width": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "height": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "dashboardId",
    "placementId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "updateDashboardPlacement",
    "arguments": {
      "dashboardId": "string",
      "placementId": "string",
      "height": 1,
      "width": 1,
      "x": 1,
      "y": 1
    }
  }
}
```

##### `deleteDashboardPlacement`

Remove a placement from a dashboard without deleting the underlying widget.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "dashboardId": {
      "type": "string"
    },
    "placementId": {
      "type": "string"
    }
  },
  "required": [
    "dashboardId",
    "placementId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "deleteDashboardPlacement",
    "arguments": {
      "dashboardId": "string",
      "placementId": "string"
    }
  }
}
```

##### `submitFeedback`

Submit explicit user-approved feedback to the Langfuse team about Langfuse skills, MCP tools, CLI, docs, or public API.
Before calling, ask the user for permission and show the exact feedback payload, including any optional goal/use-case context.
If the user wants a reply, ask them to include their email address in the feedback text; only use an address they explicitly provide and show it in the exact payload preview.
Do not include secrets, credentials, customer/project data, trace payloads, or unrelated context; the only contact detail to include is an explicitly provided reply email.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "targetType": {
      "type": "string",
      "enum": [
        "skill",
        "mcp-tool",
        "cli",
        "docs",
        "public-api",
        "other"
      ],
      "description": "Category of the thing the feedback is about."
    },
    "target": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200,
      "description": "The specific instance within targetType: the skill name, MCP tool name, CLI command, API endpoint path, or docs page path (e.g. 'queryMetrics', '/docs/mcp'). An identifier, not a sentence."
    },
    "feedback": {
      "type": "string",
      "minLength": 1,
      "maxLength": 3000,
      "description": "The concise feedback text approved by the user."
    },
    "goal": {
      "description": "Optional user-approved goal or use case they were trying to achieve. Do not infer or add secrets, customer data, trace payloads, or broad unrelated context.",
      "type": "string",
      "minLength": 1,
      "maxLength": 1500
    },
    "referenceUrl": {
      "description": "Optional URL reference. Langfuse stores it as text only.",
      "type": "string",
      "maxLength": 2048,
      "format": "uri"
    }
  },
  "required": [
    "targetType",
    "target",
    "feedback"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "submitFeedback",
    "arguments": {
      "feedback": "string",
      "target": "string",
      "targetType": "skill",
      "goal": "string",
      "referenceUrl": "https://example.com"
    }
  }
}
```

##### `listExperiments`

[Requires v4](https://langfuse.com/docs/v4)

List experiments in the current Langfuse project with cursor-based pagination.
Use this to find experiment IDs, inspect experiment summaries, and optionally include metadata or experiment-level scores.
Results are sorted newest first by the latest event for each experiment, not by the returned experiment startTime.
fromStartTime is required. Time filters and cursor bounds are applied before experiments are grouped, so a time range can return partial experiment aggregates.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "fields": {
      "description": "Response field groups to include. Available groups: core, metadata, scores.",
      "default": [
        "core"
      ],
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "core",
          "metadata",
          "scores"
        ]
      }
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "scoreLimit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 50
    },
    "cursor": {
      "type": "string",
      "description": "Base64url-encoded cursor for pagination"
    },
    "fromStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "toStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "id": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "name": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "datasetId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "filter": {
      "description": "Advanced experiment filters as objects with column, operator, value, and type. Supported columns: id, name, datasetId.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "value": {},
          "type": {
            "type": "string"
          },
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "value",
          "type"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "fields",
    "limit",
    "scoreLimit",
    "fromStartTime"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listExperiments",
    "arguments": {
      "fields": [
        "core"
      ],
      "fromStartTime": "2026-05-15T12:00:00.000Z",
      "limit": 50,
      "scoreLimit": 50,
      "cursor": "string",
      "datasetId": [
        "string"
      ],
      "filter": [
        {
          "column": "string",
          "operator": "string",
          "type": "string",
          "value": {},
          "key": "string"
        }
      ],
      "id": [
        "string"
      ],
      "name": [
        "string"
      ],
      "toStartTime": "2026-05-15T12:00:00.000Z"
    }
  }
}
```

##### `listExperimentItems`

[Requires v4](https://langfuse.com/docs/v4)

List experiment items in the current Langfuse project with cursor-based pagination.
Use this to inspect experiment item inputs, outputs, expected outputs, metadata, and optionally item or trace scores.
Results are sorted newest first by experiment item startTime.
fromStartTime is required. Request io and metadata fields only when needed because they can be large.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "fields": {
      "description": "Response field groups to include. Available groups: core, dataset, io, metadata, itemMetadata, experimentMetadata, scores.",
      "default": [
        "core",
        "dataset"
      ],
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "core",
          "dataset",
          "io",
          "metadata",
          "itemMetadata",
          "experimentMetadata",
          "scores"
        ]
      }
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "scoreLimit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 50
    },
    "cursor": {
      "type": "string",
      "description": "Base64url-encoded cursor for pagination"
    },
    "fromStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "toStartTime": {
      "type": "string",
      "format": "date-time",
      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
    },
    "experimentId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "experimentName": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "experimentItemId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "datasetId": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "filter": {
      "description": "Advanced experiment item filters as objects with column, operator, value, and type. Supported columns: experimentId, experimentName, experimentItemId, datasetId.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "value": {},
          "type": {
            "type": "string"
          },
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "value",
          "type"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "fields",
    "limit",
    "scoreLimit",
    "fromStartTime"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listExperimentItems",
    "arguments": {
      "fields": [
        "core",
        "dataset"
      ],
      "fromStartTime": "2026-05-15T12:00:00.000Z",
      "limit": 50,
      "scoreLimit": 50,
      "cursor": "string",
      "datasetId": [
        "string"
      ],
      "experimentId": [
        "string"
      ],
      "experimentItemId": [
        "string"
      ],
      "experimentName": [
        "string"
      ],
      "filter": [
        {
          "column": "string",
          "operator": "string",
          "type": "string",
          "value": {},
          "key": "string"
        }
      ],
      "toStartTime": "2026-05-15T12:00:00.000Z"
    }
  }
}
```

##### `listAlerts`

List alerts, optionally filtered by severity or tags and ordered by alert properties.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "page": {
      "default": 1,
      "type": "number",
      "minimum": 0
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "orderBy": {
      "type": "object",
      "properties": {
        "column": {
          "type": "string",
          "enum": [
            "name",
            "status",
            "severity",
            "severityChangedAt",
            "alertedAt",
            "createdAt",
            "updatedAt"
          ]
        },
        "order": {
          "type": "string",
          "enum": [
            "ASC",
            "DESC"
          ]
        }
      },
      "required": [
        "column",
        "order"
      ],
      "additionalProperties": false
    },
    "filter": {
      "description": "Filter alerts by severity or tags.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "column": {
            "type": "string"
          },
          "operator": {
            "type": "string"
          },
          "value": {},
          "type": {
            "type": "string"
          },
          "key": {
            "type": "string"
          }
        },
        "required": [
          "column",
          "operator",
          "value",
          "type"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "page",
    "limit"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "listAlerts",
    "arguments": {
      "limit": 50,
      "page": 1,
      "filter": [
        {
          "column": "string",
          "operator": "string",
          "type": "string",
          "value": {},
          "key": "string"
        }
      ],
      "orderBy": {
        "column": "name",
        "order": "ASC"
      }
    }
  }
}
```

##### `getAlert`

Get an alert by ID.

Input schema:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "monitorId": {
      "type": "string",
      "description": "ID of the alert to retrieve."
    }
  },
  "required": [
    "monitorId"
  ],
  "additionalProperties": false
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getAlert",
    "arguments": {
      "monitorId": "string"
    }
  }
}
```

### Langfuse Docs MCP

Unauthenticated MCP server for Langfuse documentation search and retrieval.

- Server ID: `langfuse-docs`
- Canonical endpoint: `https://langfuse.com/api/mcp`
- Authentication: None
- Discovered tools: 4

#### Client Setup

##### Cursor: Cursor mcp.json

```json
{
  "mcpServers": {
    "langfuse-docs": {
      "url": "https://langfuse.com/api/mcp"
    }
  }
}
```

##### VS Code Copilot: VS Code settings.json

```json
{
  "mcp": {
    "servers": {
      "langfuse-docs": {
        "type": "http",
        "url": "https://langfuse.com/api/mcp"
      }
    }
  }
}
```

##### Claude Code: Claude Code CLI

```bash
claude mcp add --transport http langfuse-docs https://langfuse.com/api/mcp
```

##### Windsurf: Proxy command

```json
{
  "mcpServers": {
    "langfuse-docs": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://langfuse.com/api/mcp"
      ]
    }
  }
}
```

##### Generic MCP client: Streamable HTTP JSON

```json
{
  "servers": {
    "langfuse-docs": {
      "transport": {
        "type": "streamable-http",
        "url": "https://langfuse.com/api/mcp"
      }
    }
  }
}
```

#### Tools

##### `submitFeedback`

Submit explicit user-approved feedback to the Langfuse team.
Before calling, ask permission and show the exact payload.
If the user wants a reply, ask them to include their email address in the feedback text; only use an address they explicitly provide and show it in the exact payload preview.
Do not include secrets, credentials, customer/project data, trace payloads, or unrelated context; the only contact detail to include is an explicitly provided reply email.

Input schema:

```json
{
  "type": "object",
  "properties": {
    "targetType": {
      "type": "string",
      "enum": [
        "skill",
        "mcp-tool",
        "cli",
        "docs",
        "public-api",
        "other"
      ],
      "description": "Category of the thing the feedback is about."
    },
    "target": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200,
      "description": "The specific instance within targetType: the skill name, MCP tool name, CLI command, API endpoint path, or docs page path (e.g. 'queryMetrics', '/docs/mcp'). An identifier, not a sentence."
    },
    "feedback": {
      "type": "string",
      "minLength": 1,
      "maxLength": 3000
    },
    "goal": {
      "type": "string",
      "minLength": 1,
      "maxLength": 1500
    },
    "referenceUrl": {
      "type": "string",
      "format": "uri",
      "maxLength": 2048
    }
  },
  "required": [
    "targetType",
    "target",
    "feedback"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "submitFeedback",
    "arguments": {
      "feedback": "string",
      "target": "string",
      "targetType": "skill",
      "goal": "string",
      "referenceUrl": "https://example.com"
    }
  }
}
```

##### `searchLangfuseDocs`

Semantic search (RAG) over the Langfuse documentation. Use this whenever the user asks a broader question that cannot be answered by a specific single page. Returns a concise answer synthesized from relevant docs. The raw provider response is included in _meta. Prefer this before guessing. If a specific page is needed call getLangfuseDocsPage first.

Input schema:

```json
{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "The user's question in natural language. Include helpful context like SDK/language (e.g., Python v3, JS v4), self-hosted vs cloud, and short error messages (trim long stack traces). Keep under ~600 characters."
    }
  },
  "required": [
    "query"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "searchLangfuseDocs",
    "arguments": {
      "query": "string"
    }
  }
}
```

##### `getLangfuseDocsPage`

Fetch the raw Markdown for a single Langfuse docs page. Accepts a docs path (e.g., /docs/observability/overview) or a full https://langfuse.com URL. Returns the exact Markdown (may include front matter). Use when you need a specific page content (Integration, Features, API, etc.) or code samples. Prefer searchLangfuseDocs for broader questions where there is not one specific page about it. Changelog pages (/changelog/...) are historical release notes: use them only to confirm that a feature exists or when it shipped, not as an implementation reference. Their code samples reflect the SDK/API at release time and may be outdated, so for implementation follow the current docs and the API/SDK reference instead.

Input schema:

```json
{
  "type": "object",
  "properties": {
    "pathOrUrl": {
      "type": "string",
      "description": "Docs path starting with \"/\" (e.g., /docs/observability/overview) or a full URL on https://langfuse.com. Do not include anchors (#...) or queries (?foo=bar) — they will be ignored."
    }
  },
  "required": [
    "pathOrUrl"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getLangfuseDocsPage",
    "arguments": {
      "pathOrUrl": "string"
    }
  }
}
```

##### `getLangfuseOverview`

Get a high-level, machine-readable index by downloading https://langfuse.com/llms.txt. Use this at the start of a session when needed to discover key docs endpoints or to seed follow-up calls to searchLangfuseDocs or getLangfuseDocsPage. Returns the plain text contents of llms.txt. Avoid repeated calls within the same session.

Input schema:

```json
{
  "type": "object",
  "properties": {},
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
```

Generated example request:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "getLangfuseOverview",
    "arguments": {}
  }
}
```

