DEV Community: Masum Ali

Connecting Honeycomb Observability & SLOs into an AI Graph Memory with Cognee

Masum Ali — Mon, 05 Oct 2026 12:36:23 +0000

Connecting Honeycomb Observability & SLOs into an AI Graph Memory with Cognee

When production goes down or latency spikes at 2 AM, autonomous SRE agents and on-call engineers need answers fast:

"Which alert triggers monitor 5xx errors on the checkout service?"
"What is our SLO error budget target for payments API and what queries measure it?"
"Which dashboards visualize database lock wait durations?"

All of this operational knowledge lives inside Honeycomb. To make that metadata instantly queryable by AI agents and LLM tools, we built and contributed the Honeycomb Connector for Cognee.

1. Why Observability Belongs in a Knowledge Graph

Rather than indexing raw high-velocity span telemetry (which belongs in high-throughput timeseries storage), high-leverage contextual intelligence lives in Honeycomb’s configuration layer:

Datasets: The telemetry boundaries and services being monitored.
Boards / Dashboards: Curated graphs tracking p99 latencies, error budgets, and spans.
Triggers: Threshold rules, evaluation frequencies, and runbook definitions.
Service Level Objectives (SLOs): Target reliability percentages (e.g. 99.95%) and SLI formulas.

flowchart TD
    HC[Honeycomb Management API] -->|Datasets / Boards / Triggers / SLOs| Client[HoneycombClient]
    Client -->|yield Structured Markdown| DLT[DLT Pipeline]
    DLT -->|DOCUMENT_SOURCE_ATTR| Cognee[Cognee Cognify]
    Cognee -->|Build Topology & Dependency Graph| Memory[(Graph DB + Vector Store)]
    Memory -->|Natural Language & Incident Automation| Agent[Autonomous SRE Agent]

2. Connector Architecture

Clean Markdown Entity Serialization

The connector normalizes triggers, SLO contracts, and board layouts into rich structured Markdown:

# Honeycomb Trigger: High 5xx HTTP Error Rate
- **Trigger ID:** `trig_api_5xx`
- **Dataset:** `api-gateway`
- **Status:** Active
- **Evaluation Frequency:** Every 60s
- **Threshold Rule:** Metric > 2.0
- **Last Updated:** 2026-10-02T11:00:00Z

### Description & Runbook
Fires when the percentage of 5xx HTTP responses exceeds 2% over a 5-minute rolling window. Check upstream ingress proxy health.

# Honeycomb Service Level Objective (SLO): Checkout Availability
- **SLO ID:** `slo_checkout_v1`
- **Dataset:** `payments-svc`
- **Target Reliability:** 99.9% over 30 days
- **SLI Metric Definition:** `checkout_success_rate`

### Target Rationale & Scope
99.9% of checkout requests must return HTTP 200 within 1000ms.

When Cognee processes this, it builds an operational knowledge graph linking Services, SLOs, Triggers, and Dashboards.

3. Quickstart Example

import asyncio
import cognee
from cognee_community_connector_honeycomb import honeycomb_source

async def main():
    source = honeycomb_source(
        api_key="YOUR_HONEYCOMB_API_KEY",
        include_datasets=True,
        include_boards=True,
        include_triggers=True,
        include_slos=True,
    )

    # Ingest and Cognify
    await cognee.add(source, dataset_name="infra_knowledge")
    await cognee.cognify(dataset_name="infra_knowledge")

    # Ask operational questions
    answers = await cognee.search(
        "What are the alerting rules and runbooks for high 5xx error rates on api-gateway?",
        dataset_name="infra_knowledge"
    )
    print(answers)

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

4. Offline Unit Testing

The package includes a comprehensive mock test suite verifying header authentication (X-Honeycomb-Team), incremental timestamp filtering (since), and pipeline extraction:

uv run pytest packages/connector/honeycomb/tests/test_honeycomb.py -v

Resources

Pull Request: topoteretes/cognee-community#237
Monorepo: github.com/topoteretes/cognee-community

