DEV Community: Jyotish Pabbisetti

The Spike on the Desk: Teaching a Local AI to Read a Rice Mill’s Invoices

Jyotish Pabbisetti — Sat, 17 Oct 2026 13:31:03 +0000

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

What I Built
In a rice mill office, the room at the front never gets completely quiet. You can feel the steady, low thrum of the destoner and the rubber-roll huskers vibrating through the concrete floor, and the air holds the dry, warm scent of paddy dust.

In the middle of that room sits a wooden desk, an older desktop PC running Tally, and a heavy steel paper spike—the upright metal pin with a weighted base where incoming slips get impaled to wait their turn. Twice a month, the pressure at that desk spikes. In India, monthly GST compliance follows an unforgiving calendar: GSTR-1 sales returns are due on the 11th, and GSTR-3B tax summaries follow on the 20th.

Before those deadlines, an independent bookkeeper sits at that desk. He manages the ledgers for this mill alongside two dozen other local traders. He opens a digital bill on one half of the monitor, Tally or an Excel spreadsheet on the other, and manually enters vendor names, GSTINs, invoice numbers, line-item quantities, rates, and tax splits row by row.

Roughly half the paperwork arriving over WhatsApp and email consists of photographed weighbridge (Dharmakanta) slips, gate passes, or handwritten chits. The other half, however, is clean, computer-generated B2B PDFs: custom-milling charges from partner mills, packaging invoices for gunny bags, transport bills, and machinery spare receipts.

I built local-invoice to handle the digital half of that pile. It is a lightweight, air-gapped document extraction microservice built with FastAPI, PyMuPDF, and Google’s Gemma 2 (2B) running locally via Ollama. It parses native digital PDF invoices and extracts validated header fields and line items into structured JSON right on the local machine—acting as an automated, quiet descendant of the steel spike on the desk.

The Side Hustle Opportunity
Cloud-based invoice tools like Suvit, Vyapar TaxOne, and AutoEntry already exist to automate data entry, and urban accounting firms use them daily. But when you ask independent bookkeepers in regional trading towns why they still type bills by hand, their hesitation comes down to two practical concerns:

Subscription fatigue versus thin workflow margins: A freelance bookkeeper typically charges a small merchant a modest monthly retainer for basic compliance and filing. Cloud tools charge per-company subscriptions or per-page processing fees. If an accountant serves 20 small businesses, paying recurring monthly SaaS fees across every client ledger significantly eats into their take-home income. An open-source tool running on the laptop they already own has a marginal operating cost of zero. Once the model weights are downloaded, they can process hundreds of invoices across all their clients without paying a rupee in API token fees.

Data confidentiality and regulatory compliance: Supplier rates, buyer identities, and per-quintal processing margins represent a commodity trader's entire competitive moat. Furthermore, accounting bodies—such as the Institute of Chartered Accountants of India (ICAI) confidentiality code and global ICAEW guidance on public AI—strictly caution against feeding identifiable client records into third-party cloud tools. With India’s Digital Personal Data Protection (DPDP) Rules notified in November 2025 and moving toward full enforcement in May 2027, passing invoices containing individual proprietor names, PAN-linked GSTINs, and bank accounts through external APIs creates compliance risks independent practitioners prefer to avoid.

Demo
GitHub Repository: https://github.com/your-username/local-invoice (Update with your repo link)

API Documentation & Swagger UI: Accessible locally at http://localhost:8000/docs

How It Works in Practice
The microservice exposes a simple endpoint: POST /api/v1/extract. You send a native PDF file as multipart form-data, and receive a validated, strictly typed JSON payload:

Bash
curl -X POST "http://localhost:8000/api/v1/extract" \
-H "accept: application/json" \
-H "Content-Type: multipart/form-data" \
-F "file=@sample_data/invoice_sample.pdf;type=application/pdf"
Sample Extracted Payload
JSON
{
"vendor_name": "Acme Tech Solutions",
"invoice_number": "INV-2026-001",
"invoice_date": "2026-03-31",
"total_amount": 1475.0,
"tax_amount": 225.0,
"line_items": [
{
"description": "Cloud Architecture Consulting",
"quantity": 10.0,
"unit_price": 125.0,
"total_price": 1250.0
}
]
}
Every numerical field is returned as a sanitized, clean float, ready for downstream processing, Excel conversion, or accounting database insertion.

