Forem: Enmanuel Magallanes Pinargote

Stop flying blind with MCP calls

Enmanuel Magallanes Pinargote — Thu, 14 May 2026 18:08:51 +0000

After getting frustrated not knowing what was actually happening inside MCP servers — which tools were slow, which failed silently, what inputs Claude was sending.

The idea: a transparent proxy that sits between your MCP client (Claude Desktop, OpenCode, Cursor) and any MCP server, captures every JSON-RPC message as an OpenTelemetry span, and persists it to a storage backend you configure.

No modifications to the target server required. You just wrap it in mcp.json:

  "command": "heimdall-mcp",
  "args": ["--store", "sqlite://~/.heimdall/traces.db", "--", "node", "my-server.js"]

For remote servers (HTTP/SSE):

  "command": "heimdall-mcp",
  "args": ["--store", "postgres://...", "--target", "http://remote-server/sse"]

Storage options: SQLite (local WASM, no native deps), Postgres, MySQL, or any OTLP-compatible backend.

Also ships as a TypeScript library with a fluent builder API if you want to embed it directly.

Why I think this is useful:

LLM agents are increasingly orchestrating MCP tools, but observability tooling hasn't caught up
IBM's ContextForge does something similar but it's a heavy Python gateway — this is meant to be a lightweight npm package

Still early (v0.1), but the core proxy + SQLite store is working. Looking for feedback on the interceptor API design and whether the OTel semantic conventions mapping makes sense.

Website: https://stack.cardor.dev/heimdall
GitHub: https://github.com/enmanuelmag/heimdall-mcp

Check the repo for more feature planned on roadmap 🚀

Heimdall MCP: Add OpenTelemetry tracing to any MCP server without touching its code

Enmanuel Magallanes Pinargote — Sat, 09 May 2026 14:03:48 +0000

If you've been building with MCP servers lately, you've probably hit this wall: something goes wrong (or just feels slow) and you have zero visibility into what actually happened.

Which tool did Claude call? What input did it send? Did the server error silently? How long did it take?

That's the gap Heimdall fills.

What is Heimdall?

Heimdall is a transparent proxy for MCP servers. It sits between your MCP client (Claude Desktop, OpenCode, Cursor, or any other) and your MCP server — local or remote — and records every interaction as an OpenTelemetry span.

No modifications to your server. No SDK to integrate. No infra to run. Just wrap your existing server and start seeing what's happening inside.

The name comes from Norse mythology: Heimdall is the guardian of the Bifrost bridge, with the ability to see and hear everything that crosses between worlds. That's exactly the role this proxy plays.

The problem in one screenshot

You're running a Claude agent that orchestrates 5+ MCP tools. One of them is consistently slow. Another occasionally returns empty results. You have no way to know which one, when, or why — unless you dig into logs manually.

With Heimdall, every tool call becomes a structured span:

{
  "name": "mcp.tool.call",
  "attributes": {
    "gen_ai.tool.name": "search_documents",
    "mcp.duration_ms": 843,
    "mcp.status": "ok"
  },
  "events": [
    { "name": "request",  "body": { "query": "quarterly report" } },
    { "name": "response", "body": { "results": [...] } }
  ]
}

Stored. Queryable. Yours.

Zero config wrapping via mcp.json

The easiest way to use Heimdall requires zero access to the server's source code. Just install it globally and update your mcp.json:

npm install -g @cardor/heimdall-mcp

Before — your current config:

{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["my-server.js"]
    }
  }
}

After — wrapped with Heimdall:

{
  "mcpServers": {
    "my-server": {
      "command": "heimdall",
      "args": [
        "--store", "sqlite://~/.heimdall/traces.db",
        "--",
        "node", "my-server.js"
      ]
    }
  }
}

That's it. Restart your client and every tool call starts being recorded. The -- separator tells Heimdall where its args end and the real server command begins.

For remote servers (HTTP or SSE), it's just as simple:

{
  "mcpServers": {
    "remote-server": {
      "command": "heimdall",
      "args": [
        "--store", "postgres://user:pass@localhost/mydb",
        "--target", "http://my-remote-mcp.com/sse"
      ]
    }
  }
}