Turning Meeting Transcripts into an AI Knowledge Graph with tl;dv & Cognee

Masum Ali — Mon, 05 Oct 2026 12:35:46 +0000

Turning Meeting Transcripts into an AI Knowledge Graph with tl;dv & Cognee

Engineering and product teams spend dozens of hours every week in meetings. Crucial technical decisions get debated, architectural tradeoffs get resolved, and action items get assigned.

Then the call ends—and all that vital context gets buried in a 45-minute recording or lost inside scattered notes.

To make meeting intelligence permanently accessible to AI agents and developers, we built the tl;dv Connector for Cognee. Here is how we turned raw meeting recordings from tl;dv into an interconnected entity graph.

Why Vector Search Isn't Enough for Meeting Notes

If you store meeting transcripts as plain vector chunks, multi-speaker reasoning falls apart. Consider this query:

"Who volunteered to lead the vector engine migration in Tuesday's sync, and what blockers did they raise?"

Vector search finds chunks containing words like "vector" or "blockers", but it lacks entity grounding. A Knowledge Graph, however, extracts explicit relationships:

(Alice:Engineer) -[:VOLUNTEERED_FOR]-> (VectorMigration:Project)
(VectorMigration) -[:HAS_BLOCKER]-> (KuzuStorageDriver:Issue)

flowchart LR
    TLDV[tl;dv API] -->|Meetings + Transcripts + Notes| Client[TLDVClient]
    Client -->|Format Markdown Document| DLT[DLT Pipeline]
    DLT -->|DOCUMENT_SOURCE_ATTR| Cognee[Cognee Cognify]
    Cognee -->|Extract Entities & Dialogue Nodes| Graph[(Knowledge Graph + Vector Store)]

Connector Architecture

1. Multi-Endpoint Synthesis

tl;dv splits data across multiple REST endpoints:

/meetings: Lists metadata (meeting title, organizer, participant list, timestamps, duration).
/meetings/{id}/transcript: Returns speaker-labeled dialogue turns with exact timestamps.
/meetings/{id}/notes: Contains AI-generated executive overviews and action item checklists.

Our connector fetches and synthesizes these into a single unified Markdown document per meeting:

# Meeting: Q4 Distributed Vector Engine Planning
- **Organizer:** Alice Product Lead
- **Participants:** Alice Product Lead, Bob Tech Lead, Charlie SRE
- **Date:** 2026-10-01T14:00:00Z
- **Duration:** 3600 seconds

### Executive Summary
Reviewed roadmap milestones for the distributed graph indexing engine and agreed on partition strategy.

### Action Items
- Bob to finalize vector engine performance benchmarks
- Charlie to configure replica autoscaling in Kubernetes

### Full Transcript
Alice Product Lead: Let's review the Q4 milestones.
Bob Tech Lead: The distributed vector engine is on track, but we need to scale the partition handler.
Charlie SRE: I will deploy the new replica pool before Friday.

2. Cognee Graph Ingestion Contract

By annotating the dlt resource with DOCUMENT_SOURCE_ATTR = "tldv_document", Cognee treats each meeting as a document node, running its NLP extraction pipeline over the executive takeaways and dialogue.

Quickstart: Ingesting Meetings with Python

import asyncio
import cognee
from cognee_community_connector_tldv import tldv_source

async def main():
    # 1. Initialize connector
    source = tldv_source(
        api_key="YOUR_TLDV_API_KEY",
        limit=50,
        include_transcripts=True,
        include_notes=True,
    )

    # 2. Add and Cognify
    await cognee.add(source, dataset_name="engineering_meetings")
    await cognee.cognify(dataset_name="engineering_meetings")

    # 3. Query meeting intelligence
    results = await cognee.search(
        "What action items were assigned to Charlie regarding replicas?",
        dataset_name="engineering_meetings"
    )
    print(results)

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

Offline Unit Testing

To ensure reliability in CI and local testing without live API tokens, the connector includes a 100% offline mocked test suite:

