Project Info

Collina

This project did not submit a demo video on Devpost.

Inspiration

Arguments happen everywhere, but strong reasoning often gets lost beneath confidence, interruptions, and rhetorical tricks. We built Collina to make debates clearer and more entertaining by turning argument analysis into a live, game-show-style experience.

What it does

Collina is an AI referee for spoken debates. It separates speakers, generates a live transcript, flags logical fallacies, rewards strong arguments and rebuttals, updates an explainable scoreboard, calls fouls out loud, and crowns a winner with a punchy final verdict.

How we built it

Next.js, React, TypeScript, and Tailwind CSS: Power the debate interface, transcript, foul flags, animations, and live scoreboard. Deepgram: Provides speech recognition, speaker diarization, and spoken referee callouts. Claude: Analyzes each turn for argument strength and fallacies, then generates the final verdict. Redis Vector Search: Retrieves the most relevant definitions from our 17-fallacy taxonomy for grounded analysis. Hugging Face Transformers: Generates local sentence embeddings for semantic fallacy retrieval. A shared debate client supports both a stage-safe prerecorded demo and a live microphone mode using the same analysis and scoring pipeline. Challenges we faced Our biggest challenge was balancing speed with accuracy. The referee must react quickly enough to feel live, but false fallacy calls can make the entire experience feel unfair. We also had to design scoring rules that were consistent, explainable, and immediately understandable to an audience. Reliability was equally important, so we built an offline mock demo and a local semantic-search fallback that keep the core experience working when an external service is unavailable.

Collina — AI Debate Referee

Two people argue out loud. Collina separates their voices, catches logical fallacies in real time, moves a live scoreboard, calls out fouls in a dramatic AI voice, and crowns a winner.

Built with Deepgram (speech-to-text + diarization + text-to-speech), Claude (fallacy analysis + verdict), and Redis (fallacy vector search).

⚡ TL;DR

npm install
npm run dev

Open http://localhost:3000 → click "Call to order". That's the full demo, no keys needed.

🎮 Two ways to run it

Button	What it does	Needs keys?
Call to order	Plays a scripted courtroom rehearsal. Polished, offline, can't fail. Keep this as the stage backup.	❌ No
Go live (mic)	Pick any topic, debate through the mic, and watch the real AI pipeline judge each turn.	✅ Yes (see below)

1️⃣ Mock demo (works right now)

npm install      # one time
npm run dev      # start the app

Open http://localhost:3000
Press F for fullscreen presentation mode
Click "Call to order"

No API keys, no internet, no setup. This is the stage-safe demo.

2️⃣ Live mode (real mic + real AI)

Live mode needs three services. Do these once:

Step 1 — Add your keys

Copy the example file and fill it in:

cp .env.example .env.local

Edit .env.local:

ANTHROPIC_API_KEY=sk-ant-...        # Claude (analysis + verdict)
DEEPGRAM_API_KEY=...                # Deepgram (mic + voice) — needs "Member" role
REDIS_URL=redis://localhost:6379
NEXT_PUBLIC_USE_REAL_PIPELINE=true  # turn the real pipeline ON

Step 2 — Start Redis

docker run -d --name debate-redis -p 6379:6379 redis/redis-stack:latest
npm run seed:redis     # load the fallacy taxonomy (run once)

Step 3 — Run it

npm run dev

Open http://localhost:3000 → enter a topic → click "Go live (mic)" → allow the microphone → debate → click "End debate" for the verdict.

🎙️ Tip for clean voice separation: take clear turns, don't talk over each other, and ideally use two distinct-sounding voices.

⌨️ Controls

Key / Button	Action
`Call to order`	Run the scripted courtroom rehearsal
`Go live (mic)`	Start a real-time mic debate
`End debate`	Stop the mic and get the verdict
`F`	Fullscreen presentation mode
`M`	Mute / unmute the AI ref voice
`R`	Restart the debate

🧰 Commands

