DEV Community: Manoir Yantai

The MCP protocol explained simply

Manoir Yantai — Thu, 18 Jun 2026 22:01:04 +0000

The MCP protocol explained simply

Model Context Protocol lets AI agents use real tools like databases, search engines, and social media APIs.

Stop Your AI Agent Forgetting Everything Between Sessions

Manoir Yantai — Thu, 18 Jun 2026 02:01:06 +0000

Stop Your AI Agent Forgetting Everything Between Sessions

You know that feeling when your AI assistant finally understands your project, your conventions, your preferences — and then you start a new session and it's like talking to a stranger?

I built something: a memory sidecar that runs alongside any AI agent and persists context between sessions. Open source, MIT.

What it does:

Saves structured memories (facts, decisions, user preferences)
Retrieves relevant context automatically
Works with any agent framework
Zero configuration

Check it out: https://github.com/mage0535/hermes-memory-installer

Why I run my servers on autopilot

Manoir Yantai — Wed, 17 Jun 2026 22:01:45 +0000

Why I run my servers on autopilot

Systemd + cron + Hermes = zero-touch server operations. My servers haven't needed human attention in weeks.

The MCP protocol explained simply

Manoir Yantai — Tue, 16 Jun 2026 22:01:35 +0000

The MCP protocol explained simply

Model Context Protocol lets AI agents use real tools like databases, search engines, and social media APIs.

Give Your AI Agent Persistent Memory with a Sidecar Architecture

Manoir Yantai — Tue, 16 Jun 2026 02:02:48 +0000

Ever restarted an AI agent session only to realize it forgot everything you discussed? That blank slate is a productivity killer when you're working on complex projects. I've tried various approaches—long system prompts, RAG pipelines, fine-tuning—but they either hit token limits, require heavy infrastructure, or force you to modify the agent's internals.

That's why I built (and open-sourced) Memory Sidecar v3.1.1. It's a separate process that runs alongside your agent—Hermes, Claude Code, Cursor, Codex, whatever—and gives it a real memory without touching a single line of agent code.

How It Works

Instead of patching the agent, Memory Sidecar uses a sidecar pattern. The agent writes session data to a shared data directory; the sidecar consumes it, processes it, and injects relevant context back into the agent's system prompt on subsequent runs. It's designed for production use where you need continuity without redesigning your agent architecture.

The retrieval system is layered:

Hot Layer: a simple memory tool with a 5KB cap, providing instant recall of recent context.
Warm Layer: Hindsight PostgreSQL for mid-term memory that survives restarts.
Cold Layer: a knowledge graph (gbrain) combined with FTS5 full-text search for long-term knowledge and topic tracking.

This tiered approach means the agent always gets the right amount of context—recent conversations are fast, important topics are remembered indefinitely, and nothing is lost when you close the terminal.

What's New in v3.1.1

The latest release adds two features that make it more robust for continuous operation:

Memory Watermark Detection (memory_watermark.py) – automatically monitors memory usage and archives old sessions before you hit limits.
Periodic Snapshot Backups (memory_snapshot_backup.py) – creates scheduled snapshots so you never lose your agent's memory state.

Plus, the onboarding guide (HERMES_ONBOARDING.md) now includes a complete tool list for integrating your own agents, and all tokens have been moved to environment variables—no more hardcoded secrets.

Getting Started

Clone the repo, run the installer, and point it at your agent's session directory. That's it. The sidecar handles the rest. It's written in Python 3.9+ and licensed under MIT, so you can drop it into any project without friction.

git clone https://github.com/mage0535/hermes-memory-installer.git
cd hermes-memory-installer
pip install -r requirements.txt
# Configure your agent path in config.yaml
python memory-sidecar.py

I've been using this setup for months with multiple agents, and it's handled everything from long-running code reviews to multi-day research sessions. The architecture doc in the repo explains the full design if you want to dive deeper.

Why Not Just Use a Vector DB?

Vector databases are great for similarity search, but they don't capture structure—relationships between entities, event ordering, or which facts are outdated. Memory Sidecar's knowledge graph preserves these connections, and the layered retrieval means you're not hammering a vector index for every trivial lookup.

It's also deliberately stateless on the agent side. You can swap agents, run experiments, or restart without losing context. That flexibility has saved me hours of debugging "where did that conversation go?"

Check it out on GitHub: Memory Sidecar v3.1.1

Open source projects need marketing too

Manoir Yantai — Mon, 15 Jun 2026 22:01:39 +0000

Open source projects need marketing too

Great code isn't enough. You need README, demos, social presence, and consistent publishing.

5 lessons from running AI agents 24/7

Manoir Yantai — Sun, 14 Jun 2026 22:01:32 +0000

