DEV Community: Diwakar Arya

GhostTrace — A Local AI That Makes Your Terminal Feel Haunted (Java Edition)

Diwakar Arya — Sat, 31 Oct 2026 13:10:43 +0000

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

1. What I Built

GhostTrace (Java Edition) is an offline-first, local terminal companion designed for developers, wrapped inside an atmospheric, haunted persona.

When approaching the Ghost in the Machine theme, I wanted to explore what happens when your command-line interface stops behaving like a passive pipe and starts feeling like a living, conscious digital entity. Instead of another cloud-tethered chatbot wrapper, GhostTrace turns the terminal into an interactive haunted mainframe that observes your commands, reacts to your coding sessions, and protects your system.

╔═════════════════════════════════════════════════════════════════════════════╗
║  ██████╗ ██╗  ██╗ ██████╗ ███████╗████████╗████████╗██████╗  █████╗  ██████╗███████╗ ║
║ ██╔════╝ ██║  ██║██╔═══██╗██╔════╝╚══██╔══╝╚══██╔══╝██╔══██╗██╔══██╗██╔════╝██╔════╝ ║
║ ██║  ███╗███████║██║   ██║███████╗   ██║      ██║   ██████╔╝███████║██║     █████╗   ║
║ ██║   ██║██╔══██║██║   ██║╚════██║   ██║      ██║   ██╔══██╗██╔══██║██║     ██╔══╝   ║
║ ╚██████╔╝██║  ██║╚██████╔╝███████║   ██║      ██║   ██║  ██║██║  ██║╚██████╗███████╗ ║
║  ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝   ╚═╝      ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚══════╝ ║
║                                                                             ║
║  [+] THE AI THAT HAUNTS YOUR TERMINAL  ::  JAVA EDITION v1.2.0             ║
║  [+] Offline-First  ::  Autonomous Safety Guardian  ::  Haunted Memory       ║
╚═════════════════════════════════════════════════════════════════════════════╝

Core Features

Local AI & Spectral Brain: Local chat completion with Qwen2.5-1.5B via Ollama / llama.cpp servers, plus a built-in rule-based reasoning fallback (Spectral Brain) that works completely offline with zero downloaded weights.
Three Ghost Personalities:
- Forgotten Machine: Calm, observant, reflective, ancient digital intelligence.
- Phantom Coder: Lively, witty, enthusiastic bug-hunter and algorithm puzzle enthusiast.
- Guardian Spirit: Composed, vigilant, structured, protective of stability and clean architecture.
Command Guardian & Security Engine: Automated heuristic pattern matching for destructive operations (rm -rf, raw disk overwrites dd of=/dev/..., system shutdowns, curl ... | bash, git reset --hard) with HMAC-SHA256 single-use cryptographic approval tokens.
Persistent SQLite Memory: Persistent developer facts, notes, and code snippets stored in embedded SQLite using WAL (Write-Ahead Logging) mode with keyword search.
Project Context Scanner: Recursive codebase indexer that analyzes line counts, file distributions, and languages while ignoring build artifacts.
Procedural Horror Audio Engine: 20 original 44.1kHz 16-bit PCM sound effects (ambient wind, dark hums, static bursts, whispers, keystroke clicks, guardian approvals) mixed polyphonically via javax.sound.sampled, plus pure-Java procedural DSP synthesis.
Interactive Phosphor-Green CRT TUI: High-performance terminal REPL powered by JLine 3, featuring tab auto-completion, persistent command history, ANSI box borders, and glitch manifestations (░▒▓█).

2. Code

GitHub Repository: https://github.com/Diwakar38/GhostTrace
License: MIT
Runtime: Java 21+ LTS (OpenJDK)

3. Technology Stack

