DEV Community: Yash Ram

Ghost Records: Hunt Down the Ghosts Haunting Your Data

Yash Ram — Thu, 29 Oct 2026 19:01:53 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Ghost Records is a local-first AI data quality auditor that hunts down the ghosts hiding in your datasets.

Real-world data is rarely perfect. Duplicate records, orphaned foreign keys, missing values, and broken relationships can quietly cause problems in applications and databases. Ghost Records helps uncover these issues and understand what went wrong.

The application scans CSV files and SQLite databases, detects anomalies using deterministic data-quality rules, and uses a locally running AI model to explain findings in plain language and suggest possible fixes.

Instead of treating every anomaly as an error to delete, Ghost Records provides evidence, remediation suggestions, and a human-reviewed workflow.

I interpreted the Ghost in the Machine theme literally: sometimes the ghosts aren't supernatural entities—they're the records nobody knows are still there.

Demo

Code

yashr5120 / Ghost-Records

Ghost Records is a local-first AI data quality auditor that detects duplicate rows, orphaned records, broken relationships, and suspicious values in CSV files and SQLite databases. Powered by local Gemma inference via Ollama, it explains anomalies and suggests safe fixes while keeping your data private.

👻 Ghost Records

“Hunt down the ghosts haunting your data.”

Ghost Records is a local-first AI data quality auditor that unmasks duplicate records, orphaned foreign keys, colliding primary keys, invalid dates, and statistical anomalies in CSV files and SQLite databases.

A locally running open-weight LLM (Gemma via Ollama) provides evidence-grounded forensic explanations and suggests safe, reviewable remediation without transmitting a single row to a third-party cloud API.

📌 Problem Statement

Real-world datasets are plagued by integrity flaws:

Duplicate records inflating transaction metrics.
Orphaned foreign keys referencing customer or product IDs that no longer exist.
Colliding primary keys causing silent row overwrites.
Missing or whitespace-only values in required operational columns.
Illegal negative numbers or malformed date strings.

Traditional data quality platforms demand complex configurations, external cloud data warehouses, or expensive hosted AI APIs that violate data confidentiality.

Ghost Records solves this by bringing deterministic forensic audits and open-weight AI explanation…

View on GitHub

How I Built It

Ghost Records combines traditional data engineering with open-weight AI.

Technology stack:
Python: Core application logic and data-quality checks.
Streamlit: Interactive investigation dashboard.
Pandas: Data profiling and anomaly detection.
SQLite: Local metadata and scan history.
Ollama + Gemma: Local AI inference for anomaly explanations.
pytest: Automated testing of detection rules and application behavior.

The architecture separates detection from explanation. Deterministic rules identify anomalies and produce evidence; the local language model uses that evidence to explain the problem and suggest appropriate remediation.

This separation makes the results more reproducible and helps prevent the model from inventing missing identifiers or treating unverified assumptions as facts.

Why Does Open Innovation Matter?

Data quality tools often work with sensitive information, including student records, HR data, financial transactions, and customer databases.

Sending that information to a hosted AI API may be unnecessary or unacceptable.

Ghost Records explores a different approach: bring the AI to the data, rather than sending the data to the AI.

Using an open-weight model through local inference makes it possible to:

Keep data local: Avoid sending datasets to an external generative AI provider in the local configuration.

Reduce dependency on paid APIs: Run AI explanations without requiring a hosted LLM subscription.

Customize the experience: Modify prompts, detection rules, and model behavior.

Encourage community contributions: Add new anomaly detectors, database adapters, and model integrations.

Improve transparency: Show the evidence behind each finding instead of presenting an AI-generated answer as unquestionable truth.

Open innovation also means that developers can inspect, extend, and adapt the system to their own data-quality needs.

The goal isn't to replace deterministic validation with AI. It's to combine reliable rules with a locally available model that makes data-quality investigations easier to understand.

The Spirit of It

Every dataset has a story. Some records are valid, some are duplicates, and some point to entities that no longer exist.

Ghost Records is about finding those forgotten pieces of data before they turn into bigger problems.

The idea behind the project is simple: data problems shouldn't remain mysterious. They should be detectable, explainable, and fixable—with the user in control.

Sometimes, the scariest thing in a database is the record nobody remembers creating.

Prize Categories

Best Use of Open Source AI
Best use of gemma

LogSloth — Lazy Developer's Error Detective

Yash Ram — Sat, 24 Oct 2026 19:04:53 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

LogSloth — Lazy Developer's Error Detective

LogSloth is a local-first AI-powered log-triage tool designed to make debugging less tedious. It helps developers analyze noisy application logs by grouping recurring errors, identifying error spikes, and generating concise diagnostic summaries with suggested debugging steps.

Instead of manually searching through hundreds of repetitive log lines, developers can let LogSloth handle the initial investigation and focus on fixing the actual problems.

Built around the idea of “You relax. We read the logs.”, LogSloth combines deterministic log processing with local AI to make debugging more efficient while keeping sensitive log data on the developer's machine.

Demo

yashr5120 / LogSloth

