v2.18.0 - Fastembed and unified graph release

MARM v2.18.0 is the release where the project stops being just a memory server and becomes one bundled local memory system.

This covers the bigger work since v2.15.2: embedded code graph tools, one-package pip and Docker installs, dashboard bundling, STDIO parity, and the fastembed backend swap.

What changed

Fastembed semantic search

MARM now uses fastembed with ONNX Runtime for sentence-transformers/all-MiniLM-L6-v2. The model stays the same at 384 dimensions, but the heavy Torch and sentence-transformers dependency stack is gone.

The swap was checked against the old backend before shipping: cosine similarity matched at 1.0000 across the test corpus, and top-5 retrieval ranking matched in the same order.

The practical result is a much smaller image and the same recall behavior. Local Docker size dropped from about 2.25GB to 847MB, and compressed size dropped from about 420MB to 167MB.

Embedded graph and indexing tools

The code graph layer is now bundled into MARM. HTTP and STDIO both expose 12 tools total: 7 core memory tools and 5 graph tools.

New graph tools:

• marm_graph_index
• marm_code_lookup
• marm_graph_trace
• marm_graph_architecture
• marm_graph_impact

Graph startup is lazy. Normal memory, logging, notebook, and recall startup stays light. The graph backend starts only when a graph tool is called.

One package, one Docker image

pip install marm-mcp-server now includes the server, dashboard, and graph package paths. The Docker image does the same.

The dashboard is mounted at:

http://localhost:8001/dashboard

There is no separate dashboard image or separate graph package required for the normal install path.

STDIO graph parity

STDIO now matches HTTP for graph tools. That means local STDIO users get the same 12-tool surface without opening a port or setting an API key.

Official MCP SDK for STDIO

The old external fastmcp dependency was removed from release packaging. STDIO now uses the official MCP Python SDK compatibility class. Tool behavior stayed the same, but the dependency conflict with packages like LiteLLM is gone.

Benchmark and embedding storage fixes

The hot-path benchmark now runs against a clean throwaway DB, checks embedding dimensions, and reports the fastembed-backed path.

MARM also now normalizes every stored embedding to float32 at the serialization boundary. That protects memory writes, notebook embeddings, compaction summaries, and chunk embeddings from dtype drift in upstream encoder output.

Notes

The latest Docker tag now means the unified all-in-one image. If you had scripts expecting the older memory-only shape, pin an older tag or update the run command.

Graph indexing still uses the pinned codebase-memory-mcp==0.8.1 backend. Treat future backend bumps as reviewed changes because that binary owns parsing, indexing, and graph behavior.

v2.15.2 - Exact recall, guided setup, attribution, and Docker fixes

What changed since v2.14.0

This release catches up the public release notes from v2.14.1 through v2.15.2. The main theme is simple: MARM is easier to start, better at finding exact technical details, safer to run in Docker, and cleaner for multi-project use.

Faster setup with marm-init

marm-init is now the recommended setup path. Instead of making users piece together install docs, MCP config, transport choices, and client commands by hand, the skill walks through the setup inside the agent environment.

It can handle local Python or Docker installs, HTTP or STDIO transport, dashboard startup, protocol loading, and connecting multiple clients to the same memory server. The manual install paths are still documented, but they are no longer the main path for a new user.

Exact recall for code, config, commands, and APIs

MARM now has an exact retrieval lane for syntax-heavy queries. Searches like RECALL_SCAN_LIMIT, --generate-key, settings.py, marm_smart_recall, HTTP routes, URLs, and command strings can route through deterministic FTS/BM25 with a LIKE fallback instead of relying on semantic similarity.

The default is exact_mode="auto", so agents and users get this behavior without changing their normal recall calls. Power users can still force exact_mode="exact" or exact_mode="semantic" when they need tighter control.

Project and platform attribution

Memories, logs, and notebook entries now carry nullable project and platform metadata. MARM can keep work from different repositories, clients, and agent surfaces in the same local database while still letting recall filter by project or platform when needed.

This also makes consolidation safer. Exact duplicate checks and semantic merge checks now respect the current project/platform scope, which reduces the risk of one project quietly merging into another.

Docker, CI, and dependency fixes

Docker and CI builds now avoid the CUDA Torch dependency flood. Runtime installs use the CPU Torch wheel path, and CI validates through requirements.txt before installing the editable package with --no-deps.

Docker ignore files were also tightened so local pytest caches, temp databases, and test scratch folders do not get sent into image build contexts.

Email signup prompt and community polish

MARM now has a one-time, server-side email signup prompt after meaningful usage. It is controlled by environment settings, stored in user_settings, and guarded against MCP response-size limits.

