Integrations

Nowledge Mem seamlessly integrates with your existing AI tools and workflows, enabling you to capture insights and access memories without disrupting your flow.

Model Context Protocol (MCP)

MCP (Model Context Protocol) is the primary integration method for AI agents to interact with Nowledge Mem.

Two Integration Paths

MCP Capabilities

• Search memories: memory_search
• Add memories: memory_add
• Update memories: memory_update
• List memory labels: list_memory_labels
• Save/Import threads: thread_persist
• Prompts: sum (summarize to memory), save (checkpoint thread)

MCP Server Configuration

Nowledge Mem MCP Server

Server Endpoint

http://localhost:14242/mcp

Configuration Guide and Examples

Cursor GuideChatWise GuideFor Any Agent

For clients like Cursor, use this JSON snippet in their settings.

{
  "mcpServers": {
    "nowledge-mem": {
      "url": "http://localhost:14242/mcp",
      "type": "streamableHttp",
      "headers": {
        "APP": "Cursor"
      }
    }
  }
}

Guide

MCP Supported Services

Cursor

ChatWise

Claude Desktop

Claude Code

Github Copilot

Trae

Codex

Gemini Cli

Qwen Code

+ any agent that supports MCP

System Prompts for Autonomous Behavior

For MCP-only apps to act autonomously (without explicit commands), add these instructions to your agent's system prompt or CLAUDE.md/AGENTS.md file:

## Nowledge Mem Integration

You have access to Nowledge Mem for knowledge management. Use these tools proactively:

**When to Search (`memory_search`):**
- Current topic connects to prior work
- Problem resembles past solved issue
- User asks about previous decisions ("why did we choose X?")
- Complex debugging that may match past root causes

**When to Save Memories (`memory_add`):**
- After solving complex problems or debugging
- When important decisions are made with rationale
- After discovering key insights ("aha" moments)
- When documenting procedures or workflows
- Skip: routine fixes, work in progress, generic Q&A

**Memory Categories (use as labels):**
- insight: Key learnings, realizations
- decision: Choices with rationale and trade-offs
- fact: Important information, data points
- procedure: How-to knowledge, workflows
- experience: Events, conversations, outcomes

**Memory Quality:**
- Atomic and actionable (not vague)
- Standalone context (readable without conversation)
- Focus on "what was learned" not "what was discussed"

**Importance Scale (0.1-1.0):**
- 0.8-1.0: Critical decisions, breakthroughs
- 0.5-0.7: Useful insights, standard decisions
- 0.1-0.4: Background info, minor details

**When to Save Threads (`thread_persist`):**
- Only when user explicitly requests ("save this session")
- Never auto-save without asking

This enables autonomous memory operations in apps like Claude Desktop, Cursor, and ChatWise.

Browser Extension

For web-based AI chat services, you can import entire conversations into Nowledge Mem with a single click, powered by Nowledge Mem Exchange, the browser extension for Nowledge Mem.

With this method, the conversation is first imported as a thread, then you can trigger Memory Distillation from within the app to extract individual memories from the conversation.

Nowledge Mem comes with a browser extension: Nowledge Mem Exchange. When you are in a supported AI chat page, click on the Nowledge Mem icon to parse & import the conversation.

Browser Extension Supported Services

ChatGPT

Gemini

Claude

Perplexitycoming soon

Poecoming soon

Qwencoming soon

+ many more

Download Extension

Chrome

Browser extension to capture conversations from Web AI chat services.

Get Extension

Firefox

Browser extension to capture conversations from Web AI chat services.

Get Extension

Edge

Browser extension to capture conversations from Web AI chat services.

Get Extension

Arc

Browser extension to capture conversations from Web AI chat services.

Get Extension

Additionally, Nowledge Mem Exchange also supports to download any conversation thread from web-based AI chat services as a .md file, which can be imported into Nowledge Mem later or archive/share with others..

For anyone who would like to convert your own conversation thread in other formats into a .md file that's importable to Nowledge Mem, here is a format reference: MD Format Reference, where, Nowledge Mem thread file format follows cursor's thread file format.

Thread File Import

Import conversations from your favorite AI tools by uploading exported conversation files directly into Nowledge Mem.

Bulk Import (Multiple Threads at Once)

For users with large conversation histories, Nowledge Mem supports bulk importing all your conversations from a single export file:

Single Thread Import

For importing individual conversations:

File based Conversation Import

Bring your existing knowledge from other apps into Nowledge Mem by importing conversation files.

How It Works

1

Navigate to Threads

Go to the 'Threads' section from the main sidebar.

2

Start the Import

Click the 'Import Thread' button to open the file.

3

Select & Preview

Choose your exported file & select messages to import.

Supported Formats

Bulk Import (Multiple Threads)

ChatGPT Data Export

chat.html from Settings → Data controls → Export data

ChatWise ZIP Export

Export all chats as .zip from ChatWise app

Single Thread Import

Cursor Exports

Cursor .md exported conversation files.

ChatWise HTML

Single conversation .html export.

Generic Markdown

