MarsNMe

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

与代理无关的持久化记忆后端。13个MCP工具,Supabase + Jina嵌入,多配置文件隔离,跨会话语义召回。

一句话选型结论

按资料字段整理

MarsNMe 属于文档知识类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
npx supabase db push --db-url "<your-supabase-db-connection-string>"

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
MarsNMe当前 未标注 stdio · 本地进程 本地部署 有 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

18.4 KB
来自项目仓库与上游目录的原文,未做删改

English · 繁體中文(台灣) · 繁體中文(香港) · 简体中文


marsnme.com — Claude.md is for context. MarsNMe is for continuity.

Your AI tools should know you — not start from scratch every time. When Perplexity helps you decide, Claude should remember why. When Cursor ships a feature, Warp should know the context. That's not context sharing. That's continuity.

Most AI memory tools help AI remember you. MarsNMe helps you and your AI remember each other — across sessions, across tools, over time.

An agent-agnostic, LLM-agnostic memory backend for MCP-compatible tools.```bash
curl -fsSL https://marsnme.com/install.sh | bash


## Real user story

&gt; I use Cursor to code, Warp to deploy, Perplexity to research, and Claude Code to manage my vault. Before MarsNMe, every tool started blank — I had to re-explain my project, my preferences, my decisions every single session. Now my AI across all four tools knows what we decided yesterday, what we tried last week, and why we chose this architecture over that one. It&#x27;s not about injecting context. It&#x27;s about having a relationship that compounds over time.
&gt;
&gt; — Leo, MarsNMe creator (3 months of daily use across 4 AI tools)

## Available MCP Tools (16)

| Tool | Description |
|---|---|
| `insert_memory` | Store short-term memory |
| `list_memories` | List recent memories |
| `search_memories` | Semantic search via Jina embeddings |
| `recall` | Long-term chunk recall — ~80-char preview per match |
| `get_summary` | Medium excerpt (~300 chars) of a chunk by ID |
| `get_full` | Complete text of a long-term chunk by ID |
| `memory_ingest` | Ingest long-term insight chunks |
| `dream_ingest` | Dream-mode long-term ingestion |
| `session_boot` | Start a session with context pre-load |
| `session_close` | Close session, summarize, auto-promote expiring memories |
| `health_check` | Coverage, expiry, conflict diagnostics |
| `reload_source_registry` | Refresh source whitelist at runtime |
| `demote_memory` | Demote a memory to lower priority |
| `soft_forget` | Soft-delete a memory |
| `explain_memory` | Explain a memory&#x27;s provenance |
| `batch_promote` | Promote expiring short-term memories to long-term |

## What&#x27;s new in 0.3.0

- **3-layer recall**: `recall` returns ~80-char previews, then `get_summary` (~300 chars), then `get_full` (complete). Avoids token-dumping full chunks on every recall; drill down only when a preview looks relevant.
- **Body-to-body note handoff**: `session_close(to=, note=...)` leaves a note that `session_boot(body=)` delivers and marks read — one agent can hand context to another.
- **Auto `batch_promote` on `session_close`**: closing a session automatically promotes soon-expiring short-term memories (48h window, up to 5) to long-term storage — no Hermes or manual promote needed.
- **`grok` + `draft` sources**: added to the source whitelist so the Grok body and Draft lifecycle hooks can write memories natively.
- **CoCo-only tool surface**: PRD tools (`save_prd`, `get_prd`, `list_prds`, `score_prd`, `spawn_to_linear`) removed from the Supabase gateway — idea/PRD/task execution now lives in Draft. MarsNMe = CoCo soul memory only.

# MarsNMe
## Why MarsNMe?

Most AI memory tools help AI remember you. **MarsNMe helps you and your AI remember each other.**

| | MarsNMe | Typical memory tool |
|---|---|---|
| **Philosophy** | Mutual continuity — human + AI both grow | AI-side context injection only |
| **Agent support** | Any MCP-compatible client | Often client-specific |
| **Memory tiers** | Short-term (TTL) + long-term (semantic) | Usually one layer |
| **Profiles** | Unlimited isolated profiles via `MCP_PROFILE` | Single-user only |
| **Data ownership** | Your own Supabase — zero vendor lock-in | Vendor-hosted |
| **Search** | Jina v3 semantic search (1024-dim pgvector) | Keyword or basic similarity |
| **Self-hostable** | ✅ Full control | Rarely |

### When MarsNMe is the right fit

- You use multiple AI assistants (Claude, Cursor, Perplexity, Warp, custom agents) and want **shared memory across all of them**
- You want AI that remembers your projects, preferences, and decisions **across sessions** without re-explaining
- You care about **data sovereignty** — your memories stay in your own Supabase project
- You&#x27;re building an AI agent and need a **production-ready memory backend** with semantic recall

### When it might not be the right fit

- You only need single-session context (just use the system prompt)
- You want fully managed, zero-config memory with no setup (try a hosted solution)

## Runtime packages

| Folder | Runtime | Who uses it |
|---|---|---|
| `marsnme-supabase/` | Supabase + Jina gateway (`@marsnme/mcp-gateway`) | **Mars Group dogfood** — Proxmox CT101 (CoCo / Toto soul memory) |
| `marsnme-cf/` | Cloudflare Workers + D1 + Vectorize | Self-host template; **not** the Proxmox deploy path |
| `marsnme-supabase/cloudflare-routing-worker/` | `mcp.marsnme.com` routing proxy | Public setup wizard → upstream gateway |

**Product split (Mars Group):** Idea / PRD / task execution → Draft + `draft-mcp`. **MarsNMe Supabase = CoCo soul memory only** (recall, session boot/close, ingest, lifecycle). As of `@marsnme/mcp-gateway` v0.3.0, PRD MCP tools (`save_prd`, `get_prd`, `list_prds`, `score_prd`, `spawn_to_linear`) are removed from the Supabase gateway — use Draft for idea/PRD/task workflows.

**Proxmox deploy:** private MarsNMe-lab — `deploy/deploy-proxmox-ct101.sh` or GitHub `cd-selfhosted` workflow. Not a single-script deploy like draft-mcp.

## Repository Packages

| Package | Description |
|---|---|
| `marsnme-supabase/` | Core MCP gateway — agent-agnostic memory backend (this package is published to npm as `@marsnme/mcp-gateway`) |
| `marsnme-supabase/cloudflare-routing-worker/` | Cloudflare Worker for `mcp.marsnme.com` — username-based MCP routing proxy with setup wizard |
| `marsnme-cf/` | Self-hosted MCP memory server on Cloudflare Workers + D1 + Vectorize (no Supabase needed) |

## Quick Setup (no install needed)

Go to **mcp.marsnme.com/setup** — create your personal MCP URL in 4 steps:

1. Pick a username
2. Enter your Supabase credentials (URL + anon key)
3. Choose preferences
4. Get your MCP URL: `https://mcp.marsnme.com/your-name`