The README also got a cleanup pass: clearer setup flow, friendlier contribution language, updated badges, a new contributors file, issue templates, Discord/Discussions links, and updated visual assets.

Security reporting

A new SECURITY.md explains how to report sensitive issues privately through support@marmsystems.com. The contributors file now includes a security acknowledgments section for responsible disclosures.

Upgrade notes

• Docker users should rebuild or pull the new image instead of reusing older local layers.
• If you run shared HTTP deployments, keep using MARM_API_KEY.
• If you rely on technical recall for config keys, commands, routes, or file paths, leave exact_mode on the default auto unless you have a reason to force another lane.

Contributors

Thanks to the contributors whose work landed in this release range:

• @vaishnavidesai09 for the exact retrieval lane in PR #71.
• @sarvesh1327 for preserving compaction trigger environment overrides in PR #43.
• @zza-830 for config safety clamping and recall debug observability in PR #54.
• @OI-OS for the earlier STDIO transport work now reflected in the contributor docs.
• The responsible security researcher who privately reported a Docker/HTTP auth-boundary issue affecting earlier deployment guidance.

v2.14.0 - Memory core modularization

v2.14.0

This release cleans up the memory core and logging flow so MARM is easier to maintain and less noisy for agents.

Logging and summaries

The legacy user-facing context/session helpers were removed from the MCP tool surface. Session routing now goes through structured marm_log_entry entries such as Session: ... and Topic: ....

marm_summary now uses a server-managed session_summary_cache table. Summaries rebuild only when logs change, cached entry counts are checked before reuse, cache rows are removed when sessions are deleted, and oversized responses are trimmed to stay within MCP response limits.

HTTP and STDIO now share the same summary service, so both transports use the same cache, truncation, and empty-session behavior.

Protocol and tool surface

The public MCP surface is now 7 tools. Behavior that used to require separate context/session tools moved behind marm_log_entry, marm_summary, and server-managed automation.

The protocol docs now include more direct guidance for when agents should act across coding, research, game development, writing, journalism, and everyday workflows. The planned marm-init skill path is documented for future protocol bootstrap work, while current runtime delivery still uses first-tool protocol injection with periodic PROTOCOL-LITE refresh.

Memory core refactor

The growing memory layer was split into focused modules while keeping the public MARMMemory facade intact. Shared helpers, database setup, chunk-aware scoring, and high-level memory operations now live in smaller files, which should make future recall and compaction work easier to review.

Parity checks were added against the old memory implementation to catch regressions in method signatures, database behavior, recall behavior, stale chunk handling, and core write-path contracts.

Release notes

This release also updates project version references to 2.14.0, moves active docs and package metadata toward Apache 2.0, fixes Docker image metadata, and adds regression coverage for summary caching, write queue behavior, and active log session restoration.

v2.13.0

MARM v2.13.0 focuses on recall quality and long-memory coverage.

Recall now starts with FTS5 BM25, reranks only that bounded candidate set semantically, and falls back to the broader semantic scan only when the keyword path is weak, malformed, or unscoreable. That cuts unnecessary scoring work on exact-term queries without giving up abstract recall when the wording is loose.

This release also fixes a real limitation in the embedding path for long memories. Short entries still use the existing single-vector path. Longer entries are now split into overlapping chunks, scored chunk-aware in both the rerank and fallback lanes, and collapsed back to one parent memory result using the best chunk match. In practice, details near the end of a long memory are much more likely to come back without flooding results with duplicate chunk hits.

Other changes in this release:

• Added FTS_CANDIDATE_LIMIT with a default of 50 to control how wide the BM25 candidate pool gets before semantic reranking.
• Tightened recall_scan_truncated so it only reports on the bounded semantic fallback lane, not the primary filter-then-rerank path.
• Moved long-memory chunk writes off the agent-visible return path and added guards so stale background writers cannot reinsert old chunks after a merge.
• Added dedicated chunking tests, rerank regression coverage, and a smoke script for end-to-end validation.
• Updated the core docs and benchmarks for the new recall path and chunked embedding behavior.

This is a performance release, but not just a speed release. The goal was to make recall faster on the common path while making long memories more trustworthy when they matter.

v2.12.2 — MCP Registry fix

v2.12.2 — Patch Release

Fixes MCP Registry publish failure from v2.12.1.

Fix

• Restored missing mcp-name: io.github.Lyellr88/marm-mcp-server tag in marm-mcp-server/README.md that caused the registry publisher to fail

No functional changes

All features from v2.12.0 are included unchanged. See the v2.12.0 release notes for the full feature details.

---

