Skip to main content

​
Getting Started

  1. Connect your data sources - Choose between connecting your observability stack (Grafana, Prometheus, etc.) or deploying the NOFire AI Kubernetes agent
  2. Configure integrations - Set up Slack bot for alerts and incident response
  3. Set up MCP (optional) - Connect your IDE for proactive deployment risk assessment
Check out the Quickstart guide for step-by-step instructions.
Both options work, but they have different trade-offs:Connect to Observability Stack:
  • Fast and effective setup
  • No agent deployment required
  • Works with existing tools (Grafana, Prometheus, Datadog, etc.)
Kubernetes In-Cluster Agent:
  • Higher causality precision
  • Deeper infrastructure visibility
  • Captures cluster topology in real-time
Recommendation: Start with observability stack connection for quick wins. Add the Kubernetes agent later for enhanced causal analysis.
Immediately! Once you connect your data sources, NOFire AI starts building the knowledge graph and is ready to analyze incidents and assess deployment risk right away.The causal graph continuously improves as NOFire AI observes your environment over time, but you don’t need to wait for an initial learning period.

​
Proactive Reliability

Before you deploy code changes, NOFire AI analyzes:
  • Which production services are affected by your changes
  • Blast radius (what else could break if this fails)
  • Dependency chains and critical services in the path
  • Historical stability patterns
You get a risk score (low/medium/high) and a deployment strategy recommendation (standard rollout, canary, or staged deployment).Learn more about Proactive Reliability
NOFire AI shifts reliability left by integrating with your IDE (Cursor, Claude Desktop) via MCP. Before merging code:
  1. Assess risk - Analyze which services your changes affect
  2. Understand impact - See blast radius and dependency chains
  3. Get guidance - Receive clear deployment strategy based on risk level
  4. Make informed decisions - Deploy confidently with canary/staged rollouts for high-risk changes
This catches risky deployments before they reach production, not after they break things.

​
Investigations & Root Cause Analysis

NOFire AI combines Causal AI (understanding cause-and-effect relationships) with GenAI (natural language reasoning) to deliver high-accuracy root cause analysis.How it works:
  1. Causal Graph - Builds a real-time model of your infrastructure dependencies and relationships
  2. Change Detection - Identifies what changed (deployments, config updates, scaling events)
  3. Impact Analysis - Traces causality through the dependency graph
  4. Pattern Recognition - Compares against known failure patterns and past incidents
  5. Hypothesis Generation - Ranks probable root causes with confidence scores
This goes beyond correlation to find the actual cause, not just symptoms. The result: accurate root cause identification within minutes instead of hours of dashboard hunting.
NOFire AI seamlessly integrates with triggering tools such as Grafana IRM and Slack. It automatically detects the alerted entity by analyzing alert labels and initiates a comprehensive automated root cause analysis.You can also manually trigger investigations from the dashboard or by asking the Slack bot to investigate a specific service.
Yes, all previous investigations are saved and accessible from the sessions list on the NOFire AI dashboard. You can revisit prior investigations to review findings and generate post-mortems.

​
Integration & Usage

Install the NOFire AI bot in your Slack workspace and invite it to your alert channels.Capabilities:
  • Automatic alert triage - Bot automatically analyzes alerts when they fire
  • Run investigations - Mention @NOFireAI bot to investigate incidents collaboratively
  • Query production - Ask questions like “What services depend on the payment API?” or “Show me recent changes to auth-service”
  • Deployment risk checks - Get risk assessments directly in Slack
Setup guide for Slack integration
Yes! NOFire AI works by connecting directly to your observability stack. You can use:
  • Monitoring: Grafana, Prometheus, Datadog, Dynatrace, New Relic
  • Logs: Loki, Elasticsearch, OpenSearch, CloudWatch
  • Traces: Tempo, Jaeger
The Kubernetes agent is optional and provides enhanced causality precision, but it’s not required to get started.
NOFire AI integrates with your existing observability stack:Metrics & Monitoring:
  • Grafana
  • Prometheus
  • Datadog
  • Dynatrace
  • New Relic
Logs:
  • Loki
  • Elasticsearch
  • OpenSearch
  • AWS CloudWatch
Traces:
  • Tempo
  • Jaeger
Alerts & Communication:
  • Slack
  • Grafana IRM
All integrations use read-only access and connect to your existing tools—no rip and replace required.See detailed setup guides in the Monitoring, Logs, and Traces sections.

​
IDE & MCP Integration

NOFire AI works with any IDE that supports Model Context Protocol (MCP):
  • Cursor - Full support with setup guide
  • Claude Desktop - Full support with setup guide
  • GitHub Copilot - Via MCP plugin
  • Other MCP-compatible tools - Any tool supporting MCP
Setup guide for MCP integration
With MCP integration, you can directly in your IDE:Before Deployment:
  • Assess deployment risk for code changes
  • Analyze blast radius and dependencies
  • Get deployment strategy recommendations
Production Knowledge:
  • Query service relationships and dependencies
  • Investigate incidents and recent changes
  • Onboard new engineers by exploring production architecture
  • Understand what changed recently in any service
All without leaving your editor or switching to dashboards.