Forem: Dragos Marincas

Dalexor MI: The MCP Server That Gives Your AI a Permanent Memory of Your Codebase

Dragos Marincas — Wed, 04 Mar 2026 19:38:45 +0000

Dalexor MI: The MCP Server That Gives Your AI a Permanent Memory of Your Codebase

If you've ever spent a morning deep in a complex problem with an AI coding assistant — only to open a new file and have it ask "can you paste the code you're talking about?" — you've experienced what Dalexor's founder calls the Goldfish Effect.

That frustrating amnesia is exactly what Dalexor MI is built to solve.

What Is Dalexor MI?

Dalexor MI is an MCP (Model Context Protocol) server that gives AI assistants like Claude and Cursor a persistent, searchable memory of your entire codebase history. Instead of re-explaining context every session, you install it once and let it build a living timeline of your project in the background.

It works with Claude Desktop, Cursor, and Windsurf out of the box, and can be installed in under two minutes:

pip install dalexor
dalexor init

The Problem It's Solving

Most AI coding tools use basic file search to pull in relevant snippets. The result is an AI that sees isolated fragments — but never the story of why your code is the way it is.

Dalexor's founder, Dragos Marincas, described the motivation on DEV Community: he didn't want to build another "chat with your files" wrapper. He wanted something that felt like a permanent brain for his project — a tool that tracks not just what changed, but why.

How It Works

Dalexor runs a lightweight CLI watcher (dx watch) in the background. Every time you save a file, it evaluates whether the change is meaningful. Trivial edits like formatting tweaks or whitespace changes are ignored. Substantive changes — a new authentication flow, a refactored data model — get captured as a Logic Snapshot, complete with an AI-written plain-English summary.

These snapshots are encrypted locally before they ever leave your machine, then stored permanently in your private cloud account and indexed for instant natural language search.

The three-step flow is:

Connect — Install the CLI and run dalexor init
Monitor — The watcher silently captures meaningful changes in real time
Search — Ask questions in plain English directly inside Claude or Cursor

What You Can Actually Ask It

Once Dalexor has been watching your project for a while, you can ask your AI assistant things like:

"Why did we choose PostgreSQL?" → "Switched from MongoDB for ACID compliance..."
"When did we add rate limiting?" → "Added 2024-12-15 after DDoS incident..."
"Find the definition of UserSession" → Returns the snapshot where it was introduced
"Show me all API changes" → Returns a filtered list of every relevant snapshot

That's a fundamentally different experience from paste-and-explain.

Key Features

AI Summarization — Every meaningful change gets an automatic plain-English note. Passive documentation that writes itself.

Conflict Prediction — Before you commit, Dalexor checks if anyone on your team has recently touched the same files or functions, warning you about likely merge conflicts before they happen.

Dependency Mapping — See exactly what else in the codebase depends on a function before you change it. Know the full impact of an edit before you make it.

Multi-Project Support — Run as many projects as you want under one account and search across all of them at once.

Visual Timeline Dashboard — Browse your project's full change history visually, scrolling through who changed what and when.

REST API Access — Hook Dalexor into CI/CD pipelines, Slack workflows, or any internal tooling via its REST API.

Security Architecture

Dalexor is built on a local-first security model. Raw code is filtered and encrypted on your machine before anything is transmitted. Encryption keys belong to you — Dalexor never holds them. Each organization's data is fully isolated at the database level, meaning no other Dalexor user can access your project history.

The dual-mode architecture — a local monitor handling encryption and IDE context, paired with a cloud engine for AI summarization and fast search — means the most sensitive processing never leaves your device.

Real-World Use Cases

Onboarding new developers — New team members can ask the project memory why architectural decisions were made, instead of interrupting senior engineers.

Debugging production issues — When something breaks, Dalexor surfaces when the relevant code changed and why, without combing through a year of git history.

Compliance and auditing — For regulated industries, Dalexor maintains a permanent, searchable, tamper-evident record of every significant change, who made it, and when.

The Backstory

Dalexor's founder started with an AI security monitoring tool that failed because he'd never validated whether a market existed for it. Rather than quit, he reframed the lesson: "I don't consider it a failure. I paid a price to learn new stuff." That pivot led to Dalexor MI — a product born directly from the pain of building with AI assistants that kept forgetting everything.

Getting Started

Dalexor MI has a free tier and requires no credit card to start. After installing and running dalexor init, you add the MCP bridge to your Claude Desktop config and immediately gain access to 11 tools including find_definition, trace_dependency, and predict_conflicts.

If you've ever lost momentum because your AI forgot what you just built, this is worth trying.

→ dalexor.com

How Dalexor "Brain" Actually Works: A Deep Dive into Codebase Intelligence

Dragos Marincas — Tue, 03 Mar 2026 19:32:51 +0000

Most people think AI tools just read your files and search for keywords. But that’s like trying to understand a book by looking at the index. To actually be useful, an AI needs to understand the choices you made while writing the code.

Here is a look at the technical areas where we’ve significantly improved Dalexor's engine to make it smarter and more secure.

The "Noise" Filter: How we decide what to remember Usually, a code-watcher is very annoying. It saves a new version every time you hit "Save," even if you only added a space or a comment.

We’ve improved our Filtering Logic. Instead of watching for "file changes," we now measure the density of information.

The Technicality: We use a mathematical calculation to see if the logic of the code changed, or just the look of it.
The Improvement: If you just move code around or change formatting, Dalexor stays quiet. If you change a core function, Dalexor wakes up. This means the AI’s memory stays clean and high-quality.

