# SQLite Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/sqlite
> Markdown URL: https://aitinkerers.org/technologies/sqlite.md
> Technology record last updated: 2026-09-18T15:13:58Z
> Generated: 2026-09-21T22:49:00Z

SQLite is a C-language library: a self-contained, serverless, zero-configuration SQL database engine embedded directly into the application process.

SQLite is the world's most deployed database engine, functioning as a compact, C-language library (under 900KiB with all features) that eliminates the need for a separate server process. It operates as a serverless, zero-configuration system, storing the entire database (up to 281 terabytes) in a single, cross-platform file. This architecture makes it ideal for countless applications: it is built into all major mobile phones, web browsers, and desktop operating systems. The engine guarantees high reliability, supporting full ACID transactions, and its source code is freely available in the public domain for any use.

- Official technology site: https://www.sqlite.org
- Public AI Tinkerers demos and talks: 28
- Result page: 1 of 2

## Recent Public Talks and Demos

### [Edge-AI Kindergarten Attendance: Automating Check-ins with Computer Vision & Local LLM Workflows](https://wellington.aitinkerers.org/talks/rsvp_s0e9vu8YVco)

I built an automated, privacy-first facial recognition attendance system for daycares to replace manual paper check-in logs, utilizing a local Python, OpenCV, DeepFace, Flask, and SQLite stack. To bridge computer vision with generative AI, the system integrates a local open-weights LLM via Ollama and Qwen. During the live demo, I will showcase how real-time camera frames trigger automated face verification, log attendance locally into SQLite, and instantly invoke the local LLM endpoint (/api/ai-summary) to generate professional natural language daily attendance reports, pattern summaries, and administrative notes completely offline. Example Pipeline & Output: The system serializes recent database rows into a structured markdown text log (e.g., - Time: 10:05:05 | Guardian: Mahesh Endla | Child: Hrithvik Endla) and passes it through strict prompt constraints. This produces professional markdown reports featuring daily attendance patterns, anomaly flags, and administrative notes: Markdown **Daily Summary Report** **Date:** August 11, 2026 **Attendance Patterns:** Today was a busy day with multiple check-ins for Hrithvik Endla at approximately 10:05 AM by his guardian, Mahesh Endla. **Administrative Note:** Please confirm with the guardian regarding check-in frequency to ensure records are accurately reflected.

- Event context: AI Tinkerers Wellington: Inaugural Meetup · 26 August 2026 — 2026-08-26 — Wellington
- Public talk page: https://wellington.aitinkerers.org/talks/rsvp_s0e9vu8YVco

### [Towerwatch: Real-Time Threat Monitoring & Security Operations](https://mombasa.aitinkerers.org/talks/rsvp_qOJvNRRLbek)

A live architecture breakdown of real-time threat monitoring dashboards for system logging, alerting, and automated security event tracking.

- Event context: AI Tinkerers – Mombasa Chapter Launch · 22 August 2026 — 2026-08-22 — Mombasa
- Public talk page: https://mombasa.aitinkerers.org/talks/rsvp_qOJvNRRLbek

### [Can AI Make the World a Better Place?](https://columbus.aitinkerers.org/talks/rsvp_M4Biz5mUKI0)

Connect an LLM via MCP and watch it autonomously build an industrial economy on a 3D Earth. The model becomes the player: it mines real geological deposits, spins up supply chains, balances a power grid, researches a tech tree, terraforms the planet, and launches space missions — all while you watch live on a shareable globe. Over-industrialize and the ecosystem collapses; the LLM has to figure that out on its own. More global concerns and features to come!

- Event context: AI Tinkerers - Columbus August Meetup — 2026-08-03 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_M4Biz5mUKI0

### [What if loops are the problem?](https://nyc.aitinkerers.org/talks/rsvp_UEhibnXmrYg)

