kodelyth-ecc 1.7.2 → 1.7.3

package/videos/video-04-mcp-server.md

@@ -0,0 +1,391 @@
+# VIDEO 4 — "MCP Server: Give LangGraph access to 70 agents in one command"
+
+**Duration:** 10–12 minutes  
+**Platform:** YouTube (AI/ML engineers, agent framework builders, Claude Desktop users)  
+**Hook:** Live wiring of ECC MCP into Claude Desktop + LangGraph  
+**Goal:** Drive adoption from the agentic AI engineering community  
+**Screen setup:** Terminal + code editor + browser (Claude Desktop or LangGraph notebook)
+
+---
+
+## FULL SCRIPT
+
+---
+
+### [0:00–0:20] COLD OPEN
+
+**[SCREEN: Claude Desktop — chat open, typing]**
+
+**[TYPE in Claude Desktop:]**
+```
+route this task for me: our checkout flow is broken in production
+```
+
+**[Show response from ECC MCP route_intent tool:]**
+```json
+{
+  "suggestions": [
+    { "agent": "incident-commander", "score": 0.94, "reason": "production + broken = P0 pattern" },
+    { "agent": "debug-detective",    "score": 0.81, "reason": "checkout flow + broken = active bug" },
+    { "agent": "silent-failure-hunter", "score": 0.62, "reason": "checkout failures often have no error" }
+  ]
+}
+```
+
+**NARRATION:**
+> "That's Claude Desktop calling an ECC tool to route a task to the right specialist."
+> "No plugins. No cloud. Just one command on your machine and MCP handles the rest."
+
+**[TITLE CARD: Kodelyth ECC MCP Server — Universal Adapter]**
+
+---
+
+### [0:20–1:30] WHAT IS MCP AND WHY IT MATTERS
+
+**[SCREEN: Simple diagram — MCP architecture]**
+
+**NARRATION:**
+> "Model Context Protocol is Anthropic's open standard for connecting AI applications to external tools and data."
+> "Think of it like USB-C for AI. Any MCP client can plug into any MCP server."
+
+**[Draw: Claude Desktop → MCP → ECC server]**
+**[Draw: LangGraph → MCP → ECC server]**
+**[Draw: AutoGen → MCP → ECC server]**
+
+**NARRATION:**
+> "ECC v1.7.0 ships a full MCP server. One command starts it."
+> "Any framework that speaks MCP now has access to 70 agents, 194 skills, 97 commands, and your local memory store."
+
+---
+
+### [1:30–2:30] WHAT THE SERVER EXPOSES
+
+**[SCREEN: Diagram — three columns: Tools / Prompts / Resources]**
+
+**NARRATION:**
+> "The ECC MCP server exposes three categories of content."
+
+**[COLUMN 1: TOOLS (16)]**
+
+**NARRATION:**
+> "16 tools. These are callable functions your AI can invoke."
+
+**[Show each with one line:]**
+```
+route_intent        → suggest the right ECC agent for a message
+list_agents         → catalog of all 70 agents
+list_skills         → catalog of all 194 skills
+get_agent           → full markdown body of any agent
+get_skill           → full markdown body of any skill
+get_command         → full slash command body
+recall_memory       → BM25 search of your local memory
+capture_memory      → store a new memory entry
+memory_stats        → stats on your memory store
+catalog_stats       → counts of agents/skills/commands
+audit_skill_match   → which skills are relevant to a task
+```
+
+---
+
+**[COLUMN 2: PROMPTS (6)]**
+
+**NARRATION:**
+> "6 prompts. Canonical ECC context blocks you can summon by name."
+
+```
+routing-rule      → the full 10-tier intent routing system
+agents-overview   → all 70 agents, one-line each
+skills-overview   → all 194 skills compact
+handoff-chains    → standard multi-agent chain protocols
+devil-mode        → the adversarial parallel sweep command
+commands-overview → all 97 slash commands
+```
+
+---
+
+**[COLUMN 3: RESOURCES (377)]**
+
+**NARRATION:**
+> "377 resources. Every agent, skill, command, rule, and bundle is addressable as a kodelyth:// URI."
+
+```
+kodelyth://agents/debug-detective
+kodelyth://skills/kodelyth-memory
+kodelyth://commands/devil-mode
+kodelyth://rules/agent-intent-routing
+kodelyth://bundles/indie-hacker
+```
+
+**NARRATION:**
+> "Any MCP client can do `resources/list` to discover everything, then `resources/read` to fetch any of it as markdown."
+
+---
+
+### [2:30–4:00] DEMO 1 — CLAUDE DESKTOP IN 30 SECONDS
+
+**[SCREEN: macOS → finder → ~/Library/Application Support/Claude/]**
+
+**NARRATION:**
+> "Let's wire it into Claude Desktop. 30 seconds."
+
+**[SCREEN: Open claude_desktop_config.json]**
+
+**[TYPE the config:]**
+```json
+{
+  "mcpServers": {
+    "kodelyth-ecc": {
+      "command": "npx",
+      "args": ["-y", "kodelyth-ecc", "mcp"]
+    }
+  }
+}
+```
+
+**NARRATION:**
+> "Save. Restart Claude Desktop."
+
+**[Restart Claude Desktop — show the server appearing in the tools panel]**
+
+**NARRATION:**
+> "ECC is now available. Claude Desktop can call all 16 tools, use all 6 prompts, and read all 377 resources."
+
+**[DEMO in Claude Desktop:]**
+
+**[TYPE:]**
+```
+Use the routing-rule prompt, then route this: 
+"I've been debugging this race condition for 3 days, nothing works"
+```
+
+**[Show: ECC routing-rule prompt loaded → route_intent called → response suggests /debug-blitz]**
+
+**NARRATION:**
+> "Claude used the ECC routing rule — the full 10-tier system — to decide that 3 days of frustration on a race condition means debug-blitz, not a single debug-detective."
+
+---
+
+**[DEMO 2 in Claude Desktop — get agent body:]**
+
+**[TYPE:]**
+```
+Get me the full debug-detective agent instructions
+```
+
+**[Show: get_agent tool called → full debug-detective.md loaded → Claude adopts the persona]**
+
+**NARRATION:**
+> "Claude fetched the full agent playbook on demand. Now it's running as debug-detective — with the real methodology, not a made-up persona."
+
+---
+
+### [4:00–6:30] DEMO 2 — LANGGRAPH INTEGRATION
+
+**[SCREEN: VS Code with a Python file open]**
+
+**NARRATION:**
+> "Now let's wire it into LangGraph. This is for developers building multi-agent workflows in Python."
+
+**[SCREEN: Show minimal LangGraph code with MCP client]**
+
+```python
+from langchain_mcp import MCPToolkit
+from langchain_anthropic import ChatAnthropic
+from langgraph.prebuilt import create_react_agent
+
+# Connect to ECC MCP server
+async with MCPToolkit("npx kodelyth-ecc mcp") as toolkit:
+    tools = await toolkit.get_tools()
+    
+    llm = ChatAnthropic(model="claude-sonnet-4-5")
+    agent = create_react_agent(llm, tools)
+    
+    # Now the agent can call any ECC tool
+    result = await agent.ainvoke({
+        "messages": [
+            {"role": "user", "content": "Route this task and get me the right agent's instructions: our API is throwing 500s"}
+        ]
+    })
+```
+
+**NARRATION:**
+> "The ECC server spawns as a subprocess. LangGraph connects via stdio. The agent now has all 16 ECC tools in its tool belt."
+
+**[RUN the script — show output:]**
+
+```
+> Calling tool: route_intent
+  input: "our API is throwing 500s"
+  
+> Result: incident-commander (score 0.91), debug-detective (0.78)
+
+> Calling tool: get_agent
+  input: "incident-commander"
+
+> Loaded: incident-commander.md (7920 bytes)
+
+[Agent now follows incident-commander playbook...]
+```
+
+**NARRATION:**
+> "The orchestrator called route_intent, got a recommendation, fetched the full agent body, and is now executing the incident-commander playbook."
+> "Your LangGraph workflow just got 70 specialists."
+
+---
+
+**[MEMORY ROUNDTRIP]**
+
+**NARRATION:**
+> "The memory tools are the most valuable part for long-running workflows."
+
+```python
+# Store a solution during a session
+await agent.ainvoke({
+    "messages": [{
+        "role": "user",
+        "content": "capture_memory: problem=API rate limiting, approach=exponential backoff with jitter, tags=[api, rate-limiting, retry]"
+    }]
+})
+
+# Recall it later, in any workflow
+result = await agent.ainvoke({
+    "messages": [{
+        "role": "user", 
+        "content": "I'm building retry logic for an API client. recall_memory first."
+    }]
+})
+```
+
+**NARRATION:**
+> "Your LangGraph workflow can now persist solutions to your local BM25 memory and recall them on future runs."
+> "The memory survives process restarts. It's a JSONL file. Your agent learns across runs."
+
+---
+
+### [6:30–8:00] DEMO 3 — CLI INSPECTION TOOLS
+
+**[SCREEN: Terminal]**
+
+**NARRATION:**
+> "You don't have to write code to explore the server. ECC ships CLI commands for everything."
+
+```bash
+# Register a server
+npx kodelyth-ecc mcp-add kodelyth -- npx kodelyth-ecc mcp
+
+# List registered servers
+npx kodelyth-ecc mcp-list
+
+# See all 16 tools
+npx kodelyth-ecc mcp-tools kodelyth
+
+# Call a tool directly
+npx kodelyth-ecc mcp-call kodelyth route_intent \
+  --json '{"message":"production is down","top_k":3}'
+
+# List resources
+npx kodelyth-ecc mcp-resources kodelyth
+
+# Read a specific resource
+npx kodelyth-ecc mcp-call kodelyth get_agent \
+  --json '{"name":"debug-detective"}'
+```
+
+**NARRATION:**
+> "The mcp-call command is especially useful for testing integrations before you wire them into code."
+
+**[Show route_intent output formatted with jq:]**
+
+```bash
+npx kodelyth-ecc mcp-call kodelyth route_intent \
+  --json '{"message":"I need to refactor my auth module"}' \
+  | jq '.content[0].text | fromjson | .suggestions[:3]'
+```
+
+---
+
+### [8:00–9:30] DESIGN PRINCIPLES
+
+**[SCREEN: Diagram]**
+
+**NARRATION:**
+> "A few things I want to be explicit about in the design."
+
+**[PRINCIPLE 1: No LLM calls]**
+
+**NARRATION:**
+> "The ECC MCP server adds zero LLM calls of its own. It reads files and passes through memory. Your client's model decides what to do with the content. No hidden API costs."
+
+**[PRINCIPLE 2: Local only]**
+
+**NARRATION:**
+> "stdio transport. No network port. No HTTP server. The MCP server is a subprocess — it dies when your client disconnects. No background process lingering."
+
+**[PRINCIPLE 3: Optional dependency]**
+
+**NARRATION:**
+> "The MCP SDK is in optionalDependencies. `npx kodelyth-ecc` installs without it. The MCP subcommand prints a helpful message if you try to use it without the SDK."
+
+```bash
+npx kodelyth-ecc mcp
+# → "Kodelyth MCP server requires @modelcontextprotocol/sdk"
+# → "Run: npm install @modelcontextprotocol/sdk"
+```
+
+**[PRINCIPLE 4: Cached catalog]**
+
+**NARRATION:**
+> "Agent and skill lists are cached in-process after first read. Sub-millisecond for subsequent calls. Heavy workflows that call list_agents repeatedly don't hit the filesystem every time."
+
+---
+
+### [9:30–10:00] WHAT'S COMING
+
+**[SCREEN: Simple roadmap card]**
+
+**NARRATION:**
+> "The MCP server opens up a second direction: ECC as an MCP client."
+
+**[Show code snippet:]**
+```bash
+npx kodelyth-ecc mcp-add stripe -- npx -y @modelcontextprotocol/server-stripe
+npx kodelyth-ecc mcp-add github -- npx -y @modelcontextprotocol/server-github
+npx kodelyth-ecc mcp-add postgres -- npx -y @modelcontextprotocol/server-postgres
+```
+
+**NARRATION:**
+> "ECC agents will be able to consume external MCP servers — Stripe, GitHub, Postgres, Redis — making ECC the hub that routes between your specialists and your data sources."
+> "That's the agentic layer I'm building toward."
+
+---
+
+### [10:00–10:30] CTA
+
+**NARRATION:**
+> "If you're building with LangGraph, AutoGen, CrewAI, or Claude Desktop — ECC's MCP server is a one-command addition to any workflow."
+
+**[SCREEN: Terminal]**
+
+```bash
+npx kodelyth-ecc mcp
+```
+
+**NARRATION:**
+> "github.com/sifxprime/kodelyth-ecc — full MCP docs at docs/mcp.md"
+> "If this was useful, subscribe — I'll be covering the ECC-as-MCP-client direction next."
+
+**[END CARD: subscribe, github link, docs link]**
+
+---
+
+## B-ROLL / EDITING NOTES
+
+- Run the REAL MCP server — don't fake responses
+- Claude Desktop wiring must be recorded live — the UX of it connecting is persuasive
+- The LangGraph demo should be in a Jupyter notebook OR a clean Python file, not a cluttered repo
+- Show the actual tool call logs from LangGraph (the `> Calling tool:` lines)
+- For the CLI commands: use --color=always and record with terminal that shows nice colors
+- Diagram for MCP architecture: keep it simple — three boxes (Client → MCP → ECC)
+- This is the most technical video — don't cut corners on accuracy
+- Thumbnail: "npx kodelyth-ecc mcp" in terminal + "LangGraph ← 70 agents" graphic
+- Consider publishing a companion GitHub Gist with the LangGraph code snippet for the description

