list-widgets
/list-widgets
This skill should be used when the user wants to list existing dashboard widgets in a Langfuse project, show widgets, see what widgets exist, get a widget inventory, or understand which widgets are deployed on which dashboards. Trigger phrases include "list widgets", "show widgets", "existing widgets", "what widgets exist", and "widget inventory". This is a shared skill used by both the data-explorer and widget-manager agents.
- Author
- alex-kopylov ↗
- Repository
- zweihander ↗
- Licence
- Apache-2.0
- Last repository change
- 19.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 19.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
This skill should be used when the user wants to list existing dashboard widgets in a Langfuse project, show widgets, see what widgets exist, get a widget inventory, or understand which widgets are deployed on which dashboards. Trigger phrases include "list widgets", "show widgets", "existing widgets", "what widgets exist", and "widget inventory". This is a shared skill used by both the data-explorer and widget-manager agents.
Triggers from the description
Original author description
This skill should be used when the user wants to list existing dashboard widgets in a Langfuse project, show widgets, see what widgets exist, get a widget inventory, or understand which widgets are deployed on which dashboards. Trigger phrases include "list widgets", "show widgets", "existing widgets", "what widgets exist", and "widget inventory". This is a shared skill used by both the data-explorer and widget-manager agents.
How it works
- Prerequisites
- Step 1: Query All Widgets
- Step 2: Query All Dashboards
- Step 3: Cross-Reference Widgets to Dashboards
- Step 4: Format Output
- Execution Methods
- Output Interpretation
- Error Handling
SKILL.md preview
---
name: list-widgets
description: >-
This skill should be used when the user wants to list existing dashboard
widgets in a Langfuse project, show widgets, see what widgets exist, get a
widget inventory, or understand which widgets are deployed on which dashboards.
Trigger phrases include "list widgets", "show widgets", "existing widgets",
"what widgets exist", and "widget inventory". This is a shared skill used by
both the data-explorer and widget-manager agents.
---
# List Dashboard Widgets
Retrieve dashboard widgets from a Langfuse project and their dashboard associations by querying PostgreSQL directly, since no public REST API endpoint lists widgets.
## Prerequisites
Ensure these credentials are available:
- **Project ID** -- the Langfuse project identifier (visible in the URL path)
- **Database connection** -- either a PostgreSQL connection string or Docker container access
## Step 1: Query All Widgets
Run this SQL query against Langfuse PostgreSQL to retrieve project widgets:
```sql
SELECT dw.id, dw.name, dw.view, dw.chart_type, dw.created_at
FROM dashboard_widgets dw
WHERE dw.project_id = '{PROJECT_ID}'
ORDER BY dw.created_at DESC;
```
This returns every widget in the project regardless of whether it is placed on a dashboard.
## Step 2: Query All Dashboards
Retrieve all dashboards and their widget placement definitions:
```sql
SELECT d.id, d.name, d.definition
FROM dashboards d
WHERE d.project_id = '{PROJECT_ID}';
```
The `definition` column is JSON with a `widgets` array; each entry has a `widgetId` referencing `dashboard_widgets.id`.
## Step 3: Cross-Reference Widgets to Dashboards
Parse each dashboard's `definition` JSON and extract `widgetId` values from `widgets`:
```python
import json
# dashboard_rows: list of (id, name, definition) tuples from Step 2
widget_to_dashboards: dict[str, list[str]] = {}
for dashboard_id, dashboard_name, definition_json in dashboard_rows:
definition = json.loads(definition_json) if isinstance(definition_json, str) else definition_json
widgets = definition.get("widgets", [])
for widget_entry in widgets:
widget_id = widget_entry.get("widgetId")
if widget_id:
widget_to_dashboards.setdefault(widget_id, []).append(dashboard_name)
```
Map each widget ID to its dashboard names. Flag widgets not referenced by any dashboard as orphaned.
## Step 4: Format Output
Present a table combining widget metadata and dashboard associations:
```
| ID | Name | View | Chart Type | Dashboards |
|----|------|------|------------|------------|
| clxxxxxxxx... | Avg Latency by Model | OBSERVATIONS | HORIZONTAL_BAR | Main Dashboard, Ops |
| cmm77s7yv... | Score Trend | SCORES_NUMERIC | LINE_TIME_SERIES | Main Dashboard |
| cmm88t8zw... | Orphaned Widget | TRACES | PIE | (none) |
```
Use full CUIDs in the ID column. Mark widgets on zero dashboards with `(none)`.
## Execution Methods
### Preferred: psycopg2 Python Script
Write and run a Python script that connects to the database, runs both queries, cross-references results, and prints the table:
```python
import json
import psycopg2
CONNECTION_STRING = "postgresql://user:pass@host:port/dbname"
PROJECT_ID = "your_project_id"
conn = psycopg2.connect(CONNECTION_STRING)
cur = conn.cursor()
# Fetch widgets
cur.execute(
"SELECT id, name, view, chart_type, created_at "
"FROM dashboard_widgets WHERE project_id = %s "
"ORDER BY created_at DESC",
(PROJECT_ID,),
)
widgets = cur.fetchall()
# Fetch dashboards
cur.execute(
"SELECT id, name, definition "
"FROM dashboards WHERE project_id = %s",
(PROJECT_ID,),
)
dashboards = cur.fetchall()
conn.close()
# Build widget-to-dashboard mapping
widget_to_dashboards: dict[str, list[str]] = {}
for _dash_id, dash_name, definition in dashboards:
defn = json.loads(definition) if isinstance(definition, str) else definition
for entry in defn.get("widgets", []):
wid = entry.get("widgetId")
if wid:
widget_to_dashboards.setdefault(wid, []).append(dash_name)
# Print table
print(f"{'ID':<30} {'Name':<35} {'View':<22} {'Chart Type':<22} {'Dashboards'}")
print("-" * 140)
for widget_id, name, view, chart_type, created_at in widgets:
dash_names = widget_to_dashboards.get(widget_id, [])
dash_str = ", ".join(dash_names) if dash_names else "(none)"
print(f"{widget_id:<30} {name:<35} {view:<22} {chart_type:<22} {dash_str}")
```
Install `psycopg2-binary` if not already available:
```bash
uv add psycopg2-binary
```
### Fallback: docker exec psql
If psycopg2 is unavailable or the database is only reachable from within a Docker container, run the widget query via `docker exec`:
```bash
docker exec {CONTAINER_NAME} psql -U {DB_USER} -d {DB_NAME} -c \
"SELECT dw.id, dw.name, dw.view, dw.chart_type, dw.created_at \
FROM dashboard_widgets dw \
WHERE dw.project_id = '{PROJECT_ID}' \
ORDER BY dw.created_at DESC;"
```
Then run the dashboard query separately:
```bash
docker exec {CONTAINER_NAME} psql -U {DB_USER} -d {DB_NAME} -c \
"SELECT d.id, d.name, d.definition \
FROM dashboards d \
WHERE d.project_id = '{PROJECT_ID}';"
```
Parse the psql output manually for cross-referencing. JSON output from psql may require careful handling of escaping and line breaks.
## Output Interpretation
- **Orphaned widgets** (Dashboards = `(none)`) exist in the database but are not visible on any dashboard. They can be added to a dashboard using the `manage-dashboard` skill or deleted using the `delete-widget` skill.
- **Widgets on multiple dashboards** are shared -- modifying the widget config affects all dashboards that display it.
- **View column** indicates the data source: `TRACES`, `OBSERVATIONS`, `SCORES_NUMERIC`, or `SCORES_CATEGORICAL`.
- **Chart Type column** indicates the visualization: `LINE_TIME_SERIES`, `BAR_TIME_SERIES`, `HORIZONTAL_BAR`, `VERTICAL_BAR`, `PIE`, `NUMBER`, `HISTOGRAM`, or `PIVOT_TABLE`.
## Error Handling
- **Connection refused**: Verify the database connection string or Docker container name. Ensure the database is running and accessible.
- **Permission denied**: Check that the database user has SELECT privileges on `dashboard_widgets` and `dashboards` tables.
- **Empty results**: The project may have no widgets yet. Confirm the `PROJECT_ID` is correct by checking it against the Langfuse URL.
- **Malformed definition JSON**: If a dashboard's `definition` column contains invalid JSON, report the dashboard ID and name so the user can investigate manually.
Versions
The database has no other skills named list-widgets.
Database snapshot: 13.11.2026 · package version 4471640f1d56 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 1 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100suggest-widgets
This skill should be used when the user wants recommendations for meaningful Langfuse dashboard visualizations based on available data. Trigger phrases include "suggest widgets", "recommend visualizations", "what should I visualize", "widget suggestions", "dashboard… - 100create-widget
This skill should be used when the user wants to create a new Langfuse dashboard widget. Trigger phrases include "create widget", "add widget", "new visualization", "create chart", "add chart to dashboard". It handles ID generation, schema validation, SQL insertion, and… - 100widget
Create, update, hide, show, list, and delete Übersicht desktop widgets on macOS. Use this skill whenever the user asks for desktop widgets, desktop gadgets, or widgets. - 100cx-search-dashboard
This skill should be used when the user asks to "find a dashboard", "search dashboards", "does a dashboard exist for X", "find widgets that query Y", "which dashboards use this field", "find a dashboard about errors", "look up dashboards by description", "search for existing… - 100dashboard-widgets
Author a dashboard widget — a small React component backed by named LangWatchQL queries — from a plain question. Discovers the analytics schema, writes the queries, writes the widget file, saves it, then proves it renders. Use when asked to build, prototype, or iterate on a… - 100orchardcore-widgets
Skill for creating and managing widgets in Orchard Core. Covers widget content types, zones, layers, layer rules, widget placement configuration, Widget shape templates and wrappers, safe rendering of widget HTML, and ManageLiquidTemplates for Liquid widgets. Use this skill when…