Skip to content
Back to search

mempalace

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/MemPalace/mempalace with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/MemPalace/mempalace'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mempalace-mempalace/badge.svg)](/listings/mempalace-mempalace)

HTML

<a href="/listings/mempalace-mempalace"><img src="/api/listings/mempalace-mempalace/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Agent-guided setup

Install the MemPalace skills first, then ask your coding agent to set up MemPalace. The setup skill detects your system, installs the Python package, configures MCP, and asks whether you want a private local palace, a shared-brain hub, or a client connected to an existing hub:

npx skills add MemPalace/mempalace

The repository exposes three skills: `mempalace` for guided installation and operations, `mempalace-recall` for search-before-answer recall, and `mempalace-task` for logstream delegation. Installing a skill does not by itself install the MemPalace CLI or MCP server; the setup skill guides the agent through those system changes and verifies the live connection.

During guided setup the agent can offer weekly stable-release checks. They are disabled by default, contact only PyPI when enabled, and never install updates automatically. Cached availability appears in scoped `mempalace_status` fields for the serving runtime and, when a local proxy is present, its client runtime, allowing the agent to explain the release and request authorization before showing an exact upgrade plan. Setup records whether the runtime came from `uv tool`, `pipx`, or `pip` so the plan never proposes an upgrade command for the wrong installation.

Direct CLI setup

MemPalace ships a CLI, so install it in an isolated environment to avoid PEP 668 errors on Debian/Ubuntu/Homebrew Pythons and to keep mempalace's deps (`chromadb`, `numpy`, `grpcio`, …) from conflicting with anything else in your global site-packages.