pip install --upgrade marm-mcp-server

v2.12.1 — CI fix (OIDC permissions)

v2.12.1 — Patch Release

Patch release to fix a CI publishing failure from v2.12.0.

Fix

• Added id-token: write permission to the publish-pypi job so the OIDC trusted publishing token is available to pypa/gh-action-pypi-publish

No functional changes

All features from v2.12.0 are included unchanged:

• FTS5 hybrid search (BM25 + vector fusion)
• 3-layer retrieval (detail=1/2/3)
• Temporal weighting (exponential half-life decay)

See the v2.12.0 release notes for the full feature details.

---

pip install --upgrade marm-mcp-server

v2.12.0 — Hybrid Search, 3-Layer Retrieval & Temporal Weighting

What's New in v2.12.0

FTS5 Hybrid Search

Full-text search index (SQLite FTS5) now runs alongside semantic vector search. Every recall scores both paths — BM25 keyword rank and cosine similarity — then merges them via weighted fusion (HYBRID_SEARCH_TEXT_WEIGHT, default 0.35). Queries that miss the embedding model (stop words, unstemmed terms) now fall through to a LIKE fallback instead of returning empty.

3-Layer Retrieval

marm_smart_recall now accepts a detail parameter (1/2/3):

• detail=1 — summary view (~200 chars). Default. Lowest token burn.
• detail=2 — context view (~500 chars).
• detail=3 — full memory content.

Truncation is applied on-read with no schema changes — works immediately on all existing memories. Agents choose the depth they need; the 1MB response limiter now budgets against truncated sizes so you get more results, not fewer.

Temporal Weighting

Recent memories rank higher. An exponential half-life decay score (default 30-day half-life) is blended additively into hybrid scores via TEMPORAL_WEIGHT (default 0.1 — conservative, additive only). Set TEMPORAL_WEIGHT=0 for exact v2.11.0 ranking behavior.

Configuration

Three new env-overridable settings with load-time validation and stderr warnings on out-of-range values:

• HYBRID_SEARCH_TEXT_WEIGHT — FTS vs vector blend (default: 0.35, clamped to [0, 1])
• TEMPORAL_WEIGHT — recency bias strength (default: 0.1, clamped to [0, 1])
• TEMPORAL_HALF_LIFE_DAYS — half-life for decay (default: 30, minimum 1)

Tests

44 new tests across three new test files: test_hybrid_search.py, test_3layer_retrieval.py, test_temporal_weighting.py. Smoke harness at scripts/test-scripts/smoke_hybrid_search.py for weight tuning.

---

Upgrade

pip install --upgrade marm-mcp-server

Or pull the latest Docker image:

docker pull lyellr88/marm-mcp-server:latest

No database migrations required. All changes are backward compatible — existing memories work without any modification.

MARM v2.9.0 - Compaction, Consolidation & Swarm Hardening

MARM v2.9.0 is the memory cleanup and swarm-readiness release.

This release adds the new consolidation and compaction system while keeping the public MCP surface lean at 9 tools. The main user-facing addition is marm_compaction, a single tool that lets agents review, stage, apply, or discard compaction candidates without exposing a pile of low-level helper tools.

Highlights

• Added write-time memory consolidation for exact and near-duplicate memories.
• Added the compaction worker pipeline for finding fragmented or duplicate memory clusters.
• Added agent-assisted compaction through one public marm_compaction tool.
• Routed compaction apply through the write queue so cleanup work stays ordered with normal writes.
• Expanded swarm support with write queue defaults, RPM presets, and compaction-aware smoke tests.
• Updated docs and registry metadata for the 9-tool surface.

What Changed

Cleaner Memory Over Time

MARM now prevents exact duplicate writes using normalized content hashes before embedding work runs. It can also merge near-duplicate memories during normal writes when consolidation is enabled, preserving session boundaries and keeping merge history in metadata.

Agent-Assisted Compaction

The new compaction worker can detect older or fragmented memory clusters and stage them for review. MARM does not assume it owns the model. Instead, it nudges the connected agent to summarize candidates through marm_compaction, then MARM safely applies the result to the database.

Better Swarm Behavior

The write queue now supports callable mutations, letting compaction apply flow through the same serialized write path as normal memory writes. Runtime presets also tune rate limits and compaction trigger counts for normal, swarm, swarm-max, trusted, and custom deployments.

Testing & Hardening

This release adds focused regression coverage and smoke scripts for consolidation, compaction staging/apply, stale guards, cross-session isolation, write-queue callable execution, HTTP RPM behavior, mocked swarm writes, and real local Ollama swarm writes.

Install

pip install marm-mcp-server
python -m marm_mcp_server