Code
The project is structured as a modular FastAPI microservice designed for low-resource environments:

Invoice-Extractor-LLM-APP/
├── app/
│ ├── init.py
│ ├── main.py # FastAPI application, streaming ingestion, routing
│ ├── pdf_parser.py # PyMuPDF in-memory parsing & scanned PDF heuristics
│ └── extractor.py # Ollama integration, Gemma 2 prompt & Pydantic models
├── sample_data/ # Synthetic sample generator and test PDFs
├── tests/ # Smoke tests and validation fixtures
├── requirements.txt
└── README.md
Key Technical Implementation Details

In-Memory Parsing & Scanned Document Guardrails (app/pdf_parser.py) Most basic document tutorials save uploaded files to /tmp before reading them. If a server crashes mid-request, confidential client records remain on the disk. In local-invoice, incoming files are read directly into memory as a byte stream:

Python
import fitz # PyMuPDF

def extract_text_from_pdf_stream(pdf_bytes: bytes) -> str:
with fitz.open(stream=pdf_bytes, filetype="pdf") as doc:
extracted_pages = []
total_non_whitespace = 0

    for page_num in range(len(doc)):
        page = doc[page_num]
        text = page.get_text("text")
        total_non_whitespace += len("".join(text.split()))
        extracted_pages.append(f"--- Page {page_num + 1} ---\n{text}")

    # Guardrail: Fail honestly on scanned PDFs without OCR layers
    if total_non_whitespace < 30:
        raise ScannedPDFError("OCR not supported yet, please upload a native PDF")

    return "\n\n".join(extracted_pages)

By counting non-whitespace characters across the stream, the system aborts with an HTTP 400 Bad Request whenever an image-only or scanned PDF is provided, preventing blank strings from being sent to the LLM where they would cause hallucinations. Documents exceeding 12,000 characters (~3,000 tokens) are safely truncated to protect Gemma's attention window.

Grammar-Guided Structured Decoding (app/extractor.py) Small 2-billion-parameter models can easily hallucinate markdown fences, pleasantries, or broken brackets if prompted with raw text. Instead of relying on prompt engineering, local-invoice passes our Pydantic v2 schema directly to Ollama's format parameter:

Python
response = client.chat(
model="gemma2:2b",
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": f"Invoice document text:\n\n{text_content}"}
],
format=InvoiceData.model_json_schema(),
options={"temperature": 0.0}
)
Ollama compiles InvoiceData.model_json_schema() into a GBNF (GGML Backus-Naur Form) grammar. At generation time, tokens that violate the JSON syntax or schema data types are masked out at the logit level, guaranteeing that the model returns syntactically valid JSON.

Pre-Validation Cleaning for Real-World Formatting Even with constrained JSON decoding, models reading invoices frequently encounter values like "₹1,250.50", "$450.00", or missing tax fields. To prevent these values from breaking strict float validation, app/extractor.py applies Pydantic v2 @field_validator(..., mode="before") hooks:

Python
class InvoiceData(BaseModel):
vendor_name: str = Field(description="Name of the business or vendor issuing the invoice")
invoice_number: str = Field(description="Invoice or bill reference number")
invoice_date: str = Field(description="Date the invoice was issued")
total_amount: float = Field(description="Total final payable amount")
tax_amount: float = Field(default=0.0, description="Total tax amount")
line_items: list[LineItem] = Field(default_factory=list)

@field_validator("total_amount", "tax_amount", mode="before")
@classmethod
def _clean_float(cls, v: Any) -> float:
    if v is None or v == "":
        return 0.0
    if isinstance(v, (int, float)):
        return float(v)
    # Strip currency symbols, commas, and trailing characters
    cleaned = re.sub(r"[^\d.-]", "", str(v).strip())
    return float(cleaned) if cleaned else 0.0

Asynchronous Event-Loop Protection (app/main.py) FastAPI runs on a single-threaded asynchronous event loop. Running CPU-bound PyMuPDF stream parsing or synchronous Ollama network requests inside an async def route freezes the entire server, causing health checks and concurrent connections to hang. We bridge the synchronous parsing pipeline using anyio.to_thread.run_sync(), offloading compute to worker threads and keeping the API responsive.

