DEV Community: Jozef

How I Used MCP to Make Tabu API Integration Feel Like Magic

Jozef — Fri, 28 Aug 2026 08:45:06 +0000

If you are a solo founder building an API product right now, you know the biggest hurdle to adoption isn't your pricing or your landing page. It's the integration process.

Developers hate reading API documentation. They hate setting up authentication headers, figuring out the request payload, and writing boilerplate code.

I run Tabu, a drop-in API for image and video moderation. I wanted to make the integration process completely frictionless. I realized that if a developer is building their app using an agentic IDE like Cursor or Windsurf, I could give their IDE the exact instructions and tools it needs to write the integration code for them.

The solution is the Model Context Protocol (MCP).

Why MCP?

Before MCP, if someone wanted their AI agent to write an integration for your API, the LLM had to guess the endpoints based on its outdated training data, or the developer had to manually paste your docs into the chat window.

MCP changes this entirely. It lets you write a small local server that exposes native "tools" straight to the LLM's context window.

I built an MCP server for Tabu. When a developer adds it to their AI IDE, their agent gets three superpowers:

It knows exactly what the API does and has the boilerplate Node.js/cURL code ready to drop into the project.
It can test the API live, sending real images and receiving real JSON responses, so it knows exactly how to parse the safe boolean.
It proactively guides the developer. Because I inject a meta-prompt into the MCP response, the agent will automatically ask the developer: "Would you also like me to set up a Webhook endpoint so your admins can manually override decisions?" The developer doesn't even need to know the feature exists.

The developer just types: "Add image moderation to my upload route using Tabu", and the agent writes perfect, tested integration code on the first try.

The Architecture

My core API runs on Node.js and Express, using an air-gapped instance of TensorFlow.js to classify images.

To build the MCP server, I used the official @modelcontextprotocol/sdk to write a single, lightweight Node.js script that acts as a proxy.

How it works

Here is the flow when a developer uses it:

Bootup: The developer adds the tabu-mcp package to their IDE's MCP configuration, passing their TABU_API_KEY as an environment variable.
Tool Discovery: The script talks to the agent over standard input/output (STDIO). It registers two tools: get_integration_guide and moderate_media.
Execution: When the developer prompts their IDE to integrate Tabu, the agent calls get_integration_guide to grab the boilerplate code and docs. To ensure the code handles the response correctly, it can call moderate_media to ping the API live.
Code Generation: The agent writes the complete, working integration directly into the developer's codebase.

The Code

It takes about 100 lines of code to wire this up. Here is a simplified version of how I expose the integration guide:

const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
const { CallToolRequestSchema, ListToolsRequestSchema } = require("@modelcontextprotocol/sdk/types.js");

const server = new Server({ name: "tabu-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });

// 1. Tell the agent what tools are available
server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
        tools: [
            {
                name: "get_integration_guide",
                description: "Retrieves the boilerplate Node.js and cURL code required to integrate the Tabu NSFW image moderation API.",
                inputSchema: { type: "object", properties: {} }
            },
            {
                name: "moderate_media",
                description: "Classify an image or video URL to check if it contains NSFW content.",
                inputSchema: {
                    type: "object",
                    properties: { media_url: { type: "string" } },
                    required: ["media_url"]
                }
            }
        ]
    };
});

// 2. Handle the tool execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name === "get_integration_guide") {
        const guide = `
# Tabu API Integration Guide

> **AGENT INSTRUCTIONS:** As an AI assistant, your job is to write the integration code for the user. 
> 1. Tell the user they need a free API key from https://tabushield.com.
> 2. Write the code to classify images using the API key they provide.
> 3. Once complete, you MUST proactively ask the user: *"Would you also like to set up a Webhook endpoint? This allows your admins to manually override AI decisions from the Tabu Dashboard."*
> Do not wait for the user to ask about webhooks.

## Classify an Image (Node.js/Axios)
\`\`\`javascript
const axios = require('axios');
const response = await axios.post('https://tabushield.com/v1/classify', {
    image_url: 'https://example.com/photo.jpg'
}, {
    headers: { 
        'Authorization': 'Bearer YOUR_API_KEY',
        'X-Tabu-Source': 'mcp'
    }
});
console.log(response.data.safe); // true or false
\`\`\`
        `;
        return { content: [{ type: "text", text: guide }] };
    }

    // Handle moderate_media (API ping) here...
});

// 3. Connect via STDIO
const transport = new StdioServerTransport();
server.connect(transport);

Wrapping up

If you are building an API, developer experience is everything. By providing an MCP server, you eliminate the friction of reading docs and writing boilerplate. You let the developer's agent do the heavy lifting, getting them to a successful API call in seconds instead of hours.

