Connectors

Nowledge Mem connectors let the tools you actually use share the same memory. Your knowledge stays in one place; the tools come and go.

The One-Prompt Connect

The fastest way to connect a supported AI tool is one prompt:

Read https://mem.nowledge.co/SKILL.md and follow the instructions to install or update Nowledge Mem for the AI tool I am using.

Paste this into Claude Code, Grok Build, Codex, Cursor, Gemini CLI, Copilot CLI, OpenClaw, Hermes, Droid, Alma, Bub, Pi, OpenCode, Kimi Code, ZCode, MiMo Code, OMP, or Claude Desktop. The agent reads SKILL.md, detects which host it is in, uses the matching setup path, verifies the connection, and tells you what to restart. Command-line hosts can usually be installed directly. App-based hosts may still ask you to confirm a marketplace step.

For remote or cross-device access, configure nmem once with nmem config client set --url ... --api-key .... In the desktop app, remote URL and key controls live under Settings → Access Anywhere.

The pages below are still useful: they describe per-tool behavior (Context Bundle or Working Memory startup, recall, distillation, save-thread paths) and the small set of surfaces that install differently (Browser Extension, Raycast, trajectory extractors). Start with the one prompt, then use the per-tool page when you need behavior details or troubleshooting.

The Autonomy Ladder

The same Mem server can feel very different depending on how your tool connects to it.

The practical rule is simple: install the most specific Nowledge path your host supports. Only fall back to generic MCP when there is no better package.

A small but important exception: some hosts work best as a hybrid. Codex is the clearest example today. Install the Codex package for Context Bundle / Working Memory guidance, automatic thread capture, bundled local MCP, and nmem fallback. If you use remote Mem or a custom local port, override the bundled MCP endpoint in Codex config.

How Thread Sync Works

Mem has three thread-sync paths. They are designed to meet at the same saved thread, not create copies.

The important boundary is where the transcript lives. If Mem runs on another machine, that server cannot scan your laptop's ~/.codex, ~/.claude, ~/.gemini, ~/.pi, or OpenCode database. Run the connector or nmem t sync on the machine where the AI tool runs; it will upload to your local or remote Mem server using the same nmem client config.

These paths use the same source names and stable thread IDs. For example, Claude Code imports land in claude-code-<sessionId> whether they came from the desktop watcher, the Claude Code hook, or a historical nmem t sync run.

If an import stops halfway through, run it again. Historical sync previews first, processes sessions one by one, and reruns append with deduplication instead of duplicating messages.

Choose Your Path

Nowledge Mem has multiple connector options, but the first decision is simple: use a dedicated native connector 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 connector, 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, except for hybrid hosts like Codex where the dedicated package and MCP are meant to be used together.
5. Use the CLI when you want manual commands, scripts, or local automation.

Remote MCP Over OAuth

Use this when an AI client asks for a remote MCP URL with OAuth. ChatGPT Connectors is the most common example: create the connector from ChatGPT Web settings, then use it from ChatGPT Web or desktop by mentioning @Nowledge Mem. The same Mem URL also works for other OAuth-capable MCP clients.

In the Mem desktop app:

1. Open Connectors.
2. Find Remote MCP over OAuth.
3. Click Start setup. Mem starts Access Anywhere if needed.
4. Copy the Access Anywhere MCP endpoint shown in the guide. It must end with /mcp, for example:

https://your-access-anywhere-domain.example/mcp

For ChatGPT as a reference flow:

1. Open ChatGPT Connectors Advanced settings.
2. Choose Create in Connectors.
3. Paste the Mem MCP endpoint.
4. Continue through ChatGPT's connector setup.
5. When Mem opens the OAuth approval page, approve access.
6. In ChatGPT Web or desktop, mention @Nowledge Mem when you want ChatGPT to search Mem.

Other OAuth MCP clients use the same endpoint. The important part is that you paste the public /mcp URL from Mem, not the normal web app URL and not a private nmem_ API key.

For the full ChatGPT screenshot walkthrough, see ChatGPT Web and Desktop.

Fastest Reusable Setup For Many Coding Agents

For agent environments supported by the skills installer:

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

This installs reusable memory skills for startup context, search, handoff, and distillation. Your agent still decides when to use them; native connectors and MCP setup give stronger automatic behavior when your tool supports them.

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 guide.

Dedicated Nowledge Connectors 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 connectors already bundle behavior rules that teach the agent when to read Context Bundle or Working Memory, search past knowledge, or save durable insights.

If you want the full host-by-host map, see Customize Connector Behavior.

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

## Nowledge Mem

Use Nowledge Mem as your external memory system.

At session start:
- Run `nmem --json context --source-app "<host>"` when identity, active space, Rules, or multi-agent behavior could matter.
- Use `nmem --json wm read` for a lightweight daily briefing or older `nmem` clients.
- If Context Bundle already includes Working Memory, do not immediately read Working Memory again.
- If the host already knows the current project, agent, or workspace space, add `--space "<space name>"` to Context Bundle, Working Memory, memory search, thread search, and save commands.
- If this agent is launched by a multi-agent orchestrator, keep `--source-app` as the AI tool being launched. In that worker process, set `NMEM_AGENT_ID="<agent id>"` so Mem can load that worker's identity.

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.

nmem agents upsert cindy \
  --name "Cindy" \
  --default-space onboarding \
  --instructions "Help with onboarding. Explain one step at a time."

NMEM_AGENT_ID="cindy"

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 connector.

Packaged Connectors vs Direct MCP

MCP Capabilities

• Search memories: memory_search
• Read Context Bundle: read_context_bundle
• Read Working Memory: read_working_memory
• Add memories: memory_add
• Update memories: memory_update
• List memory labels: list_memory_labels
• Find saved threads: thread_search, thread_fetch_messages, search_thread_messages
• Prompts: sum (distill durable decisions, procedures, and learnings to memory)

MCP does not import local transcript files. Use the native connector when your tool has one, or run nmem t save --from claude-code, nmem t save --from grok, nmem t save --from codex, or nmem t save --from gemini-cli on the machine where the agent runs. This keeps capture local and works the same way for local and remote Mem.

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. For remote Mem, run nmem config mcp show --host cursor and paste the generated block instead.

{
  "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 Memory Tools

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
- If the task is a continuation, review, regression, release, or prior-decision question, follow the briefing with targeted recall instead of stopping there

**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
- Review, release, docs-alignment, or connector-behavior questions often deserve an early search too

**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
- At the end of substantial work, review whether one durable memory should be added or updated
- Skip: routine fixes, work in progress, generic Q&A
- Pass `unit_type` when you know it: `fact`, `preference`, `decision`, `plan`, `procedure`, `learning`, `context`, or `event`

**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
- Escalate to thread search only when exact prior discussion matters

This gives MCP-only apps a strong guided path. It still does not turn raw MCP into a hook-driven native connector, so prefer the dedicated package when one exists.

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 connectors, 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 · Grok Build · Droid · Cursor · Claude Desktop · Codex · OpenCode · Pi · Kimi Code · ZCode · MiMo Code · OMP · Hermes Agent · Proma · 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

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/Grok Build/Codex/Gemini sessions
nmem t save --from claude-code
nmem t save --from grok
nmem t save --from codex -s "Summary of what was accomplished"
nmem t save --from gemini-cli -s "Summary of what was accomplished"

AI Agents

# 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