For shared HTTP deployments:

python -m marm_mcp_server --swarm
python -m marm_mcp_server --swarm-max
python -m marm_mcp_server --trusted

v2.1.0

MARM Universal MCP Server v2.1.0 - GitHub Release

🧠 Universal Memory Intelligence for AI Agents

Transform any AI conversation into a lasting memory experience. MARM provides intelligent semantic search, contextual logging, and seamless workflow management across all major AI platforms.

⚡ Key Features

19 Production-Ready MCP Tools

• Smart Memory: Semantic search with AI embeddings finds exactly what you need
• Session Management: Start, refresh, and bridge conversations across different AI agents
• Intelligent Logging: Auto-categorize and store important decisions, code snippets, and insights
• Notebook System: Create reusable knowledge templates and active instruction sets
• Context Bridging: Seamless workflow transitions between different AI agents and projects

Professional Architecture

• FastAPI Backend: Modern Python server with SQLite optimization and connection pooling
• Docker Ready: Multi-stage builds with health monitoring and configurable environments
• Professional Testing: 5 comprehensive diagnostic suites (security, performance, integration, memory, MCP compliance)
• Cross-Platform: Works with Claude Code, Qwen CLI, Gemini CLI, Grok CLI
• Rate Limiting: IP-based protection with graceful degradation

Complete Documentation

• Installation Guides: Docker, Windows, Linux, and platform integration
• Usage Handbooks: Step-by-step workflows with real-world examples
• Professional Testing: Built-in diagnostics validate security, performance, and compliance

🎯 Perfect For

• Developers: Maintain context across coding sessions, remember architecture decisions
• Researchers: Build searchable knowledge bases from AI conversations
• Content Creators: Track ideas, maintain consistent voice across projects
• Teams: Share AI conversation insights and maintain project memory

🛠 Quick Start

Docker (Recommended):

git clone https://github.com/Lyellr88/MARM-Systems.git
cd MARM-Systems/marm-mcp-server/MARMcp-beta
docker-compose up --build

Connect to your AI:

# Claude Code
claude mcp add marm-memory --transport http --url "http://localhost:8001/mcp"

# Grok CLI
grok mcp add marm-memory --transport http --url "http://localhost:8001/mcp"

📊 What's New in v2.1.0

• Universal MCP Protocol: Full Model Context Protocol implementation with 1MB response compliance
• Semantic Search Engine: AI-powered memory retrieval using sentence-transformers
• Production Hardening: Rate limiting, error isolation, health monitoring
• Professional Test Suite: 74 comprehensive tests across security, performance, and integration
• Cross-Platform Integration: Support for all major AI CLI tools
• Complete Documentation: Installation guides for every platform and use case

🔗 Learn More

• Installation Guides - Docker, Windows, Linux, platform integration
• MCP Handbook - Complete usage guide with examples
• Contributing - Join the MARM development community

---

MARM Discord
Join the waitlist

Built with ❤️ for the AI developer community. Transform your AI conversations from ephemeral chats into lasting intelligence.

MARM v2.0 Release - The AI That Remembers Your Conversations

🚀

Memory Accurate Response Mode has evolved from experimental protocol to production-ready AI framework.

The AI That Remembers Your Conversations

---

What's New in v2.0

🧠 Enhanced AI Provider & Performance

• Complete migration from Google Gemini to Llama 4 Maverick (400B parameters)
• 95% cost reduction while significantly improving response quality and speed
• 10M token context limit for handling extensive conversation histories
• Advanced streaming implementation with proper polling for real-time responses

🎯 MARM Protocol Evolution

• "MARM IS memory incarnate" - Stronger AI identity and more natural responses
• Improved command structure: /deep dive replaces /contextual reply for clearer functionality
• Enhanced notebook system with /notebook use:, /notebook clear:, /notebook status: commands
• Mid-session activation - Start MARM anytime and automatically import existing conversation context
• "💭 Thinking Trail" format replaces verbose contract responses for better user experience

🎨 Complete Interface Modernization

• Glassmorphism Revolution - Eliminated nested windows with floating message cards directly on transparent glass background
• Color-Coded Conversations - Clean white user message cards, warm gold AI response cards creating perfect contrast against cool blue glass
• Single-Layer Architecture - Modern 2025 design eliminating the "stacked windows" feeling with beautiful backdrop blur effects
• Professional Polish - Professional-grade shadows, hover effects, and smooth transitions rivaling commercial AI applications
• Contextual command menu - Moved from sidebar to intelligent popup next to input field
• File upload system (📎) - Upload and analyze 15+ file types with syntax highlighting
• MARM toggle button (🤖) - Switch instantly between structured MARM and free conversation mode
• Mobile-Responsive Glassmorphism - Adapts beautifully to any screen size while maintaining visual integrity

