Integrations

Nowledge Mem connects to the tools you actually use. Your knowledge stays in one place; the tools come and go.

Choose Your Path

Nowledge Mem has multiple integration options, but the first decision is simple: use a dedicated native integration when your tool has one. Only drop to shared packages, direct MCP, CLI, or import flows when there is no tool-specific path.

For most people, the decision tree is:

1. If your tool has a dedicated Nowledge integration, install that.
2. If your work mainly happens in ChatGPT, Claude, or Gemini on the web, install the browser extension.
3. If it does not have a dedicated package, but it supports shared skills or prompts, use a reusable workflow package.
4. Only use direct MCP when the client supports MCP but there is no better dedicated path.
5. Use the CLI when you want manual commands, scripts, or local automation.

Fastest Reusable Setup For Many Coding Agents

For OpenCode and other agent environments supported by the skills installer:

npx skills add nowledge-co/community/nowledge-mem-npx-skills

This installs four skills: search-memory, read-working-memory, save-handoff, and distill-memory. After setup, your agent reads context at session start, routes recall across memories and threads when relevant, and saves resumable handoffs when asked.

If your tool has its own reusable package instead of the generic skills path, use that dedicated guide. Codex, for example, should follow the Codex CLI guide.

Dedicated Nowledge Integrations And Full Session Capture

If you need the actual recorded session, not just a resumable summary, the path matters.

For the fuller thread matrix and import paths, see Threads.

Agent Intent Control For Custom Agents

Native integrations already bundle behavior rules that teach the agent when to read Working Memory, search past knowledge, or save durable insights.

If your agent does not have a dedicated plugin or extension, you should configure that intent directly.

Step 1: Give The Agent A Memory Surface

Use one of these:

• npx skills for shared skill-based behavior
• nmem CLI for terminal-visible commands
• MCP when the client can call tools directly

Step 2: Add A Short Intent Policy

Put a policy like this in AGENTS.md, CLAUDE.md, GEMINI.md, or the system prompt:

## Nowledge Mem

Use Nowledge Mem as your external memory system.

At session start:
- Run `nmem --json wm read` once to load current priorities and recent context.
- Do not re-read it on every turn unless the user asks or the session context changed materially.

Search proactively when:
- the user references previous work, a prior fix, or an earlier decision
- the task resumes a named feature, bug, refactor, or subsystem
- a debugging pattern resembles something solved earlier
- the user asks for rationale, preferences, procedures, or recurring workflow details

Retrieval routing:
- Start with `nmem --json m search` for durable knowledge.
- Use `nmem --json t search` when the user is asking about a prior discussion or exact conversation history.
- If a result includes `source_thread`, inspect it progressively with `nmem --json t show <thread_id> --limit 8 --offset 0 --content-limit 1200`.

When preserving knowledge:
- Use `nmem --json m add` for genuinely new durable knowledge.
- If an existing memory already captures the same decision, preference, or workflow and the new information refines it, use `nmem m update <id> ...` instead of creating a duplicate.
- Use a handoff save only when the user explicitly asks for a resumable checkpoint or handoff summary.

For MCP-only agents, use the same policy but replace the commands with the tool names read_working_memory, memory_search, thread_search, thread_fetch_messages, memory_add, and memory_update.

Step 3: Keep The Prompt Direct

The best intent prompts are short and operational. Tell the agent exactly:

• when to read Working Memory
• when to search proactively
• when to use thread tools instead of memory search
• when to add a new memory versus update an existing one
• when handoff save is explicit-only

Model Context Protocol (MCP)

MCP is Nowledge Mem's compatibility layer for tools that speak MCP directly. Use it when your client supports MCP but does not have a dedicated Nowledge integration.

Packaged Integrations vs Direct MCP

MCP Capabilities

• Search memories: memory_search
• Read Working Memory: read_working_memory
• Add memories: memory_add
• Update memories: memory_update
• List memory labels: list_memory_labels
• Save/Import threads: thread_persist
• Prompts: sum (distill to memory), save (create a handoff summary 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://127.0.0.1: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, add these instructions to your agent's system prompt or CLAUDE.md/AGENTS.md:

## Nowledge Mem Integration

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

**At Session Start (`read_working_memory`):**
- Call `read_working_memory` for today's briefing
- Understand user's active focus areas, priorities, and unresolved flags
- Reference this context naturally when it connects to the current task

**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

**When to Update Existing Memories (`memory_update`):**
- Search before saving when the topic looks familiar
- If recall already surfaced the same decision, preference, or workflow, update that memory instead of adding a near-duplicate
- Use updates when the new information refines, corrects, or extends durable knowledge

**When to Search Threads (`thread_search` / `thread_fetch_messages`):**
- User is asking about a prior discussion or exact conversation history
- A memory result points to a source thread
- Fetch messages progressively instead of dumping long threads all at once

This enables autonomous memory operations in Claude Desktop, Cursor manual MCP setups, ChatWise, and other MCP-only apps.

Browser Extension

Capture memories from supported web AI chat platforms, with auto-capture, manual distill, and thread backup.

Threads

Import and manage conversations from coding agents, exported files, the API, or the command line.

Tool Guides

Browse the setup guide that matches the product you actually use. Some are native integrations, some are built-in paths, and some are reusable workflow packages.

If you want to verify that a guide really worked after setup, use How To Know Mem Is Working.

Related guides: Claude Code · Droid · Cursor · Claude Desktop · Codex CLI · Gemini CLI · Alma · OpenClaw · Raycast · Other Chat AI

LLM-Friendly Documentation

Every page on this docs site is available as clean Markdown for AI agents and LLMs. Request any docs URL with the Accept: text/markdown header:

curl -H "Accept: text/markdown" https://mem.nowledge.co/docs/integrations

No authentication required.

API Integration

RESTful API for programmatic access.

Command Line Interface (CLI)

The nmem CLI provides terminal access to your knowledge base.

Installation

Quick Start

# Check connection
nmem status

# Search memories
nmem m search "project notes"

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

# Save Claude Code/Codex/Gemini sessions
nmem t save --from claude-code
nmem t save --from codex -s "Summary of what was accomplished"
nmem t save --from gemini-cli -s "Summary of what was accomplished"

AI Agent Integration

# 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

Command Reference

Next Steps

• Troubleshooting: Common issues and solutions
• Background Intelligence: Knowledge graph, insights, and daily briefings