v0.5.0: Knowledge Graph with Ebbinghaus memory decay + Native MCP client

Killer features for virality:

Knowledge Graph (internal/knowledge/):
- Entity storage with types: person, place, org, concept, preference, project, event, fact
- Weighted relationships between entities (directed graph)
- Ebbinghaus forgetting curve: S(t) = S₀ × e^(-λt) with spacing effect
- Automatic pruning of decayed memories below threshold
- Context injection into system prompt (strongest memories)
- Full CRUD API endpoints + Web UI panel with search
- 9/9 tests passing

Native MCP Client (internal/mcp/):
- Model Context Protocol client supporting stdio and SSE transports
- JSON-RPC 2.0 implementation (zero external dependencies)
- Tool discovery and invocation across connected servers
- Auto-reconnect from persisted server configurations
- Web UI panel for connection management
- 13/13 tests passing

Agent Integration:
- Knowledge graph skills: add, relate, query, relations, delete, stats
- MCP skills: connect, disconnect, list, call
- System prompt includes knowledge graph context + MCP tool listings
- Auto-connect configured MCP servers on startup

Web UI:
- Knowledge Graph panel with entity browser, search, stats, relation viewer
- MCP Servers panel with connection form, server list, tool inventory
- Keyboard shortcuts: Ctrl+Shift+G (Knowledge), Ctrl+Shift+M (MCP)
- Welcome screen updated with new shortcuts

README updated with new features, architecture diagram, API endpoints.
Binary size: 11MB (unchanged). All 132 tests passing.

Author: mandarl

Makefile

@@ -1,7 +1,7 @@
 # PennyClaw Makefile
-# Version: 0.4.1
+# Version: 0.5.0
 
-VERSION ?= 0.4.1
+VERSION ?= 0.5.0
 COMMIT  ?= $(shell git rev-parse --short HEAD 2>/dev/null || echo "dev")
 DATE    ?= $(shell date -u +%Y-%m-%dT%H:%M:%SZ)
 LDFLAGS  = -s -w -X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.buildDate=$(DATE)

README.md

@@ -108,6 +108,16 @@ PennyClaw ships with a comprehensive set of tools the agent can invoke:
 | **Notes** | `note_delete` | Remove notes |
 | **Notes** | `note_search` | Full-text search with snippet extraction |
 | **Email** | `send_email` | Send email notifications via SMTP |
+| **Knowledge** | `knowledge_add` | Add entities (people, places, concepts) to the knowledge graph |
+| **Knowledge** | `knowledge_relate` | Create relationships between entities |
+| **Knowledge** | `knowledge_query` | Search the knowledge graph by name |
+| **Knowledge** | `knowledge_relations` | Get all relationships for an entity |
+| **Knowledge** | `knowledge_delete` | Remove an entity and its relations |
+| **Knowledge** | `knowledge_stats` | Get knowledge graph statistics |
+| **MCP** | `mcp_connect` | Connect to an MCP server (stdio or SSE transport) |
+| **MCP** | `mcp_disconnect` | Disconnect from an MCP server |
+| **MCP** | `mcp_list` | List connected MCP servers and their tools |
+| **MCP** | `mcp_call` | Call a tool on a connected MCP server |
 
 Skills can also be loaded from external YAML/JSON bundles via the skill pack system, allowing you to extend PennyClaw without modifying Go code.
 
@@ -135,6 +145,26 @@ The embedded web interface includes:
 - Notification sound when responses arrive
 - Keyboard shortcuts: Ctrl+K (new chat), Ctrl+L (clear), Ctrl+E (export), Esc (close panels)
 
+### Knowledge Graph with Memory Decay
+
+PennyClaw maintains a knowledge graph that learns about your world over time. Entities (people, places, concepts, preferences, projects) are stored with weighted relationships and subject to **Ebbinghaus memory decay** — memories that are never reinforced gradually fade, keeping the graph lean and relevant.
+
+- **Automatic context injection** — The strongest memories are included in every system prompt, giving the agent persistent awareness
+- **Ebbinghaus forgetting curve** — Strength decays exponentially over time: `S(t) = S₀ × e^(-λt)`
+- **Spacing effect** — Frequently accessed memories decay slower (adjusted by access count)
+- **Automatic pruning** — Entities below the strength threshold are removed to save memory
+- **Web UI panel** — Browse, search, and manage entities and relationships visually
+
+### Native MCP Client
+
+PennyClaw includes a built-in [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) client, allowing it to connect to any MCP-compatible server and use its tools. This gives PennyClaw instant access to hundreds of community-built integrations.
+
+- **Stdio transport** — Launch MCP servers as subprocesses (e.g., `npx @modelcontextprotocol/server-filesystem`)
+- **SSE transport** — Connect to remote MCP servers via HTTP Server-Sent Events
+- **Auto-reconnect** — Server configurations are persisted and reconnected on restart
+- **Web UI panel** — Add, manage, and monitor MCP server connections visually
+- **Zero dependencies** — Pure Go JSON-RPC 2.0 implementation
+
 ### Automation
 
 - **Cron scheduler** — Schedule recurring tasks with cron expressions (e.g., daily summaries, periodic checks)