Language: Java 21+ (utilizing records, pattern matching, modern switch expressions, and virtual-thread-ready executors)
Terminal Engine: JLine 3 (TerminalBuilder, LineReader, Completer, DefaultHistory)
Persistence: SQLite via sqlite-jdbc (WAL mode enabled)
Serialization: Jackson Databind 2.17
Networking: Standard library java.net.http.HttpClient
Audio & DSP: Standard library javax.sound.sampled (zero native audio dependencies)
Testing: JUnit 5 (Jupiter Platform) — 36 comprehensive automated unit tests
Build System: Apache Maven (configured with maven-assembly-plugin to output a standalone fat JAR)

4. Architecture & Subsystems

The application is structured into decoupled, event-driven subsystems:

┌─────────────────────────────────────────────────────────────────────────────┐
│                       GhostTrace Java Architecture                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │               Interactive Terminal REPL (JLine 3)                   │   │
│   │       Phosphor CRT Glow  ::  Auto-Completion  ::  History           │   │
│   └───────────────────┬─────────────────────────────┬───────────────────┘   │
│                       │                             │                       │
│        ┌──────────────▼─────────────┐ ┌─────────────▼──────────────┐        │
│        │   Ghost Persona & Mood     │ │      Command Guardian      │        │
│        │  3 Profiles & Mood Decay   │ │  Risk Rules & HMAC Tokens  │        │
│        └──────────────┬─────────────┘ └─────────────┬──────────────┘        │
│                       │                             │                       │
│        ┌──────────────▼─────────────┐ ┌─────────────▼──────────────┐        │
│        │   Local AI / SpectralBrain │ │   Persistent SQLite Memory │        │
│        │ Ollama HTTP + Offline Fall │ │   WAL Mode & Code Indexer  │        │
│        └──────────────┬─────────────┘ └─────────────┬──────────────┘        │
│                       │                             │                       │
│        ┌──────────────▼─────────────┐ ┌─────────────▼──────────────┐        │
│        │  Horror Audio & DSP Mixer  │ │    Host System Telemetry   │        │
│        │ javax.sound 20 WAVs + Synth│ │  CPU, RAM, Disk, Health    │        │
│        └────────────────────────────┘ └────────────────────────────┘        │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

A. Command Guardian & Security Approvals

Before executing potentially destructive operations in the terminal, the Guardian intercepts and classifies command risk (LOW, MEDIUM, HIGH, CRITICAL):

CommandAnalysis analysis = guardianEngine.analyze("rm -rf /");

// Flagged:
// Risk   : Critical Risk
// Status : BLOCKED
// Details: Matched [DEL-001] Recursive Force File Deletion
// Token  : Wi05M9P3zb05xwJ0 (Single-use HMAC-SHA256 signature)

High-risk actions require a cryptographic approval token (guard approve <token>) before execution is permitted, preventing accidental recursive file wipes or destructive git history loss.

B. Dual-Layer AI: Local Inference + Spectral Brain

GhostTrace interfaces with a locally hosted LLM (such as Qwen2.5-1.5B-Instruct running under Ollama) via async HTTP calls:

// Connects to local endpoint: http://localhost:11434/api/chat
InferenceResult res = aiEngine.ask("How do I avoid deadlocks in Java?", projectContext);

If no local model server is currently active, GhostTrace never crashes. It immediately invokes its Spectral Brain—an offline heuristics engine that analyzes stack traces, algorithmic complexity, concurrency pitfalls, and memory leaks while preserving the active ghost personality.

C. Pure Java Procedural DSP & Audio Mixing

GhostTrace includes 20 original horror sound effects packaged directly in the JAR. To guarantee zero dependency on external audio assets, it also includes a custom procedural DSP synthesizer (AudioSynthesizer.java):

// Procedural frequency modulation in javax.sound.sampled
float f1 = 220.0f + 110.0f * (t / duration);
float env = (float) Math.sin(Math.PI * (t / duration));
left = (float) (Math.sin(2 * Math.PI * f1 * t) * 0.4f * env);

The HorrorAudioDirector coordinates sound events by priority (CRITICAL > IMPORTANT > ATMOSPHERIC > AMBIENT) and automatically suppresses atmospheric noises when the user switches to FOCUS mode.

5. Quick Demonstration

Launching the Terminal