How I Built It
To make this practical for everyday office hardware, the system had to run smoothly alongside Tally and Chrome on a standard 8GB RAM computer without requiring a dedicated graphics card.

While newer models like the Gemma 4 family offer native vision and 128K context windows, their 4-bit quantized weights hover near 5GB of memory, leaving little headroom on an 8GB office PC. I deliberately chose Gemma 2 (2B) served locally through Ollama. At approximately 1.6GB in Q4 quantization, it leaves the host machine fully responsive while running text extraction quickly on standard CPU cores.

[ Native B2B PDF ]
│
▼
[ In-Memory PyMuPDF Stream ] ──( < 30 non-ws chars? )──► [ HTTP 400 Scanned PDF Error ]
│
▼ (Valid text layer)
[ Threadpool Offload (anyio) ]
│
▼
[ Ollama: Gemma 2 (2B) ] ────► GBNF Schema-Constrained Decoding
│
▼
[ Pydantic v2 Sanitizer ] ───► Regex Currency Cleaning ('₹1,250.50' -> 1250.5)
│
▼
Validated Structured JSON
Why Does Open Innovation Matter?
Let's be candid about the trade-off: frontier closed-source models will always parse unstructured, highly complex documents with greater baseline versatility than a 2-billion-parameter local model.

Yet for the independent bookkeeper sitting in a mill office, open-source AI delivers where closed APIs cannot:

Uncompromising Data Residency: Initial model weights are downloaded once during setup. After that, the network cable can be unplugged. Confidential client invoices, PAN details, and supplier price points never leave the local laptop.

Deterministic Unit Economics: A solo practitioner can process 50 invoices or 5,000 invoices in a month without monitoring token meters or worrying about sudden API pricing changes.

System Predictability: By combining small, efficient open-weight models with strict grammar constraints and deterministic validation, we create reliable, task-specific accounting tools that do not depend on cloud uptime.

What's Next for the Project
With local-invoice producing clean, normalized JSON, the extracted data is ready for direct downstream integration:

Tabular Anomaly Detection with TabPFN: Because line items and tax amounts are output as normalized floats, they can be converted directly into a pandas DataFrame (pd.json_normalize) and passed into tabular foundation models like TabPFN (Prior Labs). This allows an accountant to compare incoming invoices against a merchant's historical ledger to catch abnormal unit prices, unexpected tax rate changes, or duplicate billings without training a custom model.

Direct Tally Prime XML Export: Generating a downloadable Tally-compatible .xml voucher file alongside the JSON response, allowing bookkeepers to import an entire batch of verified invoices directly into Tally in two clicks.

Local Multimodal Vision: Upgrading to Gemma 4's lightweight vision models on machines with 16GB of RAM to process photographed weighbridge slips and WhatsApp receipts locally, bridging the gap between digital PDFs and physical paper.

On the night of the 10th, before the GSTR-1 portal locks, the goal of this software is straightforward: make sure that by the time the bookkeeper reaches the final paper on that steel spike, the manual entry is already done, the data has stayed private, and they can close the office door and go home on time.

Prize Categories
Best Use of Gemma: Integrated Google's open-weight Gemma 2 (2B) locally via Ollama with schema-constrained JSON decoding as the core privacy-preserving extraction engine.

try it out
github link:

Jyotish08 / local-invoice

local-invoice

A 100% offline, zero-cost, private AI microservice for freelance accountants and financial data pipelines. Processes client invoice PDFs locally with FastAPI, PyMuPDF, and Gemma 2 (2B) via Ollama.

Key Features

Zero Cloud Leakage: Works completely offline without an internet connection. No client data ever leaves your computer.
Zero API Costs: Replaces cloud LLMs (OpenAI, Gemini) with local inference using Google's gemma2:2b.
PyMuPDF Native Ingestion: High-speed text extraction across multi-page PDF documents.
Scanned PDF Guardrail: Detects non-searchable/scanned PDFs and returns a clear 400 Bad Request informing the user that native text is required.
Structured Output via Ollama: Enforces strict Pydantic v2 JSON schema adherence.
TabPFN & Pandas Ready: Flat, normalized JSON outputs directly ingestible into pandas and downstream anomaly detection models.

Architecture & Technology Stack