Loopbreaker is a public, local-first MCP server and visual SQLite review graph extracted from a deeper review-and-shipping system embedded in my application, Rordi. I built the original system after an AI code review reached thirteen passes and continued discovering new reasons not to ship. Loopbreaker isolates the reusable mechanism: an issue has a frozen set of enforced behaviors, evidence is attached to those behaviors, and review is limited to one comprehensive pass, one repair-verification pass, and—only when necessary—one shipping-decision pass. I’ll demo the working system live: clone the public repo, start its local MCP server, connect an AI coding agent, load a synthetic version of the thirteen-pass incident, and inspect the review graph. I’ll show the agent querying the acceptance surface, recording exact test evidence, completing a repair pass, and stopping automatically—while the visual interface separately explains whether the issue is actually ready to ship.

- Event context: NYC Summer Social: Rooftop Oyster Demo Day (two years of Tinkering in NYC) — 2026-07-29 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_UEhibnXmrYg

### [From AI Prospect Memos to a Scored Warm-Intro Queue](https://poland.aitinkerers.org/talks/rsvp_k0DCDscxWlA)

I built a dogfood workflow on top of graph.one that connects AI-assisted company qualification to a relationship-graph work queue. I'm the founder of graph.one, but this demo is about the internals of the build, not a product pitch. It starts in Prospector: a Node CLI pipeline that creates frozen public-source packets, runs AI-generated prospect memos, validates structured outputs, and stores decisions in append-only JSONL ledgers. The handoff is a qualified-company record. Intro Queue then takes a relationship-graph org-path export with organization identity, relationship owner, optional connector, target person/role, and strength fields. It caches the export in SQLite, collapses duplicate and noisy paths into scored route options, groups selected routes by connector, tracks per-company outcomes, and surfaces fallback routes as a human action queue. In the demo I'll follow one fully synthetic target company from source packet to memo to graph path row to scored route option to failed route/fallback. The queue output is a person-centric ask docket for a human operator; there is no send pipeline. I'll use fully synthetic graph data and redacted schema/log excerpts only.

- Event context: AI Tinkerers Warsaw: GTM Engineering Track — 2026-06-24 — Poland
- Public talk page: https://poland.aitinkerers.org/talks/rsvp_k0DCDscxWlA

### [Building an AI Language Tutor for iOS](https://berlin.aitinkerers.org/talks/rsvp_VPPtB_Q1kCM)

A German learning app for iOS. Every card is a unique AI-generated illustration, and instead of swiping through cards you can practice by speaking with a realtime voice tutor that drops you into dynamically generated scenarios -- order a coffee, miss a train, argue with your landlord. It mines your conversation transcripts for the mistakes you actually made and turns them into new cards overnight. FSRS spaced repetition underneath, and I use it every day for my own German.

- Event context: AI Tinkerers Berlin - June 17, 2026 — 2026-06-17 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_VPPtB_Q1kCM

### [Hive: Local-First AI Gateway](https://bogota.aitinkerers.org/talks/rsvp_ukV86hfl3Q0)

Explore building a local-first AI agent gateway with Bun and SQLite. Learn to orchestrate autonomous agents across multiple communication channels, manage tools, and switch LLM providers seamlessly.

- Event context: AI Tinkerers Bogotá: Demos for builders — 2026-04-23 — Bogotá
- Public talk page: https://bogota.aitinkerers.org/talks/rsvp_ukV86hfl3Q0

### [ThreadHop: local-first context sharing across coding agent sessions](https://montreal.aitinkerers.org/talks/rsvp_72wf-elK3uc)

ThreadHop is a local TUI and CLI app that turns isolated coding-agent sessions into a connected workspace with a chat history view, cross-session Full Text Search (FTS5), a kanban board for session tagging, automatically extracted decisions and TODOs, bookmarks, and compressed handoffs. In this demo, I want to show how conversation history can be reused instead of ignored. ThreadHop indexes local transcripts, lets you organize chats on a kanban board with simple states like backlog, in progress, in review, and done, and makes it easy to bring the right context into a new session — whether that is a bookmarked turn, the open TODOs and decisions a background observer has already pulled out, or a full handoff through the /threadhop:handoff skill that packages decisions, TODOs, ADRs, and cross-session conflicts so work can carry forward. The goal is to make multi-agent coding feel like one continuous workspace rather than a pile of disconnected chats.