Heimdall exposes stdio to your client, talks HTTP/SSE to the real server, and intercepts everything in between.

What gets recorded

Heimdall captures all standard MCP events:

Event	What's recorded
`tools/call`	Tool name, input args, response, duration, status
`tools/list`	Available tools and their schemas
`resources/read`	URI, MIME type, response size
`prompts/get`	Prompt name, arguments, rendered output
`initialize`	Client/server versions, negotiated capabilities
`shutdown`	Total session duration

Every span follows the OpenTelemetry gen_ai.* semantic conventions,
so if you later want to send traces to Jaeger, Honeycomb, or Grafana Tempo, the data is already well-formed.

Storage options

Pick the backend that fits your setup:

SQLite — local file, zero infra

--store sqlite://./traces.db
# or with absolute path
--store sqlite:///Users/you/.heimdall/traces.db

Best for: local development, single-machine setups, quick debugging sessions.

Uses @libsql/client under the hood — pure WASM, no native bindings, no node-gyp.

Postgres — your existing database

--store postgres://user:password@localhost:5432/mydb

Best for: production environments, teams sharing observability data,
long-term storage with SQL queries across multiple servers.

MySQL

--store mysql://user:password@localhost:3306/mydb

Same use case as Postgres. Pick whichever you already run.

All three use drizzle-orm with a shared schema, so the query experience is consistent regardless of which backend you choose.

Using it as a TypeScript library

If you have access to your server's code and want tighter integration, Heimdall ships as a fully-typed TypeScript library with a fluent builder API:

import { McpProxy } from 'heimdall-mcp'

const proxy = await McpProxy
  .create()
  .inbound({ transport: 'stdio' })
  .outbound({ transport: 'http', url: 'http://localhost:3001' })
  .store('sqlite://./traces.db')
  .build()

await proxy.start()

You can also plug in custom interceptors — for example, to redact sensitive fields before they're persisted, or to add your own business logic on top of the tracing:

import { McpProxy, type Interceptor } from 'heimdall-mcp'

// Custom interceptor: redact API keys from tool inputs before storing
const redactSecrets: Interceptor = {
  name: 'redact-secrets',
  async intercept(request, ctx, next) {
    const sanitized = redactSensitiveFields(request)
    return next(sanitized)
  }
}

const proxy = await McpProxy
  .create()
  .inbound({ transport: 'stdio' })
  .outbound({ transport: 'http', url: 'http://localhost:3001' })
  .store('postgres://user:pass@host/db')
  .intercept(redactSecrets)
  .build()

Design goals

A few decisions worth calling out:

No native dependencies. SQLite runs via WASM (@libsql/client), Postgres via the pure-JS postgres package, MySQL via mysql2. You can install and run Heimdall in any Node 22+ environment without compilation steps.

No policy opinions. Heimdall doesn't block, approve, or modify tool calls. It only observes and records. If you need access control or rate limiting, pair it with a tool like mcpwall.

Transport mixing. Your client connects via stdio. Your server can be stdio, HTTP, or SSE. Heimdall bridges them transparently — useful for wrapping local CLI servers behind an HTTP interface without touching their code.

Get started

npm install -g @cardor/heimdall-mcp

GitHub: github.com/enmanuelmag/heimdall-mcp
Website: https://heimdall-mcp.cardor.dev

If you try it out, I'd love to hear what you think — especially feedback on the interceptor API design and the OTel schema. Open an issue or find me on X [@enmanuelmag].

I got tired of AI agents roaming my codebase — so I built a harness layer

Enmanuel Magallanes Pinargote — Wed, 06 May 2026 00:55:08 +0000

The problem

Every time I open Claude Code or any MCP-compatible AI tool, the same thing happens: the agent starts working, does something, and I have no idea what it changed, what it tried, or why it got stuck. Across sessions, it's even worse — the agent has no memory of what was already attempted.

If you want multiple agents working in parallel or in sequence, good luck coordinating them without race conditions, double work, or conflicting changes.

