Building an Autonomous AI Incident Knowledge Engine with Cognee and Uptime Kuma

In modern infrastructure management, keeping services online is only half the battle. When downtime, degraded performance, or cascading outages occur, engineering teams scramble across alert histories, heartbeat charts, and incident post-mortems to understand what failed, when, and why.

While monitoring tools like Uptime Kuma (with over 65,000+ GitHub stars) excel at real-time alerting, health-checking, and status-page communication, their historical telemetry often remains locked in transient time-series logs and relational tables.

Enter Cognee: an open-source, AI-native memory engine that transforms unstructured text, logs, and relational data into interconnected knowledge graphs and vector databases.

In this guide, we introduce the Uptime Kuma Cognee Community Connector, enabling autonomous LLMs, triage agents, and site reliability engineers (SREs) to query, reason over, and correlate infrastructure incidents using natural language.

---

Why Connect Uptime Kuma to Cognee?

Integrating Uptime Kuma telemetry into Cognee's memory graph unlocks several high-leverage capabilities:

1. Incident Post-Mortem & Timeline Synthesis: Automatically generate root-cause summaries by correlating heartbeat latency spikes, HTTP error codes, and maintenance windows.
2. Context-Aware Alert Triage: When a critical service degrades, LLM agents can query Cognee memory to determine: "Has this endpoint timed out before during scheduled maintenance, or did it coincide with a specific deployment?"
3. Automated Status Page Summaries: Ingest public status pages and incident announcements into conversational AI assistants for customer support and engineering teams.
4. Self-Healing Infrastructure: Power autonomous troubleshooting agents that inspect monitor topologies, analyze failure trends, and suggest remediation steps before incidents escalate.

---

Architectural Deep Dive

The Uptime Kuma connector is designed to be resilient, modular, and privacy-first:

• Full Data Ingestion:
  • Monitors: Health check types (http, ping, port, dns, keyword), target URLs/hosts, check intervals, retry strategies, and active tags.
  • Heartbeats: Ping latency metrics, response codes, downtime durations, and error descriptions.
  • Incidents & Status Pages: Published incident timelines, maintenance windows, and status-page service groups.
• Cognee Pipeline Integration:
  • Sets DOCUMENT_SOURCE_ATTR = "uptime_kuma" on all emitted documents, ensuring seamless processing through Cognee's cognify() pipeline.
  • Employs write_disposition="replace", ensuring orphan records are cleaned up when monitors are reconfigured or resolved.
  • Generates deterministic uuid5 document IDs based on monitor IDs and slug identifiers, preventing duplicate nodes in the knowledge graph.
• Enterprise-Grade Reliability:
  • Exponential backoff with jitter on HTTP 429 and 5xx responses.
  • Automatic credential and token sanitization in all debug log outputs.
  • Clean Markdown document generation structured for optimal chunking and embedding retrieval.

---

Quickstart Guide

1. Installation

Install Cognee and the community Uptime Kuma connector:

pip install cognee cognee-community-connector-uptime-kuma

Or using uv:

uv add cognee cognee-community-connector-uptime-kuma

2. Basic Usage

Run the connector to ingest your monitors and status pages into Cognee memory:

import asyncio
import os
import cognee
from cognee_community_connector_uptime_kuma import (
    UptimeKumaConfig,
    uptime_kuma_connector,
)

async def main():
    # Configure your Uptime Kuma instance
    config = UptimeKumaConfig(
        api_url=os.getenv("UPTIME_KUMA_URL", "https://uptime.example.com"),
        api_key=os.getenv("UPTIME_KUMA_API_KEY", "your-api-key"),
        slug="main-status", # Optional status page slug
        heartbeat_limit=50,
    )

    print("Fetching Uptime Kuma telemetry...")
    documents = await uptime_kuma_connector(config)
    print(f"Generated {len(documents)} incident & monitor reports.")

    # Ingest into Cognee Memory
    print("Ingesting into Cognee...")
    await cognee.add(documents, dataset_name="infrastructure_telemetry")
    await cognee.cognify(dataset_name="infrastructure_telemetry")

    # Natural Language Incident Reasoning
    query = "Which services experienced downtime or high latency in the last 24 hours?"
    print(f"\nQuerying Cognee: '{query}'")
    results = await cognee.search(query, dataset_name="infrastructure_telemetry")

    for result in results:
        print(f"\nMemory Result: {result}")

if __name__ == "__main__":
    asyncio.run(main())

---

What Does Ingested Memory Look Like?

The connector parses complex JSON telemetry into structured markdown documents tailored for vector similarity and graph extraction:

# Uptime Kuma Status Page: Production Infrastructure (main-status)

**Description**: Live public status for core APIs, auth services, and databases.

## Services & Monitors
- **Primary API Gateway** (HTTP Monitor)
  - Target: `https://api.internal.network/health`
  - Current Status: UP
  - Interval: 60s
  - Average Latency: 42ms

## Recent Incident Log
- **2026-10-23 14:15 UTC**: Elevated Latency on Auth Cluster
  - Status: Resolved
  - Impact: Response times peaked at 1,450ms before auto-scaling engaged.

When Cognee processes this markdown through cognify(), it constructs knowledge graph nodes representing:

• Services (e.g., Primary API Gateway, Auth Cluster)
• Incidents (e.g., Elevated Latency on Auth Cluster)
• Relationships (e.g., Auth Cluster -> EXPERIENCED -> Elevated Latency, Auth Cluster -> RESOLVED_BY -> Auto-scaling)

This enables downstream AI agents to uncover hidden failure patterns across distinct services and cloud providers.

---

Open Source & Community

The Uptime Kuma connector is an open-source contribution to the Cognee Community ecosystem.

• Cognee Core: https://github.com/topoteretes/cognee
• Community Connectors: https://github.com/topoteretes/cognee-community
• Uptime Kuma: https://github.com/louislam/uptime-kuma

Try it out today to bring intelligent incident memory to your observability stack!