Then add it to any MCP client (Claude, Cursor, Perplexity, Warp).

**Self-hosted?** Deploy `marsnme-cf/` to your own Cloudflare account — no Supabase needed, uses D1 + Workers AI + Vectorize.

---

## Before You Start (External Dependencies)
1. Create a Supabase project (free plan is enough):
   - Sign up: https://supabase.com
   - Create project: https://supabase.com/dashboard/new
   - Open API settings (Project Settings → API):
     - Project URL → `SUPABASE_BASE_URL`
     - `service_role` key → `SUPABASE_SERVICE_ROLE_KEY`
   - Keep `SUPABASE_SERVICE_ROLE_KEY` private. Never commit it.
2. Create a Jina API key (free tier available):
   - Get key: https://jina.ai/api-key/
   - Copy key to `JINA_API_KEY`

## Quick Start (15-20 minutes)
For the fastest path, use the one-line installer: `curl -fsSL https://marsnme.com/install.sh | bash`

The manual path below follows the same tools-first flow as `docs/onboarding-a-mcp-zero-to-recall.md` and `docs/onboarding-b-platform-skill-install.md`.
1. Clone repository:```bash
git clone https://github.com/Marsmanleo/MarsNMe.git
cd MarsNMe
  1. Verify Node.js version (20+ required):```bash
    node --version
