# Plecto MCP

> Plecto connects your AI agent directly to your business intelligence platform, letting you manage KPIs, track performance, and orchestrate dashboards using natural conversation. You can use `list_kpi_dashboards` to see all active boards or use `create_data_registration` to feed new data points immediately. It’s built for BI teams who need real-time access to team structures and performance metrics.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** kpi-tracking, performance-management, real-time-data, gamification, data-visualization

## Description

You're done manually building reports and wrestling with dashboards. Plecto hooks your AI agent right into your business intelligence platform so you can manage KPIs, track performance data, and orchestrate complex metrics just by chatting with it. Your agent uses these tools to do the heavy lifting, letting you focus on what actually matters: making decisions.

### Dashboard Oversight and KPI Querying

Your agent handles dashboard queries two ways. If you want a bird's-eye view of everything set up, it runs **`list_kpi_dashboards`** to pull every active and configured KPI board name. Need the deep dive on one specific metric? It uses **`get_dashboard`** to retrieve all the granular details and metadata for that single dashboard you mention. When your agent pulls data from a widget, it's not guessing; it knows exactly which board it belongs to.

### Logging Live Performance Data

For real-time number crunching, your agent can feed live numbers directly into your KPIs using **`create_data_registration`**. This function lets you programmatically add a brand new data point to update an existing metric on any dashboard. If you're checking historical performance or need the full audit trail on a specific value, it runs **`list_data_registrations`** to give you a list of every stored data record and registration in Plecto. To see exactly what happened with one entry—the metadata, the history, everything—it hits **`get_registration`**. This whole system means your dashboards never show stale numbers.

### Understanding Your People and Teams

When it comes to resource management, your agent knows who's in the building. It uses **`list_organizational_teams`** to pull a complete list of all formal organizational teams within your account structure. If you need to know every single person under your Plecto umbrella, it runs **`list_account_employees`** to get that master roster. And if you're asking about one specific individual—say, 'Jane Doe' or an employee ID—it uses **`get_employee`** to fetch all their detailed information right away.

### Data Source and Formula Inspection

Your agent doesn't just pull numbers; it understands where the numbers come from. Before running any report, it can use **`list_data_sources`** to query and list every single configured data source available in your Plecto setup. This ensures that any reports generated are scoped correctly against the right feed. Furthermore, if a KPI is based on a complex calculation, you don't have to guess what formula was used. It runs **`list_formulas`** to pull a complete list of every custom KPI calculation formula deployed across your dashboards. Knowing these formulas lets your agent validate results and explain exactly how the number was calculated.

### How It Works With Your Agent

Your setup is simple: You subscribe to this server on Vinkius, and then you feed your Plecto API Token into your preferred AI client or agent. You don't write code; you just talk to it. You can ask things like, "What was the average sales metric for Q3?" or "Show me all the teams that report to Marketing." Your agent uses this toolkit—the **`list_kpi_dashboards`**, the **`get_employee`**, and the **`create_data_registration`** functions—to get the raw data, process it against your formulas, and present you with a clean answer. It's all conversational, always real-time, and built for BI teams who need immediate access to performance metrics and internal structure.

## Tools

### get_dashboard
Retrieves the specific details and metadata for one configured KPI dashboard.

### get_employee
Fetches detailed information about a single employee by name or ID.

### get_registration
Gets the full details and history for one specific data registration entry.

### list_formulas
Lists all the custom KPI calculation formulas used across your dashboards.

### list_widgets
Retrieves a list of every individual widget component on a specified dashboard.

### create_data_registration
Adds a new data point to update an existing metric on your dashboard.

### list_kpi_dashboards
Retrieves a list of every active and configured KPI dashboard available for monitoring.

### list_data_sources
Queries and lists every configured data source available in your Plecto setup.

### list_account_employees
Retrieves a list of all employees managed under your Plecto account.

### list_data_registrations
Lists all historical data records and registrations stored in Plecto.

### list_organizational_teams
Lists all formal organizational teams within your account structure.

## Prompt Examples

**Prompt:** 
```
List all my KPI dashboards in Plecto.
```

**Response:** 
```
I've retrieved your dashboards. You have 5 active KPI boards, including 'Sales Team Overview' and 'Customer Support Live'.
```

**Prompt:** 
```
Show me the sales leaderboard for the current month with all team member performance metrics.
```

**Response:** 
```
Sales leaderboard for May 2025. Top performer: Sarah Chen with $127,400 in closed revenue (142% of target). Second: James Park at $98,200 (109%). Third: Lisa Wang at $87,600 (97%). Team average: $72,300. Total team revenue: $578,400 against a $600,000 target (96.4%). 3 team members are below 80% of their individual targets. The "Enterprise Deals" data source was last synced 15 minutes ago.
```

**Prompt:** 
```
Register a new data point for Sarah Chen with $45,000 in closed deals today on the Revenue data source.
```