We recommend [`uv`](https://docs.astral.sh/uv/) — `uv tool install` puts the `mempalace` CLI in an isolated environment on your PATH:

uv tool install mempalace
mempalace init ~/projects/myapp

[`pipx`](https://pipx.pypa.io/) works the same way if you prefer it: `pipx install mempalace`.

Prefer plain `pip` only inside an activated virtualenv where you explicitly want `import mempalace` available:

python -m venv .venv && source .venv/bin/activate
pip install mempalace

Android / Termux

Native Termux installation is not currently supported because compiled dependencies such as ChromaDB and ONNX Runtime publish Linux wheels, not Android wheels. Android ARM64 users can run the regular Linux packages in an isolated Debian PRoot container instead. See the [Termux installation guide](website/guide/termux.md) for the tested setup and an argv-preserving launcher.

Docker

A container image is also available for running the MCP server or the CLI without a local Python toolchain. Multi-arch (amd64 + arm64), so it runs natively on Apple Silicon:

docker pull ghcr.io/mempalace/mempalace:latest

Everything persists under `/data` — palace, config, and the cached embedding model — so mount a volume there and reuse it across runs:

# MCP server over stdio — note the `-i` flag (JSON-RPC needs stdin)
docker run -i --rm -v mempalace-data:/data ghcr.io/mempalace/mempalace

# Run any CLI command instead. The container only sees what you mount, so
# mount the directory you want to mine — read-only is enough, mining never
# writes to the source.
docker run --rm -v mempalace-data:/data -v /path/to/project:/work:ro \
  ghcr.io/mempalace/mempalace mine /work
docker run --rm -v mempalace-data:/data ghcr.io/mempalace/mempalace search "why GraphQL"

The first command that needs embeddings downloads the model into `/data` (~80 MB for the default `minilm`, ~300 MB for `embeddinggemma`). It is a one-off as long as the volume persists, but it does mean the first call is slow and needs network — worth knowing before assuming a hung container.

Wire it into an MCP client (e.g. Claude Code) as a stdio server. Mount anything you want the server to be able to mine — it cannot reach your transcripts otherwise:

{
  "mcpServers": {
    "mempalace": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "mempalace-data:/data",

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 18 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "mempalace",
  3. "owner": {
  4. "name": "milla-jovovich",
  5. "url": "https://github.com/MemPalace"
  6. },
  7. "plugins": [
  8. {
  9. "name": "mempalace",
  10. "source": "./.claude-plugin",
  11. "description": "AI memory system — mine projects and conversations into a searchable palace. 47 MCP tools, auto-save hooks, guided setup.",
  12. "version": "3.12.0",
  13. "author": {
  14. "name": "milla-jovovich"
  15. }
  16. }
  17. ]
  18. }
README.md · README · 374 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <img src="assets/mempalace_logo.png" alt="MemPalace" width="240">
  3. # MemPalace
  4. Local-first AI memory. Verbatim storage, pluggable backend, 96.6% R@5 raw on LongMemEval — zero API calls.
  5. [![][version-shield]][release-link]
  6. [![][python-shield]][python-link]
  7. [![][license-shield]][license-link]
  8. [![][discord-shield]][discord-link]
  9. </div>
  10. > [!CAUTION]
  11. > **Beware of impostor sites.** MemPalace has no other official websites. The **only** official sources are this **[GitHub repository](https://github.com/MemPalace/mempalace)**, the **[PyPI package](https://pypi.org/project/mempalace/)**, and the docs at **[mempalaceofficial.com](https://mempalaceofficial.com)**. Any other domain (including `.tech`, `.net`, or other `.com` variants) is an impostor and may distribute malware. Details and timeline: [docs/HISTORY.md](docs/HISTORY.md).
  12. > [!IMPORTANT]
  13. > **Claude Code sessions expire in 30 days without auto-save hooks wired.** [Read this →](https://github.com/MemPalace/mempalace/discussions/1388)
  14. >
  15. > Need the shortest recovery/setup path? Use the [Claude Code retention setup checklist](https://mempalaceofficial.com/guide/claude-code-retention.html).
  16. ---
  17. ## What it is
  18. MemPalace stores your conversation history as verbatim text and retrieves
  19. it with semantic search. It does not summarize, extract, or paraphrase.
  20. The index is structured — people and projects become *wings*, topics
  21. become *rooms*, and original content lives in *drawers* — so searches
  22. can be scoped rather than run against a flat corpus.
  23. The retrieval layer is pluggable. The current default is ChromaDB; the
  24. interface is defined in [`mempalace/backends/base.py`](mempalace/backends/base.py)
  25. and alternative backends can be dropped in without touching the rest of
  26. the system.
  27. Nothing leaves your machine unless you opt in.
  28. Architecture, concepts, and mining flows:
  29. [mempalaceofficial.com/concepts/the-palace](https://mempalaceofficial.com/concepts/the-palace.html).
  30. ---
  31. ## Install
  32. ### Agent-guided setup
  33. Install the MemPalace skills first, then ask your coding agent to set up
  34. MemPalace. The setup skill detects your system, installs the Python package,
  35. configures MCP, and asks whether you want a private local palace, a shared-brain
  36. hub, or a client connected to an existing hub:
  37. ```bash
  38. npx skills add MemPalace/mempalace
  39. ```
  40. The repository exposes three skills: `mempalace` for guided installation and
  41. operations, `mempalace-recall` for search-before-answer recall, and
  42. `mempalace-task` for logstream delegation. Installing a skill does not by
  43. itself install the MemPalace CLI or MCP server; the setup skill guides the
  44. agent through those system changes and verifies the live connection.
  45. During guided setup the agent can offer weekly stable-release checks. They are
  46. disabled by default, contact only PyPI when enabled, and never install updates
  47. automatically. Cached availability appears in scoped `mempalace_status` fields
  48. for the serving runtime and, when a local proxy is present, its client runtime,
  49. allowing the agent to explain the release and request authorization before showing an exact
  50. upgrade plan. Setup records whether the runtime came from `uv tool`, `pipx`, or
  51. `pip` so the plan never proposes an upgrade command for the wrong installation.
  52. ### Direct CLI setup
  53. MemPalace ships a CLI, so install it in an isolated environment to avoid
  54. PEP 668 errors on Debian/Ubuntu/Homebrew Pythons and to keep mempalace's
  55. deps (`chromadb`, `numpy`, `grpcio`, …) from conflicting with anything
  56. else in your global site-packages.
  57. We recommend [`uv`](https://docs.astral.sh/uv/) — `uv tool install` puts
  58. the `mempalace` CLI in an isolated environment on your PATH:
  59. ```bash
  60. uv tool install mempalace
  61. mempalace init ~/projects/myapp
  62. ```
  63. [`pipx`](https://pipx.pypa.io/) works the same way if you prefer it:
  64. `pipx install mempalace`.
  65. Prefer plain `pip` only inside an activated virtualenv where you
  66. explicitly want `import mempalace` available:
  67. ```bash
  68. python -m venv .venv && source .venv/bin/activate
  69. pip install mempalace
  70. ```
  71. ### Android / Termux
  72. Native Termux installation is not currently supported because compiled
  73. dependencies such as ChromaDB and ONNX Runtime publish Linux wheels, not
  74. Android wheels. Android ARM64 users can run the regular Linux packages in an
  75. isolated Debian PRoot container instead. See the
  76. [Termux installation guide](website/guide/termux.md) for the tested setup and
  77. an argv-preserving launcher.
  78. ### Docker
  79. A container image is also available for running the MCP server or the CLI
  80. without a local Python toolchain. Multi-arch (amd64 + arm64), so it runs
  81. natively on Apple Silicon:
  82. ```bash
  83. docker pull ghcr.io/mempalace/mempalace:latest
  84. ```
  85. Everything persists under `/data` — palace, config, and the cached embedding
  86. model — so mount a volume there and reuse it across runs:
  87. ```bash
  88. # MCP server over stdio — note the `-i` flag (JSON-RPC needs stdin)
  89. docker run -i --rm -v mempalace-data:/data ghcr.io/mempalace/mempalace
  90. # Run any CLI command instead. The container only sees what you mount, so
  91. # mount the directory you want to mine — read-only is enough, mining never
  92. # writes to the source.
  93. docker run --rm -v mempalace-data:/data -v /path/to/project:/work:ro \
  94. ghcr.io/mempalace/mempalace mine /work
  95. docker run --rm -v mempalace-data:/data ghcr.io/mempalace/mempalace search "why GraphQL"
  96. ```
  97. The first command that needs embeddings downloads the model into `/data`
  98. (~80 MB for the default `minilm`, ~300 MB for `embeddinggemma`). It is a
  99. one-off as long as the volume persists, but it does mean the first call is
  100. slow and needs network — worth knowing before assuming a hung container.
  101. Wire it into an MCP client (e.g. Claude Code) as a stdio server. Mount
  102. anything you want the server to be able to mine — it cannot reach your
  103. transcripts otherwise:
  104. ```json
  105. {
  106. "mcpServers": {
  107. "mempalace": {
  108. "command": "docker",
  109. "args": [
  110. "run", "-i", "--rm",
  111. "-v", "mempalace-data:/data",
  112. "-v", "/absolute/path/to/.claude/projects:/transcripts:ro",
  113. "ghcr.io/mempalace/mempalace"
  114. ]
  115. }
  116. }
  117. }
  118. ```
  119. Use a real absolute path there — `~` and `$HOME` are not expanded by every
  120. MCP client. Paths are container paths from then on: mine `/transcripts`, not
  121. `~/.claude/projects`.
  122. **Mount permissions on Linux.** The image runs as uid 1000 and bind mounts
  123. keep their host ownership, so a mounted directory has to be readable by that
  124. uid — an ordinary `0755` checkout is fine, a `0700` directory is not, and the
  125. failure surfaces as `PermissionError: [Errno 13]` rather than anything about
  126. Docker. Docker Desktop maps uids on macOS and Windows, so this only bites on
  127. Linux. Do **not** work around it with `--user`: `/data` is owned by uid 1000
  128. inside the image, so another uid cannot write the palace at all.
  129. `docker compose run --rm mcp` works too (see `docker-compose.yml`), and
  130. `deploy/docker-compose.server.yml` stands up the team server. To build the
  131. image yourself instead of pulling — required for the GPU variant, which is not
  132. published:
  133. ```bash
  134. docker build -t mempalace . # CPU
  135. docker build --build-arg EXTRAS="extract,spellcheck" -t mempalace .
  136. docker build -f Dockerfile.gpu -t mempalace:gpu . # CUDA; run with --gpus all
  137. ```
  138. The GPU image is x86_64-only: `onnxruntime-gpu` publishes no aarch64 Linux
  139. wheels, so that last build fails on an ARM host (including Apple Silicon) with
  140. a dependency-resolution error rather than an obvious one.
  141. Note that a build from a clone uses whatever branch you checked out; `develop`
  142. is the default branch, so pull the published image if you want the released
  143. version.
  144. ## Storage backends
  145. ChromaDB is the default and needs no configuration. MemPalace also ships a
  146. pluggable backend contract, exercised across deliberately different substrates
  147. so the contract is never accidentally shaped around one vendor. Every
  148. non-default backend is opt-in.
  149. | Backend | Mode | Install | Namespaces | Lexical | Configure with |
  150. | ------- | ---- | ------- | :--------: | :-----: | -------------- |
  151. | `chroma` _(default)_ | Local (embedded) | bundled | – | ✓ | – |
  152. | `sqlite_exact` | Local (exact NumPy) | bundled | – | ✓ | – |
  153. | `rust_exact` | Local (native vectors) | wheel / compiled | – | ✓ | – |
  154. | `milvus` | Local (Lite) · Server opt-in | `mempalace[milvus]` | ✓ | ✓ | `MEMPALACE_MILVUS_URI` |
  155. | `qdrant` | Server (REST) | bundled | ✓ | ✓ | `MEMPALACE_QDRANT_URL` |
  156. | `pgvector` | Server (Postgres) | `mempalace[pgvector]` | ✓ | ✓ | `MEMPALACE_PGVECTOR_DSN` |
  157. Select with `--backend <name>`, `MEMPALACE_BACKEND=<name>`, or
  158. `"backend": "<name>"` in `config.json`. `rust_exact` uses the exact same `sqlite_exact.sqlite3` file on disk as `sqlite_exact` with zero data migration. See [native installation and vector CLI usage](crates/README.md) for the separately distributed wheel and executables.
  159. ### Native vector search
  160. `rust_exact` and the standalone `mempalace-native` CLI scan the same `sqlite_exact` database with a native Rust engine. The `rust_exact` adapter falls back to the Python backend for complex filters, requests for returned embeddings, and installs without the native extension; the `mempalace-native` executable is Rust-only and has no Python fallback. No benchmark figures are published for this release; `mempalace-native bench --db <sqlite_exact.sqlite3>` measures it on your own data. See [`crates/`](crates/) for the core workspace, PyO3 bindings, and native CLI.
  161. ## Quickstart
  162. ```bash
  163. # Mine content into the palace
  164. mempalace mine ~/projects/myapp # project files
  165. mempalace mine ~/.claude/projects/ --mode convos # Claude Code sessions (scope with --wing per project)
  166. # Search
  167. mempalace search "why did we switch to GraphQL"
  168. # Load context for a new session
  169. mempalace wake-up
  170. # Score how well organized the palace is (read-only, safe while the MCP server runs)
  171. mempalace audit
  172. ```
  173. For Claude Code, Gemini CLI, [Antigravity](https://mempalaceofficial.com/guide/antigravity.html),
  174. MCP-compatible tools, and local models, see
  175. [mempalaceofficial.com/guide/getting-started](https://mempalaceofficial.com/guide/getting-started.html).
  176. ---
  177. ## Benchmarks
  178. All numbers below are reproducible from this repository with the commands
  179. in [`benchmarks/BENCHMARKS.md`](benchmarks/BENCHMARKS.md). Full
  180. per-question result files are committed under `benchmarks/results_*`.
  181. **LongMemEval — retrieval recall (R@5, 500 questions):**
  182. | Mode | R@5 | LLM required |
  183. |---|---|---|
  184. | Raw (semantic search, no heuristics, no LLM) | **96.6%** | None |
  185. | Hybrid v4, held-out 450q (tuned on 50 dev, not seen during training) | **98.4%** | None |
  186. | Hybrid v4 + LLM rerank (full 500) | ≥99% | Any capable model |
  187. The raw 96.6% requires no API key, no cloud, and no LLM at any stage. The
  188. hybrid pipeline adds keyword boosting, temporal-proximity boosting, and
  189. preference-pattern extraction; the held-out 98.4% is the honest
  190. generalisable figure.
  191. The rerank pipeline promotes the best candidate out of the top-20
  192. retrieved sessions using an LLM reader. It works with any reasonably
  193. capable model — we have reproduced it with Claude Haiku, Claude Sonnet,
  194. and minimax-m2.7 via Ollama Cloud (no Anthropic dependency). The gap
  195. between raw and reranked is model-agnostic; we do not headline a "100%"
  196. number because the last 0.6% was reached by inspecting specific wrong
  197. answers, which `benchmarks/BENCHMARKS.md` flags as teaching to the test.
  198. **Other benchmarks (full results in [`benchmarks/BENCHMARKS.md`](benchmarks/BENCHMARKS.md)):**
  199. | Benchmark | Metric | Score | Notes |
  200. |---|---|---|---|
  201. | LoCoMo (session, top-10, no rerank) | R@10 | 60.3% | 1,986 questions |
  202. | LoCoMo (hybrid v5, top-10, no rerank) | R@10 | 88.9% | Same set |
  203. | ConvoMem (all categories, 250 items) | Avg recall | 92.9% | 50 per category |
  204. | MemBench (ACL 2025, 8,500 items) | R@5 | 80.3% | All categories |
  205. We deliberately do not include a side-by-side comparison against Mem0,
  206. Mastra, Hindsight, Supermemory, or Zep. Those projects publish different
  207. metrics on different splits, and placing retrieval recall next to
  208. end-to-end QA accuracy is not an honest comparison. See each project's
  209. own research page for their published numbers.
  210. **Reproducing every result:**
  211. ```bash
  212. git clone https://github.com/MemPalace/mempalace.git
  213. cd mempalace
  214. uv sync --extra dev # or: pip install -e ".[dev]"
  215. # see benchmarks/README.md for dataset download commands
  216. uv run python benchmarks/longmemeval_bench.py /path/to/longmemeval_s_cleaned.json
  217. ```
  218. ---
  219. ## Knowledge graph
  220. MemPalace includes a temporal entity-relationship graph with validity
  221. windows — add, query, invalidate, timeline — backed by local SQLite.
  222. Usage and tool reference:
  223. [mempalaceofficial.com/concepts/knowledge-graph](https://mempalaceofficial.com/concepts/knowledge-graph.html).
  224. ## MCP server
  225. 47 MCP tools cover palace reads/writes, knowledge-graph operations,
  226. cross-wing navigation, drawer management, agent diaries, and agent
  227. coordination (logstream events + artifact handoffs). Installation
  228. and the full tool list:
  229. [mempalaceofficial.com/reference/mcp-tools](https://mempalaceofficial.com/reference/mcp-tools.html).
  230. ## Agents
  231. Each specialist agent gets its own wing and diary in the palace.
  232. Discoverable at runtime via `mempalace_list_agents` — no bloat in your
  233. system prompt:
  234. [mempalaceofficial.com/concepts/agents](https://mempalaceofficial.com/concepts/agents.html).
  235. ## Auto-save hooks
  236. Auto-save hooks for **Claude Code, Codex CLI, and Cursor IDE** save
  237. periodically and before context compression:
  238. - Claude Code + Codex →
  239. [mempalaceofficial.com/guide/hooks](https://mempalaceofficial.com/guide/hooks.html)
  240. - Cursor IDE (adds session-start recall and a transcript snapshot before
  241. compaction) →
  242. [mempalaceofficial.com/guide/cursor-hooks](https://mempalaceofficial.com/guide/cursor-hooks.html)
  243. If you are installing under time pressure, start with the
  244. [Claude Code retention setup checklist](https://mempalaceofficial.com/guide/claude-code-retention.html):
  245. wire the hooks, back up existing JSONL transcripts, and backfill them with
  246. `mempalace mine ~/.claude/projects/ --mode convos`.
  247. For per-message recall on top of the file-level chunks the hooks produce,
  248. run `mempalace sweep <transcript-dir>` periodically — it stores one
  249. verbatim drawer per user/assistant message, idempotent and resume-safe.
  250. ---
  251. ## Requirements
  252. - Python 3.10+
  253. - A vector-store backend (ChromaDB by default)
  254. - ~300 MB disk for the embedding model. Pick it with `mempalace init --embedding-model`: `embeddinggemma` (embeddinggemma-300m, multilingual, 100+ languages, recommended) or `minilm` (all-MiniLM-L6-v2, English-only, ~30 MB). See the docstring at [`mempalace/embedding.py`](mempalace/embedding.py) for details and migration notes.
  255. - Optional — compute embeddings on a server instead of locally. Set `embedding_model: "openai-compat"` in `~/.mempalace/config.json` together with `embedding_api_url` / `embedding_api_model` (and `embedding_api_key` if the server needs auth) to use any OpenAI-compatible `/v1/embeddings` endpoint — LM Studio, llama.cpp, vLLM, Ollama's OpenAI shim, or a self-hosted server (e.g. a larger multilingual or GPU-served embedder). Each key is overridable via the matching `MEMPALACE_EMBEDDING_API_*` env var. When the endpoint is on your machine or LAN, no content leaves your network. Switching to it requires `mempalace repair rebuild-index` (different vector space).
  256. For GPU setup, see the [model/device support table](website/guide/configuration.md#embedding-models-and-devices).
  257. On Apple Silicon, CPU is expected for MiniLM and EmbeddingGemma ONNX: MiniLM
  258. disables CoreML, while EmbeddingGemma excludes it from automatic selection to
  259. avoid invalid vectors. Experimental [EmbeddingGemma 2](docs/embeddinggemma2.md)
  260. supports PyTorch MPS with health checks and CPU fallback. Changing models on an
  261. existing palace requires re-embedding; changing only the device does not.
  262. No API key is required for the core benchmark path.
  263. ## Docs
  264. - Getting started → [mempalaceofficial.com/guide/getting-started](https://mempalaceofficial.com/guide/getting-started.html)
  265. - CLI reference → [mempalaceofficial.com/reference/cli](https://mempalaceofficial.com/reference/cli.html)
  266. - Python API → [mempalaceofficial.com/reference/python-api](https://mempalaceofficial.com/reference/python-api.html)
  267. - Full benchmark methodology → [benchmarks/BENCHMARKS.md](benchmarks/BENCHMARKS.md)
  268. - Release notes → [CHANGELOG.md](CHANGELOG.md)
  269. - Corrections and public notices → [docs/HISTORY.md](docs/HISTORY.md)
  270. ## Contributing
  271. PRs welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
  272. ## License
  273. MIT — see [LICENSE](LICENSE).
  274. <!-- Link Definitions -->
  275. [version-shield]: https://img.shields.io/badge/version-3.12.0-4dc9f6?style=flat-square&labelColor=0a0e14
  276. [release-link]: https://github.com/MemPalace/mempalace/releases
  277. [python-shield]: https://img.shields.io/badge/python-3.10+-7dd8f8?style=flat-square&labelColor=0a0e14&logo=python&logoColor=7dd8f8
  278. [python-link]: https://www.python.org/
  279. [license-shield]: https://img.shields.io/badge/license-MIT-b0e8ff?style=flat-square&labelColor=0a0e14
  280. [license-link]: https://github.com/MemPalace/mempalace/blob/main/LICENSE
  281. [discord-shield]: https://img.shields.io/badge/discord-join-5865F2?style=flat-square&labelColor=0a0e14&logo=discord&logoColor=5865F2
  282. [discord-link]: https://discord.com/invite/ycTQQCu6kn

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.