package/wiki/FAQ.md

@@ -6,7 +6,7 @@
 
 **What is Kodelyth ECC?**
 
-An AI coding toolkit (v1.7.1) that installs into 11 AI coding platforms (13 install targets). It adds 70 specialist agents (including 8 adversarial devil-mode agents), 194 skills, 97 slash commands, 20+ automation hooks, and a compound learning system. Zero cloud, zero telemetry, all local.
+An AI coding toolkit (v1.7.3) that installs into 11 AI coding platforms (13 install targets). It adds 70 specialist agents (including 8 adversarial devil-mode agents), 194 skills, 97 slash commands, 20+ automation hooks, and a compound learning system. Zero cloud, zero telemetry, all local.
 
 **Is it free?**
 

package/wiki/Home.md

@@ -2,7 +2,7 @@
 
 **Kodelyth Enhanced Coding Companion** — production-grade AI coding toolkit for Claude Code, Windsurf, Cursor, Codex CLI, Google Antigravity, and more.
 
-> Version: **v1.7.2** · Agents: **70** (including 8 adversarial) · Skills: **194** · Commands: **97** (including 8 parallel) · Hooks: **22+** · Platforms: **11** · Tests: **336**
+> Version: **v1.7.3** · Agents: **70** (including 8 adversarial) · Skills: **194** · Commands: **97** (including 8 parallel) · Hooks: **22+** · Platforms: **11** · Tests: **336**
 
 ---
 
@@ -56,7 +56,7 @@ After install, type `/kodelyth-quickstart` in your AI tool to begin.
 
 ---
 
-## Key Features (v1.7.0)
+## Key Features (v1.7.3)
 
 ### Semantic Intent Routing