LogSloth is a local-first AI log-triage tool that groups recurring errors, detects error spikes, and generates actionable debugging insights using open-weight Gemma models via Ollama. Built for privacy-conscious developers.

🦥 LogSloth — Lazy Developer's Error Detective

You relax. We read the logs.

LogSloth is a local-first AI log-triage tool that automatically parses, groups, and explains your application errors — powered by a locally running Gemma model via Ollama.

Built for Hacktoberfest 2026 — Slow and Steady challenge.

🚨 The Problem

Application logs are noisy. A single bug can generate thousands of nearly-identical error lines. Finding the signal in that noise is tedious, manual, and slow. Most log tools send your data to the cloud.

✅ The Solution

LogSloth runs entirely on your machine:

Reads your log files
Parses and normalises entries (including multiline stack traces)
Redacts secrets before anything is analysed
Groups repeated errors into incidents using deterministic fingerprints
Detects error spikes automatically
Uses a local Gemma model (via Ollama) to generate evidence-backed summaries
Shows everything in a polished Streamlit dashboard
Persists incident metadata in SQLite
Exports sanitised…

View on GitHub

Code

https://github.com/yashr5120/LogSloth

How I Built It

I built LogSloth using Python, Streamlit, Ollama, and Gemma, with SQLite for incident history.

The application follows a simple pipeline:

Log ingestion: Load application logs and monitor selected log files.

Error grouping: Normalize messages and group recurring errors using deterministic fingerprints.

Detection: Count occurrences, prioritize incidents, and identify unusual increases in error frequency.

Local AI analysis: Use a Gemma model running through Ollama to summarize sanitized log evidence and suggest debugging checks.

Incident dashboard: Present prioritized errors, supporting evidence, and diagnostic reports in a developer-friendly interface.

An important design decision was to let conventional code handle predictable tasks such as parsing, counting, and grouping, while using AI for interpreting error patterns and generating explanations.

Why Does Open Innovation Matter?

Open innovation is central to LogSloth because application logs can contain sensitive information about software systems, infrastructure, and users.

By using an open-weight model locally through Ollama, LogSloth can analyze logs without requiring a hosted AI API. Once the model and dependencies are installed, the core workflow can operate without an internet connection, subject to the local environment and configuration.

The open-weight approach also makes it possible to experiment with different compatible models, customize prompts, inspect the processing pipeline, and adapt the tool to different development workflows.

Instead of relying on a recurring cloud inference service, developers can run their own local diagnostic assistant and retain greater control over their data.

The Lazy Payoff

LogSloth aims to reduce the repetitive work involved in investigating application logs.

Rather than reading the same error message dozens of times, developers can inspect grouped incidents, review a concise explanation, and follow targeted debugging checks.

The intended payoff is less time spent searching through noisy logs and more time spent building and fixing software.

Prize Categories

Best use of Gemma

LogTriage

Yash Ram — Sun, 18 Oct 2026 08:31:56 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

LogTriage is an automated, privacy-first log analysis and triage engine designed to prevent developers and SREs from drowning in log noise[cite: 1].

When applications throw errors, standard log management tools flood on-call engineers with repetitive stack traces and raw dumps[cite: 1]. LogTriage solves this by ingesting live streams or log files, stripping noise and duplicates via fingerprinting, redacting sensitive data (like API tokens or PII), and using local LLMs to generate instant root-cause analysis, severity scores, and actionable fix recommendations[cite: 1].

Who would pay for it?

Managed Service Providers (MSPs) & SOCs: Needing scalable, automated first-responder triage without sending sensitive client data over third-party APIs.
DevOps & Engineering Teams: Looking to reduce Mean Time to Resolution (MTTR) and cut out-of-hours alert fatigue by receiving high-context summaries instead of raw error dumps.

Code

yashr5120 / LogTriage

An offline-first log triage engine that uses local Gemma AI via Ollama to detect critical errors, deduplicate log events, and generate concise diagnostic alerts while preserving privacy and reducing log noise.

Smart Local Log & Error Triage Engine

GitHub repository

An offline-first Python service that turns noisy application logs into grouped redacted, structured diagnostic alerts. Rules work without Ollama; an installed local Gemma model is optional and never receives a cloud request.

Features

Streaming stdin, regular-file, and tail -f-style file ingestion.
Case-insensitive severity rules with JSON and timestamped-text parsing.
Bounded traceback/context assembly and stable fingerprint deduplication.
Cooldown and severity escalation handling.
Ollama /api/generate integration with strict validation and rules fallback.
JSONL or human-readable output and optional SQLite history.
Deterministic demo scenarios and machine-readable benchmark metrics.

flowchart TD
 A[stdin/file/follow] --> B[Parser and severity rules]
 B --> C[Traceback context]
 C --> D[Sliding-window fingerprint groups]
 D --> E[Rules or local Ollama]
 E --> F[Validated Alert]
 F --> G[JSONL/console]
 F --> H[Optional SQLite]

Install and run

py -m venv .venv
.venv\Scripts\Activate.ps1
pip install -e ".[dev]"
logtriage demo --scenario

