DEV Community: Suyash Srivastava

OpenGuard: Self-Hosted Static Code Analysis (SCA) with Local AI Auto-Fixes (Gemma 4)

Suyash Srivastava — Wed, 20 May 2026 19:38:55 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

OpenGuard is a developer-centric, self-hosted static code analysis (SCA) platform designed to act as an open-source alternative to tools like SonarQube. Built with OpenGrep (a Semgrep fork), FastAPI, PostgreSQL, and React, it enables developers to scan codebases, compute real-time project security health scores, track issues across historical scans, and manage remediation efforts via a native Jira-style Kanban board.

To bridge the gap between finding a vulnerability and fixing it, OpenGuard features an AI-driven remediation pipeline. With a single click on any code vulnerability, OpenGuard packages the entire target file, localizes the error coordinates, and calls a local Gemma 4 instance to generate high-fidelity, contextual explanations and beautified drop-in code fixes.

Demo

Our platform features a highly responsive, premium dashboard engineered with an editorial design aesthetic. The UI utilizes a warm parchment background, bold ink-black typography, and serif-led headings for a state-of-the-art experience:

Interactive Project Dashboard: A clean visual split of issues by severity level (Critical, High, Medium, Low) featuring semantic color-coding. The dashboard includes a dynamic, natively animated SVG Security Health Gauge and an interactive historical trend chart with hover-activated data tooltips.
Kanban Board: A Jira-like ticket board allowing developers to transition issues between Backlog, Todo, In Progress, and Done. Each issue card features visual tags showing its historical persistence, severity badges, and details.
AI Fix Interface: An interactive code viewer inside the ticket details that displays the native explanation alongside a pre-formatted, syntax-highlighted code block containing the recommended fix.
End-User Packaging: The entire infrastructure is packaged into a seamless, single-command Docker Compose environment with an easy-to-install Python CLI (openguard scan) for scanning local repositories.

OpenGuard Real Demo

Application Dashboard
Workspace
Project overview
List of issues in the scan.
AI suggest explanation & fix

Code

The complete source code for OpenGuard is open-source and available on GitHub:

GitHub Repository - suyash-srivastava-dev/open-analyzer

How I Used Gemma 4

OpenGuard leverages the local inference capabilities of Gemma 4 (gemma4:e4b) served via Ollama.

Why Gemma 4?

Vulnerabilities are rarely self-contained; they require systemic understanding of the surrounding code. We chose the Gemma 4 9B parameter model because of its excellent performance in coding tasks and its ability to process large instruction sets locally.

Implementation Details:

Large Context Processing (128K Tokens): In order to provide accurate fixes without hallucinating, we supply Gemma 4 with the entire source file (up to a 128K context limit) rather than just the isolated line of code. This allows the model to understand local variables, imports, and architectural patterns.
Structured JSON Output: To build a reliable API, we configured the Ollama request with the format constraint json and structured the prompt to guarantee responses matching:

   {
     "explanation": "Brief context on why this is a vulnerability.",
     "code_fix": "The fully corrected file or function block."
   }