uv run pytest packages/connector/tldv/tests/test_tldv.py -v

Links & Contributions

Pull Request: topoteretes/cognee-community#236
Monorepo: github.com/topoteretes/cognee-community

Ingesting Mixpanel Event Dictionaries & Cohorts into Cognee Knowledge Graphs

Masum Ali — Mon, 05 Oct 2026 12:35:04 +0000

Ingesting Mixpanel Event Dictionaries & Cohorts into Cognee Knowledge Graphs

When engineering AI agents to analyze user churn or feature adoption, the common knee-jerk reaction is to dump millions of raw event logs into a vector database.

That almost never works. Millions of rows like {"event": "checkout_clicked", "time": 1728144000} quickly blow past token budgets, bloat vector indexes, and return noisy semantic matches.

The real high-leverage intelligence in Mixpanel lives in Lexicon Schemas, User Cohort Criteria, and Saved Report Bookmarks.

Here is how we built the official Mixpanel Connector for Cognee to turn that semantic product knowledge into an autonomous graph memory.

1. What We Ingest: Context Over Noise

Instead of flooding your graph with every repetitive click timestamp, our connector focuses on the core conceptual primitives:

Lexicon Schemas: The data dictionary of your product (what properties exist on workspace_created, what each property represents, and its active status).
User Cohorts: Dynamic user groupings (e.g. "Power Users active > 5 days a week" or "Dormant Enterprise Accounts").
Saved Reports / Insights: The queries and metrics your growth and product teams care about most.

flowchart LR
    MP[Mixpanel API] -->|Lexicon / Cohorts / Bookmarks| Client[MixpanelClient]
    Client -->|yield Semantic Markdown| DLT[DLT Pipeline]
    DLT -->|DOCUMENT_SOURCE_ATTR| Cognee[Cognee Cognify]
    Cognee -->|Graph Nodes & Relations| DB[(Graph DB + Vector Storage)]

2. Engineering the Connector

Resilience & Rate-Limit Handling

Mixpanel APIs enforce strict query limits. We built an exponential backoff loop with status code inspection to gracefully handle HTTP 429 and network blips:

for attempt in range(MAX_RETRIES):
    try:
        response = http.request(method, url, auth=self.auth, params=params)
        if response.status_code == 429:
            retry_after = float(response.headers.get("Retry-After", 2**attempt))
            time.sleep(retry_after)
            continue
        response.raise_for_status()
        return response.json()
    except (httpx.TransportError, httpx.TimeoutException):
        if attempt == MAX_RETRIES - 1:
            raise
        time.sleep(2**attempt)

Semantic Prose Serialization

Each event schema is parsed into a clean document capturing its data dictionary:

# Mixpanel Lexicon Event: payment_failed
- **Event Name:** payment_failed
- **Status:** active
- **Tags:** billing, alerts, core_checkout

### Description
Fired whenever a Stripe or PayPal payment intent returns an error during checkout.

### Event Properties & Data Dictionary
- `error_code` (string) - Raw gateway error code
- `retry_count` (number) - Number of automatic retry attempts
- `plan_tier` (string) - Target subscription tier (starter, pro, enterprise)

When Cognee indexes this, questions like "What triggers a payment failure event and what properties are logged?" are answered instantly with graph precision.

3. Quickstart Example

import asyncio
import cognee
from cognee_community_connector_mixpanel import mixpanel_source

async def main():
    source = mixpanel_source(
        project_id="YOUR_MIXPANEL_PROJECT_ID",
        secret="YOUR_SERVICE_ACCOUNT_SECRET",
        include_schemas=True,
        include_cohorts=True,
        include_reports=True,
    )

    await cognee.add(source, dataset_name="mixpanel_knowledge")
    await cognee.cognify(dataset_name="mixpanel_knowledge")

    answer = await cognee.search(
        "Which user cohorts track dormant enterprise accounts?",
        dataset_name="mixpanel_knowledge"
    )
    print(answer)

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