3. Copy environment template:```bash
cp .env.example .env
  1. Fill required values in .env:
    - SUPABASE_BASE_URL
    - SUPABASE_SERVICE_ROLE_KEY
    - JINA_API_KEY
  2. Run required Supabase migrations before first start:
    - Option A (recommended, Supabase CLI):```bash
    npx supabase db push --db-url "<your-supabase-db-connection-string>"
   - Note: `--db-url` must be the Postgres database connection string from `Project Settings → Database → Connection string`.
   - It is not the same as `SUPABASE_BASE_URL` (`https://.supabase.co`, REST API URL).
   - Use a role that can execute DDL on your target schemas.
   - On Supabase-hosted Postgres this is typically `supabase_admin` (not `postgres`).
   - Option B (Supabase Dashboard SQL Editor):
     1. Open SQL Editor.
     2. Ensure the `vector` extension is enabled first (Database → Extensions).
     3. Run migration files in filename order from `supabase/migrations/`:
        - `20260504052744_semantic_vector_dual_profile.sql`
        - `20260513213800_memory_lifecycle_tracking.sql`
        - `20260513222500_health_check_detect_conflicts_v2.sql`
        - `20260517183000_provenance_audit_trail.sql`
        - `20260517194000_memory_scope_agent_body_environment.sql`
        - `20260517200500_forget_demote_mechanism.sql`
        - `20260517223500_usage_cost_telemetry_light.sql`
        - `20260517231000_memories_source_constraint_regex.sql`
        - `20260517232000_source_registry_table.sql`
6. Start gateway:
   - `MCP_PROFILE` separates memory by agent or use case.
   - Use any profile name you want (for example: `default`, `my-agent`, `profile-a`).
   - Legacy built-in profile IDs `coco` and `toto` are still supported for compatibility.
   - If `PORT` is omitted, default port is profile-based (`coco=18790`, `toto=18791`, other profiles deterministic in `20000-29999`).```bash
MCP_PROFILE=profile-a PORT=18790 npx @marsnme/mcp-gateway
  1. Verify health:```bash
    curl -sS http://127.0.0.1:18790/health
8. Connect your MCP client (next section), then run the first round-trip check.

## Try In 30 Seconds (Docker, M1)
If you only want a local demo path, use Docker Compose.

**One-line install (recommended):**```bash
curl -fsSL https://marsnme.com/install.sh | bash

Or manually:
1. Set only the required key:```bash
cp .env.example .env

fill JINA_API_KEY in .env

2. Start local stack:```bash
docker compose up

This starts:
- PostgreSQL + pgvector
- SQL migrations from supabase/migrations/
- PostgREST + rest-proxy
- MarsNMe gateway (http://127.0.0.1:18790/mcp)

  1. Verify health:```bash
    curl -sS http://127.0.0.1:18790/health

## M2 Cloudflare Tunnel Profile (Demo)
When you need a temporary public endpoint for remote AI tools:```bash
docker compose --profile tunnel up

Expected output (from tunnel logs):```text
https://xxxx.trycloudflare.com


Get MCP endpoint:```bash
docker compose --profile tunnel logs tunnel | grep -Eo &#x27;https://[^ ]+trycloudflare.com&#x27; | head -n1
# append /mcp

Notes:
- trycloudflare.com URL is temporary (demo only).
- Local endpoint remains: http://127.0.0.1:18790/mcp.
- For production/stable URL, use named tunnel (outside M2 scope).
- Optional env:
- MCP_TUNNEL_PROFILE (default coco)
- MCP_TUNNEL_REQUIRE_BEARER (default false for demo convenience)

MCP Client Connection Guide

Local endpoint:
- http://127.0.0.1:18790/mcp

If bearer auth is enabled (MCP_REQUIRE_BEARER=true), include:
- Authorization: Bearer

Claude Desktop

  1. Open claude_desktop_config.json (macOS default path: ~/Library/Application Support/Claude/claude_desktop_config.json).
  2. Add/update:```json
    {
    "mcpServers": {
    "marsnme-cf": {
    "url": "http://127.0.0.1:18790/mcp"
    }
    }
    }
3. Restart Claude Desktop.

### Cursor
1. Open Cursor Settings and search for MCP.
2. Add a new server:
   - Name: `marsnme-cf`
   - URL: `http://127.0.0.1:18790/mcp`
   - Headers: optional bearer header if enabled
3. Reconnect MCP in Cursor.

### Warp
1. Open `Settings &gt; Agents &gt; MCP servers`.
2. Add a server pointing to:
   - URL: `http://127.0.0.1:18790/mcp`
3. Add optional bearer header if required, then reconnect.

### Perplexity
1. Open a Space in Perplexity and go to Space Settings.
2. Under MCP servers, add:
   - URL: `http://127.0.0.1:18790/mcp`