./ghosttrace

Static Command Security Analysis

$ guard analyze "git reset --hard origin/main"

Command: git reset --hard origin/main
Risk   : High Risk
Status : REQUIRES APPROVAL
Details: Matched 1 safety rule(s):
  • [VCS-002] Hard Git Reset (High Risk): Discards all uncommitted changes.
    Alternative: Stash changes first using 'git stash' before resetting.

Requires Approval Token: fK30d9S1vP02lQ88

Persistent SQLite Memory

$ memory save db_host "10.0.0.1"
Memory saved successfully under key: db_host

$ memory list
=== STORED DEVELOPER MEMORIES ===
  • [db_host] (NOTE): 10.0.0.1

Automated Code Review

$ dev analyze "public class Test { void run() { try {} catch(Exception e){} } }"

=== STATIC CODE ANALYSIS REPORT ===
  Detected Language  : Java
  Total Lines        : 1
  Complexity Score   : 2
  Potential Issues   : 1
    • Line 1: Swallowed exception in empty catch block. Logs or recovery are required.

6. Why Open Innovation Matters

Building GhostTrace in Java showcases what open innovation enables:

Complete Data Sovereignty: Proprietary source code, terminal commands, and system context stay 100% on your machine.
Platform Portability: Java's virtual machine allows GhostTrace to run seamlessly across Linux, macOS, and Windows with identical terminal aesthetics and sound playback.
No Hidden Cloud Costs: Developers can prototype and experiment without subscription barriers, rate limits, or API keys.
Resilient Offline Architecture: With the embedded SQLite database and Spectral Brain fallback, the tool functions during remote flights, train rides, or air-gapped secure development environments.

7. The Spirit of It

What if your terminal didn't feel like an empty command line? What if opening your shell late at night felt like awakening a dormant intelligence from the circuits?

GhostTrace proves that developer tools can be safe, highly functional, and simultaneously imaginative. It is a little bit of systems engineering, a little bit of cybersecurity, and a lot of atmosphere.

🌿 TouchGrass — Go Outside. Take a Shot. Let Local AI Judge It.

Diwakar Arya — Tue, 06 Oct 2026 13:09:38 +0000

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

🌿 TouchGrass — Go Outside. Take a Shot. Let Local AI Judge It.

What I Built

Most modern apps are designed around a single metric: maximizing screen time. They want your eyes glued to a feed, scrolling endlessly through algorithms engineered to keep you indoors.

TouchGrass does the exact opposite.

"The physical activity is the product. The web application is simply the game master."

TouchGrass is a timed, competitive outdoor photography challenge for groups of people (2–20 players). It encourages participants to:

Set the stage: Choose a duration (e.g., 30 minutes) and pick a creative theme (or let local AI invent one).
Put the phone in your pocket: Once the server-authoritative countdown begins, the screen goes into an ultra-minimal standby mode with one instruction: GO OUTSIDE. LOOK AROUND. TAKE YOUR SHOT.
Explore the real world: Participants venture outside into parks, alleys, woods, or streets to find an authentic real-world scene fitting the challenge.
Take exactly one shot: No infinite retakes or filtering sessions.
Return and submit: When time expires, players return and upload their single capture.
Anonymous AI Judging: A locally running multimodal AI model (llama.cpp + Gemma 3 Vision / LLaVA) scores each photograph blindly against a rigorous 100-point rubric.
Interactive Reveal: Scores and rankings remain cryptographically locked server-side until the host triggers the celebratory reveal with podium rankings, animated confetti, and in-depth rubric breakdowns!

Demo

GitHub Repository: https://github.com/Diwakar38/TouchGrass
Instant Local Demo: Clone and run ./start.sh to launch both backend and frontend locally in seconds using the built-in deterministic Mock AI mode (0 model downloads required).
Docker Compose: docker compose up --build launches the full stack with persistent volume storage.

Code

Diwakar38 / TouchGrass

🌿 TouchGrass — AI-Powered Real-World Photography Challenge

