I am Mikhail Deynekin — a senior sysadmin and developer based in Frankfurt am Main, Germany, in IT continuously since 1991: from DOS workstations and BBS boards to Kubernetes-era infrastructure and, today, LLM agent tooling. I build the kind of software I want to operate at 3 a.m.: idempotent, self-documenting, honest about its failures, and measurable.

• 🔧 35+ years across Windows & Linux infrastructure: automation, hardening, forensics
• 🤖 Current focus: code knowledge graphs for agents (RAGRAF), MCP contracts, multi-model consensus (AI-Consensus)
• 📧 Email infrastructure specialist: hMailServer, Exim, Roundcube, SpamAssassin, SPF/DKIM/DMARC
• 🖥️ RDP security toolkit author and the Windows 11 25H2 enablement script used in production fleets
• 🧾 Docs-as-product: every serious repo ships architecture notes, agent regimens, options references
• 🌐 deynekin.com · 📬 Mikhail@Deynekin.com · 🕐 replies within 24 h

Not a pile of experiments — a connected toolchain. Each tool closes one gap of the agent-assisted development loop, and every gap I hit in my own work became a repo:

flowchart LR
  ctf["ctf<br/>sources → one<br/>token-budgeted doc"] --> sess(("LLM<br/>session"))
  ragraf["RAGRAF<br/>code knowledge graph<br/>23 MCP tools"] --> sess
  sess --> cons["AI-Consensus<br/>multi-model council:<br/>roles → consensus"]
  cons --> proj["LLM Code Projector<br/>markdown → real<br/>file structures"]
  proj --> view["MD.Viewer<br/>docs, published<br/>beautifully"]
  proj --> sr["sr-search-replace<br/>surgical edits<br/>with rollback"]

Answers “where is it, who calls it, what breaks if I change it, how is it done elsewhere” with verifiable file:line facts — instead of blind rg and full-file reads. One SQLite per corpus holds the graph, the BM25 lexicon, the vectors and the drift ledger.

Indexing pipeline & stores

flowchart TB
  scan["scan — walk + checksums"] --> ast["ast — tree-sitter: symbols, calls, SQL"]
  ast --> load["load"] --> resolve["resolve — names"]
  resolve --> schema["schema — tables from migrations"]
  schema --> cpg["cpg — Joern interprocedural calls (optional)"]
  cpg --> lexvec["lexvec — FTS5 + vectors + raw chunk text"]
  lexvec --> g[("graph.sqlite<br/>nodes · edges · db schema")]
  lexvec --> l[("lexvec.sqlite<br/>BM25 + vectors + chunks")]
  lexvec --> c[("control.sqlite<br/>revisions · drift ledger · telemetry")]
  g --> mcp{{"23 MCP tools · 22 CLI operations"}}
  l --> mcp
  c --> mcp

Measured, not promised — real PHP portal, 14 navigation tasks, artifacts in bench/results/:

Three design decisions, each born from a measured defect

1. Immutable index + drift ledger instead of “update on the fly”. Inside a revision the index never changes; code edits accumulate in the ledger and affected facts turn stale. Mixing timestamps inside one answer is exactly how wrong conclusions are born.
2. No free-form graph query language for the agent. Fixed operations only: in LLMxCPG (USENIX Security ’25) base models produced 132/1278 and 19/1278 valid CPGQL queries versus 1278/1278 for a fine-tuned one — a query language turns base models into error generators.
3. Every fact carries proof: path:line, provenance (stated / derived), index_rev, confidence. An edge without evidence looks credible only because it came “from the database”.

Quick start

ragraf init <project-dir>                       # creates config/myproject.yaml
python tools/ragraf.py --project config/myproject.yaml index

{
  "mcpServers": {
    "ragraf": {
      "command": "python",
      "args": ["<repo>/tools/ragraf-mcp.py", "--project", "<repo>/config/myproject.yaml"]
    }
  }
}

A PHP 8.4 web application where several models deliberate in defined roles, a consensus engine scores their agreement, and every answer ships a clickable DAG of the whole session. Full audit trail: every model response, every step, every score — in MySQL.

flowchart TB
  q["User query"] --> l0["L0 · Skill Router — pick the matching SKILL,<br/>or auto-create one from the query"]
  l0 --> l1["L1 · Query distribution — parallel calls<br/>to multiple roles × models (BotHub, OpenAI-compatible)"]
  l1 --> l2["L2 · Response normalization —<br/>JSON-schema enforcement per role"]
  l2 --> l3["L3 · Consensus analysis —<br/>agreement scores, conflict detection"]
  l3 --> ans["Answer + interactive “Details” DAG"]
  mem[("Vector memory:<br/>short & long term")] -.-> l1
  aud[("MySQL 8 audit trail:<br/>PDO, prepared, transactions")] -.-> l3

