Repository navigation
Description
Update: implemented in topoteretes/cognee-community#397. Its description lists where the code differs from this plan.
Problem Statement
cognee has five data-source connectors (confluence, gmail, google-drive, notion, slack) and open issues for Grafana (#4779), Datadog (#4549), New Relic (#4780) and Honeycomb (#4781). There is nothing for Prometheus. A search of issues and PRs across cognee, cognee-community and cognee-integrations turns up no connector, issue or proposal for it.
A Prometheus server holds a small layer that people write by hand: alerting rules with their summary, description and runbook_url annotations, and recording rules. That is where a team writes down what "broken" means for each service. An agent using cognee can't see any of it today.
This proposal ingests no samples and runs no queries. It is also unrelated to cognee's own OpenTelemetry export, which sends cognee's telemetry out. This reads a team's rules in.
Proposed Solution
Add a prometheus connector under packages/connector/prometheus/ in cognee-community, following the Notion connector's shape and built on dlt's declarative rest_api source.
- Auth: none by default, since a stock Prometheus has none. Optional basic auth, bearer token and extra headers for servers behind a proxy. The base URL may include a path prefix.
- Ingest: alerting and recording rules from
GET /api/v1/rules, one document per rule: name, group, file, expression,for, labels and annotations. Metric help text from/api/v1/metadatais opt-in and off by default. - Incremental sync: Prometheus has no change feed or modified-since for rules, so each run reads the whole rule list in one request. Unchanged rules keep the same content hash and cognee does not re-cognify them. This is the full-snapshot model Hackathon [Feature]: Add incremental sync to the Notion connector #4820 describes for Notion, without its read cost, because the rule list is a single call.
- Forget-on-delete:
write_disposition="replace". A rule removed from the server drops out of the snapshot and orphan cleanup forgets it.
Watch out for:
- The rules response mixes definitions with runtime state. Two reads of https://prometheus.demo.prometheus.io/api/v1/rules a few seconds apart differ only in
evaluationTimeandlastEvaluation.stateandalertschange when an alert fires, andhealthandlastErrorwhen an evaluation fails. Rows are built from an allowlist of definition fields, so an unchanged server produces identical rows. - Rules have no id, and a rule name can repeat inside a group. On that demo server five alert names appear twice in the
node-exportergroup, once per severity. The row id is a hash of file, group, type, name and labels. - Under
replace, a failed or partial response would make cognee forget real rules. Any non-2xx status, non-JSON body orstatusother thansuccessaborts the run.
Alternatives Considered
-Samples or PromQL query results. Out of scope: #4549 already says raw metrics "answer nothing a knowledge graph is good at".
- Active alerts from
/api/v1/alerts. The endpoint returns only what is pending or firing right now, so every sync would rewrite it. - Getting rules through the Grafana connector in Hackathon [Feature]: Add Grafana data-source connector #4779. That issue covers dashboards, panel titles and annotations through Grafana's API. Prometheus rules live on the Prometheus server
Use Case
My upstream work is in metrics code: a merged change in OpenTelemetry Go's Prometheus exporter (PR 7866 in open-telemetry/opentelemetry-go) and one in kubernetes-sigs/resource-state-metrics (PR 102), which generates Prometheus metrics for Kubernetes custom resources. The question that comes up around alerts is what they mean: what a given alert checks, what its runbook says, which service it pages for, and which rules use a given metric. The answers are written in rule annotations and expressions, and this connector would put them where an agent can recall them.
Implementation Ideas
packages/connector/prometheus/
├── README.md
├── cognee_community_connector_prometheus/
│ ├── __init__.py
│ └── prometheus.py
├── examples/
├── tests/
└── pyproject.toml
- One
prometheus_source(base_url, ...)factory returning arest_apisource:single_pagepaginator,data_selector: "data.groups", and a processing step that emits one row per rule with the group's name and file copied in. - Rows carry
id,titleandcontent, withDOCUMENT_SOURCE_ATTRset, so each rule goes through cognify as a document. - Offline tests on recorded responses: two captures of an unchanged server give identical rows, an edited rule changes exactly one row, a removed rule removes its row, and a 503 or truncated body raises.
- The first version claims Prometheus itself. Mimir, Thanos and VictoriaMetrics serve a compatible rules API with their own differences (path prefix, tenant header, missing parameters). I'd list them as untested.
Additional Context
Acceptance criteria, in the shape of the other connector issues:
- A user points the connector at a Prometheus base URL, with optional credentials, and selects what to ingest
- Rules are ingested and searchable in cognee
- A re-sync re-processes only rules whose definition changed
- A rule removed from Prometheus is removed from the graph on the next sync
- README with setup steps and a runnable example under
examples/ - Tests covering the ingest path, determinism and removal
Testing against a real server: a Prometheus I run locally in Docker (prom/prometheus) with a rules file I control, so I can edit a rule, remove a rule and reload between syncs. For a larger real rule set I'd also read the public demo server at prometheus.demo.prometheus.io, read-only.
@NMZivkovic I'd like to build this for Mergetober. If it fits, could you add the INTEGRATIONS and hackathon labels? My assignment request is in the first comment.
Pre-submission Checklist
- I have searched existing issues to ensure this feature hasn't been requested already
- I have provided a clear problem statement and proposed solution
- I have described my specific use case
Activity
itssaharsh commentedon Oct 6, 2026
Hi @NMZivkovic, I'd like to work on this one for Mergetober.
How I'd build it:
rest_apisource. One request,GET /api/v1/rules, with/api/v1/metadataas an opt-in. No auth by default, optional basic or bearer.for, labels, annotations) so runtime fields never change the content hash. Full snapshot withreplace, so a removed rule is forgotten on the next sync.prom/prometheus) with a rules file I control, so I can edit a rule, remove a rule and reload between syncs. For a larger real rule set I'd also read the public demo server at prometheus.demo.prometheus.io, read-only.Could you assign it to me?
dexters1 commentedon Oct 9, 2026
Accepted as part of the hackathon. Thanks!
pooja-bhavani commentedon Oct 9, 2026
Hi @NMZivkovic!
I would like to be assigned to build the Prometheus data-source connector as I am participating in Mergetober (#5424).
Proposed Technical Architecture
packages/connector/prometheus/incognee-communityusingdlt's declarativerest_apisource.GET /api/v1/rules(with/api/v1/metadataopt-in). Support unauthenticated instances by default, with optional basic auth or bearer tokens.name,group,file,expression,for,labels,annotations) and construct deterministic row IDs viahash(file, group, type, name, labels). This prevents runtime evaluation changes (state,lastEvaluation) from modifying content hashes.write_disposition="replace") so deleted rules drop from the graph. Abort synchronization immediately on non-2xx HTTP status or invalid JSON to safeguard existing graph nodes.pytestunit coverage over recorded API payloads, and validate real-world sync behavior against a local Docker Prometheus container (prom/prometheus) and[suspicious link removed].I will wait for official assignment before opening the Pull Request. Could you please assign this issue to me? Thanks!
PratikPawar1401 commentedon Oct 9, 2026
Hi @dexters1 and @NMZivkovic,
I’d like to work on #5424 — the Prometheus data-source connector
I reviewed the Building a cognee Integration guide. I’ll implement this as a Path B scheduled-pull integration under
packages/connector/prometheus/, following the community connector structure:cognee.remember().DOCUMENT_SOURCE_ATTRso rules follow cognee’s document ingestion path.write_disposition="replace", andself_improvement=False.resolve_dlt_sourcesflow so deletion cleanup works correctly.The connector will ingest alerting and recording rules from
GET /api/v1/rules?exclude_alerts=true. It will support unauthenticated servers, basic or bearer authentication, proxy headers, path-prefixed URLs, and Prometheus rule filters.Each rule will become a deterministic document containing its PromQL expression, group, file, duration, labels, and annotations. Runtime fields such as health, state, active alerts, and evaluation timestamps will be excluded.
The complete response will be validated and buffered before any rows are emitted. API errors, warnings, malformed responses, or incomplete snapshots will abort the sync without deleting existing cognee data. A successfully removed rule will disappear through full-snapshot replacement and orphan cleanup.
Tests will cover authentication, filtering, deterministic output, duplicate rule names, updates, removals, failure-safe snapshots, searchability, and graph cleanup. I’ll also live-test against a controlled Prometheus Docker instance and publish the required Medium post showing a real alert-rule search and deletion workflow.
If this approach matches the integration guidelines, could you please assign the issue to me? I’ll wait for assignment before starting.
szed0 commentedon Oct 9, 2026
Hi @NMZivkovic, I'd like to build #5424 for Mergetober if it is still available.
I'll add
prometheus_sourceunderpackages/connector/prometheus/using dlt's declarative REST source. Selected alerting/recording rules become document-mode records containing their expressions, labels and runbook annotations. Authentication and path-prefixed servers are configurable; runtime evaluations and active alerts stay out of content hashes.The rules API now supports group pagination, whose results are not consistent during concurrent changes. I'll default to a complete unpaginated read, validate the response envelope and reject unexpected truncation or paging before reconciliation. Paginated support will need an explicit completeness policy. IDs distinguish repeated names using file, group, type and canonical labels.
Publish complete scoped
replacesnapshots, retaining unchanged documents, with matchingdlt_configin thecognee.remember()example. Failed extraction or downstream ingestion must preserve retryable work.Acceptance checks: runtime-only changes cause no reprocessing; an expression edit changes the intended document; removing the final rule clears Data, graph and vectors; malformed/error/partial responses preserve existing memory. I'll validate on a local Prometheus monitoring my Cognee example and write the separate blog from the observed workflow. Those runs are planned, not completed.
Include offline fixtures, setup/example and signed-off commits. Could you assign #5424 to @szed0? I'll start implementation after assignment.
Atharva-Ramawat commentedon Oct 9, 2026
Hi @NMZivkovic and @dexters1,
I see several excellent proposals have already been submitted, including from the original author (@itssaharsh). If they are unable to take this on for Mergetober, I would love to step in as a backup to build the Prometheus connector.
To ensure we maintain a stable, human-readable graph without generating redundant updates or missing rules during transient network issues, here is my implementation design:
dlt's declarativerest_apisource againstGET /api/v1/rules(with/api/v1/metadataopt-in). I will fully support unauthenticated instances, Basic Auth, Bearer tokens, proxy headers, and custom path prefixes.evaluationTime, active alerts). I will enforce a strict allowlist of static fields (name, group, file, expression, for, labels, annotations) so transient runtime changes never alter the document content hash.file,group,type,name, andlabels. This ensuresDOCUMENT_SOURCE_ATTRcorrectly anchors nodes in the graph.write_disposition="replace"to handle deletions via orphan cleanup. Crucially, the connector will buffer and validate the full API response before emitting any rows. Any non-2xx status, truncated body, or unexpected pagination failure will immediately abort the run, preventing Cognee from accidentally deleting existing rules due to a transient server failure.pytestcoverage using recorded offline API responses to validate identical hashes across unchanged reads, edit propagation, rule deletion via snapshot replacement, and fail-safe aborts on 503s. I will also include a live Docker setup (prom/prometheus) inexample.pyfor end-to-end validation.Please let me know if I can help take this across the finish line!
somuai commentedon Oct 10, 2026
Hi @dexters1 and @NMZivkovic,
I would like to be considered for #5424 (Prometheus data-source connector) for Mergetober.
As proof of execution on the
cognee-communityconnector architecture, I have already designed, implemented, and tested two completedlt-backed Cognee data-source connectors during this hackathon:pytestsuite[PASS])pytestsuite[PASS])Below is our production-ready architectural specification for
packages/connector/prometheus/that addresses deterministic rule hashing, composite identity resolution, fail-safe full-snapshot replacement, secret scrubbing, and optional operational context enrichment.1. End-to-End Architecture & Data Flow
flowchart LR subgraph Prometheus["Prometheus HTTP API v1"] R["GET /api/v1/rules"] M["GET /api/v1/metadata (Opt-In)"] T["GET /api/v1/targets (Opt-In)"] A["GET /api/v1/alerts (Opt-In)"] Q["GET /api/v1/query & /api/v1/query_range (Opt-In)"] end subgraph Connector["packages/connector/prometheus"] Client["PrometheusClient (Exponential Backoff 429/5xx)"] Buffer["Atomic Snapshot Validator & Watermark Cursor"] Scrubber["Regex Secret & Credential Scrubber"] Projector["Deterministic Semantic Markdown Projector"] DLT["@dlt.source (DOCUMENT_SOURCE_ATTR = 'prometheus')"] end subgraph Cognee["Cognee Memory Engine"] Add["cognee.add(dataset_name=..., write_disposition='replace', data_per_batch=...)"] Orphan["resolve_dlt_sources + orphan_cleanup"] Cognify["cognee.cognify()"] Memify["cognee.memify()"] end R --> Client M --> Client T --> Client A --> Client Q --> Client Client --> Buffer Buffer --> Scrubber Scrubber --> Projector Projector --> DLT DLT --> Add Add --> Orphan Orphan --> Cognify Cognify --> Memify2. Package Structure
Following the canonical
cognee-community/packages/connector/layout established in our #348 and #351 PRs:3. Configuration Schema (
PrometheusConfig) & Endpoint CoverageWe define a strict Pydantic
BaseModelconfiguration supporting stock unauthenticated Prometheus instances as well as authenticated/proxied enterprise deployments (Thanos/Mimir/VictoriaMetrics path prefixes and tenant headers):GET /api/v1/rules[ENABLED]name,group,file,query(PromQL),duration(for),keep_firing_for,labels,annotations(summary,description,runbook_url)evaluationTime,lastEvaluation,state,health,alerts) stripped from document body so unchanged rules keep identical content hashesGET /api/v1/metadata[OPT-IN]type(counter,gauge,histogram,summary),helpdocstrings, andunitGET /api/v1/targets[OPT-IN]lastScrape/lastScrapeDurationGET /api/v1/alerts[OPT-IN]GET /api/v1/query&/api/v1/query_range[OPT-IN]promql_summary_queries4. Core Engineering Safeguards
Prometheus rules do not have server-assigned UUIDs, and identical alert names frequently appear multiple times within the same group differentiated only by severity labels (e.g.,
NodeFilesystemAlmostOutOfSpacewithseverity="warning"vs.severity="critical"). We compute a deterministic primary key:last_evaluation_timestamp):name,type,group,file,query,duration,labels,annotations). Two consecutive reads against a live server with changingevaluationTime,lastEvaluation, oralertsproduce byte-for-byte identical Markdown and identicaldata_idhashes, preventing redundantcognify()LLM calls.last_evaluation_timestampindlt.current.resource_state()for auditability and optional incremental diagnostics without polluting the static content hash.write_disposition="replace"):write_disposition="replace"instructs Cognee'sresolve_dlt_sourcesandorphan_cleanupto purge any previously ingested document missing from the current batch, emitting a partial or empty stream on a failed request would catastrophically wipe the knowledge graph.PrometheusClientbuffers the complete response payload in memory and validates: (a) HTTP 200 status, (b) valid JSON structure, (c)payload.get("status") == "success", and (d) presence ofdata.groupslist (rejecting unexpected group pagination truncation unless all page tokens are resolved). Any error raises before yielding a single row, preserving existing Cognee memory intact.orphan_cleanupremoves its Data row, vector embeddings, and graph nodes.Before any document is yielded to
dltorcognee.add(), a recursive sanitizer scrubs:Authorizationheaders (Bearer ...,Basic ...)runbook_urlannotations (https://user:password@host/...->https://[REDACTED]@host/...)(?i)(token|secret|password|api_key|credential|auth_header)HTTP 429&5xxBackoff):PrometheusClientimplements exponential backoff (0.5s * 2^(attempt-1)) honoringRetry-Afterheaders across429,500,502,503, and504responses.ingest.py):@dlt.sourceobject withDOCUMENT_SOURCE_ATTR = "prometheus"(imported fromcognee.tasks.ingestion.dlt_utilswhereDOCUMENT_SOURCE_ATTR = "cognee_document_source").await cognee.add(source, dataset_name=dataset_name, write_disposition="replace", data_per_batch=config.data_per_batch), followed byawait cognee.cognify(datasets=[dataset_name])andawait cognee.memify(dataset=dataset_name).5. Offline
pytestVerification Plan (tests/test_prometheus.py)All unit tests run 100% offline in CI using deterministic
httpx.MockTransportfixtures:test_static_rule_hash_stabilityevaluationTime,lastEvaluation, and activealertsproduce identicalidandcontent[READY]test_duplicate_rule_names_in_groupnameinnode-exporterwith distinctseveritylabels receive distinct deterministic SHA-256 IDs[READY]test_rule_edit_and_orphan_deletionwrite_disposition="replace"triggers cleanup[READY]test_fail_safe_abort_on_503_or_malformedstatus="error"raises prior to yielding, preventing false orphan deletion[READY]test_secret_scrubbing_in_targets_and_annotations[REDACTED][READY]test_optional_metadata_and_targets_enrichment/api/v1/metadataand/api/v1/targetsenrich rule documents with metrictype/helpand target pool topology[READY]test_retry_backoff_on_429_and_502[READY]If this architecture looks good to you, could you please assign #5424 to me? I am ready to open the PR immediately upon assignment.
arindewangan commentedon Oct 11, 2026
Hi @NMZivkovic, I'd like to claim this issue for Mergetober and build the Prometheus data-source connector. Here's my approach:
I'll implement the
prometheusconnector underpackages/connector/prometheus/in thetopoteretes/cognee-communityrepo, modeled on the notion reference connector. Auth: none required by default, with optional basic/Bearer token configuration for proxied or protected servers.For ingest, I'll build a dlt declarative
rest_apisource onGET /api/v1/rules, covering both alerting and recording rules. Each rule becomes a document with name, group, file, expression,for, labels, and annotations (summary, description, runbook_url), tagged withDOCUMENT_SOURCE_ATTRso rules flow through cognee's document ingestion path. I'll use a full-snapshot model withwrite_disposition="merge"plus a_deletedhard-delete column, so a rule removed from the server is forgotten on the next sync. Non-2xx or malformed responses abort the run to protect existing data.Testing: unit tests covering the ingest path and determinism, plus a live integration test against the public demo server prometheus.demo.prometheus.io, as the issue prescribes. I'll include a README with a runnable example, sign all commits with DCO sign-off (
git commit -s), and open the PR against thedevbranch with a conventional title.Could you please assign this to me for Mergetober? I'll wait for assignment before opening the PR.
somuai commentedon Oct 11, 2026
Hi @dexters1, @NMZivkovic,
Following up on our detailed architectural proposal submitted on Oct 10 (Comment #6097268704), we wanted to provide a quick status update:
The complete Prometheus data-source connector has already been fully built, linted, and tested on branch
somuai/cognee-community:feat/connector-prometheus(commit8311b33).Verification metrics:
ruff checkandruff format100% clean.We are ready to open the upstream pull request immediately upon assignment.
shiv-69-debug commentedon Oct 12, 2026
Hi @NMZivkovic and @dexters1, I’d like to be considered for the Prometheus integration.
My focus would be definition-only ingestion with a reproducible local lifecycle test. I recognize the existing proposals and published implementation branch, and would coordinate the preferred implementation direction after assignment.
Scope
I would use the standard community package layout and the requested dlt REST-source approach. Configuration would support the Prometheus base URL, path prefixes, optional authentication and headers, and selected rule types, groups, or files.
Documents would preserve rule expressions, durations, labels, annotations, and group/file context. Metric metadata would be optional. Metric samples and PromQL query execution would remain outside the requested scope.
Deterministic content
I would explicitly map the API’s query and duration fields and exclude runtime evaluation state from indexed content.
A key test would supply two responses with identical rule definitions but different evaluation timestamps, health, and timing values. They must produce identical document content.
Safe synchronization
Each replacement would require a complete, validated rule snapshot. Failed requests, malformed envelopes, or unexpected pagination would not authorize removal. Stable scoped identities would distinguish similarly named rules, with ambiguous duplicates reported rather than silently overwritten.
Validation and delivery
After assignment, I would use local Docker Prometheus to demonstrate ingestion, search, a definition edit, reload, deletion, and removal of the final rule. Tests would cover selection, authentication, deterministic rendering, incomplete responses, and recovery.
I would verify actual Cognee cleanup alongside staging behavior and include setup documentation, a runnable example, package metadata, the required blog, signed-off commits, and DCO affirmation.
I have not completed these tests yet and will wait for assignment before implementing
SawhneySatvik commentedon Oct 12, 2026
Hi @dexters1 and @NMZivkovic, I'd like to take the Prometheus connector for Mergetober.
I'll follow the issue's design: a
prometheuspackage underpackages/connector/prometheus/, built on dlt'srest_apisource and shaped like the Notion connector.GET /api/v1/rules, one document per rule, with rows built from an allowlist of definition fields so runtime state (health,lastEvaluation,alerts) never changes a row.write_disposition="replace"for forget-on-delete, and any non-2xx, non-JSON or non-successresponse aborts the run so a failed fetch can't wipe the graph.I'll open the PR with signed commits and the DCO statement. Could you assign it to me?
Darshan3690 commentedon Oct 12, 2026
Issue: #5424
Author: @Darshan3690
Hi @NMZivkovic @Vasilije1990 @dexters1 @siillee @thisisharsh7 sir,
I'd like to take full ownership of the Prometheus connector for MergeTober. Following my work on the Confluence DLT connector (
incremental sync + orphan cleanup), I am very familiar with Cognee's DLT ingestion path and snapshot reconciliation models.Below is my technical design proposal so we can align on the implementation approach before I submit the PR:
Design Proposal: Prometheus Rules DLT Connector
1. Motivation & Use Case
Prometheus servers store manually authored operational knowledge: alerting and recording rules, expressions, severity levels, descriptions, and runbook URLs. When alerts fire or incidents escalate, engineers ask:
HighErrorRatealert actually measure, and what is its runbook URL?"This connector ingests rule definitions and metadata (not time-series metrics/samples) into Cognee memory so an agent can reason over a team's operational SLOs and alerting logic.
2. Package Architecture & Layout
Following the standard
cognee-communitylayout:3. Core Technical Design
A. Authentication & Transport
https://monitor.internal/prometheus).GET /api/v1/rules: Ingests alerting and recording rules.GET /api/v1/metadata: Optional/opt-in ingestion of metricHELPandTYPEtext (include_metric_metadata=Falseby default).B. Ingestion & Content Modeling
DOCUMENT_SOURCE_ATTR = "prometheus"for seamless Cognee chunking and graph extraction:C. Deterministic Identity & Runtime State Stripping
/api/v1/rulesresponse mixes static definitions with volatile runtime fields (evaluationTime,lastEvaluation,state,health,lastError,alerts). The connector strips these dynamic fields, extracting only static definition fields so unchanged rules produce identical content hashes across syncs.idis computed as a deterministic SHA-256 hash of(file, group, type, name, sorted_labels).D. Full-Snapshot Sync & Forget-on-Delete
write_disposition="replace".orphan_cleanuppurges the obsolete rule and its associated graph nodes/vectors during the replace sync.replace, any partial response, non-2xx HTTP status, non-JSON payload, or response wherestatus != "success"immediately raises an exception to abort ingestion and preserve existing graph memory.4. Usage Example
5. Acceptance Criteria & Test Coverage
GET /api/v1/ruleswith optional authentication.replacewrite disposition.tests/test_prometheus.py.README.mdandexamples/example.py.shanaldo7 commentedon Oct 13, 2026
Hi @NMZivkovic and @dexters1,
I’d like to contribute to #5424 — Add Prometheus data-source connector as part of Mergetober, if the issue is still available for assignment.
My implementation plan would be to follow the existing Notion connector and Cognee community integration guidelines:
/api/v1/rulesendpoint, creating one document per rule.I’ll first review the existing connector patterns and coordinate with the maintainers to avoid duplicating any implementation already in progress. I’ll wait for assignment before starting development and follow the required testing and DCO guidelines.
Could you please let me know if this issue is still available and assign it to me if appropriate?
Thank you!
abhinayteja commentedon Oct 13, 2026
Hi @NMZivkovic! I'd like to contribute the Prometheus data-source connector as part of the open-source integration challenge.
My proposed implementation is to create a connector in
cognee-communitythat fetches Prometheus alerting and recording rules through its HTTP API and converts them into structured documents compatible with Cognee's ingestion pipeline.I'll aim to include:
Before starting implementation, I'll review the existing connector patterns and contribution guidelines to ensure the solution fits the project.
Could you please confirm whether this issue is available and assign it to me?
Thank you!
dexters1 commentedon Oct 13, 2026
Issue assigned to @itssaharsh
feat(connector): Add Prometheus connector
mahilsaily306-max commentedon Oct 16, 2026
@NMZivkovic I'd like to work on this Prometheus connector integration for Mergetober. I have experience building monitoring integrations and time-series data connectors. My approach would be to:
I'll start by reading the notion connector as reference, then implement the connector following the proposed structure. Please assign me to this issue so I can begin working on it.