Self-Learning MCP Server

Self-improving memory for AI agents — Antigravity-native MCP server

A persistent memory system that lets AI agents learn from their own work. Records tasks, extracts patterns, detects mistakes, and proactively surfaces insights — all using the agent's own model through a cooperative intelligence pattern.

Quick Start (Antigravity)

# 1. Clone and build
git clone <repo-url> && cd Self-Learning-MCP
npm install && npm run build

# 2. Register in Antigravity
node dist/src/cli.js init

That's it. No API keys. No model config. No env vars. The server uses Antigravity's own model for all reasoning.

How It Works

Agent-Cooperative Intelligence

Unlike traditional memory systems that need their own LLM, this server uses a cooperative pattern:

Server handles storage, retrieval, and structuring (SQLite + FTS5)
Agent (running on Antigravity's model) does all reasoning and synthesis
Agent commits learned patterns back to the server

Agent does work → calls mem_end_task → server returns synthesis context
→ agent reasons over it → calls mem_commit_synthesis → patterns stored
→ next task: mem_get_briefing → patterns influence approach

The Learning Loop

┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
│  Record  │────▶│  Recall  │────▶│Synthesize│────▶│ Proactive│
│          │     │          │     │          │     │          │
│ Tasks    │     │ Briefings│     │ Patterns │     │ Insights │
│ Steps    │     │ Context  │     │ Anti-pat │     │ Drift    │
│ Errors   │     │ Wiki     │     │ Wiki     │     │ Risks    │
└──────────┘     └──────────┘     └──────────┘     └──────────┘

Compact Wire Codec

All tool outputs use a token-efficient format (~77% smaller than verbose JSON):

Verbose: {"type":"pattern","description":"validate webhooks","confidence":0.95,"tags":["api","security"]}
Compact: {"t":"P","d":"validate webhooks","c":95,"ta":"api|security"}

Tools Reference

Record (6 tools)

Tool	Description
`mem_start_task`	Begin a task trace `{d, j?, conv?}` → `{tid, has_insights}`
`mem_record_step`	Record a step `{tid, action, tool?, result?, ok?}`
`mem_record_correction`	Record a correction `{tid, wrong, fix, cause?}`
`mem_end_task`	Close trace `{tid, outcome?, summary?}` → synthesis context
`mem_store_entity`	Store entity `{t, nm, d?, j?, obs?[]}`
`mem_add_relationship`	Create edge `{src, tgt, rel}`

Recall (6 tools)

Tool	Description
`mem_recall`	Full-text search `{q, n?, t?, j?}`
`mem_get_context`	Context packet for topic `{topic, j?}`
`mem_get_wiki`	Retrieve wiki `{j?, sec?}`
`mem_query_graph`	Structured query `{t?, rel?, j?, since?, n?}`
`mem_get_entity`	Entity details `{id}`
`mem_get_briefing`	Pre-task intelligence `{d, j?}`

Cooperative (3 tools)

Tool	Description
`mem_commit_synthesis`	Commit learned patterns `{tid, patterns[], anti[]}`
`mem_commit_wiki`	Save wiki sections `{sections[{sec, j?, x}]}`
`mem_regenerate_wiki`	Gather wiki context `{j?}`

Proactive (3 tools)

Tool	Description
`mem_get_insights`	Active insights `{t?, n?}`
`mem_dismiss_insight`	Dismiss insight `{id, reason?}`
`mem_set_watch`	Set watch `{condition, entity_id?}`

Compact Codec Decoder Ring

Short Key	Full Name
`t`	type
`d`	description
`c`	confidence (0-100)
`h`	hit count
`j`	project
`nm`	name
`x`	content
`n`	count / total
`tid`	task ID
`ok`	success
`ts`	timestamp
`sec`	section

Entity Types: T=task, P=pattern, E=error, S=solution, J=project, C=code, R=person

Relationships: RB=resolved_by, DP=depends_on, CB=caused_by, IB=improved_by, FB=followed_by, TF=transferred_from, EF=extracted_from, UI=used_in

Configuration

All optional, via environment variables:

Variable	Default	Description
`SELF_LEARNING_MCP_DB`	`~/.gemini/antigravity/self-learning-mcp/memory.db`	Database path
`SELF_LEARNING_MCP_PROACTIVE_MIN`	`30`	Minutes between proactive analysis
`SELF_LEARNING_MCP_STALENESS_DAYS`	`30`	Days before pattern flagged stale
`SELF_LEARNING_MCP_CODEC`	`compact`	Wire format: `compact` or `verbose`
`SELF_LEARNING_MCP_LOG`	`info`	Log level

Architecture

src/
├── server.ts              # MCP entry point + proactive engine startup
├── config.ts              # Env-var configuration
├── cli.ts                 # Init command for Antigravity setup
├── codec/                 # Token-efficient wire format
│   ├── types.ts           # Type codes, field maps
│   ├── encoder.ts         # Internal → compact
│   ├── decoder.ts         # Compact/verbose → internal
│   └── index.ts           # Public API
├── db/
│   ├── schema.sql         # SQLite schema (13 tables + 5 FTS5)
│   └── database.ts        # Database class (SQL embedded)
├── tools/
│   ├── record.ts          # 6 recording tools
│   ├── recall.ts          # 6 recall tools
│   ├── cooperative.ts     # 3 synthesis tools
│   └── proactive.ts       # 3 proactive tools
├── wiki/
│   └── generator.ts       # Wiki context gathering
└── proactive/
    ├── engine.ts           # Hybrid scheduler orchestrator
    ├── staleness-detector.ts
    ├── drift-detector.ts
    ├── risk-forecaster.ts
    ├── opportunity-surfacer.ts
    ├── briefing-assembler.ts
    └── index.ts

Generic MCP Usage

Works with any MCP client, not just Antigravity. Add to your MCP config:

{
  "mcpServers": {
    "self-learning-mcp": {
      "command": "node",
      "args": ["/absolute/path/to/Self-Learning-MCP/dist/src/server.js"]
    }
  }
}

The difference: without instructions.md, the client agent needs to know when to call the memory tools on its own.

License

MIT