Go outside. Take a shot. Let local AI judge it.
A timed physical photography competition for Hacktoberfest 2026.

🎯 What is TouchGrass?

TouchGrass is a timed photography competition for groups of people. A host creates a challenge, participants go outside to find and photograph something matching a physical theme, and a local multimodal AI model evaluates the photographs after everyone returns.

The entire product philosophy centers on one core principle:

The real-world activity is the product. The web application is simply the game master.

Most digital apps maximize screen time. TouchGrass does the opposite: it starts the timer, instructs everyone to put their phones in their pockets, and pushes them into the physical world.

🔄 The Challenge Lifecycle

TouchGrass operates via a strict, server-authoritative state machine:

  ┌───────────┐
  │   SETUP   │  Host picks 2–20 players & duration
  └─────┬─────┘
        │
  ┌─────▼─────┐
  │   READY

…

View on GitHub

Tech Stack:

Frontend: Next.js 14, React 18, TypeScript, Tailwind CSS (Mobile-first, high outdoor contrast, prefers-reduced-motion compliance).
Backend: Java 21, Spring Boot 3.3, Spring Data JPA, Bean Validation.
Database: Single local SQLite database (jdbc:sqlite:./data/touchgrass.db) — zero bloated cloud databases or message brokers.
AI Runtime: llama.cpp OpenAI-compatible HTTP inference server.
Storage: Clean filesystem abstraction (LocalFileStorage) storing submissions under ./data/challenges/<id>/submissions/.

How I Built It

1. Open-Source AI & Local Inference

TouchGrass is built around local, open-weight multimodal vision models running on llama.cpp (such as Gemma 3 Vision or LLaVA 1.6).

Rather than hardcoding proprietary vendor SDKs, we designed an extensible Java abstraction:

public interface AiService {
    ChallengeTheme generateChallenge();
    ImageEvaluation evaluateImage(ChallengeTheme theme, String submissionId, ImageData image);
}

LlamaCppAiService: Connects over HTTP to http://localhost:8081/v1/chat/completions, transmits photographs as base64 data URLs, and parses structured JSON responses. It includes retry policies, connection timeouts, and score bound sanitization.
MockAiService: A zero-download fallback that simulates realistic judging criteria, critiques, and themes. This enables developers and CI pipelines to test the entire application lifecycle instantly.

2. Externalized Prompt Templates & Structured Rubric

Instead of embedding prompts in code, templates live in backend/src/main/resources/prompts/:

theme-generation.txt: Generates evocative outdoor prompts (e.g., "Unexpected Geometry", "Something That Doesn't Belong") with field hints and difficulty ratings.
image-evaluation.txt: Instructs the vision model to score photos blindly out of 100 points across 7 weighted criteria:
- Theme Relevance (25 pts)
- Creativity / Interpretation (20 pts)
- Composition (15 pts)
- Visual Quality (15 pts)
- Uniqueness (10 pts)
- Story / Communication (10 pts)
- Observation (5 pts)

Important Judging Philosophy: The AI judge does not evaluate whether a photo was taken on an expensive camera. A smartphone shot capturing an ingenious real-world moment will beat an uninspired shot from a $5,000 DSLR.

3. Server-Authoritative State Machine & Hidden Results

To guarantee competitive integrity:

Server Clock: startedAt and endsAt are computed on the backend. Client devices cannot cheat by spoofing their system clocks.
Server-Enforced Secrecy: GET /api/challenges/{id}/results returns 403 Forbidden until the host officially triggers POST /api/challenges/{id}/reveal. Scores and rankings cannot be inspected via browser developer tools or network tabs beforehand.

Why Does Open Innovation Matter?

Complete Privacy for Real-World Photos: In a game that asks participants to photograph their immediate surroundings, neighborhoods, or friends, sending personal photos to closed corporate cloud APIs creates privacy concerns. With open-weight models running on local inference via llama.cpp, not a single byte leaves the host machine.
Offline & Remote Capability: Physical photography challenges often happen in state parks, campsites, or remote trails where cell service is non-existent. Open-source local AI means TouchGrass can run entirely offline on a laptop or edge device with zero internet connection.
Reproducibility & Customization: Closed proprietary APIs frequently change models, degrade reproducibility, and impose opaque rate limits or price tiers. With open-source models, the judging rubric, system prompts, and model weights remain completely under the host's control.