npm run dev             # start the app (http://localhost:3000)
npm run build           # production build
npm run lint            # strict TypeScript check
npm run seed:redis      # load fallacies into Redis (live mode)
npm run test:scoring    # verify the scoring math
npm run test:analyze    # test fallacy detection (needs Anthropic key + Redis)
npm run test:transcribe -- <audio-file>   # test a recorded clip

🩹 Troubleshooting

Problem	Fix
"credit balance too low" (analysis/verdict fail)	Add credits to your Anthropic account → console.anthropic.com → Plans & Billing
403 on mic / "Insufficient permissions"	Your Deepgram key needs the Member role — create a new key with it
Live mic does nothing	Check `NEXT_PUBLIC_USE_REAL_PIPELINE=true`, all keys set, Redis running, mic permission allowed
Redis errors	Start it: `docker start debate-redis` (then `npm run seed:redis`)
Falls back to mock	That's intentional when keys/flag are missing — the demo always works

🧠 How it works

Audio ─▶ Deepgram (transcribe + who-said-what)
      ─▶ split into turns
      ─▶ Redis finds the most relevant fallacies
      ─▶ Claude judges the turn (fallacies + strength)
      ─▶ score updates live  +  Deepgram voices the foul
End  ─▶ Claude delivers the winner's verdict

The UI imports only startDebate and getVerdict from lib/debate-client.ts. Mock and real pipelines share that exact contract, so the UI is identical either way.

Analysis

Compare with all teams

View

Metric

Claude Opus 4.8
6
Evan Lee
1

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
Next.jsIn code
ReactIn code
RedisIn code
Tailwind CSSIn code
TypeScriptIn code

7 of 7 appear in the indexed code.

AI coding agents

Claude CodeCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

158 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

Feature verification

14 Verified