4. Testing & Verification

100% offline mocked pytest tests verify schema parsing, cohort mapping, date filters, and Cognee ingestion without hitting live network endpoints:

uv run pytest packages/connector/mixpanel/tests/test_mixpanel.py -v

Bridging Pendo Product Telemetry into an AI Knowledge Graph with Cognee

Masum Ali — Mon, 05 Oct 2026 12:34:11 +0000

Bridging Pendo Product Telemetry into an AI Knowledge Graph with Cognee

Product teams sit on a goldmine of context inside Pendo: in-app onboarding guides, user feature clicks, customer accounts, and drop-off points.

Yet, when product managers or AI agents want to answer fundamental qualitative questions—like "Which enterprise accounts struggled with our latest SSO migration guide?"—they are forced to write multi-tab CSV exports or complex Segment queries.

To bridge this gap, we built and shipped the Pendo Connector for Cognee. Here’s a breakdown of how it works, the architectural choices we made, and how to get it running in your environment.

The Challenge: Telemetry vs Semantic Context

Raw product analytics is dominated by click events (button_clicked_id_382). By itself, that click means nothing to an LLM unless linked to:

The Feature Definition: What screen or workflow did that button belong to?
The Guide / Walkthrough: Was the user engaged in an active onboarding tour?
The Account Context: What subscription tier or industry does this user belong to?

flowchart TD
    subgraph Pendo API
        G[Guides & Tours]
        F[Feature Definitions]
        E[Track Events]
        A[Accounts & Visitors]
    end

    G --> Client[PendoClient]
    F --> Client
    E --> Client
    A --> Client

    Client --> DLT[DLT Pipeline]
    DLT -->|DOCUMENT_SOURCE_ATTR| Cognee[Cognee Cognify Engine]
    Cognee --> KG[(Graph Database + Vector Embeddings)]

Architectural Deep Dive

1. Multi-Resource Aggregation with `dlt`

Rather than treating Pendo as a dumb event pipe, our connector extracts four distinct knowledge layers:

Guides: Onboarding tooltips, banners, and walkthrough step texts.
Features: Element selectors, UI tags, and human descriptions.
Track Events: Custom behavioral events sent by backend services.
Visitor Context: Account groupings and last-seen metadata.

class PendoClient:
    def __init__(self, integration_key: str, base_url: str = "https://app.pendo.io") -> None:
        self.integration_key = integration_key
        self.base_url = base_url.rstrip("/")

    def get_guides(self) -> list[dict[str, Any]]: ...
    def get_features(self) -> list[dict[str, Any]]: ...
    def get_track_events(self) -> list[dict[str, Any]]: ...

2. Turning UI Hierarchies into LLM-Ready Markdown

For every guide, feature, and event, we construct rich semantic documents:

# Pendo In-App Guide: Workspace Onboarding Tour (ID: guide_489)
- **Status:** Published
- **Audience Segment:** All New Workspace Admins
- **Created At:** 2026-08-15T09:00:00Z

### Guide Steps & UI Content
- **Step 1:** Welcome to your team workspace! Let's configure your data sources.
- **Step 2:** Click here to connect your PostgreSQL or Neo4j databases.
- **Step 3:** Invite your teammates to collaborate.

When Cognee's cognify() pipeline digests this, it extracts relationships between Guides, Features, and Onboarding Steps, allowing autonomous agents to understand the exact UX journeys users experience.

How to Use It in 60 Seconds

Installation

pip install cognee-community-connector-pendo

Ingestion Script

import asyncio
import cognee
from cognee_community_connector_pendo import pendo_source

async def main():
    source = pendo_source(
        integration_key="YOUR_PENDO_INTEGRATION_KEY",
        include_guides=True,
        include_features=True,
        include_events=True,
        since="2026-09-01T00:00:00Z",
    )

    # Ingest into Cognee memory
    await cognee.add(source, dataset_name="product_telemetry")
    await cognee.cognify(dataset_name="product_telemetry")

    # Ask deep product questions
    results = await cognee.search(
        "What guides are active for onboarding new workspace admins?",
        dataset_name="product_telemetry"
    )
    print(results)

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