@@ -193,10 +223,12 @@ graph TD
         LLM["LLM Gateway<br/>OpenAI / Anthropic / Gemini / OpenRouter"]
         SKILLS["Skills Registry<br/>shell / files / web / tasks / notes / email"]
         SKILLPACK["Skill Packs<br/>YAML/JSON bundles"]
+        KG["Knowledge Graph<br/>Ebbinghaus memory decay"]
+        MCP["MCP Client<br/>stdio + SSE transports"]
     end
 
     subgraph Storage["Storage"]
-        SQLITE["SQLite<br/>conversations + memory"]
+        SQLITE["SQLite<br/>conversations + memory + knowledge"]
         TASKS["JSON<br/>task store"]
         NOTES["Markdown<br/>knowledge base"]
         WORKSPACE["Workspace<br/>persistent files"]
@@ -224,6 +256,9 @@ graph TD
     AGENT --> SQLITE
     AGENT --> WORKSPACE
     AGENT --> CRON
+    AGENT --> KG
+    AGENT --> MCP
+    KG --> SQLITE
     VALIDATE -.-> AGENT
 
     style Channels fill:#064e3b,stroke:#34d399,stroke-width:2px,color:#34d399
@@ -246,8 +281,10 @@ internal/
   config/               Config loading, env var resolution, validation
   cron/                 Cron scheduler for recurring tasks
   health/               Health checks, system metrics, Prometheus endpoint
+  knowledge/            Knowledge graph with Ebbinghaus memory decay (SQLite)
   llm/                  Multi-provider LLM gateway (OpenAI, Anthropic, Gemini)
   logging/              Structured leveled logger (JSON or human-readable)
+  mcp/                  Model Context Protocol client (stdio + SSE transports)
   memory/               SQLite-backed conversation store
   notify/               Email notifications via SMTP
   sandbox/              Linux namespace/cgroup sandboxing for tool execution
@@ -262,8 +299,8 @@ docs/                   Deploy tutorial, assets
 
 1. A message arrives via one of the channels (web UI, Telegram, or webhook).
 2. The agent saves the message to SQLite and builds a context window from conversation history.
-3. The system prompt is assembled from the base prompt plus workspace context.
-4. The LLM is called with the message history and available tools.
+3. The system prompt is assembled from the base prompt, workspace context, knowledge graph memories, and MCP tool listings.
+4. The LLM is called with the message history and available tools (including MCP tools from connected servers).
 5. If the LLM returns tool calls, the agent executes each skill and feeds results back.
 6. Steps 4-5 repeat (up to 10 iterations) until the LLM returns a text response.
 7. The response is saved to memory and returned to the channel.
@@ -438,6 +475,15 @@ config validation failed:
 | `PUT` | `/api/config` | Update configuration |
 | `POST` | `/api/webhooks` | Webhook endpoint (when enabled) |
 | `POST` | `/api/upload` | File upload |
+| `GET` | `/api/knowledge` | List knowledge graph entities |
+| `GET` | `/api/knowledge/search?q=` | Search entities by name |
+| `GET` | `/api/knowledge/stats` | Knowledge graph statistics |
+| `GET` | `/api/knowledge/:id/relations` | Get entity relationships |
+| `DELETE` | `/api/knowledge/:id` | Delete an entity |
+| `GET` | `/api/mcp` | List MCP connections and tools |
+| `POST` | `/api/mcp/connect` | Connect to an MCP server |
+| `POST` | `/api/mcp/disconnect` | Disconnect from an MCP server |
+| `GET` | `/api/mcp/tools` | List all available MCP tools |
 
 ## Security
 

cmd/pennyclaw/main.go

