DEV Community: Shivam Kumar

Home Builder

Shivam Kumar — Mon, 15 Sep 2025 05:40:04 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

I have build an AI app that will helps to make your home starting to end like making Home Layout, Interior Designing, Exterior Designing, and You can view your home in 3D

Demo

How I Used Google AI Studio

I used Google AI studio for making all the features and generating image, sketch, 3D of home

Multimodal Features

User can interact with text, Image, and Voice

ClearPath: A Privacy-First Supply Chain with AI-Powered Audits

Shivam Kumar — Fri, 05 Sep 2025 14:13:27 +0000

This is a submission for the Midnight Network "Privacy First" Challenge - Protect That Data prompt

What I Built

I built ClearPath, a modern dashboard for tracking high-value goods like pharmaceuticals and luxury items.

The biggest problem in supply chains today is trust. Businesses need to prove where their products have been, but they can't afford to leak sensitive business information (like their list of suppliers and customers) on a public database. ClearPath solves this by using privacy technology to create a verifiable history for any product, while keeping the details of who owns it completely private. It provides proof without the risk.

Demo

You can try the live demo and see all the code in the public GitHub repository. The entire application runs right in your browser!

Git Hub Repo

Here are a few screenshots of ClearPath in action:

How I Used Midnight's Technology

To create a great experience for other developers, ClearPath simulates the Midnight Network's core features. This allows anyone to run the project in their browser instantly, without any complicated setup. This is a key part of my goal to "Enhance the Ecosystem"—by providing a tool that lets developers build and test a beautiful frontend for a privacy DApp before needing to write a single smart contract.

I created two main JavaScript objects to mimic a real backend:

MockChainDB: This acts like our private blockchain database. It stores all the product information and transfer histories right in the browser, pretending to be a secure, on-chain ledger.

ZKCircuits: This object pretends to be the Zero-Knowledge Proof system. It has functions like generateTransferProof and verifyTransferProof, which work just like you would expect from the real Midnight SDK.

This approach lets developers get a feel for building on Midnight and focus on creating a great user experience first.

Data Protection as a Core Feature

In ClearPath, privacy isn't just an add-on; it's the foundation of everything. Every single product transfer is protected by a (simulated) Zero-Knowledge Proof.

Think of it like a secret handshake. To transfer a product, you don't have to show your ID to the whole world. You just have to prove you know the secret handshake for that specific item. The system verifies your handshake is correct and approves the transfer—all without ever revealing who you are.

This means a company can provide a 100% verifiable audit trail for its products, but its list of suppliers, customers, and business partners remains a complete secret.

Set Up Instructions / Tutorial

ClearPath: A Developer's Guide to Building Private Supply Chain DApps on Midnight
Welcome to the deep-dive tutorial for ClearPath! This guide is for developers looking to build sophisticated, privacy-preserving decentralized applications. We'll walk through the entire ClearPath project—from the core concepts to a feature-rich, working application.

This project was built for the DEV.to Midnight Network "Privacy First" Challenge. More than just a DApp, ClearPath is designed as a developer accelerator. It provides a fully simulated backend and a complete UI, allowing developers to rapidly prototype and build the frontend of a privacy-enabled application before ever needing to write a single line of smart contract code. This approach dramatically improves the developer experience and speeds up the journey from idea to implementation on the Midnight Network.

The Vision: Why Private Supply Chains Matter In the world of high-value goods—like pharmaceuticals, luxury items, and sensitive electronics—trust and transparency are everything. Businesses need to prove the origin and journey of their products, but they face a critical dilemma: public blockchains, while transparent, expose sensitive business data like supplier lists, customer details, and transaction volumes. This is a deal-breaker for almost any real-world enterprise.

The Problem: How can a business prove the authenticity of a product's history without revealing its confidential business operations?

The Solution: ClearPath.
ClearPath leverages the power of the Midnight Network's privacy-first blockchain to create a verifiable and private supply chain. It allows companies to track and transfer assets with cryptographic certainty, while Zero-Knowledge Proofs (ZKPs) ensure their operational data remains completely confidential.

Core Concepts for the Midnight Developer Before we dive into the code, let's understand the foundational technologies.

What are Zero-Knowledge Proofs (ZKPs)?
ZKPs are the core magic behind Midnight. In simple terms:

A Zero-Knowledge Proof lets you prove that you know a secret, without revealing the secret itself.

Analogy: Imagine your friend is colorblind and has two identical-looking balls, one red and one green. You want to prove to them that the balls are different colors without revealing which one is red and which is green. You could ask your friend to hide the balls behind their back, show you one, then hide it again and either switch them or not. Every time they show you a ball, you can correctly state whether they switched them or not. After enough rounds, they would be convinced you can tell the difference (you know the secret color), but you never once had to say "this ball is red."

In ClearPath, we use ZKPs to prove that a user has the right to transfer a product without revealing the user's identity on the public chain.