• SKILLS system — declarative JSON workflows defining agent roles, prompts and consensus rules; the router auto-selects or auto-creates the most relevant SKILL per query.
• Strict PHP 8.4 — strict types, readonly properties, enums throughout; six-part design doc from architecture to the full CouncilEngine module.

One self-contained POSIX script (bash 4.2+, shellcheck-clean) that folds a source tree into a single Markdown / JSON / JSONL / text document with relative paths — the document an LLM reasons over best, or a reviewer reads in one pass.

ctf --budget 60000 src/ > context.md        # LLM context, capped at a token budget
ctf --format jsonl --hashes . > audit.jsonl  # auditable snapshot, per-file hashes

It does not shell out to eval, does not execute anything it reads, never writes outside the file you asked for.

The reverse direction of the loop: feed it a ChatGPT/Claude/DeepSeek/Gemini answer with project trees and code fences — get a runnable directory tree in one command. Recognizes ASCII and Unicode trees, any nesting depth.

./MD_to_Files.sh chatgpt_response.md ./my-new-project

The loop’s last mile: LLM- and human-written markdown rendered as polished docs. Auto TOC with heading numbering, Mermaid with auto-repair, glossary tooltips, dark mode, code-copy controls, searchable file browser, built-in self-updater — no build step, no database, no framework: copy md.php next to your .md files and open it.

Universal search & replace with session rollback, binary detection and backup management: the safe way to let an agent (or yourself) touch forty files at once.

The other half of my life: systems that must stay up, stay secure, and stay boring.

.\Upgrade-Win11-To-25H2.ps1 -RetryCount 5    # enterprise guardrails baked in

flowchart LR
  net((Internet)) --> mx["hMailServer / Exim<br/>MX + TLS"]
  mx --> sa["SpamAssassin (spamd)<br/>daily rule updates"]
  sa --> mb["Mailboxes<br/>idempotent SPAM provisioning"]
  mb --> rc["Roundcube<br/>IIS + PHP FastCGI"]
  rc --> pg[("PostgreSQL<br/>prefs & cache")]
  le["cert-unifier · Let’s Encrypt"] -. TLS .-> mx
  le -. TLS .-> rc

• hMailServer at the core: domains, accounts, aliases, lists, CSV/JSON export, antivirus integration (Defender, Kaspersky, ClamAV)
• SpamAssassin as a Windows service under PowerShell 7 with Task-Scheduler rule updates
• Deliverability stack: SPF · DKIM · DMARC configured and monitored, not “set and forgotten”
• Roundcube ops: deployment on IIS + FastCGI, PostgreSQL backend, cache truncation tooling

• HTML.PHP — single-file PHP 8.3+ template engine: Apache SSI directives, html4.pl-compatible API, XSS-safe by default
• IIS-PHP-FastCGI-AutoDeploy — one-shot IIS + PHP FastCGI installer (Roundcube-ready)
• pg-encoding-migrator — safe PostgreSQL encoding migration (e.g. WIN1251 → UTF-8)
• woocommerce-1c-data-cleaner · Bash_WP-CLI_Update · Clean_BOM_Senior · BAS-IP

• sata-spindown-guard — cron-based HDD spindown guard (hdparm), safe for unmounted drives
• cert-unifier — unified PEM (key + chain) for Let’s Encrypt deployments
• RouterOS filtering & monitoring practice; bash tooling with cron discipline and dry-run habits

Stats & language cards are local SVG snapshots rebuilt from the live GitHub API by build_svg_assets.py (delivery package) — immune to third-party rate limits and outages; streak stays live via streak-stats.

Every serious repo ships its own field guide. The most useful entry points:

Where I add value fastest:

• 📧 Email deliverability rescues — SPF/DKIM/DMARC alignment, spam-filter tuning, hMailServer/Exim migrations
• 🖥️ RDP hardening & session operations for Windows fleets, from diagnostics to forensics
• 🪟 Windows upgrade/update automation with enterprise guardrails (signatures, retries, logging)
• 🤖 LLM agent tooling — code knowledge bases, MCP contracts, context pipelines, consensus patterns
• 🧾 Evidence-based codebase audits — RAGRAF-driven, every finding with file:line

Open-source collaboration is welcome on any repo: issues with reproduction steps get answers, pull requests with tests get merged.

• 🔭 Building: RAGRAF — making code knowledge bases a first-class citizen for LLM agents
• 🌱 Exploring: agent-safe MCP contracts, consensus scoring for multi-model councils
• 👯 Open to: collaborations on AI tooling · consulting on email & RDP infrastructure
• 📫 Reach me: Mikhail@Deynekin.com — I reply within 24 hours