I wanted something I could actually trust to run on my codebase.

What I built

agent-harness-kit (ahk) is a scaffolding layer for structured multi-agent workflows. One command drops it into any project:

npx ahk init

t creates a local MCP server (runs on stdio, no ports needed), a SQLite database, a task backlog, a health gate, and four agent definition files.

How it works

The 4-agent workflow

Lead → Explorer → Builder → Reviewer

Lead decomposes the task into a plan. Never reads source files.
Explorer maps the codebase. Never writes files.
Builder implements. Only writes to writablePaths you define.
Reviewer checks acceptance criteria. Runs health check before approving.

Each role has its own Markdown file you can customize. They're created once and never overwritten.

Atomic task claiming

tasks.claim(id, agent)  // SQLite transaction — no double-work possible

Two agents can't grab the same task. The second one gets task_already_claimed and moves on.

Health gate

Before any agent starts or closes a task, it runs your health.sh:

#!/usr/bin/env bash
npm test || exit 1
curl -sf http://localhost:3000/health > /dev/null || exit 1
echo "All checks passed."

If it exits with anything other than 0, the task stays open. You define what "healthy" means for your project.

Full audit trail

Every action is recorded:

actions.start(taskId, agent)             // start
actions.write(actionId, 'files_modified', 'src/auth.ts, src/routes/login.ts')
actions.write(actionId, 'result', '...')
actions.complete(actionId, 'summary')    // close

ahk export --json dumps the full history.

Provider-agnostic

Works with Claude Code today. Moving to OpenCode? One command:

ahk migrate --to opencode

Your task history, agent definitions, and config stay intact.

No cloud, no native deps

Everything lives in .harness/harness.db (SQLite, gitignored). Uses node:sqlite built-in — no node-gyp, no native compilation.

Requirements: Node ≥ 22 or Bun.

Get started

npx ahk init

Interactive setup. Asks for your project name, AI provider, docs path, and an optional first task. Creates everything in under a minute.

GitHub: link
npm: @cardor/agent-harness-kit

I'd love feedback on the health gate design and the atomic claiming approach — those were the trickiest parts to get right.

Security Logger

Enmanuel Magallanes Pinargote — Tue, 16 Jan 2024 13:56:10 +0000

Disclaimer: The only real data in this site was hidden to protect the privacy of the user. The rest of the data is fake.

This project is build with ViteJs and ReactJs, the main idea is to create a web app and also a native desktop app to register new visitors on urbanization, the web app is for the directive (i.e urbanization president) and the desktop app is for the security guard.

The app allow to create user three types of user:

Admin: Can create new users and also can see all the logs
Security guard: Can create, read and update new logs
Guest: Can only read the logs

The records are stored first in the IndexDB and then are synced with the Firestore database, the app also has a offline mode, so the user can use the app without internet connection and when the connection is available the app will sync the data with the database.

The records could be filtered by visitor name, visitor ID, date, and also by the house number, the app also has a search bar that allow to search by name quickly. Also, you can exported the entire records of filtered records to a XLSX file or a PDF file.

Deep learning integration

This app also has a integration with a other personal project, that consist in a Deep Learning model that can detect and extract the text of visitor name and ID from a image. So the app can extract the image from the security camera that focus the visitor ID and the model will extract the text and fill the form with the data. The information can be edited by the security guard too. The model is build with Tensorflow based on a little version of YOLOv5.

Currently the app is only available in Spanish, and deploy or installation is only available previos contact and agreement. The app will have more tools powered by AI to detect and extract more information as vehicle plate, visitor face, etc.

Tech used

Firebase (Auth, Firestore)
ReactJs, React Router, React Context
React-Query
Zod (Validation)
Tensorflow

Budgetfy

Enmanuel Magallanes Pinargote — Tue, 16 Jan 2024 13:50:59 +0000

In this web app you can create budget to define your expenses and incomes as unique events or recurrent events as you usually create events for a calendar, in order to plan your budget through slice of time that you can define.

The Budget view has show you one card per moth with three sections. The first section is Category summary, it show the total amount of money for each category that you have defined.