Offline Unit Testing

The package includes an offline pytest suite testing pagination, rate-limit backoffs, and Cognee pipeline compatibility:

uv run pytest packages/connector/pendo/tests/test_pendo.py -v

Summary & Links

Pull Request: topoteretes/cognee-community#234
Source Code: cognee-community repo

Let us know what other product tools you'd love to see connected to Cognee!

Why We Built a Typeform Knowledge Graph Connector for Cognee

Masum Ali — Mon, 05 Oct 2026 12:34:08 +0000

Why We Built a Typeform Knowledge Graph Connector for Cognee

If you’ve ever tried piping survey responses into an LLM application or RAG pipeline, you know the pain.

Forms don't output clean prose. They spit out disjointed JSON arrays: arbitrary field IDs, cryptic choice indexes, nested metadata, and missing answers. Dump that raw tabular data into standard vector search, and your similarity lookups fall apart the moment someone asks:

"What did enterprise leads in Europe say about our self-hosted pricing tier?"

To solve this, we built and contributed the official Typeform Connector for Cognee (cognee-community-connector-typeform). Here is how we designed it, how Cognee's document model works under the hood, and how you can use it in your own stacks.

The Problem with Naive Survey Ingestion

When ingesting form telemetry into a Knowledge Graph, two approaches usually fail:

Flat Relational Dumps: Flattening every submission into rows strips away semantic context. The LLM has to guess what choice_id_892 actually meant in relation to the respondent's company size.
Raw JSON String Dumps: Embedding raw JSON blobs wastes token budget on structural boilerplate ({"type": "multiple_choice", "field": {"ref": "..."}}) rather than the respondent's actual voice.

The Solution: Form-Aware Prose Serialization

Our connector hooks into Typeform's Forms and Responses APIs via a resilient dlt (data load tool) pipeline. It resolves form definition schemas, maps each question title directly to its submitted answer, and constructs a structured markdown document for every response:

flowchart LR
    TF[Typeform API] -->|Form Schema + Responses| Client[TypeformClient]
    Client -->|Resolve Question Titles & Answers| DLT[DLT Resource]
    DLT -->|DOCUMENT_SOURCE_ATTR='typeform_responses'| Cognee[Cognee Cognify]
    Cognee -->|Extract Entities & Relationships| Graph[(Knowledge Graph + Vector Store)]

How It Works Under the Hood

1. The Schema-to-Answer Resolver

Typeform splits form definitions (/forms/{id}) from respondent answers (/forms/{id}/responses). The connector caches question titles and maps varied response types (choices, text, number, boolean, payment):

def _extract_answer_value(ans: dict[str, Any]) -> str:
    ans_type = ans.get("type", "")
    if ans_type == "text":
        return ans.get("text", "")
    if ans_type == "choice":
        return ans.get("choice", {}).get("label", "")
    if ans_type == "choices":
        labels = ans.get("choices", {}).get("labels", [])
        return ", ".join(labels)
    if ans_type == "boolean":
        return "Yes" if ans.get("boolean") else "No"
    if ans_type == "number":
        return str(ans.get("number", ""))
    return str(ans.get(ans_type, ""))

2. The Cognee Document Contract

Cognee's cognify() engine needs to know when incoming records should undergo entity and relation extraction rather than flat tabular storage. We register this via DOCUMENT_SOURCE_ATTR:

DOCUMENT_SOURCE_ATTR = "typeform_responses"
setattr(typeform_responses_resource, DOCUMENT_SOURCE_ATTR, True)

Each submission is transformed into clean prose:

# Typeform Response: Customer Feedback Survey (ID: resp_8821)
- **Submitted At:** 2026-10-04T16:00:00Z
- **Response ID:** resp_8821

