Show & Tell: Inside the Servers Module — Kenny Graph Live via MCP + SSE, 89,574 Nodes, 1,405 Agents

[web3guru888]

The External Window Into the Knowledge Network

Most ASI:BUILD modules operate internally — they read from and write to the Cognitive Blackboard, process data through their pipelines, and publish results back. But one module does something different: it opens a live window into an external knowledge graph, letting the outside world query and stream ASI:BUILD state in real time.

That module is servers — and this thread is a deep dive into how it works.

---

What is Kenny Graph?

Kenny Graph is a Memgraph (Neo4j-compatible) knowledge graph containing:

Metric	Value
Nodes	89,574
Relationships	96,871
Query language	Cypher
Agent army	1,405 autonomous agents across 48 teams
Public endpoint	http://13.213.179.32:8090/sse

It is the external knowledge substrate that complements ASI:BUILD's internal reasoning modules. While ASI:BUILD's knowledge_graph module stores in-process knowledge, Kenny Graph holds the broader persistent conceptual network that agents build over time.

---

Two Servers, Two Protocols

1. kenny_mcp_server.py — MCP (Model Context Protocol)

The MCP server exposes Kenny Graph via the Model Context Protocol — the emerging standard for tool-augmented LLMs.

Resources exposed:

kenny://graph/stats      — Overall statistics
kenny://graph/nodes      — Node browser by type
kenny://graph/relationships  — Relationship browser
kenny://agent/status     — Live status of 1,405 agents

Tools available:

query_kenny_graph      — Execute arbitrary Cypher queries
search_kenny_concepts  — Full-text search over concept names
get_node_relationships — Expand a node's neighborhood
analyze_connectivity   — Centrality, clusters, shortest_path

Any MCP-compatible client (Claude, Cursor, VS Code, custom LLM agents) can connect, enumerate these tools, and run live Cypher queries against the 89K-node graph — with nothing but an SSE connection.

2. kenny_graph_sse_server.py — SSE (Server-Sent Events)

The SSE server is a FastAPI app that streams real-time snapshots every 5 seconds to any HTTP client.

Three streaming endpoints:

GET /sse/kenny-graph   — graph node/edge counts + node type distribution
GET /sse/supervisor    — agent army health metrics
GET /sse/combined      — full stats bundle (graph + analysis + supervisor)

Each event is a JSON blob:

{
  "timestamp": "2026-04-12T04:45:00Z",
  "status": "healthy",
  "nodes": 89574,
  "relationships": 96871,
  "node_types": ["Concept", "Agent", "Knowledge", "Task"],
  "relationship_types": ["RELATES_TO", "KNOWS", "ASSIGNED_TO"],
  "recent_activity": [...]
}

There's also a built-in /demo HTML page — load it in a browser and watch the graph stats update live.

---

Architecture: Where Does This Fit?

┌──────────────────────────────────────────────────────────┐
│                    ASI:BUILD Runtime                     │
│                                                          │
│  ┌─────────────┐    ┌──────────────────────────────┐    │
│  │  Cognitive  │    │        servers module         │    │
│  │  Blackboard │    │                              │    │
│  │             │    │  kenny_mcp_server     MCP    │    │
│  │  (internal) │    │  kenny_graph_sse_server SSE  │    │
│  └─────────────┘    └──────────────┬─────────────┘    │
│                                    │                    │
└────────────────────────────────────│────────────────────┘
                                     │ bolt://
                              ┌──────▼──────┐
                              │ Kenny Graph  │
                              │  (Memgraph)  │
                              │ 89,574 nodes │
                              └─────────────┘

Currently, the servers module is standalone — it connects directly to Memgraph and exposes data outward, but doesn't yet feed Kenny Graph events into the Cognitive Blackboard. Issue #89 tracks this: adding a KennyGraphBlackboardAdapter that subscribes to the SSE stream and publishes knowledge graph changes as Blackboard entries.

---

The Interesting Design Questions

1. Push vs pull for external knowledge integration

The SSE stream updates every 5 seconds. When a KennyGraphBlackboardAdapter is built (Issue #89), should it poll the snapshot endpoint, or maintain a persistent SSE connection and react to each event?

SSE subscription seems better — it allows reactive behavior when Kenny's 1,405 agents produce new knowledge. The 5-second cadence means Blackboard entries would arrive with at most 5s latency, which fits the ~120ms cognitive cycle constraint if we treat Kenny Graph events as background/async rather than synchronous.

2. Which graph events are cognitively significant?

Kenny's graph changes continuously. Not every node addition or relationship update should surface in the Blackboard. A relevance filter — perhaps keyed on node type (Knowledge, Concept) and relationship type (KNOWS, RELATES_TO) — would keep Blackboard churn manageable.

3. Bidirectional sync

Long term: should ASI:BUILD's knowledge_graph module (bi-temporal, 24+ Cypher functions) be able to push to Kenny Graph? This would create a bidirectional knowledge exchange — ASI:BUILD's temporal reasoning feeding back into the persistent knowledge base.

---

By the Numbers

File	LOC	Purpose
kenny_mcp_server.py	498	MCP protocol server
kenny_graph_sse_server.py	522	FastAPI SSE streaming server
Total	1,020	External data bridge

---

Try It

If you have curl and an internet connection:

# Live SSE stream from Kenny Graph
curl -N http://13.213.179.32:8090/sse

# One-shot JSON snapshot
curl http://13.213.179.32:8090/stats/current 2>/dev/null | python3 -m json.tool

Or connect any MCP client to http://13.213.179.32:8090 and run:

list_tools  → query_kenny_graph, search_kenny_concepts, get_node_relationships, analyze_connectivity

---

Happy to answer questions about the SSE streaming architecture, the MCP protocol integration, or the planned Blackboard adapter. And if you've worked with MCP servers before, I'd love to hear how this compares to other graph-backed MCP implementations.