The Architecture: Simulating Midnight for Rapid Development
To improve the developer experience, ClearPath uses a simulated backend. This allows any frontend developer to build and test the full application logic locally in a browser, without needing to compile circuits or deploy contracts.

Here's the architecture:

Frontend (React): A modern, responsive user interface built with React and Tailwind CSS. This is what the end-user interacts with.

Simulation Layer (JavaScript Objects):

MockChainDB: A JavaScript Map object that acts as our "blockchain." It stores all product data and transfer histories in the browser's memory.

ZKCircuits: A JavaScript object that mimics the functions of a real ZK circuit. It has methods to generateTransferProof and verifyTransferProof, returning realistic-looking data structures.

AI Integration (Gemini): A layer that connects to a powerful language model to provide intelligent features, demonstrating how modern AI can enhance DApps.

This setup means you can focus on building a fantastic user experience first, and then swap out the simulation layer for real MidnightJS calls when you're ready to deploy.

Getting Started: Running ClearPath Locally The entire project is self-contained in a single index.html file.

Prerequisites: A modern web browser (like Chrome, Firefox, or Edge).

Running the App:

Download the index.html file.

Open the file directly in your web browser.

That's it! The application is now running locally. You can interact with all its features, add users, transfer products, and test the AI integrations.

A Deep Dive into the Code Let's break down the key sections of the source code.

The Simulation Layer: Your Local Midnight Testnet
This is the core of our developer-friendly approach. Instead of complex setup, we have simple JavaScript objects.

MockChainDB: This object is initialized with a set of sample products. It uses Map objects to efficiently store and retrieve product data and their associated histories. This simulates a persistent ledger.

const MockChainDB = {
    products: new Map(),
    history: new Map(),
    init: () => { /* ... loads initial data ... */ }
};
MockChainDB.init();

ZKCircuits: This object simulates the creation and verification of proofs. The functions return data that structurally resembles what you would get from a real ZK circuit, making it easy to replace later.

const ZKCircuits = {
    generateTransferProof: (product, fromOwner, toOwner) => {
        // In a real app, this would be a complex cryptographic operation.
        return {
            proof: `zk_proof_${Math.random().toString(36).substr(2, 9)}`,
            publicInputs: { productId: product.id, newOwner: toOwner }
        };
    },
    verifyTransferProof: (proof) => {
        // Simulates checking the validity of the proof string.
        return proof.startsWith('zk_proof_');
    }
};

The Application Logic: Handling a Private Transfer
The most critical function is handleConfirmTransfer. This is where we see the full flow of a private transaction.

const handleConfirmTransfer = (product, toOwner) => {
    // 1. Generate the Proof (Simulated)
    // We prove we have the right to transfer, without revealing our identity publicly.
    const { proof } = ZKCircuits.generateTransferProof(product, currentUser, toOwner);

    // 2. Verify the Proof (Simulated)
    // The "network" verifies the proof is valid before proceeding.
    const isProofValid = ZKCircuits.verifyTransferProof(proof);

    if (isProofValid) {
        // 3. Update the State (Simulated)
        // If valid, the product's owner is updated in our mock database.
        const updatedProduct = { ...product, owner: toOwner, status: 'In Transit' };
        MockChainDB.products.set(product.id, updatedProduct);

        // 4. Record the History
        // A new entry is added to the product's private history log.
        const newHistoryEntry = { /* ... owner, timestamp, proof ... */ };
        const currentHistory = MockChainDB.history.get(product.id);
        MockChainDB.history.set(product.id, [newHistoryEntry, ...currentHistory]);

        // 5. Update the UI
        setProducts(Array.from(MockChainDB.products.values()));
    }
};

This function provides a perfect template for developers. The logic is identical to a real DApp; only the function calls in steps 1 and 2 would change.

Enhancing the DApp with AI
We use a simple, powerful function callGeminiAPI to interact with the AI model.

AI-Generated Product Descriptions: When a user adds a new product, we provide a button that generates a professional description. This improves user experience by saving time and ensuring high-quality data.

const handleGenerateDescription = async () => {
    setIsGenerating(true);
    const prompt = `Generate a brief, professional product description for a product named '${product.name}'...`;
    const desc = await callGeminiAPI(prompt);
    setProduct(prev => ({ ...prev, description: desc }));
    setIsGenerating(false);
};

AI Audit Summaries: This is a more advanced feature. We compile the entire transfer history of a product, send it to the AI, and ask it to perform an audit.

const handleGenerateSummary = async () => {
    setIsGenerating(true);
    const formattedHistory = history.map(/* ... format data ... */).join('\n');
    const prompt = `Act as a supply chain auditor. Based on the following transfer log...provide a concise summary... Here is the log:\n${formattedHistory}`;
    const result = await callGeminiAPI(prompt);
    setSummary(result);
    setIsGenerating(false);
};

M&A Deal Flow Orchestrator

Shivam Kumar — Mon, 01 Sep 2025 05:17:13 +0000

The Problem: Manual M&A Deal Sourcing