This ensures that the frontend can parse the response natively and present the suggested fix in a beautiful, copyable code block without raw markdown delimiters (`) bleeding into the UI.

Optimized Development Loop: The AI responses are cached in the PostgreSQL database so that recurring views are instant, with a --force flag implemented to let developers request a fresh generation when needed.

Gemma 4 provides the speed of local developer workflows with the intelligence of a security expert, making local static analysis interactive and highly actionable.

Reach Out

Built by Suyash Srivastava. If you have any feedback, questions, or are interested in collaborating on OpenGuard or similar AI-driven developer tooling, I'd love to hear from you!

📧 Contact me at: suyashmtech+openanlyzer@gmail.com

Learn Django through Inventory management system

Suyash Srivastava — Wed, 08 Jan 2025 21:33:43 +0000

About project

Youtube : Project Overview
Github : https://github.com/suyash-srivastava-dev/Inventory-Management

This project aims covers application with Database, models, Views, templates with CRUD functionality.

I have implemented an inventory management system using Django to efficiently manage products, stock levels, suppliers and sales. It supports crud operations for product and suppliers, facilitate stock management and enable tracking of sales order.

I have used django as a backend and for front-end it involves HTML CSS JavaScript with the django template that is jinja. For the database I have used mysql or sqlite. You can below settings for postgres & mysql.

# Postgres
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql', 
        'NAME': 'your_database_name', 
        'USER': 'your_db_user', 
        'PASSWORD': 'your_db_password', 
        'HOST': 'localhost', 
        'PORT': '5432', 
    }
}

# MySQL
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', 
        'NAME': 'your_database_name', 
        'USER': 'your_db_user', 
        'PASSWORD': 'your_db_password', 
        'HOST': 'localhost', 
        'PORT': '3306', 
    }
}

Database model parameters

product which consists of name description category price stock quantity and supplier
supplier table which contains name email phone number and address
sales order that contains product quantity total price sales data and status
stock movement that contains product quantity movement type movement date and notes

Models : inventory_management/models.py

Tasks

The application is allows you to add product ,list product, add supplier, list supplier, add stock movements ,create sales order, cancel sales order ,complete sales order, list sales order and stock level check.

Run project

Note: Recommended to use virtual environment for the application.

From Project

Install dependecy : pip install -r requirements.txt
Run the django application : python manage.py runserver
check project on http://localhost:8000/

From Docker

Build the application image : docker-compose build
Create container out of the image: docker-compose up -d
check project on http://localhost:8000/

Image Annotation for AI Model training using Pinata

Suyash Srivastava — Sun, 13 Oct 2024 12:51:09 +0000

This is a submission for the The Pinata Challenge

What I Built

I have built an image annotation application using :

FastAPI : Backend
Angular: Frontend
Pinata : Blob/File Storage

This application would help in doing the annotations of the image dataset. Then these annotations could be exported and be used for AI model training.

Demo

My Code

Flow Diagram

Pinata setup

Create an account with Pinata, and fetch the keys.
Install and setup .env files

npm i pinata

PINATA_API_KEY=""
PINATA_API_SECRET=""
PINATA_GATEWAY="*.mypinata.cloud"
PINATA_JWT=""

import { PinataSDK } from "pinata";

const pinata = new PinataSDK({
  pinataJwt: "PINATA_JWT",
  pinataGateway: "example-gateway.mypinata.cloud",
});

Create methods for Upload & Retrieve Files

Upload File

const file = new File(["hello"], "Testing.txt", { type: "text/plain" });
    const upload = await pinata.upload.file(file);
    console.log(upload);

Retrieve Files

const url = await pinata.gateways.createSignedURL({
        cid: "bafkreib4pqtikzdjlj4zigobmd63lig7u6oxlug24snlr6atjlmlza45dq",
        expires: 1800,
    })
    console.log(url)

Backend & Frontend Code Repo

backend Fastapi : https://github.com/suyash-srivastava-dev/annotation-editor-backend
frontend Angular : https://github.com/suyash-srivastava-dev/annotation-editor

More Details

Pinata group was created for each project in the application.
Pinata was used for saving the image dataset, with & without annotations. Also the annotation files are saved as JSON on Pinata. Access to the images & Json file is through the signed SDK.

Very Own bookmarks

Suyash Srivastava — Mon, 24 Jun 2024 06:43:30 +0000

This is a submission for Twilio Challenge v24.06.12

What I Built

Use Case: When scrolling through news articles, blog posts or youtube video. I often send WhatsApp messages to myself with important links I want to bookmark. However, finding the right link later can be challenging, as I have to sift through several sent links before locating the one I need. To solve this problem, I created an application.

This application accepts the links I share and provides a brief description of each one. This feature helps me quickly find the desired link when using the search option in WhatsApp.

Demo

Twilio and AI

I have taken into consideration the type of data that I share, that is generally either an article from web or a youtube video.

So the flow is as below.

Additional Prize Categories

Impactful Innovators: Though it's a simple application but it solves a major problem of finding right content that was bookmarked by the user.