Claude-generated final verdictVerified
Claude generates the final verdict, crowning a winner with a punchy final verdict
Claimed on Devposthigh confidence
- lib/verdict.ts:12 — generateVerdict computes the winner deterministically then calls Claude to write a punchy 3-4 sentence verdict consistent with that winner
- app/api/verdict/route.ts:1 — API route exists to expose verdict generation to the client
Fallacy detection via ClaudeVerified
Claude analyzes each turn for argument strength and fallacies
Claimed on Devposthigh confidence
- lib/analyze.ts:103 — analyzeTurn calls Claude (claude-sonnet-4-6) with a schema-constrained prompt returning fallacies, argumentStrength, and isRebuttal
Fullscreen presentation mode and keyboard controls (F/M/R)Verified
F for fullscreen presentation mode, M to mute/unmute, R to restart
Claimed on readmehigh confidence
- components/DebateArena.tsx:217 — Keydown handler checks for 'f', 'm', 'r' keys and calls toggleFullscreen, toggleMuted, and runDebate respectively
Live explainable scoreboard updatesVerified
Updates an explainable scoreboard in real time
Claimed on Devposthigh confidence
- lib/scoring.ts:21 — computePointDelta deterministically derives point changes from argumentStrength, rebuttal bonus, and fallacy penalties so the score reason is legible
- components/Scoreboard.tsx:118 — Scoreboard component animates score changes live and shows a legend explaining point deltas
Live mic mode with real-time diarized streamingVerified
Go live (mic): pick any topic, debate through the mic, and watch the real AI pipeline judge each turn
Claimed on readmehigh confidence
- lib/realtimeDebateClient.ts:46 — startMicDebate opens a Deepgram live websocket with diarize:true, streams MediaRecorder audio, and assembles turns via LiveTurnAssembler
- lib/liveSegmentation.ts:32 — LiveTurnAssembler merges diarized word stream into per-speaker turns with flicker suppression
Local semantic-search fallback when Redis is unavailableVerified
We built a local semantic-search fallback that keeps the core experience working when an external service is unavailable
Claimed on Devposthigh confidence
- lib/fallacyStore.ts:155 — retrieveFallacies catches Redis errors and falls back to localFallback, an in-process cosine similarity search over the same embedded snippets
Local sentence embeddings via Hugging Face Transformers.jsVerified
Hugging Face Transformers generates local sentence embeddings for semantic fallacy retrieval
Claimed on Devposthigh confidence
- lib/embeddings.ts:4 — Uses @huggingface/transformers pipeline with Xenova/all-MiniLM-L6-v2 to produce 384-dim normalized embeddings locally, no external API key
Next.js/React/TypeScript/Tailwind debate interfaceVerified
Next.js, React, TypeScript, and Tailwind CSS power the debate interface, transcript, foul flags, animations, and live scoreboard
Claimed on Devposthigh confidence
- components/DebateArena.tsx:1 — Main React/TSX component orchestrating the debate UI, fullscreen mode, and keyboard shortcuts
- tailwind.config.ts:1 — Tailwind CSS configuration present
- components/FallacyFlag.tsx:1 — Dedicated component for rendering fallacy/foul flags
Redis vector search over a 17-fallacy taxonomyVerified
Redis Vector Search retrieves the most relevant definitions from a 17-fallacy taxonomy for grounded analysis
Claimed on Devposthigh confidence
- lib/fallacyStore.ts:118 — retrieveFallacies runs a Redis FT.SEARCH KNN query over embedded fallacy snippets to ground the Claude prompt
- lib/fallacies.ts:8 — FALLACIES array contains exactly 17 named fallacy definitions, confirmed by counting name: entries
- scripts/seed-redis.ts:1 — seed script exists to load the taxonomy into Redis (npm run seed:redis)
Rewards for strong arguments and rebuttalsVerified
Rewards strong arguments and rebuttals
Claimed on Devposthigh confidence
- lib/scoring.ts:21 — basePoints rewards higher argumentStrength and computePointDelta adds a rebuttal bonus when isRebuttal is true and base>0
Scripted test commands (scoring, analyze, transcribe)Verified
npm run test:scoring, test:analyze, test:transcribe verify the scoring math, fallacy detection, and transcription
Claimed on readmemedium confidence
- scripts/test-scoring.ts:1 — Test script for scoring math exists
- scripts/test-analyze.ts:1 — Test script for fallacy analysis exists
- scripts/test-transcribe.ts:1 — Test script for transcription exists
Speech-to-text with speaker diarizationVerified
Deepgram provides speech recognition and speaker diarization to separate speakers and generate a live transcript
Claimed on readmehigh confidence
- lib/deepgram.ts:58 — transcribeClip calls Deepgram's transcribeFile with diarize: true and utterances: true, mapping results to speaker-tagged utterances
- app/api/transcribe/route.ts:44 — API route calls transcribeClip then segmentTurns to produce diarized turns from an uploaded or demo clip
Spoken foul callouts (referee voice)Verified
Calls fouls out loud in a dramatic AI voice using Deepgram TTS
Claimed on readmehigh confidence
- lib/callout.ts:7 — buildCalloutText generates a spoken foul line like 'X! Minus N, Speaker Y' for moderate+ severity fallacies
- lib/tts.ts:7 — synthesizeSpeech calls Deepgram's speak API (aura-orion-en voice) to turn callout text into audio
- lib/realtimeDebateClient.ts:93 — processTurn calls buildCalloutText then posts to /api/tts to attach callout audio to the turn
Stage-safe prerecorded mock demoVerified
A shared debate client supports both a stage-safe prerecorded demo (Call to order) and a live microphone mode using the same analysis and scoring pipeline
Claimed on Devposthigh confidence
- lib/mockDebateClient.ts:10 — startDebate replays pre-scored mockTurns on a timer with zero backend calls
- lib/debate-client.ts:19 — Shared startDebate/getVerdict contract dispatches to mock or real implementation based on source and NEXT_PUBLIC_USE_REAL_PIPELINE flag, both consumed identically by the UI

An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.