Web Framework: FastAPI (with Pydantic v2)
PDF Parser: PyMuPDF (fitz)
Local Inference: Ollama Python SDK running gemma2:2b
Test Suite:…

View on GitHub

A Dog's Day — What If You Could Experience a Morning Through a Dog's Eyes?

Jyotish Pabbisetti — Sun, 16 Aug 2026 16:49:12 +0000

This is a submission for Weekend Challenge: Dog Days Edition

What I Built

We know what our dogs do all day.

We don't really know what that day feels like to them.

I built A Dog's Day to explore that idea as a single interactive experience rather than another dog utility.

You start by scrolling through a Golden Retriever's morning: waking up, waiting for breakfast, heading outside, meeting another dog, losing a favorite red ball, and eventually finding it again.

The story is built around scroll-driven visual beats, so the page behaves more like a short interactive film than a collection of sections.

Then, instead of simply ending the story, it asks:

What if you could experience the world through the eyes of your favorite animal?

That leads into the second half of the project.

Choose an animal and talk to it.

The Dog character is a fictional Golden Retriever with context from the story you just experienced. Ask why the ball mattered, why everything outside smells interesting, or what it noticed when it met another dog, and the conversation is grounded in that character's perspective rather than a generic "tell me about dogs" chatbot.

The experience currently includes five animal perspectives:

Golden Retriever
Domestic Cat
European Rabbit
Red Fox
Gray Wolf

The idea is simple: the same world can feel very different depending on who is experiencing it.

Demo

Live: https://dev-cha-git-main-jyotishpabbisetti2025-1209s-projects.vercel.app/

Video: https://youtu.be/WRw55khrIBI

The demo shows the project as one continuous experience:

the opening story
the missing-ball sequence
the transition into the animal experience
a voice conversation with the Dog
interruption while the character is speaking

The part I wanted to get right is the transition from watching the story to being able to talk to the character inside it.

Code

GitHub: https://github.com/Jyotish08/dev-cha

The project is a single Next.js application using the App Router.

The story is organized around reusable components for scroll progress, scene beats, media, typography, and the transition into the interactive chapter.

The conversation system has separate animal configurations, a voice conversation state layer, a Gemini Live WebSocket client, and a fallback API path.

How I Built It

The first half is a small story engine.

Each chapter has authored visual beats and text, and the user's scroll position determines which beat is active. The story uses sticky full-screen sections with Motion to control the pacing and crossfade between the story frames.

For example, the four main chapters are:

Morning Comes Quietly — the dog wakes.

Breakfast — anticipation, eating, and the empty bowl.

The Walk — the neighborhood, another dog, and the dog's sense of smell.

The Missing Ball — chase, loss, searching, discovery, and getting the ball back.

The visual layer combines 1536×1024 story frames with short ambient MP4 overlays. The frames carry the actual narrative beats, while the videos add movement without making every moment depend on a full video sequence.

The second half is where the architecture changes.

Instead of sending recorded speech to a normal text-generation endpoint and then using browser text-to-speech, I connected the conversation directly to Google's Gemini Multimodal Live API over a persistent WebSocket.

Microphone audio is captured as 16 kHz linear PCM and streamed to Gemini. The returned 24 kHz audio is scheduled through the Web Audio API for continuous playback.

That matters because the interaction is supposed to feel like a conversation, not:

record → wait → generate → speak.

The Live connection also supports interruption. If the Dog is speaking and the user starts talking, the current playback can be stopped and the conversation can continue from the new turn.

The animal personalities are configured separately. The Dog's system instructions include the fictional events from the story itself, including breakfast, the walk, the other dog, and the red ball. That lets the conversation continue from the story instead of starting from zero at the bottom of the page.

There is also a fallback path for the parts of the experience that depend on external AI services. Gemini rate limits, network conditions, microphone permissions, and temporary connection failures can all affect a live session, so the project does not silently pretend a failed request succeeded. A secondary Gemini text-streaming path and an offline scripted mode are available when the live connection cannot be established.

The goal was not to make the project depend on AI for every part.

The goal was to use Google AI exactly where it changes the experience:

the story shows you the animal's world; Gemini Live lets you talk from inside it.

Prize Categories

Best Use of Google AI

I am submitting A Dog's Day for Best Use of Google AI.