🔒 Production-Grade Security

• Comprehensive XSS protection with dedicated security module across all components
• Centralized state management with immutable patterns and validation
• Multi-tab synchronization matching ChatGPT/Claude standards
• Memory leak prevention with trackable cleanup system for all resources

🧪 Professional Testing Infrastructure

• Comprehensive Test Suite: 74 passing tests covering Voice, UI, State, Commands, and Security modules
• Automated Testing: GitHub Actions CI/CD with Node.js 18.x & 20.x compatibility testing
• Quality Assurance: 42.39% test coverage with browser API mocking and edge case validation
• Developer Ready: Professional-grade testing setup ensuring code quality and contributor confidence

🐛 Critical Stability Improvements

• Fixed memory loss bug - MARM now preserves conversation context when activated mid-session
• Enhanced Sessions - Conversations survive page refreshes and mode switches
• Runtime crash elimination - Resolved 15+ critical bugs affecting core functionality
• Voice system fixes - Smooth text-to-speech without interruption errors
• Performance optimization - 60+ lines of duplicate code eliminated, O(1) size tracking

---

Why Upgrade to v2.0?

For New Users

MARM v2.0 is your gateway to AI conversations that remember context, maintain consistency, and grow with you over time. Unlike traditional AI chats that forget everything, MARM builds a enhanced memory of your interactions.

For Existing Users (v1.5 → v2.0)

• Better performance with 95% cost reduction and faster responses
• Smoother experience with modern UI and eliminated crashes
• Enhanced capabilities with file uploads and mid-session activation
• Production stability ready for serious workflows

---

Quick Start

Try MARM Online

Visit the live webchat interface - no installation required.

Use MARM in Any AI Chat

Copy the protocol from PROTOCOL.md and paste into ChatGPT, Claude, or your preferred AI.

Local Installation

git clone https://github.com/yourusername/MARM-Systems-MARM.git
cd MARM-Systems-MARM/webchat
npm install
npm start

---

What Makes MARM Different?

Traditional AI: Forgets context every conversation
MARM: Builds enhanced memory and grows smarter over time

Traditional AI: Generic responses for everyone
MARM: Personalized responses based on your specific knowledge base

Traditional AI: No control over AI behavior
MARM: Toggle between structured memory mode and free conversation instantly

---

Core Features

📝 Session Management

• /start marm - Activate memory-enhanced responses
• /log session:name - Create structured conversation logs
• /compile SessionName --summary - Generate intelligent summaries

🗂️ Personal Knowledge Base

• /notebook add:key value - Store facts, preferences, and context
• /notebook use:key - Reference your stored information
• Steel trap memory - MARM treats your notebook as absolute truth

🔍 Advanced Analysis

• /deep dive topic - Get comprehensive analysis with reasoning trails
• File upload support - Analyze code, documents, and data files
• Context preservation - Never lose conversation flow when switching modes

---

Technical Improvements

• 50+ files modified across frontend, backend, and configuration
• 1000+ lines of code optimized for performance and maintainability
• Complete HTML/JS separation following modern web development standards
• Comprehensive testing suite with XSS protection and memory leak detection
• Production deployment ready with proper error handling and monitoring

---

Migration Notes

From v1.5

• All existing /log and /notebook data remains compatible
• New /deep dive command replaces /contextual reply
• Enhanced notebook commands available (see HANDBOOK.md)
• UI will feel familiar but significantly more polished

From v1.4 and Earlier

• Session management now more robust with automatic recovery
• Protocol responses now more natural and user-friendly

---

What's Next?

MARM v2.0 establishes the foundation for our expanding AI ecosystem:

• MCP Integration - Model Context Protocol implementation
• N8N Workflows - Automation and workflow integration
• Dual RAG System - Advanced retrieval augmented generation
• Multi-AI Personalities - MoreLogic, HybridLogic, and specialized AI variants

---

Community & Support

• GitHub Discussions - Share use cases and get help
• Issue Tracker - Report bugs and request features
• Live Demo - Try it before you download, either local or with my chatbot visit my readme.md

---

Acknowledgments

MARM v2.0 represents months of refinement based on community feedback, real-world testing, and continuous iteration. Thank you to everyone who provided feedback, reported bugs, and helped shape this release.

Stop settling for forgetful AI. Transform your conversations. Empower your workflows. Experience the future where AI truly remembers. The revolution starts now. Dive into MARM v2.0! Get Started Here | webchat interface