DEV Community: Harshal Limaye

I got tired of vibe-testing my MCP servers, so I built a Bruno-style client for MCP

Harshal Limaye — Tue, 14 Jul 2026 02:25:18 +0000

I've been writing MCP servers for a few months now, and most of that time was spent staring at JSON. Hand-writing request payloads, eyeballing responses, mentally diffing nested objects to check if a tool call actually worked. My "testing" wasn't much better: point an LLM at the server, ask it to try some tool calls, read the vibes.

That's not testing. That's hoping.

Here's the thing — LLMs are non-deterministic by design. Your protocol layer isn't supposed to be. If your tool returns the wrong shape, a missing field, or a broken error response, you don't need a model's opinion about it. You need a failing assertion.

So I built MCPFlo — an offline-first, open-source, MIT-licensed Electron app for testing and debugging MCP servers. The core idea is boring on purpose: deterministic assertions against real protocol responses.

expect(result.isError).to.equal(false);
expect(result.content[0].type).to.equal("text");
expect(json.total).to.be.a("number");

If it passes, it passes every time. If it fails, you know exactly where. No vibes involved.

What it does

Chai.js-style assertions against real tool responses. Write expect().to.equal() tests for your tools, resources, and prompts. Run them against the actual server, not a mock.
Auto-generated forms from your schemas. MCPFlo renders your tool's input schema as a proper form — including nested objects and arrays — via RJSF. Stop hand-writing JSON payloads for every tool call. If your schema is deep and ugly, that's exactly when this matters most.
Token budget visualizer. See what your tools, resources, and prompts actually cost against different model context windows — before you find out the expensive way. An MCP server with 40 verbose tool descriptions is quietly eating someone's context budget. Now you can see it.
OAuth 2.1 support, so you can test servers that actually require auth instead of stripping it out for local dev.
Fully offline. No telemetry, no cloud dependency, no login, no server-side anything. Your requests and test data live on your machine as git-friendly JSON.

What it deliberately doesn't do

MCPFlo won't tell you whether an LLM uses your tools well — whether your descriptions are clear enough for a model to pick the right tool at the right time. That's behavioral evaluation, and it's a different layer of the stack. MCPFlo covers the layer below it: does your server actually do what the protocol says it does?

Both layers matter. This tool is for the deterministic one.

The honest part

It's early. There are rough edges. I'd rather ship it and get real feedback than keep polishing in private.

If you're building or maintaining MCP servers, I'd genuinely like to know: is this useful, or am I solving a problem nobody has?

Repo: github.com/harshalslimaye/mcpflo
Site: mcpflo.com

Happy to answer questions or get roasted in the comments.

How to use APP_INITIALIZER token in Angular

Harshal Limaye — Wed, 28 Dec 2022 03:28:12 +0000

APP_INITIALIZER is a powerful feature in Angular that allows developers to perform tasks before the application starts. It is essentially a way to run code during the bootstrapping process of an Angular app. One common use case for APP_INITIALIZER is to load configuration data from a server or a local file. This data is often required for the application to function properly, and it is important to have it available as soon as possible.

To use APP_INITIALIZER, you need to import the APP_INITIALIZER token from the @angular/core module and use it to provide a factory function. This factory function should return a Promise that resolves when the initialization is complete.

Let's understand this in detail using an example:

import { APP_INITIALIZER, NgModule } from '@angular/core';
import { HttpClientModule } from '@angular/common/http';

export function loadConfig(http: HttpClient) {
  return () => http.get('/config').toPromise();
}

@NgModule({
  imports: [HttpClientModule],
  providers: [
    {
      provide: APP_INITIALIZER,
      useFactory: loadConfig,
      deps: [HttpClient],
      multi: true
    }
  ]
})
export class AppModule {}

In this example, the loadConfig function uses the HttpClient to make a request to a server to retrieve the configuration data. The function returns a Promise that resolves when the data has been retrieved.

It is important to note that the APP_INITIALIZER factory function should be marked as multi: true, as this allows multiple initializers to be run. If you do not mark the factory function as multi: true, only the last initializer registered will be run.

And that's it! I hope you found this post useful. Incase you have any questions or queries, feel free to drop a comment.

How to Create a Custom Assets Folder in Angular

Harshal Limaye — Wed, 09 Nov 2022 16:07:37 +0000

Every Angular app generated with @angular/cli comes bundled with an assets folder located inside the src directory. And any file or folder created inside the assets folder becomes publicly accessible. However, your options are not limited to this folder. You can easily create more assets like folders by adding their paths in the angular.json file. Let's understand this in detail with an example.

Let's say I want to create another folder inside src directory called users and add following json file to this folder.



{
  "firstName": "John",
  "lastName": "Doe",
  "username": "rambo_was_real",
  "occupation": "Mall Santa"
}

We'll name the file profile.json.

Once you've created the folder and added the file, you need to make Angular aware of this folder.

This can be done by simply dropping following line of code in your angular.json file under the assets array key.

And that's it! After doing this you can simply restart your Angular application and try to access the file via the web browser. If you've done everything as expected, you'll see following output in the web browser.

You can also query the profile.json file using the HttpClient Service.



this.http
  .get('/users/profile.json')
  .subscribe((response) => console.log(response));

I hope you enjoyed this post. In case you've any queries or feedback, feel free to drop a comment or reach out to me on Twitter @harshalslimaye.

Also, I would like to recommend another article I've written which talks about the technique called Virtual Scrolling in Angular which allows the developers to display subset of large lists within small viewports and change the subset data as user continues to scroll through the list.