### Survey Responses
- **What is your company size?** 50-200 employees
- **Which feature is most critical for your team?** On-premise vector index synchronization
- **Any additional feedback?** The current REST API latency is solid, but we need better RBAC controls.

When Cognee processes this, its GLiNER and LLM extractors recognize companies, features, feedback sentiments, and create connected nodes in your graph database (Kuzu, Neo4j, or Postgres).

Quickstart: Adding Typeform to Your Cognee Pipeline

1. Installation

pip install cognee-community-connector-typeform

2. Ingestion in 4 Lines of Python

import asyncio
import cognee
from cognee_community_connector_typeform import typeform_source

async def main():
    # Configure connector
    source = typeform_source(
        token="YOUR_TYPEFORM_PERSONAL_ACCESS_TOKEN",
        form_ids=["abc123xyz"],  # Or omit to sync all forms
        since="2026-09-01T00:00:00Z",
    )

    # Ingest and Cognify
    await cognee.add(source, dataset_name="survey_insights")
    await cognee.cognify(dataset_name="survey_insights")

    # Ask multi-hop questions over survey feedback
    insights = await cognee.search(
        "What are mid-sized companies saying about RBAC requirements?",
        dataset_name="survey_insights"
    )
    print(insights)

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

Resilient Offline Testing

Because CI runners shouldn't rely on live API keys, we wrote a complete mock-tested suite covering:

Handling paginated responses and token auth headers.
Graceful fallbacks when questions have no answers.
since ISO timestamp filtering.

Run it locally anytime:

uv run pytest packages/connector/typeform/tests/test_typeform.py -v

Check It Out

PR: topoteretes/cognee-community#233
Monorepo: github.com/topoteretes/cognee-community

Have ideas for more data connectors or graph models? Jump into Cognee's Discord and let's build!

DEV Community: Masum Ali

Connecting Honeycomb Observability & SLOs into an AI Graph Memory with Cognee

Connecting Honeycomb Observability & SLOs into an AI Graph Memory with Cognee

1. Why Observability Belongs in a Knowledge Graph

2. Connector Architecture

Clean Markdown Entity Serialization

3. Quickstart Example

4. Offline Unit Testing

Resources

Turning Meeting Transcripts into an AI Knowledge Graph with tl;dv & Cognee

Turning Meeting Transcripts into an AI Knowledge Graph with tl;dv & Cognee

Why Vector Search Isn't Enough for Meeting Notes

Connector Architecture

1. Multi-Endpoint Synthesis

2. Cognee Graph Ingestion Contract

Quickstart: Ingesting Meetings with Python

Offline Unit Testing

Links & Contributions

Ingesting Mixpanel Event Dictionaries & Cohorts into Cognee Knowledge Graphs

Ingesting Mixpanel Event Dictionaries & Cohorts into Cognee Knowledge Graphs

1. What We Ingest: Context Over Noise

2. Engineering the Connector

Resilience & Rate-Limit Handling

Semantic Prose Serialization

3. Quickstart Example

4. Testing & Verification

Links

Bridging Pendo Product Telemetry into an AI Knowledge Graph with Cognee

Bridging Pendo Product Telemetry into an AI Knowledge Graph with Cognee

The Challenge: Telemetry vs Semantic Context

Architectural Deep Dive

1. Multi-Resource Aggregation with dlt

2. Turning UI Hierarchies into LLM-Ready Markdown

How to Use It in 60 Seconds

Installation

Ingestion Script

Offline Unit Testing

Summary & Links

Why We Built a Typeform Knowledge Graph Connector for Cognee

Why We Built a Typeform Knowledge Graph Connector for Cognee

The Problem with Naive Survey Ingestion

The Solution: Form-Aware Prose Serialization

How It Works Under the Hood

1. The Schema-to-Answer Resolver

2. The Cognee Document Contract

Quickstart: Adding Typeform to Your Cognee Pipeline

1. Installation

2. Ingestion in 4 Lines of Python

Resilient Offline Testing

Check It Out

1. Multi-Resource Aggregation with `dlt`