**Response:** 
```
Data registration created successfully. Employee: Sarah Chen. Data source: Revenue. Value: $45,000. Date: May 13, 2025. This brings Sarah's monthly total to $172,400 (191% of target). She is now #1 on the leaderboard. The dashboard widgets have been updated automatically and a notification was sent to her team manager. Achievement badge "Top Closer" triggered.
```

## Capabilities

### Querying KPI Dashboards
The server retrieves metadata for existing dashboards (`list_kpi_dashboards`) or fetches specifics about a single board using `get_dashboard`.

### Logging Performance Data
You can programmatically add new data entries to feed KPIs directly into the system via `create_data_registration`.

### Managing Organizational Structure
The server lists all teams and employees (`list_organizational_teams`, `list_account_employees`) so your agent knows who's in the company.

### Inspecting Data Sources
You can list available data sources using `list_data_sources` to ensure your queries are scoped correctly before running any reports.

## Use Cases

### End-of-Month Reporting
The Project Lead just closed a big deal. Instead of logging into Plecto's interface to manually update the 'Revenue' metric, they tell their agent: 'Run `create_data_registration` for Sarah Chen with $127k in revenue.' The system logs it, updates the dashboard widget, and sends a notification automatically.

### Auditing Dashboard Health
The BI Analyst needs to know if a specific KPI board is still active or if widgets are broken. They ask their agent to use `list_kpi_dashboards`, then select the troubled dashboard and run `list_widgets` to see exactly what components need fixing.

### Onboarding New Team Members
The Operations Manager needs to confirm if a new hire, Jane Doe, is assigned to the correct department. They ask their agent to use `get_employee` for Jane's details and then check `list_organizational_teams` to verify her placement against current resource limits.

### Verifying Data Scope
The Data Scientist is building a new report but isn't sure if the 'Client Address' data source is available. They run `list_data_sources` first, confirm its status, and then use `get_registration` to check the last time valid data was pulled.

## Benefits

- Automated Data Logging: Instead of manually updating spreadsheets, use `create_data_registration` to feed real-time numbers directly into your KPIs. Your agent handles the API call, and the dashboard updates instantly.
- Total Dashboard Visibility: Need to know what boards exist? Running `list_kpi_dashboards` gives you an immediate inventory of every KPI board without clicking through multiple menus.
- People Lookup on Demand: Stop asking HR or your teammates for employee directories. Use `list_account_employees` and `get_employee` to pull specific contact details or roles instantly when needed.
- Contextual Data Scope: Before querying anything, run `list_data_sources`. This ensures your agent knows exactly which data set it's pulling from, preventing bad reports based on wrong context.
- Team Structure Mapping: Quickly check who belongs where. Running `list_organizational_teams` gives you the full team breakdown, letting you manage access and resource allocation in one prompt.

## How It Works

The bottom line is: You connect your existing BI platform to conversational AI so you can treat complex data tasks like sending a Slack message.

1. First, subscribe to the Plecto MCP Server and get your API Token from your Plecto account.
2. Next, paste that token into your preferred AI client (Claude, Cursor, etc.)'s settings.
3. Finally, tell your agent what you need—like 'Show me all KPI dashboards for Q2,' and it runs the necessary tools.

## Frequently Asked Questions

**How do I find out what KPI dashboards are available using list_kpi_dashboards?**
You tell your agent to run `list_kpi_dashboards`. It will give you a full, current list of every dashboard configured in Plecto, letting you know exactly which metrics exist.

**Can I update the board with create_data_registration?**
Yes. `create_data_registration` lets your agent log a new data point (like closed revenue) and immediately feed it into the dashboard, updating the widgets in real time.

**What is the difference between list_account_employees and get_employee?**
`list_account_employees` gives you a full directory—a list of every person. `get_employee` requires you to pinpoint one specific person so your agent can pull their exact details.

**Does the server help me track data sources with list_data_sources?**
It does. Running `list_data_sources` shows every context available in Plecto, making sure you and your agent know exactly which source is feeding which numbers.

**If I use `list_formulas`, how do I get the actual calculation logic for a specific KPI?**
The server lists all available KPI formulas. To see the detailed logic, you must then pass the formula ID to the dedicated metadata endpoint (reference the documentation). This reveals exactly which data sources and metrics feed into that calculation.

**What does `list_widgets` show me? Can I figure out how a dashboard is built?**
`list_widgets` gives you an inventory of every component on a given board. It lists the widget type (e.g., chart, gauge) and which data source it pulls from. This helps map the entire dashboard structure.

**What’s the practical difference between calling `list_data_registrations` and using `get_registration`?**
Calling `list_data_registrations` shows you a summary list of all your data entries. You need `get_registration` when you want to pull the full, granular details—like timestamps or metadata fields—for one specific record.

**If I run a complex action like `create_data_registration`, how does the server handle API token expiration or bad data?**
The server validates your connection credentials immediately. If the API token is expired or invalid, the call fails instantly with an authentication error code before any action happens. Bad data formats will trigger a specific validation failure.

**Can I add a new data registration using my AI agent?**
Yes! Use the `create_data_registration` action. Provide the Data Source ID along with your data fields to feed your dashboard programmatically.