The second section is Timeline, that show the following information:

Timeline: show all the events for that month (expenses and incomes) and the estimated balance for that month. Also if you clic on the event you can mark it as paid (for expenses) or received (for incomes). This will update the balance.
Balance: section you will see all the money available without expenses for that month and the monthly balance, it mean the difference between the incomes and the expenses for that specific month.

Finally the third section is the Timeline plot, that show the evolution of the incomes, expenses and balance for the the defined range of time on the budget creation.

You can create a account for free using a email and password or Google account, then you can create your budget and start to add your incomes and expenses. Visit the website to see more details.

Tech used

Firebase (Auth, Firestore)
ReactJs, React Router, React Context
React-Query
Highcharts
Zod (Validation)

IAflow

Enmanuel Magallanes Pinargote — Tue, 16 Jan 2024 13:42:19 +0000

This library help to create models with identifiers, checkpoints, logs and metadata automatically, in order to make the training process more efficient and traceable.

For install the library, you can use pip:

pip install iaflow

Then you can create the ia_make with the following code:

ia_maker = IAFlow(
  models_folder='./models',
  checkpoint_params={
    'monitor': 'val_loss',
    'save_best_only': True,
    'save_weights_only': True
  },
  tensorboard_params={
    'histogram_freq': 1,
    'write_graph': True,
    'write_images': True
  }
)

And then you can add the model with the following code:

model_1_data = ia_maker.add_model(
  model_name='model_1',
  model_params={ 'input_shape': (2, 1) },
  load_model_params={},
  compile_params={
    'metrics': ['accuracy'],
    'optimizer': 'adam', 'loss': 'mse'
  },
)

Finally, you can train the model with the following code:

ia_maker.train(
  model_1_data,
  epochs=5,
  dataset_name='dataset_1'
)

This library has integration with Notifier Status Function, so you can send notifications to Telegram when the training process is finished. To check how to use it and more feature as managing Dataset and Models with the library, you can check the documentation.

Tech used

Python
Tensorflow
Telegram API
Notifier Status Function (personal lib)
Webhooks

Mi Horario Web (MHW)

Enmanuel Magallanes Pinargote — Tue, 16 Jan 2024 13:39:51 +0000

Disclaimer: Currently we are working on improve and update of NodeJS version of the Lambda functions, so the website is not working properly.

This is an online timetable generator for students of the ESPOL University. It allows to obtain information of the planned courses, statistics of the teacher in charge and to generate options of schedules according to the courses and selected parallels.

The project is developed in React and Material-UI, MongoDB as main database for all courses information and FireStore as realtime database for update de progress of schedule generation on the client side.

The steps to create schedules are:

Select the subjects that you will take.
Selected the course numbers that you would like to choose. In this section you can also see the course's teacher, his/her qualification and student's opinios about him/her.
The you can execute the schedules generations, the process can take a while, so a progress bar is show up with the progress update in real time.
Finally you can see all the options of schedules with out conflict on hours class or exams. You can also download the information as a table (just course numbers and subject) or download the calendar view.

Tech used

React
Material-UI
MongoDB
Highcharts
AWS State Machine
AWS Lambda Functions
Firebase (Auth, Firestore)
Github Actions

Notifier Function Status

Enmanuel Magallanes Pinargote — Tue, 16 Jan 2024 13:34:38 +0000

This library provides a decorator to show a toast in your screen and if you setup, send a email when your function end. All that you need to do is use a decorator and some specific parameters, like in the following example:

from notifier import notify

# Send a message to telegram
@notify(api_token='your_api_token', chat_id='your_chat_id')
def your_function():
    print('Hello World!')

Another way is by manually calling the function:

from notifier import Notifier

notifier = Notifier(
  title='Execution for',
  api_token='your_api_token'
  chat_id='your_chat_id'
)

for i in range(10):
    notifier(msg=f'Hello World {i}!')

# You can also override all the previous parameters,
# on the constructor, by passing them to the function
notifier(title='Execution done', msg='Finished!')

Check these features a more detailed on the GitHub repository.

Tech used

Python
Telegram API
Discord webhooks