Open connectors
In Claude, open your account menu and go to
Settings -> Connectors
PeppermintConnect MCPMCP memory for agents
Connect Peppermint to your Claude
Give Claude private MCP memory for the work context your team already has. Peppermint brings decisions, artifacts, blockers, and next steps into the conversation without making the user rebuild the story.
Add Peppermint
Choose Add custom connector, name it Peppermint, and paste:
https://api.peppermint.com/mcp/Connect in chat
Authenticate with Peppermint, then enable the connector from the chat tools menu when you need work memory.
TipClaude web and Claude Desktop use the Connectors UI for remote MCP. This is the clearest path for non-terminal users.
MCP memory for coding agents
Give agents the work memory they cannot infer from code.
Peppermint is a private AI memory and work-context layer for teams. Through MCP, Claude Code, Codex, Cline, and other agents can ask for source-grounded context before they summarize, plan, edit, or delegate.
The agent starts with the thread of work.
Peppermint MCP gives coding agents access to decisions, source artifacts, blockers, owners, and next steps before they plan or edit.
Claude Code and Codex get what the repo cannot know.
Repository context is only part of the story. Peppermint brings in the work context around the code: docs, meetings, tickets, notes, and recent decisions.
Read-first memory keeps agents useful and bounded.
Agents can retrieve private, source-grounded context without getting broad write power. When memory is incomplete, they should ask before acting.
What it does
Your agent asks Peppermint before it guesses.
The MCP server turns work memory into a callable context layer: decisions, artifacts, collaborators, blockers, and next steps returned directly inside the agent session.
Integration lanes
Memory should follow the agent, not the tab.
Peppermint MCP is the agent-facing memory surface. Tool-specific integrations can feed that memory or call it, but the canonical story stays the same: agents ask Peppermint for context before they act.
Claude Code, Codex, and Cline
Coding agents can use Peppermint MCP to retrieve launch decisions, product context, source artifacts, blockers, and owners before editing files.
Obsidian as context, not the headline
Obsidian can become a powerful source of user-approved notes, backlinks, tags, and knowledge graph context. It belongs in the integration lane, not as the core page promise.
Slack, docs, Linear, and meetings
The most useful agent memory often lives outside the repo: decisions, handoffs, customer notes, specs, threads, and status updates scattered across the tools where work happened.
Agent questions
Agents do not need more tabs. They need user context.
These are the questions a useful agent asks before it edits, drafts, responds, escalates, or decides what to do next.
State
I am an autonomous agent picking up Liam's work. What context should I know before I act?
DecisionsWhat decisions has Liam already made that I should not make him re-explain?
ArtifactsWhat work artifacts explain the current Peppermint MCP direction?
RisksWhat would be risky for an agent to assume about Liam's current work?
Next moveWhat should an agent do next if it wants to help Liam without interrupting him?
CollaboratorsWho has Liam been collaborating with, and what context should an agent preserve?
Proposed tool surface
Start read-first. Make the agent useful before it acts.
This is the public shape of the MCP server: context, evidence, and artifacts that help the agent make better decisions before it acts.
memory.searchRead
Find relevant work context across connected apps before the agent guesses.
artifact.lookupRead
Surface the docs, tickets, Slack threads, and notes behind an answer.
decision.summaryRead
Recover what was already decided, who decided it, and what changed.
status.briefRead
Give an agent a compact project brief before it takes the next step.
Security model
Give agents memory, not unlimited power.
Peppermint should be positioned as a private, scoped memory layer. The agent gets enough context to help, while the user keeps control over authentication, permissions, and what the agent can do next.
Prefer scoped auth
Use OAuth where the client supports it, and scoped bearer tokens where it does not.
Permission-aware recall
Agents should retrieve context from sources the user connected.
Read-first by default
Memory lookup should be the first win before any write actions.
FAQ
Questions an agent builder will ask immediately.
MCP memory is a way for AI agents to retrieve useful context through the Model Context Protocol instead of relying only on the current prompt or a model's built-in memory. Peppermint makes that memory private, source-grounded, and connected to the work your team already did.
No. This page is for connecting Peppermint as an MCP server so agents can retrieve the user's work memory. The app and backend wiring can evolve behind the same setup surface.
Start with state: what the user is working on, what changed recently, what was already decided, which artifacts matter, what is blocked, and what the safest next step is.
The first useful surface is searchable memories, source snippets, structured facts, summaries, artifacts, source type, recency, tags, and ranked matches across connected work tools.
Treat docs, tickets, Slack threads, notes, and files as evidence. Return artifact names or links when available, and avoid unsupported summaries when Peppermint does not have the source context.
The agent should say the context is incomplete and ask the user before acting. The product should make good agents less interruptive, not more confident while guessing.
The strongest first version is read-first: retrieve context before writing, sending, deleting, or changing anything. Later write actions should be explicit, scoped, and permissioned.
Peppermint should be scoped and permission-aware. Agents retrieve context from sources the user connected, with private memory and shared team context handled as different trust boundaries.
Use Claude connector setup for non-terminal users. Use Claude Code, Codex, and Cline when the agent is editing code. Treat OpenClaw and Hermes Agent as runtime-specific paths while their setup surfaces vary.
Built-in memory is usually model-specific and easy to lose when the interface changes. Peppermint is an external work-memory layer anchored in the user's connected tools and artifacts.
Skills tell an agent when and how to call Peppermint. The MCP server supplies the actual context. The instruction layer and the memory layer should reinforce each other without pretending to be the same thing.
A concise brief: current state, relevant decisions, artifact references, blockers, owner or collaborator context, and the next safe action. Enough context to move, not a wall of archaeology.
Agents are useful when they understand what the user was doing, what was already decided, and when to ask before acting. Peppermint turns that scattered work history into a callable context layer.