…

View on GitHub

How I Built It

LogTriage is built natively around local, open-weights AI models using Ollama:

Ingestion & Processing Engine (src/logtriage/ingestion/, processing/): Reads logs via standard input (stdin), static log files, or live continuous tailing (follow)[cite: 1]. It parses log formats, extracts multi-line stack traces, and groups identical errors into fingerprint clusters using local hashing[cite: 1].
Local Privacy & Redaction (src/logtriage/redaction.py): Before any log content touches an inference model, sensitive credentials, API keys, and personal data are scrubbed locally[cite: 1].
Open-Source AI Inference (src/logtriage/inference/): Connects to Ollama running open models (e.g., Llama 3 or Mistral)[cite: 1]. A structured prompt template extracts root causes and proposed fixes while enforcing strict output JSON validation[cite: 1].
Alerting & Metrics (src/logtriage/alerts/, metrics.py): Dispatches structured alerts to designated endpoints (like webhooks or Slack) while tracking token usage and processing latency[cite: 1].

Why Does Open Innovation Matter?

Log management is inherently fraught with strict compliance and data sovereignty constraints (GDPR, HIPAA, SOC 2). Sending raw, unredacted application logs or stack traces to closed cloud APIs poses significant data privacy risks.

Open-source AI and open-weights models make local, on-premise log triage possible. By running inference via Ollama directly on the local machine or internal server, LogTriage guarantees that raw enterprise logs never leave the internal infrastructure[cite: 1]. Closed APIs simply cannot offer this level of privacy, zero-latency local execution, and total control over data flow.

Prize Categories

Best Overall Side Hustle
Best Use of Local Inference / Open-Weight Models

🌿WindQuest-Explore more. Scroll less.

Yash Ram — Fri, 09 Oct 2026 17:41:18 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

WildQuest — Explore more. Scroll less.

WildQuest is an open-source, local-AI outdoor adventure app that turns an ordinary walk into a personalized nature quest.

The idea is simple: instead of spending more time on your phone, use AI to discover reasons to put it away and explore the world around you.

Users can choose their preferred activity, duration, difficulty, and accessibility preferences. Gemma generates a nature quest with actionable missions and safety guidance. Users then head outdoors, complete the missions, and record their observations in a private nature journal.

What WildQuest offers:

Personalized nature quests powered by locally running Gemma.
Outdoor missions for plants, wildlife observation, nature patterns, and mindfulness.
Interactive mission checklists and progress tracking.
A private nature journal that stores observations in the browser.
Optional JSON export of journal entries.
A responsive, installable Progressive Web App designed for use before and after an outdoor adventure.

WildQuest is designed to make the screen a starting point for exploration, not the destination.

Demo

!(https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/xh3ru4lhn84su4h49ape.png)

!(https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/u1ya1kq0y9piyz8rizba.png)

The demo will show the complete journey: configuring a quest, generating it with local Gemma inference, completing missions outdoors, and saving observations in the nature journal.

Code

GitHub repository: https://github.com/yashr5120/wildquest

Built with React, TypeScript, Vite, Tailwind CSS, Node.js, Express, Zod, Ollama, and Gemma.

The repository includes the frontend, local AI integration, quest-generation logic, browser-side journal, PWA configuration, and automated tests.

How I Built It

I built WildQuest around Gemma 4 E2B (gemma4:e2b), using Ollama to run the open-weight model locally on my computer.

The application follows a straightforward architecture:

Frontend: React and TypeScript provide the quest setup, mission checklist, completion flow, and nature journal.
Backend: An Express API validates quest requests and communicates with the local Ollama runtime.
AI generation: Gemma receives the user's selected duration, interests, difficulty, activity type, movement preference, and accessibility requirements. It generates a structured nature quest.
Quest processing: The backend parses the model's response and normalizes the quest before returning it to the interface.
Local persistence: IndexedDB stores journal entries in the browser, and users can optionally export their data.
Progressive Web App: PWA support helps cache the application for a more resilient experience.

I also included a fallback quest generator so users have an alternative when local AI inference is unavailable. Fallback quests are separate from model-generated content.

The focus was to keep the architecture simple, avoid unnecessary cloud services, and make the core experience practical for a small open-source project.

Why Does Open Innovation Matter?

For WildQuest, open innovation is about giving people more control over the AI they use and the data they create.

Privacy by design: Running Gemma locally means quest-generation prompts do not need to be sent to a hosted AI provider. Journal entries remain in the browser by default.

More independence: Once the model is installed and the local runtime is available, the application can generate quests without relying on a paid, per-request cloud AI API.

Freedom to experiment: Developers can modify the prompts, experiment with model configurations, and adapt quests for different environments and communities.

Community-driven improvement: An open-source implementation makes it easier for contributors to improve quest quality, accessibility, validation, and support for additional models.

Most importantly, local AI makes the experience more personal without requiring users to hand their observations to a third-party service.

For a project about getting people outside, I wanted the technology to be useful without making people more dependent on their screens.

Prize Categories

Gemma — Best Use of Gemma