Cognee MCP is my new AI Memory for making rules

Brian

• 3 min read
Cognee MCP is my new AI Memory for making rules

It started with a simple mistake. I'd create new documentation pages for our Mintlify site, get them ready for review, and then... they'd be invisible on the live site. Every single time, I'd forget to add them to docs.json.

That's when I realized I needed something smarter than sticky notes. Then I discovered the Cognee MCP, an AI memory engine that learns from every interaction and actually remembers what you teach it.

The Problem: My Assistant Had Goldfish Memory

Here's the thing about migrating hundreds of documentation pages: you hit the same issues repeatedly. During our Continue docs migration to Mintlify, I kept forgetting a crucial step. Mintlify keeps new pages hidden by default, which is great for drafting, but terrible when you push to production and wonder why your new docs are MIA.

The continue-mcp reference page? Almost went to a PR review completely invisible. It wasn't just one page either, it was every new file I created. I'd forget to add to docs.json. My AI assistant was no help; it would generate perfect documentation but never remind me about this critical step.

Every time I'd catch the mistake in review, fix it, and then... nothing. Next documentation page, same oversight. It was like Groundhog Day, but for missing docs.

The Solution: An AI That Actually Learns

Cognee MCP turns your local machine into a memory palace for your AI assistant. Unlike sending your data to some cloud service, everything stays local, your interactions become a searchable knowledge graph powered by LanceDB and Kuzu.

What sold me wasn't the tech stack (though it's pretty sweet). It was this: Cognee suggested using the Mintlify MCP to ensure we always use the latest syntax. Then it recommended indexing our docs.json so it would never hallucinate the syntax again.

An AI suggesting how to make itself smarter? Now we're talking.

Setting Up Cognee MCP in Continue

git clone https://github.com/topoteretes/cognee.git
cd cognee/cognee-mcp
pip install uv
uv sync --dev --all-extras --reinstall
source .venv/bin/activate
python src/server.py

Now for the Continue integration. Add this to your config.yaml:

mcpServers:
  - name: cognee
    command: uv
    args:
      - --directory
      - /path/to/your/cognee-mcp
      - run
      - cognee
    env:
      TOKENIZERS_PARALLELISM: "false"
      LLM_API_KEY: "sk-your-api-key"

The Magic: Project Rules That Learn

Here's where it gets interesting. Create .continue/rules/cognee_rules.yaml in your project:

---
name: Generate rules during chat from user-agent interaction
alwaysApply: true
description: >
  Cognee's save_interaction tool captures every exchange,
  building a memory of what works and what doesn't.
rules:
  - tool: save_interaction
    auto: true

Now every interaction gets stored. When I explained that new Mintlify pages need to be added to docs.json, Cognee remembered. When I showed it where to add entries in the navigation structure, it learned. The next time I created a new documentation page, my assistant knew to remind me and in agent mode, it could even add the entry automatically.

Real Results from Real Work

During the migration, Cognee caught patterns I didn't even realize I was teaching:

  • It learned to check docs.json whenever I created new .mdx files
  • It started suggesting the correct navigation structure based on file location
  • It remembered to add pages to the appropriate section (like adding continue-mcp to the reference section at line 263)

The kicker? It works with your existing Continue workflow. You're not learning a new tool, you're just making your current assistant smarter.

Tips from the Trenches

When Rules Don't Generate: Check your database connection. Cognee needs proper setup to build its knowledge graph.

Model Quality Matters: Better models = better rule inference. Don't skimp here.

Start Simple: Begin with obvious patterns like syntax corrections. Let Cognee learn your style gradually.

Your Assistant Should Remember

We're all context engineering these days, but why should we repeat the same context every session? Cognee MCP solves this by giving your AI assistant actual memory.

The Mintlify migration taught me something: the best documentation tool isn't the one with the most features. It's the one that learns from how you actually work. And when your AI assistant remembers that every new page needs a docs.json entry? That's when you know you've found something special.

Try it on your next migration. Let your assistant learn. Because honestly, we've got better things to do than teach the same lessons twice.

Want to see the results? Check out docs.continue.dev and see the pages features referenced in the article.