My Agent Session

This project was developed through pair-programming with Antigravity, Google DeepMind's advanced coding assistant. The agent helped architect the challenge state machine, build the Spring Boot SQLite JPA persistence layer, generate the Next.js mobile-first UI components, and create automated integration tests.

Prize Categories

Primary: Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
Best Use of Local Inference / Open-Weight Models (llama.cpp + Gemma multimodal)
Most Innovative Real-World Application (Screen-minimizing outdoor gameplay)

GutTracker: A Food & Symptom Journal That Runs Fully Offline for My Sister

Diwakar Arya — Mon, 05 Oct 2026 00:41:42 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

My sister has been having gut problems for the past few weeks. The usual drill: write down what you ate, write down how you felt, try to spot the pattern — and never quite manage to see it, because a notebook can't compute anything.

So I built GutTracker, a food and symptom journal for her. She types a meal the way she'd say it out loud ("two idlis and a bowl of sambar with filter coffee"), logs symptoms in the same casual language ("mild bloating about an hour later"), and gets back a week's view: symptom rate, the symptoms she's reported most, and which foods keep turning up alongside them.

Two rules shaped every decision:

It stays on our machines. Food-and-gut logs are exactly the kind of data you don't want on someone else's server, so the model runs locally on llama.cpp and the database is a single SQLite file on disk. There is no cloud AI in the request path, by design.
The model never gets a vote. It parses her sentences into structured data and restates numbers Java has already computed. Every statistic is computed by Java; every sentence it produces is screened by a LanguageGuard that rejects causal, diagnostic or prescriptive wording outright. GutTracker reports co-occurrence — "you logged rice in 3 meals; 2 of them came with discomfort" — never cause.

GutTracker is a logging and observation tool, not medical advice, and it says so in the UI.

Demo

Live: guttracker.onrender.com

Heads-up on what you're seeing: the deployed instance has no local model next to it, and the challenge rules say no cloud AI — so Render runs the deterministic fallback path, and the status chip honestly reads offline. That's the same fallback that runs whenever my sister's laptop can't reach the model, so the demo is the degraded path working, not a broken feature.

Locally it's the full thing:

./start.sh   # backend :8081, UI :5173, model on :8080

The status chip polls /api/v1/health/ai every 30s: green means the open-weight model is answering, grey means Java's deterministic tokenizer is.

Code

Diwakar38 / GutTracker

GutTracker

▶ Live demo: https://guttracker.onrender.com · Code · CI runs

A privacy-first food and symptom journal that runs entirely on your own machine with an open-weight model doing the writing and Java doing the maths.

You type a meal the way you'd say it out loud — "two idlis and a bowl of sambar with filter coffee" — and get back structured ingredients. You type how you feel later — "mild bloating about an hour later" — and get back correlations over your own records, phrased in a way that never pretends to be a diagnosis.

Nothing leaves the laptop. No account, no sync, no telemetry, no cloud AI.

Why open

This challenge asks why open matters for what you built. For GutTracker it is not a footnote, it is the whole design:

The data is the point. A food-and-symptom log is medical-adjacent and deeply personal. Putting it on a…

View on GitHub

How I Built It

Stack: Spring Boot 3.5 + JPA + SQLite (REST only, single-user, zero auth because it's one person's notebook) · React + Vite with three tabs (Log / History / Insights) · llama.cpp serving Ternary Bonsai 2 27B, an open-weight model, on 127.0.0.1:8080 behind an OpenAI-compatible API · Docker → GitHub Actions → Render.