- Event context: AI Tinkerers Montreal - April Demo Night — 2026-04-22 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_72wf-elK3uc

### [From Chat to CASE: Building an AI Agent That Scouts and Fills Real Complaint Forms](https://singapore.aitinkerers.org/talks/rsvp_y-Gl78fWqSw)

I built Onestop, a chat-first complaint agent that turns a user’s issue into an execution workflow: it extracts the complaint from natural language, plans the escalation path, drafts the complaint email, and for verified portals like CASE Singapore, scouts the live web form and attempts a browser fill through a Form Genome pipeline. The demo is intentionally technical and code-first: a FastAPI orchestrator, structured complaint state, Playwright-based browser execution, and truthful fallbacks when a route is not production-safe.

- Event context: AI Tinkerers Singapore: The Agentic Future & Dev/Eng Workflows — 2026-04-21 — Singapore
- Public talk page: https://singapore.aitinkerers.org/talks/rsvp_y-Gl78fWqSw

### [Soul, Memory, Skills, Brain: Building a Zero-PII Personal AI Agent in Docker](https://austin.aitinkerers.org/talks/rsvp_11W1r8whPMs)

Rent-An-Agent.AI is a self-hostable personal AI agent platform where each agent is a four-layer artifact — Soul (persona in SOUL.md), Memory (SQLite+FTS5 with daemon-thread fact extraction), Skills (52 marketplace skills exposed through an OpenAI-compatible bridge API), and Brain (user-configurable LLM: DeepSeek, Ollama, Claude). It runs on a Mac Mini in Austin, ships as Docker containers on GitHub, exposes itself via Cloudflare Tunnel, and uses a 48-character hex token as the only identity — no email, no password, no PII. Live demo: provision a fresh agent in 10 seconds with persona picker, have a conversation, show the daemon thread silently extracting facts into SQLite, rewrite the Soul mid-conversation („Luna, sei ab jetzt formeller"), fire a marketplace skill call through the Bridge, and settle a tier upgrade with a real BOLT11 Lightning invoice via the Alby webhook.

- Event context: AI Tinkerers Austin: April 2026 Demo Night — 2026-04-16 — Austin
- Public talk page: https://austin.aitinkerers.org/talks/rsvp_11W1r8whPMs

### [Seams Showing: Deconstructionist Approach to AI Engineering](https://dc.aitinkerers.org/talks/rsvp_M_8O9nWG6RU)

AO is a governed AI pipeline for MTG rules adjudication. Instead of a chat loop, it's a layered system where each stage — input, retrieval, semantic gating, and response — has an explicit contract and a single owner. The interface is built around a single animated spine element that reflects system state rather than a chat UI. Inference runs fully on-device.

- Event context: AI Tinkerers x Softengi - DC Metro Meetup - April 9th, 2026 — 2026-04-09 — DC
- Public talk page: https://dc.aitinkerers.org/talks/rsvp_M_8O9nWG6RU

### [Calendar Club](https://columbus.aitinkerers.org/talks/rsvp_PguV58U8t70)

Ambient deep-research agent that discovers in person events and automatically syncs them to the user’s calendar. Built with LangGraph, the agent runs a multi-step research workflow, asking clarifying questions and gathers feedback during the middle of the research. Finally the result is rendered as agenda of the next week’s related events to sync with the users calendar.

- Event context: AI Tinkerers - Columbus April Meetup — 2026-04-06 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_PguV58U8t70

### [Hive — Building a Local-First AI Agent Gateway with Bun, SQLite & Multi-Channel Orchestration](https://pereira.aitinkerers.org/talks/rsvp_xTm-4SxgHLw)

Hive is an open-source, local-first AI agent gateway built entirely with Bun and TypeScript. It lets you deploy autonomous AI agents that communicate across Telegram, Discord, WhatsApp, and CLI — all orchestrated through a single SQLite database with zero cloud dependency. The architecture follows a native Context Engine + ACE (Agentic Context Engineering) pattern: agents are stored as data, not hardcoded classes, and a Coordinator agent dynamically spawns sub-agents, assigns tools, and routes tasks. Hive supports multiple LLM providers (OpenAI, Gemini, Ollama, OpenRouter, Moonshot) through a unified provider adapter layer, making it truly model-agnostic. Built independently from Bogotá, Colombia and published on npm as @johpaz/hive.

- Event context: AI Tinkerers Pereira — The Builders Lab — 2026-03-25 — Pereira
- Public talk page: https://pereira.aitinkerers.org/talks/rsvp_xTm-4SxgHLw

### [AgentChatBus: A Persistent Multi-Agent Debate Room for AI Coding Workflows](https://toronto.aitinkerers.org/talks/rsvp_0rs9k8evwXA)

I will demo AgentChatBus, a 100% free and open-source project (with zero commercial elements) featuring an MCP server, a browser-based Web UI, and an experimental VS Code extension. It turns a normal IDE coding task into a persistent multi-agent review-and-debate workflow. Instead of relying on a single assistant response, a task is sent into a shared thread where multiple role-specific agents, such as security, performance, and architecture reviewers, can inspect the same context, challenge each other, and return a concrete repair checklist. Humans can monitor agent activities, view thread states via Server-Sent Events (SSE), and jump into the debates in real time using the built-in browser UI, our VS Code extension, or through full compatibility with other popular MCP-enabled IDEs (like Cursor, Antigravity, etc). The demo will be shown live from VS Code (though it fully supports other IDEs), leveraging both the standard MCP tools for AI agents and our human-facing interfaces for orchestration. The core idea is editor-agnostic: using MCP and REST/SSE as open infrastructure for reproducible agent-human collaboration. I will show the workflow end to end, then briefly open the hood on the protocol mechanics, including strict message synchronization, persistent thread state, and dynamic agent joins.

- Event context: AI Tinkerers Toronto - March - hosted by Mozilla! — 2026-03-25 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_0rs9k8evwXA

### [Niuwn AI: Building an AI Twin That Speaks As Me to Strangers](https://bremen.aitinkerers.org/talks/rsvp_BIo4d4pBN0I)

I built a system where anyone can create a conversational AI version of themselves, not a chatbot that answers questions about you, but one that talks as you in first person to anyone who visits a shareable link. Think of it as replacing your static CV or LinkedIn profile with something people can actually have a conversation with. The core idea is a two-agent architecture. One agent (the Curator) works with you privately; you talk to it, upload your CV, share your blog posts, import your LinkedIn export and GitHub profile. It interviews you like a thoughtful journalist, asks follow-ups, spots gaps, and organizes everything into a structured knowledge base. The second agent (the Twin) is what visitors see. It reads from that knowledge base, speaks in your voice, respects boundaries you've defined, and gracefully handles things it doesn't know instead of hallucinating. What makes the system interesting technically: the entire knowledge base is plain Markdown files, transparent, editable, and version-controllable. Retrieval uses memsearch for hybrid BM25 + vector search over those markdown files, which turns out to work really well for professional data where you need both semantic understanding and exact matching on names, dates, and technologies. The two agents have strict asymmetric access, the Curator writes, the Twin only reads, which keeps the trust boundary clean and makes prompt injection defense on the public-facing side much more manageable. The system is built with GDPR in mind, owners can view, edit, or delete anything their Twin knows, and visitors are informed upfront that conversations may be reviewed by the owner. During the Live demo, I'll teach the Twin something new on stage and let the audience interrogate it.

- Event context: AI Tinkerers Bremen — 2026-03-25 — Bremen
- Public talk page: https://bremen.aitinkerers.org/talks/rsvp_BIo4d4pBN0I

### [An RTS-Style Interface for AI Agents and Codebases](https://berlin.aitinkerers.org/talks/rsvp_n4kJ2vGsbwA)

A desktop app that renders your codebase as a 3D city -- files become buildings, directories become districts. It picks up Claude Code, Codex and Opencode telemetries locally and animates agents flying through the scene as they read, write, and edit files. All local-first -- no data leaves your machine.

- Event context: AI Tinkerers Berlin Meetup - March 11, 2026 — 2026-03-11 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_n4kJ2vGsbwA

### [Un Agente AI que si puede tocar tu terminal](https://bogota.aitinkerers.org/talks/rsvp_qIkbtvBBLeI)

Un proyecto open Source, que combina análisis estático de Código (tree-sitter) visualización 3D interactiva (three.js) y un sistema de agentes AI tool- use real, que te ayuda a explorar las decisiones de arquitectura.

- Event context: AI Tinkerers Bogotá: El Primer Meetup de 2026 — 2026-02-26 — Bogotá
- Public talk page: https://bogota.aitinkerers.org/talks/rsvp_qIkbtvBBLeI

### [Fluo aka we have Duolingo at home](https://toronto.aitinkerers.org/talks/rsvp_3TuvA7LAEd0)

My partner is Turkish, and I'm taking classes to learn his language. But there's a gap that no textbook or classroom can fill—I don't have a learning companion who actually knows what I've learned and can meet me where I am. So I built it. Architecture Overview I built a multi-agent conversational system using FastAPI, SQLAlchemy, and OpenAI's API (GPT-4o + Whisper + TTS). The system maintains persistent state of the learner's knowledge and dynamically adapts conversation difficulty in real-time. Core Components 1. Note Extraction Pipeline (NoteExtractorAgent) Accepts multiple image uploads or raw text input Uses GPT-4o's vision capabilities to parse handwritten/printed class notes Extracts structured data: vocabulary (target word, native translation, example sentences) and grammar concepts (name, description, usage examples) Supports configurable native/target language pairs 2. Knowledge Persistence Layer SQLAlchemy ORM with SQLite backend Per-language vocabulary and grammar tables with fluency tracking (low/medium/high) Tracks times_practiced and times_correct for spaced-repetition-style prioritization 3. Lesson Planning Agent (LessonPlannerAgent) Selects vocabulary/grammar items prioritizing low-fluency scores Generates a structured lesson plan constrained to CEFR levels (A1-C2) Passes both practice items and all known items to enable natural vocabulary reuse without exceeding learner's level 4. Dialogue Agent (DialogueAgent) Maintains conversation state and full transcript Bidirectional speech support: Whisper for STT, OpenAI TTS for audio responses Receives lesson plan + full knowledge context to stay within learner's vocabulary bounds Detects conversation end signals and handles graceful session termination 5. Analysis Agent (AnalysisAgent) Post-conversation transcript analysis Identifies: correctly used target vocabulary, grammatical errors, new words attempted Updates fluency scores in database based on performance

- Event context: AI Tinkerers Toronto - February 2026 @ Cohere! — 2026-02-26 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_3TuvA7LAEd0

### [Gradient Descent for Prompts](https://milan.aitinkerers.org/talks/rsvp_KxccPz0PSKs)

What if you could optimize your prompts the way you optimize model weights — with a loss function, an optimizer, and an iterative loop? This talk presents a practical methodology for agentic prompt optimization: using an LLM as an optimizer to iteratively improve system prompts against a test suite, treating prompt text as a tunable parameter rather than a static artifact.

- Event context: AI Tinkerers Milan - February 24, 2026 - Agentic Orchestration in Financial Services: Architectures & Demos — 2026-02-24 — Milan
- Public talk page: https://milan.aitinkerers.org/talks/rsvp_KxccPz0PSKs

### [Stop Wasting Time Giving AI Context It Should Already Have](https://prague.aitinkerers.org/talks/rsvp__P7J5gqyEG8)

Every time you open an AI chat, you start from zero. Re-explaining what you're working on, pasting in links, setting the scene. MemoryLane fixes that. It quietly watches your screen, understands what you're doing, and gives your AI tools that context through MCP. I'll walk through the full system live: how we capture your activity without killing your machine, how we turn pixels into searchable meaning, and how the MCP server is designed so AI assistants ask smart questions about your actual workflow. By the end, I'll ask Claude what I was doing during the talk - and it'll know.

- Event context: ❄️ AI Tinkerers Prague – February Meetup — 2026-02-19 — Prague
- Public talk page: https://prague.aitinkerers.org/talks/rsvp__P7J5gqyEG8

### [Edge-First AI: Per-Student Agents on Cloudflare](https://singapore.aitinkerers.org/talks/rsvp_2uQx8tjb9FA)

ow we built mcq.sg - an AI tutoring platform where every student gets their own stateful agent. The defining infrastructure choice: Cloudflare Durable Objects. Each student has a dedicated DO with built-in SQLite storing mastery data, attempt history, and recommendation queue. The AI agent runs inside the DO - no centralized database, no bottleneck, no cold starts for returning students. I'll show the code for: - Per-student DO with local SQLite schema - Multi-model extraction pipeline (Moondream for detection, Claude for reasoning) - Async batch processing for 50% cost savings on non-realtime tasks Built by 2 people. Previously led engineering on ParkingSG and RedeemSG at Open Government Products.

- Event context: AI Tinkerers - The Age of AI & Infrastructure (Singapore) — 2026-02-11 — Singapore
- Public talk page: https://singapore.aitinkerers.org/talks/rsvp_2uQx8tjb9FA

### [Beads: My coding agent memory bank & planning system](https://seattle.aitinkerers.org/talks/rsvp_6lBG3aBqrV4)

I'll give a live demo of my workflow with multiple coding agents on multiple projects using Beads. Beads is a lightweight issue tracker that replaces markdown files for agent planning. It turns your implementation plan into a big queryable graph, so you can sit down in every new session and just say, "what's next?"

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — November 3, 2025 — 2025-11-04 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_6lBG3aBqrV4

### [Lyra: A Private Home-Network LLM with Proactive Memory in 5 Minutes](https://prague.aitinkerers.org/talks/rsvp_hlUvbKGXQco)

I’ll show a tiny but real home-network LLM that understands my household context—no cloud, no slides. We’ll start with Ollama on Ubuntu, bake a system prompt via a Modelfile, bind safely to LAN, and hit it with curl. Then I’ll add a 60-line FastAPI “Lyra Hub” that ingests real-world signals, stores them in SQLite/FTS5, and augments chat by prepending concise household notes to the prompt, turning a stateless model into a proactive assistant. We’ll show: 1) Modelfile + build: FROM tinyllama:1.1b-chat SYSTEM """You are Lyra… private LAN… family-safe… Czech by default…""" # ollama create lyra-assistant -f Modelfile 2) Minimal hub (core idea): @app.post("/ingest") -> save to SQLite + FTS @app.post("/chat") -> notes = recent() + search(); call /api/chat with [system(notes)] + messages 3) Safe LAN exposure: UFW + optional Caddy (internal TLS + Bearer). Everything is reproducible, copy-pasteable, and runs on a 4GB refurb PC. Fellow tinkerers can clone the pattern and drop in their own connectors in minutes.