Identifying potential merger and acquisition (M&A) targets is a high-stakes, manual process. Analysts spend hundreds of hours sifting through news, manually profiling companies, and performing preliminary analysis. This process is slow, expensive, and prone to human error, causing valuable opportunities to be missed.

The Solution: An Automated Intelligence Pipeline

The M&A Deal Flow Orchestrator is a multi-agent workflow built in n8n that automates the entire deal sourcing pipeline. It transforms a complex, manual task into a streamlined, automated process that runs in minutes. By providing a few simple criteria, an analyst can trigger a sophisticated intelligence-gathering and qualification system.

Workflow Architecture: A Multi-Agent System

The workflow operates as a sequence of four specialized agents, each handling a distinct phase of the process.

The Scout Agent (Market Scanning)
The workflow begins when an analyst submits a form with target criteria like industry, company size, and investment keywords. The Scout Agent uses the n8n RSS Feed node to scan industry news sites and press releases, identifying articles that mention companies matching these criteria.
The Profiler Agent (Deep Data Extraction)
This is where the power of the Bright Data node comes into play. For each company identified by the Scout:

Website Discovery: The workflow constructs a Google search query to find the company's official website. The Bright Data node scrapes the search results to identify and extract the correct URL.

Website Scraping: It then uses the Bright Data node again to scrape the company’s "About Us," "Team," and "Products" pages, extracting core business information.

LinkedIn Profiling: A second Bright Data-powered search identifies the company's official LinkedIn page to scrape key metrics like current employee count.

The Analyst Agent (AI-Powered Analysis & Scoring) Once the raw data is collected, the Analyst Agent takes over.

AI Summary: The consolidated text is sent to the OpenAI node, which generates a concise executive summary and analyzes the sentiment of the source news.

Fitness Score: A custom Code node calculates a proprietary "Acquisition Fitness Score" based on weighted parameters like employee count growth and news sentiment. This quantifies the target's potential.

The Reporter Agent (Briefing & Archiving) The final agent delivers the actionable intelligence.

Qualification Gate: An IF node checks if the company's score meets a predefined threshold (e.g., >70).

Archiving: High-scoring, qualified leads are automatically appended to a Google Sheet, creating a persistent database of all promising targets.

Notification: A formatted, data-rich briefing is sent to a dedicated Slack channel, alerting the M&A team in real-time.

Tech Stack & Business Impact

Core Technologies: n8n, Bright Data, OpenAI, Google Sheets, Slack.
Key Requirement: The workflow exclusively uses officially verified n8n nodes, with the Bright Data node as the central component for web data extraction.
This workflow provides measurable business value by:
Accelerating Deal Flow: Reduces a weeks-long process to minutes.
Increasing Efficiency: Frees up hundreds of analyst hours for higher-value tasks like negotiation and due diligence.
Improving Data Accuracy: Eliminates manual data entry errors and provides consistent, structured profiles.
Uncovering Hidden Gems: Systematically scans the market to surface opportunities that might otherwise be missed.

Supply Chain Intelligence Dashboard

Shivam Kumar — Mon, 28 Jul 2025 05:06:26 +0000

This is a submission for the Algolia MCP Server Challenge

What I Built

Supply-Chain Query Dashboard — a smart, AI-enhanced logistics dashboard that helps businesses and individuals track delayed shipments across warehouses using natural language queries.

This tool empowers users to:

Ask intuitive questions like "Where is my parcel?" or "Show all delayed orders from Warehouse B over 2 days".
Filter by warehouse, delivery status, or delay duration.
Visualize shipment origins on an interactive map.
Get intelligent delay summaries and AI-categorized product types using integrated backend enrichment.

Built with Streamlit, Algolia MCP Server, Flask, and AI agents (OpenAI) to deliver a seamless, fast, and intelligent user experience.

Demo

Github - https://github.com/shivamkumar123321/Supply-Chain-Dashboard

How I Utilized the Algolia MCP Server

This project leverages the Algolia MCP Server in multiple powerful ways:

Natural Language Query Translation
Queries like "delayed over 2 days from A" are processed through the MCP server and converted into Algolia-compatible filters (facetFilters, numericFilters, etc.).
AI Agent Proxy Layer
A custom mcp_proxy.py Flask server receives requests, forwards them to MCP, and then pipes the structured response directly into Algolia’s search.
Dynamic Search Experience
The frontend interacts live with the MCP-backed Algolia API, ensuring fast, semantic, and precise data retrieval.

Key Takeaways

Building with MCP: Learned how powerful Algolia’s MCP server is when combined with open-ended user input.

AI Enrichment: Integrated Claude + OpenAI for real-time classification and summary generation.
Frontend–Backend Coordination: Created a proxy pattern (mcp_proxy.py) to ensure clean API usage between UI and MCP.
Challenge: Balancing real-time filters with flexible NLP required careful query translation and testing

💥 This project could easily scale into a full logistics SaaS product for e-commerce vendors, warehouse operators, or shipping companies!