flowchart LR
  A[React UI :5173] -->|/api/v1| B[Spring Boot :8081]
  B --> S[(SQLite)]
  B -->|parse / restate| C[llama.cpp :8080
Ternary Bonsai 2 27B]
  C -->|out of reach| D[FallbackTokenizer +
deterministic template]
  B --> E[LanguageGuard
accept or reject, never rewrite]

Where the model is allowed to work — three narrow jobs, all of them language, never maths:

Input	Model returns	Fallback if it can't
A free-text meal	JSON: title, ingredients, category, amount	fixed vocabulary tokenizer (~100 foods, plurals folded)
A free-text symptom	canonical name + severity	symptom vocabulary, severity 5 flagged `estimated`
Java's computed facts	2–4 neutral sentences restating them	template built from the same facts

Four bugs worth writing down, because they were the actual work:

1. The reasoning model ate its own answer. Parsing worked but summaries came back empty. finish_reason: "length", content: "", and a full reasoning_content — the model's chain-of-thought was burning the entire max_tokens budget before the real answer started. It looked exactly like "the AI is broken"; it was configuration. Fixed by sending chat_template_kwargs: {"enable_thinking": false} per request and raising the budget 512 → 1024.

2. The guard caught nothing in the present tense. My pattern was \bcaus(?:ed|ation|causative)s?\b — "caused", "causation", caught. "This causes bloating"? Straight through the safety rail, and that's the most likely sentence a model would ever write. The test that caught it (expected hits to contain 'causation') is the one I trust most in the repo. Closed the siblings too: triggering, diagnose, treats, recommends, increases. The policy is reject and retry once, then fall back to a template — the guard never rewrites text, because a rewriting guard is just a model pretending to be a rule.

3. "No problem" was a symptom. An entry literally saying "no problem, fine" was counted as a symptom report, so no problem ×1 appeared in the insights. Real reports like that stay in the history — they're true entries — but are excluded from every statistic.