The Logic Timeline: Tracing the "Ancestry" of a Bug Before, if an AI saw a bug, it could only see the broken code in front of it. We’ve improved our Heritage Mapping to fixed this.

Now, Dalexor builds a "family tree" for every function.

How it works: Every time you make a meaningful change, Dalexor links it to the previous version and the reason why you changed it.
The Result: When the AI analyzes your code, it can say: "Wait, don't change this line. I see that three months ago, Joe changed this to fix a specific crash on Windows." It provides context that a regular search would completely miss.

Predictive Safety: Finding crashes before they happen One of our biggest improvements is in Conflict Detection. In a team, it’s easy for two people to edit the same area of the code at the same time.

The Technicality: Dalexor now tracks the "neighborhood" of where everyone is working in real-time.
The Improvement: Instead of waiting for you to try and "Merge" your code (when it’s already too late), Dalexor predicts the collision. It warns you in your terminal: "Someone else is currently refactoring the Auth module you are working on." It’s like a traffic control system for your codebase.

The Neural Vault: Keeping your code a secret We have completely overhauled how we handle Privacy.

The Technicality: We moved from basic encryption to a Sovereign Vault system.
The Improvement: Your code is now "locked" on your machine before it ever touches the internet. We use a private key that only you have. This means that even if someone hacked our servers, they would see nothing but scrambled text. We’ve also added a new layer that recognizes your specific devices, ensuring that your private key can't be used by anyone else but you.

Smart Architecture: Fairer, Faster, Smoother We rebuilt our Limit System from the ground up.

The change: We moved away from "Team Limits" and into "User-Specific Tracking."
The Benefit: This prevents one person from "eating up" all the AI's processing power for the whole team. It makes the entire system faster for everyone and ensures that the AI stays responsive even when you're working on massive, complex projects.

Why this matters
We didn't just build a search tool. We built a system that understands the evolution of your work. By focusing on these technical improvements—filtering the noise, tracing the history, and locking down the security—we’ve made Dalexor the most reliable memory your AI assistant could have.

Stop re-explaining your code. Start building.

Check https://dalexor.com for more informations

Why I spent the last few months building a long-term memory for AI

Dragos Marincas — Tue, 24 Feb 2026 17:55:13 +0000

If you use an AI to help you code, you know the exact moment it fails.

It’s usually around 2:00 PM. You’ve spent the whole morning working through a logic problem. You and the AI have finally figured out how a specific part of your app should work. You feel unstoppable. Then, you open a new file to connect that logic to your database, and you ask the AI a simple question.

The AI looks at you (digitally) and says: "I don't see any database logic. Can you paste the code you're talking about?"

Just like that, the momentum is gone. You’re back to copy-pasting code blocks from one tab to another, trying to "remind" a genius model what you literally just did ten minutes ago.

I call this the Goldfish Effect. And I got so tired of it that I decided to build a fix. I call it Dalexor MI.

The Problem: AI has no "Big Picture"
We keep hearing about how smart these AI models are, and they are. But they have a massive flaw: they only see what is right in front of them.

Most tools use a simple search to find snippets of your code. It’s like trying to understand a 500-page book by only looking at the specific page you’re on and three random paragraphs from the middle. You see the words, but you lose the story. You lose the why.

When you're building a real project, the why is everything. You need the AI to know why you chose one library over another three weeks ago, or how a change in your "user" file is going to break your "payment" file on the other side of the folder.

How I built Dalexor to solve this (The simple version)
I didn't want to build another "chat with your files" wrapper. I wanted something that felt like a permanent brain for my project. Here is how it actually works:

It watches in the background I built a small tool you run in your terminal (

dx watch
). It just sits there silently. It doesn't nag you. But every time you save a file, it takes a look. It’s like a silent partner taking notes on the project while you work.

It filters the signal from the noise If I record every single time I fix a typo or add a space, the AI's memory gets cluttered with junk. So, I built an engine that measures how "meaningful" a change is. If you just changed a comment, Dalexor ignores it. If you added a new login flow or changed how your data is structured, it says, "Okay, this is important," and it saves a "snapshot" of that logic.
It builds a map, not just a list Files in a project aren't just a list of names; they are connected. My tool maps these connections. It understands that File A depends on File B. When the AI looks at your history, it isn't just seeing a bunch of text files; it’s seeing a map of your entire system architecture. It knows how the pieces fit together.
Privacy that's actually private This was the most important part for me. My code is my life's work. I don't want to send my entire history to a third-party cloud where someone else can see it. So, I made sure that your code is "locked" on your own computer. It uses a key that only you have. By the time it hits the internet to be saved in your history, it’s already unreadable to everyone—including me. Your AI assistant can see it (because you give it the key), but no one else can.

Why this changes how you build
The goal isn't just to write code faster. The goal is to stop re-explaining yourself.

Since I've been using this, my conversations with AI have changed. Instead of saying "Here is my code, please fix this bug," I can say "Look at the changes I made this morning—did I break the way we handle user sessions?"

And because the AI has that history, it can actually give me a real answer. It remembers the decisions we made. It has context.

I’m finally at a point where I’m ready to share the documentation and the first build with other developers. It’s simple, it’s private, and it actually remembers.

If you’ve been hitting that same "context wall" and you're tired of re-pasting your work every twenty minutes, I’d love for you to check it out.