5 lessons from running AI agents 24/7

They hallucinate less with better prompts. They need fallbacks. They're not autonomous but they're close.

Vector search vs keyword search

Manoir Yantai — Sun, 14 Jun 2026 12:21:02 +0000

Vector search vs keyword search

Keyword search finds text. Vector search finds meaning. Both have their place in AI systems.

AI Agent vs API: What's the difference?

Manoir Yantai — Sun, 14 Jun 2026 12:07:02 +0000

AI Agent vs API: What's the difference?

An AI Agent thinks and acts. An API just responds. One is a worker, the other is a tool. Know the difference.

Stop Your AI Agent Forgetting Everything Between Sessions

Manoir Yantai — Sat, 13 Jun 2026 02:03:27 +0000

Stop Your AI Agent Forgetting Everything Between Sessions

You know that feeling when your AI assistant finally understands your project, your conventions, your preferences — and then you start a new session and it's like talking to a stranger?

I built something: a memory sidecar that runs alongside any AI agent and persists context between sessions. Open source, MIT.

What it does:

Saves structured memories (facts, decisions, user preferences)
Retrieves relevant context automatically
Works with any agent framework
Zero configuration

Check it out: https://github.com/mage0535/hermes-memory-installer

Production Memory for AI Agents: Give Your Agent Persistent Context Without Patching Its Internals

Manoir Yantai — Fri, 12 Jun 2026 15:46:15 +0000

Every time I restart my AI coding agent, it feels like onboarding a new junior developer. It doesn't remember the project architecture, the ongoing bugs, or the decisions we made last week. I tried prompt engineering, fine-tuning, and custom plugins — none gave me a persistent, structured memory that crosses sessions.

Most memory solutions require deep integration with the agent's internals. You patch the agent itself, which ties you to a specific platform and breaks on updates. Or you rely on naive chat history dumping, which doesn't scale. I wanted something that works with any agent — Hermes, Claude Code, Cursor, Codex — without modifying the agent. A separate process that archives sessions, builds knowledge, and injects relevant context when needed. That's how Memory Sidecar was born.

Memory Sidecar runs alongside your agent as a sidecar: separate process, shared data directory. It doesn't patch anything. The architecture uses three layers:

Hot Layer – recent context (∼5KB cap), fast access for what happened in the last few turns.
Warm Layer – a PostgreSQL-based hindsight service that analyzes sessions and extracts structured memories.
Cold Layer – a knowledge graph (gbrain) with FTS5 search, storing long-term knowledge about people, projects, and recurring problems.

When the agent starts a new session, the sidecar injects tiered context into the system prompt. It pulls from all three layers, prioritizing recency and relevance. The agent gets a compressed but rich summary of what's worth remembering.

The latest release (v3.1.1) adds several production‑ready features:

memory_watermark.py — automatically detects when memory usage crosses a threshold and archives old data, so you don't blow past context limits.
memory_snapshot_backup.py — periodic, configurable backups of the memory state.
hindsight-service.py — simplified standalone daemon for the warm layer, no complex orchestration needed.
session_to_gbrain.py — now reads tokens from environment variables (no more hardcoded configs).
HERMES_ONBOARDING.md — a complete integration guide for connecting any agent, with full tool listings and examples.

When to use it: This setup shines for agents that work on long‑running projects, need to remember user preferences, or handle complex debugging across sessions. If you're tired of repeating yourself every time you restart your agent, this gives you a real, persistent memory layer that works out of the box.

When not to use it: It's not for real‑time memory within a single session — that's handled by the agent's built‑in context window. Nor is it a replacement for fine‑tuning; it's a caching and retrieval layer, not a model update.

I've been running this for a few weeks, and the difference is night and day. My agent now remembers the project's exception patterns, the API keys we use, and the preferences I set three sessions ago. No more repeating context. No more mental overhead of re-explaining everything.

The project is open source (MIT) and you can find it here: Memory Sidecar on GitHub. If you're building agents that need to work across sessions, give it a try — I think you'll find it just works.

Stop Your AI Agent Forgetting Everything Between Sessions

Manoir Yantai — Fri, 12 Jun 2026 15:40:19 +0000

Stop Your AI Agent Forgetting Everything Between Sessions

You know that feeling when your AI assistant finally understands your project, your conventions, your preferences — and then you start a new session and it's like talking to a stranger?

I built something: a memory sidecar that runs alongside any AI agent and persists context between sessions. Open source, MIT.

What it does:

Saves structured memories (facts, decisions, user preferences)
Retrieves relevant context automatically
Works with any agent framework
Zero configuration

Check it out: https://github.com/mage0535/hermes-memory-installer