@@ -87,7 +87,7 @@ func main() {
 
 	// Start web server
 	srv := web.NewServer(cfg.Server.Host, cfg.Server.Port, ag.HandleMessage, cfg, *configPath,
-		ag.Memory(), version, ag.Workspace(), ag.Scheduler(), ag.SkillPack(), webhookHandler, ag.Health(), ag.TaskStore(), ag.NoteStore())
+		ag.Memory(), version, ag.Workspace(), ag.Scheduler(), ag.SkillPack(), webhookHandler, ag.Health(), ag.TaskStore(), ag.NoteStore(), ag.Graph(), ag.MCPManager())
 	go func() {
 		log.Printf("PennyClaw %s starting on %s:%d", version, cfg.Server.Host, cfg.Server.Port)
 		if err := srv.Start(); err != nil {

internal/agent/agent.go

@@ -13,7 +13,9 @@ import (
 	"github.com/mandarl/pennyclaw/internal/config"
 	"github.com/mandarl/pennyclaw/internal/cron"
 	"github.com/mandarl/pennyclaw/internal/health"
+	"github.com/mandarl/pennyclaw/internal/knowledge"
 	"github.com/mandarl/pennyclaw/internal/llm"
+	"github.com/mandarl/pennyclaw/internal/mcp"
 	"github.com/mandarl/pennyclaw/internal/memory"
 	"github.com/mandarl/pennyclaw/internal/notify"
 	"github.com/mandarl/pennyclaw/internal/sandbox"
@@ -38,6 +40,8 @@ type Agent struct {
 	health    *health.Checker
 	taskStore *skills.TaskStore
 	noteStore *skills.NoteStore
+	graph     *knowledge.Graph
+	mcpMgr    *mcp.Manager
 	// supportsTools indicates whether the LLM provider supports tool/function calling.
 	supportsTools bool
 }
@@ -104,6 +108,19 @@ func New(cfg *config.Config, dataDir string) (*Agent, error) {
 	// Register productivity skills (tasks, notes)
 	ts, ns := skills.RegisterProductivitySkills(skillRegistry, dataDir)
 
+	// Initialize knowledge graph
+	kg, err := knowledge.NewGraph(mem.DB())
+	if err != nil {
+		log.Printf("Warning: failed to initialize knowledge graph: %v", err)
+	}
+	if kg != nil {
+		log.Printf("Knowledge graph initialized")
+	}
+
+	// Initialize MCP manager
+	mcpManager := mcp.NewManager(dataDir)
+	log.Printf("MCP client manager initialized")
+
 	// Initialize health checker
 	hc := health.NewChecker(Version, provider.Name(), cfg.LLM.Model, len(skillRegistry.AsTools()))
 
@@ -118,6 +135,8 @@ func New(cfg *config.Config, dataDir string) (*Agent, error) {
 		health:        hc,
 		taskStore:     ts,
 		noteStore:     ns,
+		graph:         kg,
+		mcpMgr:        mcpManager,
 		supportsTools: supportsTools,
 	}
 
@@ -152,6 +171,28 @@ func New(cfg *config.Config, dataDir string) (*Agent, error) {
 	// Register cron skills
 	agent.registerCronSkills()
 
+	// Register knowledge graph skills
+	agent.registerKnowledgeSkills()
+
+	// Register MCP skills
+	agent.registerMCPSkills()
+
+	// Auto-connect configured MCP servers
+	go func() {
+		configs, err := mcpManager.LoadConfigs()
+		if err != nil {
+			log.Printf("Warning: failed to load MCP configs: %v", err)
+			return
+		}
+		for _, cfg := range configs {
+			if cfg.Enabled {
+				if err := mcpManager.Connect(context.Background(), cfg); err != nil {
+					log.Printf("Warning: failed to connect MCP server %s: %v", cfg.Name, err)
+				}
+			}
+		}
+	}()
+
 	// Update skill count now that all skills are registered
 	hc.UpdateSkillCount(len(skillRegistry.AsTools()))
 
@@ -443,12 +484,26 @@ func (a *Agent) handleMessage(ctx context.Context, sessionID, userMessage, chann
 
 		// If no tool calls, return the text response
 		if len(resp.ToolCalls) == 0 {
+			content := resp.Content
+			// Guard against empty responses — the LLM sometimes returns
+			// empty content when it's unsure how to proceed
+			if content == "" {
+				if i > 0 {
+					// We executed tools but got no summary — ask the LLM to summarize
+					messages = append(messages, llm.Message{
+						Role:    "user",
+						Content: "Please summarize what you just did and provide a helpful response to the user.",
+					})
+					continue
+				}
+				content = "I'm not sure how to help with that. Could you rephrase your request?"
+			}
 			// Save assistant response
-			if err := a.memory.SaveMessage(sessionID, "assistant", resp.Content, channel); err != nil {
+			if err := a.memory.SaveMessage(sessionID, "assistant", content, channel); err != nil {
 				log.Printf("Warning: failed to save response: %v", err)
 			}
 			a.health.RecordRequest(time.Since(start), nil)
-			return resp.Content, nil
+			return content, nil
 		}
 
 		// Execute tool calls
@@ -516,6 +571,22 @@ func (a *Agent) buildSystemPrompt() string {
 		prompt += "\n\n" + skillpackContext
 	}
 
+	// Add knowledge graph context
+	if a.graph != nil {
+		kgContext := a.graph.GetContext(20)
+		if kgContext != "" {
+			prompt += "\n\n--- Knowledge Graph (things I remember) ---\n" + kgContext
+		}
+	}
+
+	// Add MCP tools context
+	if a.mcpMgr != nil {
+		mcpTools := a.mcpMgr.Tools()
+		if len(mcpTools) > 0 {
+			prompt += fmt.Sprintf("\n\n--- MCP Tools (%d available from external servers) ---", len(mcpTools))
+		}
+	}
+
 	return prompt
 }
 
@@ -564,6 +635,16 @@ func (a *Agent) NoteStore() *skills.NoteStore {
 	return a.noteStore
 }
 
+// Graph returns the agent's knowledge graph.
+func (a *Agent) Graph() *knowledge.Graph {
+	return a.graph
+}
+
+// MCPManager returns the agent's MCP connection manager.
+func (a *Agent) MCPManager() *mcp.Manager {
+	return a.mcpMgr
+}
+
 // HealthCheck returns the agent's health status.
 func (a *Agent) HealthCheck() map[string]interface{} {
 	return map[string]interface{}{