Gemini is not being used as a wrapper around a normal chatbot.

The interactive chapter uses the Gemini Multimodal Live API for the core voice experience: continuous microphone input, streamed spoken responses, story-aware animal personas, and interruption handling.

Remove Gemini Live from that part of the project and the central interaction changes completely.

The technology is what allows the final chapter to move from:

"Here is a story about a dog."

to:

"You can actually talk to the animal whose morning you just followed."

The Ten Days I Wasted My AI Usage Limits (And What I Learned After)

Jyotish Pabbisetti — Thu, 06 Aug 2026 16:33:07 +0000

For almost four months, I did nothing but dream. I would think up a product, imagine how it would work, picture it finished — and never write a single line of code. In my head, building it was the easy part. I had ChatGPT and Claude. How hard could it be?

Then summer break came. May 2026. And one thought kept hitting me: I had spent four months thinking about products and zero months building them.

So I decided to actually start.

The naive part

People had already warned me — learn the basics first, don't skip the fundamentals. I nodded along, but I didn't really believe that was the real problem. I still thought AI was some kind of magician. Explain the idea, get the code, done. One idea, one solution, no friction.

Here's how naive I actually was: I would describe my idea to ChatGPT, ask it for a plan and a prompt, then copy that prompt straight into my IDE — without reading what the prompt actually told the AI to do. I just trusted it.

The output, unsurprisingly, was often the opposite of what I wanted. I burned through my usage limits chasing fixes for problems I had created myself, just by not reading my own prompts.

The part nobody warns you about

The real barrier was never syntax or libraries. It was the gap between having an idea in your head and actually turning it into something real. That gap doesn't show up in any tutorial. You only find it by trying to cross it — and falling in.

What changed

The first ten days were pure confusion. But somewhere after that, things started clicking. I learned actual prompt engineering — not just "ask nicely," but understanding what a prompt does before I run it. I got a real feel for what AI is actually good at, and where it quietly hands you garbage dressed up as an answer.

Oddly, this made me a better programmer, not a lazier one. Reading and correcting AI output forced me to understand code faster than writing it alone ever did. I started filling the gaps AI left with my own thinking, instead of just more prompts.

It also made me more consistent — not just in coding, but in how I studied and how I showed up to work every day.

The one thing I'd tell myself in May

None of this — the prompt engineering, the sharper code sense, the consistency — happens if I don't take that first messy, confused step. The confusion wasn't a sign I was doing it wrong. It was the cost of finally doing it at all.

Rivalry Roast — you talk smack about your team or favorite player, out loud, and an AI rival fan claps back at you, in voice, in real time.

Jyotish Pabbisetti — Mon, 13 Jul 2026 02:26:21 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

Tomorrow I have my semester exam. Between assignments, revision, and general exam-season chaos, my schedule right now is not exactly forgiving. And yet — every day, no matter how packed things get, I carve out an hour, sometimes an hour and a half, just to build. Not because I have to. Because it's the one part of my day that actually feels like mine.

So when this challenge landed during exam week, it felt less like bad timing and more like an invitation. I'm a solo developer on this one, and I'm also a lifelong football fan — Ronaldo has been my guy for as long as I can remember. Building something around fan passion and rivalry wasn't a stretch for me; it's basically autobiographical.

The goal was simple: talk smack, get roasted back — out loud, not just in text.

Demo