3. Save and start a new conversation in that Space.

### Any MCP client (generic HTTP/SSE)
Use a streamable HTTP/SSE MCP entry:```json
{
  &quot;marsnme-cf&quot;: {
    &quot;url&quot;: &quot;http://127.0.0.1:18790/mcp&quot;
  }
}

First Connection Validation (Round Trip)

After client connection, verify this sequence once:

  1. tools/list:```bash
    curl -sS http://127.0.0.1:18790/mcp \
    -H 'content-type: application/json' \
    -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
2. `insert_memory`:```bash
curl -sS http://127.0.0.1:18790/mcp \
  -H &#x27;content-type: application/json&#x27; \
  -d &#x27;{&quot;jsonrpc&quot;:&quot;2.0&quot;,&quot;id&quot;:2,&quot;method&quot;:&quot;tools/call&quot;,&quot;params&quot;:{&quot;name&quot;:&quot;insert_memory&quot;,&quot;arguments&quot;:{&quot;body&quot;:&quot;quickstart memory check&quot;,&quot;source&quot;:&quot;warp&quot;,&quot;session_id&quot;:&quot;quickstart-smoke&quot;}}}&#x27;
  1. recall:```bash
    curl -sS http://127.0.0.1:18790/mcp \
    -H 'content-type: application/json' \
    -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"recall","arguments":{"query":"quickstart memory check","limit":3}}}'

## What this repository is
`mars-memory-mcp` is the core MCP gateway repository behind the public-facing MarsNMe release.
One codebase (`marsnme-supabase/server.mjs`) serves multiple profile schemas through `MCP_PROFILE`.
This public repository currently keeps two built-in legacy profile IDs (`coco`, `toto`) for backward compatibility.

## Current capabilities
- MCP methods: `initialize`, `notifications/initialized`, `tools/list`, `tools/call`, `ping`
- Profiles: configurable profile IDs (legacy built-ins: `coco`, `toto`)
- Memory tools (16):
  - `insert_memory` (short-term memory)
  - `list_memories`
  - `search_memories` (Jina embedding search)
  - `recall` (~80-char preview) then `get_summary` (~300-char excerpt) then `get_full` (complete text)
  - `memory_ingest` / `dream_ingest` (long-term chunk ingestion)
  - `session_boot` / `session_close` (daily rhythm lifecycle; close auto-promotes expiring memories + supports body-to-body note handoff)
  - `health_check` (coverage, expiry, conflict diagnostics)
  - `reload_source_registry` (refresh source whitelist at runtime)
  - `demote_memory` / `soft_forget` / `explain_memory` (memory lifecycle management)
  - `batch_promote` (promote expiring short-term memories to long-term)
- Sources: `perplexity`, `cursor`, `warp`, `openclaw`, `hermes`, `draft`, `grok`
- OAuth-protected MCP endpoint (configurable by environment variables)

## Memory model
- Short-term memory table: `.memories`
- Long-term memory table: `.marsvault_chunks`
- Recommended usage:
  - Keep daily interaction context in `insert_memory`
  - Promote durable insights through ingest tools

## Repository layout
- `marsnme-supabase/server.mjs` — gateway entry point
- `marsnme-supabase/scripts/hermes_digest_runner.py` — optional digest runner
- `marsnme-supabase/scripts/dream_runner.py` — public self-host dream runner
- `marsnme-supabase/deploy/systemd/` — systemd templates
- `marsnme-supabase/deploy/phase2/` — build/deploy scripts
- `marsnme-supabase/deploy/phase3/smoke_gate.sh` — smoke gate script
- `supabase/migrations/` — schema-as-code migrations

## Environment setup
1. Copy `.env.example` to your local `.env` (do not commit real secrets).
2. Fill required values:
   - `MCP_PROFILE` (your profile identifier; this repo ships with legacy `coco`/`toto`)
   - `SUPABASE_BASE_URL`
   - `SUPABASE_SERVICE_ROLE_KEY`
   - `JINA_API_KEY`
3. Optional security flags:
   - `MCP_REQUIRE_BEARER=true`
   - `MCP_CLIENT_ID`
   - `MCP_CLIENT_SECRET`

### Optional Hermes digest runner
Hermes is optional and disabled by default:
- `HERMES_ENABLED=false`
- `HERMES_DIGEST_MCP_URL`
- `HERMES_DIGEST_MCP_BEARER_TOKEN`
- `HERMES_DIGEST_ORIGIN`
- `HERMES_DIGEST_SOURCE_DIR`