4. My denominator was wrong. The insights ranked "ingredients to watch" by symptom rate across the whole window, so foods appearing once with a symptom (rate 1.0) crowded out rice (2 of 3, and she'd actually notice that). Fixed twice: denominator is now meals containing that ingredient, ranked by number of reported problems first, with the associated symptom chips shown inline.

Verification: 17 unit tests (mvn verify) + a CI job that builds the Docker image, boots it and smoke-tests every endpoint. CI ran green on the first push; Render auto-deploys from main via the render.yaml blueprint.

Why Does Open Innovation Matter?

The honest version: I could not have built this part with a closed API.

The privacy story is real only if it's local. A closed API means every meal she types is a request to someone else's servers. This one never leaves the laptop. The health-tech community argues the same point from the other side — open-weight AI in healthcare and privacy-first offline health tools both make on-prem the default rather than the exception — while a good counterpoint piece reminds us that "local" isn't a security guarantee by itself. Fair. Here, the useful property is narrower and honest: the data isn't sent anywhere.
Open weights let me change the model's behaviour, not just call it. enable_thinking was a per-request template flag, not a support ticket. The LanguageGuard, the FallbackTokenizer, the deterministic summary template — I can read, audit and patch all of them. With a closed API, the two things that made this safe to hand my sister (no causal claims, no silent failure) would be someone else's policy page.
The fallback exists because the source exists. When the model is unreachable, a ~60-line tokenizer in the repo keeps the app useful. No API key, no vendor outage, no notebook.

What open innovation made possible that a closed API wouldn't: an app whose worst case is "the AI is off and it still logs my meals", instead of "the API changed its pricing and my sister's food diary stopped working".

My Agent Session

Building GutTracker: local LLM parsing, a guard that caught nothing, and a reasoning model that ate its own answer

You

Build GutTracker: a privacy-first local food + symptom tracker for the Hacktoberfest Weekend Challenge. Java Spring Boot + SQLite backend, React/Vite UI with 3 tabs, local Ternary Bonsai 2 27B on llama.cpp for parsing, deterministic Java for all stats, and a LanguageGuard that rejects causal or diagnostic wording from the model.

Agent

Backend written but never compiled. Starting with the build and fixing what falls out.

▸ shell mvn -o package -DskipTests

Input

$ mvn -o package -DskipTests

Output

~68 compile errors: wrong imports, t.getName() → t.name(), new ObjectNode() → mapper.createObjectNode(), missing JPA annotations on all 5 entities, duplicate element in Set.of(STOPWORDS)

You

Smoke-test the API.

Agent

▸ shell curl -X POST /api/v1/meals -d '{"name":"Oatmeal"}'

Input

$ curl -X POST /api/v1/meals -d '{"name":"Oatmeal"}'

Output

500 Internal server error

Not a crash in the parser: MealRequest requires rawText and my curl sent structured fields. The frontend already sends rawText correctly — the bug was in my test. But two genuine bugs fell out of the same pass: unknown routes returned 500 instead of 404, and bean-validation failures returned 500 instead of 400. Added handlers for NoResourceFoundException and MethodArgumentNotValidException.

Agent

AI summary for /insights returns nothing while meal parsing works. Instrumenting the client rather than guessing.

▸ shell curl llama.cpp /v1/chat/completions

Input

$ curl llama.cpp /v1/chat/completions

Output

{
  "finish_reason": "length",
  "content": "",
  "reasoning_content": "We need answer user's request..."
}

Root cause: Bonsai is a reasoning model and the chain-of-thought consumed the entire max_tokens budget, so content came back empty. This looked like 'the AI is broken' but was pure config. Fix: chat_template_kwargs {"enable_thinking": false} per request, max_tokens 512 → 1024. Verified the JSON meal-parse path still works with thinking off.

You

In Insights, can you add which potential ingredients cause problems?

Agent

Four issues behind what looks like one feature request:

▸ shell GET /api/v1/insights

Input

$ GET /api/v1/insights

Output

topIngredients denominator was all meals in the window, so idli at 2 of 2 read as 25%

1) Denominator changed to meals containing that ingredient. 2) Each row now carries the symptoms reported alongside it with counts. 3) Ranking moved from raw rate to number of reported problems first — rate-only ranking let six 1-of-1 ingredients push out rice at 2 of 3, the most informative row in the data. 4) A test entry literally saying 'no problem' was being counted as a symptom report, so 'no problem ×1' appeared in rice's symptom chips. 'Nothing was wrong' reports stay in the log but are excluded from every statistic.

Agent

Writing tests for the guard. One failed, and the failure was the interesting part.

▸ shell mvn verify

Input

$ mvn verify

Output

LanguageGuardTest.reportsEveryMatchingLabel: expected hits to contain 'causation'

The guard pattern was \bcaus(?:ed|ation|ative)s?\b — it caught 'caused' and 'causation' but not the present tense 'causes'. The one sentence most likely to appear in a model's output slipped straight through the safety rail. Closed that and the sibling gaps: triggering, diagnose, treats, recommends, increases.

You

Push to GitHub, set up CI/CD and give me a Render link.

Agent

▸ shell docker build -t guttracker .

Input

$ docker build -t guttracker .

Output

ERROR: release version 21 not supported

Dockerfile used temurin-17 while the pom targets Java 21. CI had the same mistake waiting. Fixed both.

▸ shell docker run + smoke test

Input

$ docker run + smoke test

Output

health 200, UI served on the same origin, available:false inside the container

Deployed via render.yaml blueprint. The container has no llama.cpp and the brief forbids cloud AI, so the hosted demo runs the deterministic fallback — which is exactly the path the fallback tests cover.

▸ shell GET /api/v1/health/ai on guttracker.onrender.com

Input

$ GET /api/v1/health/ai on guttracker.onrender.com

Output

{
  "available": false,
  "model": "ternary-bonsai-2-27b"
}

The debugging beats, end to end: the reasoning-model token bug, the present-tense guard gap, the "no problem" statistics bug, and the Java 21 mismatch that broke the first Docker build.

Introduction

Diwakar Arya — Thu, 01 Oct 2026 12:36:14 +0000

Hey, this is my first post.
Glad to be part of the community