- Event context: 🍂 AI Tinkerers Prague – October 2025 Meetup — 2025-10-23 — Prague
- Public talk page: https://prague.aitinkerers.org/talks/rsvp_hlUvbKGXQco

### [From Chaos to Concurrency: Building a Scalable Medical Document Processor with AI](https://pereira.aitinkerers.org/talks/rsvp_9bnOR7GfOXw)

This is a technical deep-dive into how we tried (and failed, repeatedly) to turn a messy pile of unstructured medical documents — scanned PDFs, DOCX files, and images — into a clean, structured clinical database, and what we learned along the way. We began with a naive approach: a single Python script (document_processor.py) that extracted raw text using PyPDF2 and python-docx, then sent it all to Gemini with a massive prompt asking for 80 fields in JSON format. That broke quickly — the model returned incomplete or hallucinated data, with under 30% success, and most scanned PDFs were unreadable by PyPDF2. In Phase 2, we split the problem: a fallback pipeline used pdf2image and Tesseract OCR for robust text extraction, we introduced specialized prompts for each section (e.g., _extract_basic_data, _extract_medical_history), and added a lightweight AI classifier to detect form type (initial vs. follow-up) and select the correct taxonomy. This improved accuracy but killed performance, with each document requiring 5–6 sequential API calls and batch processing taking hours. So we moved to Phase 3: a parallel architecture using Docker. We introduced a SQLite task queue, split the system into two containers — medical-survey-processor (a Flask API that registers documents as PENDING) and worker.py (a Python service that processes jobs and updates their status) — and scaled using deploy: replicas: in docker-compose.yml to run multiple workers in parallel. The result is a resilient, scalable system combining deterministic logic with contextual AI, capable of processing hundreds of medical documents in parallel. The live demo will show a real file upload triggering the pipeline, key pieces of the code (OCR fallback, classification, prompts, worker orchestration), and no slides — just raw code, terminal logs, and real-world pain turned into working architecture.