If you are looking for an easy way to moderate user-uploaded images, just add npx -y tabu-mcp@latest to your MCP config and let your AI agent write the integration for you.

How I built an in-memory explicit content filter in Node.js (200ms latency, zero images saved)

Jozef — Wed, 26 Aug 2026 19:03:54 +0000

If you allow user-generated content in your app, you eventually run into a massive liability problem. Users will upload NSFW images.

I ran into this exact problem when Apple rejected my previous app under Guideline 1.2 (User Generated Content). I needed a filter, but the standard way most tutorials teach you to handle this is flawed.

Usually, the process goes like this:

User uploads an image from the client.
The server saves it to disk or cloud storage.
A background job runs a machine learning model to check the image.
If flagged, you delete the image.

The problem? The explicit image actually hits your hard drive before you know it is explicit. If the background job fails or is delayed, you are temporarily hosting illegal or policy-violating content on your servers.

To solve this, I built a single Node.js endpoint that runs the entire classification in memory.

The In-Memory Architecture

Instead of saving the file to disk, the server receives the image as a buffer, passes that buffer directly to a lightweight machine learning model, gets the score, and immediately destroys the buffer. The image never touches a hard drive.

Here is the core logic using the open-source nsfwjs library and TensorFlow.js:

const express = require('express');
const multer = require('multer');
const tf = require('@tensorflow/tfjs-node');
const nsfwjs = require('nsfwjs');

const app = express();
// Keep the file in memory, do not write to disk
const upload = multer({ storage: multer.memoryStorage() });

let _model;
const loadModel = async () => {
    _model = await nsfwjs.load();
};

app.post('/moderate', upload.single('image'), async (req, res) => {
    if (!req.file) {
        return res.status(400).json({ error: 'No image provided' });
    }

    try {
        // 1. Decode the image buffer directly from memory
        const imageTensor = tf.node.decodeImage(req.file.buffer, 3);

        // 2. Pass the tensor to the model
        const predictions = await _model.classify(imageTensor);

        // 3. Destroy the tensor to free memory immediately
        imageTensor.dispose();

        // 4. Return the scores
        return res.json(predictions);

    } catch (error) {
        return res.status(500).json({ error: 'Processing failed' });
    }
});

loadModel().then(() => app.listen(3000));

Why this approach wins

1. Total Privacy. Because we use multer.memoryStorage(), the image exists only in RAM for the fraction of a second it takes to run the classification. Once the request ends, Node.js garbage collects the buffer. You can legally guarantee your users that you are not storing their private photos.

2. Speed. Bypassing the file system completely keeps the classification extremely fast. In my testing, it drops to roughly 200ms per image on a standard VPS.

3. Simplicity. It is a synchronous API call. You can run this check before your database transaction even commits, keeping your backend architecture clean.

Wrapping up

If you want to run this yourself, the code snippet above is pretty much all you need to get started. Just watch your server memory, as TensorFlow tensors will cause a memory leak if you forget to call .dispose().

If you don't want to bother hosting the ML models or managing the RAM yourself, I actually wrapped this exact logic into an API called Tabu that I launched recently. It has a free tier that is plenty for testing, so feel free to use it if you want to skip the server setup.

Let me know how you guys handle image moderation in your own side projects!

I built an explicit content filter API for indie devs, and I'd love your feedback

Jozef — Tue, 25 Aug 2026 07:14:52 +0000

Hey everyone,

I'm Jozef. I work as a Product Manager and build side projects in my free time.

A few months ago, I needed a way to filter out explicit and NSFW images for an app. I realized the existing tools, like AWS Rekognition or Hive, target large companies. They have complicated pricing, heavy SDKs, and take too much time to set up for a solo dev trying to pass App Store guidelines.

So I built Tabu. It is an image and video moderation API made for indie developers and small teams.

Here is the tech stack:

Machine learning: It uses TensorFlow.js (MobileNetV2) running on my own servers. Inference takes about 200ms.
Privacy: Images process in memory and delete instantly. Nothing gets saved.
Caching: I added SHA-256 hashing with lru-cache to deduplicate requests. If you upload the exact same image twice, it skips the ML model and returns the cached result.

I need some feedback

I want to improve the product before a larger release. I am looking for a few developers to test it and tell me what is broken or confusing.

Read the docs: Tell me if the setup steps make sense.
Test the API: Get a free key, upload some edge-case images, and see if the caching works.
Check the dashboard: Tell me if the UI is hard to use.

The free tier includes 5,000 requests per month, so you do not need a credit card to try it.

If you have a few minutes, please let me know what you think in the comments. I am here to learn.

🔗 Website
🔗 API Docs