Cursor exported compatible .md files.

Grow with Us

We are working hard to support more import sources. For any tools you'd love to see integrated, please let us know.

Request or Contribute an Integration

For user who are interested in building your own conversation file exchanging tools ready for Nowledge Mem, we have following options:

• Calling Thread API to create a thread from your tool, ref
• Converting your conversation thread to a .md file that's importable to Nowledge Mem, ref

Tight Integrations

Apart from general MCP, Browser Extension, and Thread File Import, Nowledge Mem is also tightly integrated with some popular AI tools for your convenience.

For instance Claude Desktop Extension, Claude Code plugin, Codex Custom Commands.

For some other cool AI Tools like DeepChat and LobeHub Desktop, Nowledge Mem is built-in as an external memory option.

Claude Desktop

Nowledge Mem provides a one-click extension for Claude Desktop, enabling Claude to search, update, and add memories to your Nowledge Mem knowledge base.

which brew || /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
python3.13 --version || /opt/homebrew/bin/brew install python@3.13

Note, if you failed to enable Mem in Claude Desktop, check logs via tail -n 20 -F ~/Library/Logs/Claude/mcp*.log and share with us.

Claude Code

Use Nowledge Mem directly from Claude Code via the CLI-based plugin. The plugin includes skills that automatically:

• Search your knowledge base when relevant context exists
• Suggest distillation at breakthrough moments
• Save sessions on explicit request

# Add the Nowledge community marketplace
claude plugin marketplace add nowledge-co/community

# Install the Nowledge Mem plugin
claude plugin install nowledge-mem@nowledge-community

# Option 1 (Recommended): Use uvx (no installation needed)
curl -LsSf https://astral.sh/uv/install.sh | sh
uvx nmem --version

# Option 2: Install with pip
pip install nmem

claude plugin marketplace update
claude plugin update nowledge-mem@nowledge-community
# Restart Claude Code to apply changes

{
  "hooks": {
    "SessionEnd": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "nmem t save --from claude-code"
          }
        ]
      }
    ]
  }
}

Autonomous Knowledge Capture

For proactive memory management, create a custom agent that automatically captures insights, decisions, and learnings during your work.

See the complete example: AGENTS.md

This example shows how to:

• Create a memory-keeper agent for autonomous knowledge capture
• Use the 5 memory categories (insight, decision, fact, procedure, experience)
• Apply importance scoring (0.1-1.0)
• Link memories to source threads with --source-thread
• Combine agents with hooks for comprehensive session management

The AGENTS.md file follows the universal agents.md standard and works with any AI coding agent.

Codex CLI

Use Nowledge Mem with Codex using the nmem CLI and custom prompts for a streamlined experience.

# Option 1 (Recommended): Use uvx (no installation needed)
curl -LsSf https://astral.sh/uv/install.sh | sh
uvx nmem --version

# Option 2: Install with pip
pip install nmem

curl -fsSL https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-codex-prompts/install.sh | bash

curl -fsSL https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-codex-prompts/install.sh -o /tmp/install.sh && bash /tmp/install.sh --force && rm /tmp/install.sh

Troubleshooting

• "Command not found: nmem" → Use uvx nmem or install with pip install nmem
• "Command not found: uvx" → Install uv with curl -LsSf https://astral.sh/uv/install.sh | sh
• Sessions not listing → Ensure you're in the correct project directory

DeepChat

DeepChat comes with built-in Nowledge Mem integration, allowing one-click switch on memory saving and searching over Nowledge Mem.

LobeHub

LobeHub(formerly LobeChat) comes with built-in Nowledge Mem integration, allowing one-click switch on memory saving and searching over Nowledge Mem.

API Integration

Nowledge Mem provides RESTful APIs for you to leverage your knowledge freely.

Command Line Interface (CLI)

For developers and AI agents, Nowledge Mem includes a CLI tool called nmem that provides terminal access to your knowledge base.

Installation

Quick Start

# Check connection
nmem status

# Search memories
nmem m search "project notes"

# List recent memories
nmem m

# Create a memory
nmem m add "Important insight" --title "Project Learnings"

# Search threads
nmem t search "architecture"

# Save Claude Code/Codex sessions (auto-import)
nmem t save --from claude-code
nmem t save --from codex -s "Summary of what was accomplished"

# Create a thread from content
nmem t create -t "Session Notes" -c "Key discussion points..."

# Create a thread from file
nmem t create -t "Meeting Notes" -f notes.md

AI Agent Integration

The CLI is designed for AI agent workflows with JSON output:

# Get JSON output for parsing
nmem --json m search "API design"

# Chain commands
ID=$(nmem --json m add "Note" | jq -r '.id')
nmem --json m update "$ID" --importance 0.9

# Multi-message thread creation
nmem t create -t "Session" -m '[{"role":"user","content":"Q"},{"role":"assistant","content":"A"}]'

Command Reference

Next Steps

Having trouble with your setup? Check the troubleshooting guide:

• Troubleshooting - Common issues and solutions
• Advanced Features - Explore knowledge graph capabilities