### Optional Dream Runner (self-host)
Dream Runner is public-friendly and can run without Hermes private environment:
- `DREAM_ENABLED=true`
- `DREAM_MODE=lite · standard · pro`
- `DREAM_DIGEST_MCP_URL`
- `DREAM_MCP_BEARER_TOKEN` (if required)
- `DREAM_ENABLE_ISSUE_SIGNALS`, `DREAM_ENABLE_REPO_SCAN`, `DREAM_ENABLE_SOUL_CONTEXT` (optional overrides)

Quick start:```bash
DREAM_ENABLED=true DREAM_MODE=lite python3 marsnme-supabase/scripts/dream_runner.py

If you run this repository with bundled defaults and no profile remapping, use coco and toto.

See docs/dream-runner-self-host.md for full configuration.

Onboarding

  • Zero-to-first-recall guide: docs/onboarding-a-mcp-zero-to-recall.md
  • Platform install guide (optional skill layer): docs/onboarding-b-platform-skill-install.md

Skill library

  • Skill index and update workflow: skills/README.md
  • Perplexity template: skills/perplexity/memory-daily-boot/SKILL.md
  • Cursor template: skills/cursor/memory-daily-boot/rule.mdc
  • Warp template: skills/warp/memory-daily-boot/prompt.md

Local run (from cloned repo)```bash

MCP_PROFILE=profile-a npx @marsnme/mcp-gateway
``````bash
MCP_PROFILE=profile-b npx @marsnme/mcp-gateway


Health endpoints:
- `GET /health`
- `POST /mcp`

## Systemd deployment
Use `marsnme-supabase/deploy/systemd/memory-mcp-gateway@.service` with instances:
- `memory-mcp-gateway@profile-a.service`
- `memory-mcp-gateway@profile-b.service`

Recommended env files:
- `/opt/mars-memory-mcp/shared/.env`
- `/opt/mars-memory-mcp/shared/.env.profile-a`
- `/opt/mars-memory-mcp/shared/.env.profile-b`

## Release/deploy scripts
1. Build artifact:```bash
bash marsnme-supabase/deploy/phase2/build_release_artifact.sh
  1. Apply migrations with an explicit DDL-capable role:```bash
    npx supabase db push --db-url "<postgres://supabase_admin:<password>@<host>:5432/postgres>"
3. Run pre-deploy schema gate (must pass before any service restart):```bash
bash marsnme-supabase/deploy/phase2/pre_deploy_schema_gate.sh \
  --db-url &quot;&lt;postgres://supabase_admin:&lt;password&gt;@&lt;host&gt;:5432/postgres&gt;&quot; \
  --profiles coco,toto \
  --expected-role supabase_admin
  1. Run your platform-specific rollout/restart adapter.
    - This repository ships generic artifact + gate scripts; rollout adapters are environment-specific.
    - If schema gate exits non-zero, stop deployment and do not restart services.
  2. Smoke gate:```bash
    bash marsnme-supabase/deploy/phase3/smoke_gate.sh --spawn-local
6. Automated npm + MCP Registry release (tag-driven):
   - Workflow: `.github/workflows/publish-release.yml`
   - Trigger: push tag `v*`
   - Gate: tag version must match `marsnme-supabase/package.json` version
   - Optional local Fish helper:```bash
mrel patch
mrel minor
mrel major
mrel 0.1.2

The helper updates marsnme-supabase/package.json and server.json, commits, tags, and pushes.

Security and version control

  • Never commit .env, runtime tokens, or oauth-clients.json
  • Keep .env.example committed as the only environment template
  • Prefer bearer/OAuth for public exposure

License and policy

  • License: Apache-2.0 (LICENSE)
  • Notice: NOTICE
  • Trademark policy: TRADEMARK.md
  • Contribution guide: CONTRIBUTING.md
  • Contributor agreement: CLA.md
  • Release notes: CHANGELOG.md

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
MarsNMe 怎么安装?

在客户端按下面的安装命令接入:npx supabase db push --db-url "<your-supabase-db-connection-string>"。装完在客户端配置里引用同一个包或端点。

MarsNMe 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

MarsNMe 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

MarsNMe 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

MarsNMe 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Cline、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

MarsNMe 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

MarsNMe 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

MarsNMe 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。