# Coralogix MCP

> Coralogix lets you manage your entire observability stack from a natural conversation. You can ingest logs with specific metadata, set system reliability goals using SLOs, create or update Grafana dashboards, and track deployment versions—all without leaving your chat window.

## Overview
- **Category:** devops-cicd
- **Price:** Free
- **Tags:** observability, log-analytics, slo-tracking, grafana-dashboards, tco-optimization

## Description

You're already watching logs in Coralogix, but managing the underlying rules, costs, and metrics still requires jumping between consoles. This MCP lets you take control of those core observability functions using only natural language commands. You can send application logs with custom severity levels and metadata instantly. Want to update your dashboards? You can search for existing Grafana views or create entirely new ones on the fly. Need to keep an eye on costs? Programmatically manage Total Cost of Ownership overrides, ensuring you're not paying too much just because a log volume spiked overnight. If your workflow needs this kind of deep control over logging and metrics, connecting through Vinkius is the simplest way to get it working with any AI client.

## Tools

### get_rules
Get all parsing rules

### get_tco_overrides
Get all TCO policy overrides

### list_custom_enrichments
List custom enrichments

### list_slos
List all SLOs

### search_grafana_dashboards
Search hosted Grafana dashboards

### create_rule_group
Create a parsing rule group

### create_slo
Create a Service Level Objective (SLO)

### create_tco_override
Create a TCO policy override

### send_logs
Provide an array of log objects.

Send logs to Coralogix

### create_version_tag
Create a version tag

### delete_custom_enrichment
Delete a custom enrichment

### delete_rule_group
Delete a parsing rule group

### delete_slo
Delete an SLO

### delete_tco_override
Delete a TCO policy override

### get_grafana_home
Get hosted Grafana home dashboard

### get_rule_group
Get a specific parsing rule group

### create_grafana_dashboard
Create or update a hosted Grafana dashboard

## Prompt Examples

**Prompt:** 
```
List all log parsing rules currently active in Coralogix.
```

**Response:** 
```
I've retrieved your parsing rules. You have 3 active rule groups: 'JSON-Parser', 'Nginx-Logs', and 'Security-Events'. Would you like to see the details of a specific group?
```

**Prompt:** 
```
Search for Grafana dashboards related to 'Kubernetes'.
```

**Response:** 
```
Searching... I found 2 dashboards: 'K8s Cluster Health' and 'Pod Resource Usage'. Which one would you like to inspect?
```

**Prompt:** 
```
Create a version tag named 'v2.4.0' for the 'Payment-Service' application.
```

**Response:** 
```
The version tag 'v2.4.0' has been successfully created for 'Payment-Service'. This deployment is now marked in your Coralogix timeline.
```

## Capabilities

### Stream logs into Coralogix
Send arrays of log objects directly to Coralogix while specifying severity levels and metadata.

### Define Service Level Objectives (SLOs)
Programmatically create, list, or delete SLOs, ensuring your system's reliability metrics are always monitored.

### Manage data parsing rules
Retrieve, create, or delete entire groups of log parsing rules to restructure how Coralogix interprets incoming data.

### Control Grafana dashboards
Search for existing hosted Grafana dashboards or generate and update full dashboard configurations.

### Optimize log storage costs
Manage Total Cost of Ownership (TCO) policy overrides to save money on long-term log retention.

### Track deployments and releases
Mark specific versions or deployments using version tags, tying system behavior directly back to code changes.

## Use Cases

### Diagnosing a performance regression
A developer notices slow query times. They ask their agent: 'What happened after the v2.3 release?' The agent uses `create_version_tag` to mark that deployment, then sends logs using `send_logs`, letting them immediately see all high-latency errors correlated with the specific version.

### Adjusting logging costs
The SRE team is over budget due to excessive retention on certain log types. They instruct their agent to 'Apply a cheaper storage rule for logs older than 90 days.' The MCP executes `create_tco_override`, saving the company money without manual console work.

### Building a new service dashboard
A team needs visibility into microservice health. Instead of manually configuring Grafana, they ask their agent to 'Create a dashboard for Payment-Service metrics.' The MCP uses `create_grafana_dashboard` and populates the view instantly.

### Auditing compliance requirements
An auditor requires proof of system reliability goals. Instead of exporting data, they ask the agent to 'List all active SLOs.' The MCP calls `list_slos` and provides a clean, structured list for immediate review.

## Benefits

- Stop context switching. Instead of jumping between the log view, Grafana, and a separate cost dashboard to check an SLO, you manage all these elements in one conversation with your agent.
- Pinpoint deployment impact instantly. When something breaks, use `create_version_tag` to mark the release, then query logs using `send_logs` to see exactly what changed when the system started acting up.
- Save money on log retention without manual effort. Use `get_tco_overrides` and `create_tco_override` to programmatically manage how long certain data streams are kept, optimizing your costs instantly.
- Build complex dashboards faster. You can search for existing views with `search_grafana_dashboards` or tell the agent to build a whole new dashboard using `create_grafana_dashboard`, skipping manual setup time.
- Maintain system health goals easily. Defining and checking SLOs is critical; you can use `list_slos` and `create_slo` to keep your reliability metrics accurate without needing platform admin access.

## How It Works

The bottom line is that your AI client handles all the API calls so you don't have to leave your chat window or open multiple consoles.

1. First, subscribe your AI client to this MCP and provide your Coralogix API Key and Domain.
2. Next, you tell the agent what needs doing—for example, 'List all SLOs' or 'Search for K8s dashboards'.
3. The agent executes the request against Coralogix and returns structured data, letting you act on it immediately.

## Frequently Asked Questions

**How do I use the Coralogix MCP to check my current SLO status?**
You simply ask your agent to list all Service Level Objectives. The agent uses `list_slos` and returns a comprehensive list, showing which services are meeting their reliability goals right now.

**Can the Coralogix MCP help me create dashboards?**
Yes, it can. You tell your agent what you need, and they use `create_grafana_dashboard` to build or update a dashboard configuration for you directly from the chat.

**Does Coralogix MCP handle log ingestion?**
It does. Use `send_logs` to provide an array of logs and metadata, sending them instantly into your Coralogix account without needing a separate upload tool.

**What is the difference between get_rules and create_rule_group in Coralogix MCP?**
`get_rules` just shows you what rules are active. You use `create_rule_group` when you need to build a new, structured collection of parsing rules for incoming data.

**If I update my code, how do I track it with the Coralogix MCP?**
Use the `create_version_tag` tool. This marks the system with your specific version name, allowing you to correlate any log spike or performance drop directly back to that exact deployment.