- Event context: AI Tinkerers - Pereira: Mentes en Beta: Prototipar, Fallar, Reinventar con IA — 2025-08-28 — Pereira
- Public talk page: https://pereira.aitinkerers.org/talks/rsvp_9bnOR7GfOXw

## Related Technologies

- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 662 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 205 public demos
- [FastAPI](https://aitinkerers.org/technologies/fastapi) ([Markdown](https://aitinkerers.org/technologies/fastapi.md)) — 181 public demos
- [React](https://aitinkerers.org/technologies/react) ([Markdown](https://aitinkerers.org/technologies/react.md)) — 220 public demos
- [MCP](https://aitinkerers.org/technologies/mcp) ([Markdown](https://aitinkerers.org/technologies/mcp.md)) — 129 public demos
- [Next](https://aitinkerers.org/technologies/next) ([Markdown](https://aitinkerers.org/technologies/next.md)) — 186 public demos
- [OpenAI API](https://aitinkerers.org/technologies/openai-api) ([Markdown](https://aitinkerers.org/technologies/openai-api.md)) — 520 public demos
- [Bun](https://aitinkerers.org/technologies/bun) ([Markdown](https://aitinkerers.org/technologies/bun.md)) — 19 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 174 public demos
- [Claude API](https://aitinkerers.org/technologies/claude-api) ([Markdown](https://aitinkerers.org/technologies/claude-api.md)) — 21 public demos
- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 215 public demos
- [CLI](https://aitinkerers.org/technologies/cli) ([Markdown](https://aitinkerers.org/technologies/cli.md)) — 9 public demos
- [Codex](https://aitinkerers.org/technologies/codex) ([Markdown](https://aitinkerers.org/technologies/codex.md)) — 44 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 147 public demos
- [Flask](https://aitinkerers.org/technologies/flask) ([Markdown](https://aitinkerers.org/technologies/flask.md)) — 24 public demos
- [FTS5](https://aitinkerers.org/technologies/fts5) ([Markdown](https://aitinkerers.org/technologies/fts5.md)) — 2 public demos
- [Gemini](https://aitinkerers.org/technologies/gemini) ([Markdown](https://aitinkerers.org/technologies/gemini.md)) — 188 public demos
- [LangGraph](https://aitinkerers.org/technologies/langgraph) ([Markdown](https://aitinkerers.org/technologies/langgraph.md)) — 67 public demos

## More Results

- Next: https://aitinkerers.org/technologies/sqlite.md?page=2