Youtube demo link(https://youtube.com/shorts/QNnVdpfzGNE?si=GFmKuYos3FgXRtx4)

https://dev-uq5k.onrender.com

Code

https://github.com/Jyotish08/dev

How I Built It

The flow is simple to describe but has three real moving parts: you speak your trash talk, it gets converted to text, that text goes to an AI for a witty comeback, and the comeback gets converted back into voice so you actually hear the rival roast you.

I used Groq for speech-to-text, Google Gemini for generating the roast itself, and ElevenLabs for turning that roast into voice.

The voice piece was the part I was most excited about, and it wasn't totally unfamiliar territory — I've built voice cloning from scratch before, using open-source models, piecing together my own pipeline to get a voice to sound right. This was my first time using ElevenLabs specifically, and it was humbling: what used to take real pipeline-building effort on my end, it handled almost instantly once I found my footing with it.

Gemini impressed me just as much on the other side — fast turnaround, and it consistently understood the tone I was going for without me needing to over-engineer the prompt.

The part nobody tells you about: building the idea took maybe twenty minutes of thinking. Getting it working took closer to two hours, and almost all of that time went into APIs that had quietly moved on without telling me. A model I called by name had already been retired. A voice model I picked had been phased out on the free tier. The specific voice I wanted wasn't available to my account at all due to a free-tier restriction I didn't know existed. Deployment brought its own round of small chaos — a build tool throwing a permission error, a config silently skipping a dependency it needed, a server going live but unable to find its own front end.

None of these were dramatic bugs individually — each took a couple of minutes to fix once I knew what it was. But stacked back-to-back, on exam eve, with the clock ticking, it turned into a genuine debugging crawl through error messages and dashboards. And honestly, that's passion too — not just the fun highlight-reel part, but the part where something keeps refusing to work and you keep showing up anyway because you already care too much to walk away.

Prize Categories

Best Use of Google AI, Best Use of ElevenLabs

Building Confidence out of Chaos: How Copilot Saved My First AI Project

Jyotish Pabbisetti — Sun, 07 Jun 2026 06:04:10 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built
I built Local PDF, a completely local, privacy-first utility website designed to handle all your PDF processing needs right in the browser. The idea started because I wanted a fast, reliable tool that didn't force users to upload their sensitive documents to the cloud. As I navigate my first year of computer science, what makes this project so meaningful to me is that it was my true gateway into advanced, real-world development. It wasn't just another assignment; it was something I built from scratch to solve a real problem.

Demo:

Localpdf — Your PDFs. Done in Seconds. Right in Your Browser.

Free online PDF tools that work entirely in your browser. Compress, merge, and split PDFs instantly with no uploads, no registration, and no data stored.

localpdf.dev

The Comeback Story
When I first started this project, my workflow was a complete mess. It was entirely disconnected. At one crucial point, the app was lagging horribly, the components were breaking, and I couldn't figure out why. I sat there for 45 incredibly frustrating minutes, just staring at my screen, trying to trace the errors by myself.

It was my very first time experimenting with AI agents in a development environment, and the complexity felt overwhelming. Honestly, I was completely drained. I was so close to just shutting my laptop, throwing my hands up, and postponing the whole thing for "tomorrow"—which, let's be real, often means abandoning it entirely. The barrier felt too high.

But instead of giving up, I decided to try a different approach. I stepped back, engineered a clear prompt to gather my thoughts using ChatGPT, and then I turned to the auto model selection feature in GitHub Copilot right inside VS Code.

My Experience with GitHub Copilot
That decision completely turned the project around. I asked Copilot to analyze the repository, and within just a few minutes, it handed me a comprehensive report detailing exactly where the bottlenecks were and why the app was breaking. I was absolutely blown away by how it handled the chaos of my code. I applied the changes it suggested, and it worked flawlessly.

If Copilot hadn't helped me in that exact moment, that bug would have been the end of the road for Local PDF. But more importantly, solving that problem gave me an incredible surge of confidence. It made me realize that I can build complex, ambitious things. Since that night, I've gone on to build multiple other projects, and I haven't felt those negative emotions or the heavy weight of imposter syndrome while coding ever again. Copilot didn't just fix my code; it changed how I feel about being a developer.

DEV Community: Jyotish Pabbisetti

The Spike on the Desk: Teaching a Local AI to Read a Rice Mill’s Invoices

Jyotish08 / local-invoice

local-invoice

Key Features

Architecture & Technology Stack

A Dog's Day — What If You Could Experience a Morning Through a Dog's Eyes?

What I Built

Demo

Code

How I Built It

Prize Categories

Best Use of Google AI

The Ten Days I Wasted My AI Usage Limits (And What I Learned After)

**Rivalry Roast** — you talk smack about your team or favorite player, out loud, and an AI rival fan claps back at you, in voice, in real time.

What I Built

Demo

Code

How I Built It

Prize Categories

Building Confidence out of Chaos: How Copilot Saved My First AI Project

Localpdf — Your PDFs. Done in Seconds. Right in Your Browser.

Rivalry Roast — you talk smack about your team or favorite player, out loud, and an AI rival fan claps back at you, in voice, in real time.