# React Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/react?page=3
> Markdown URL: https://aitinkerers.org/technologies/react.md?page=3
> Technology record last updated: 2026-09-18T15:13:52Z
> Generated: 2026-09-21T04:44:49Z

React is an open-source JavaScript library for building dynamic user interfaces (UIs).

React is a component-based JavaScript library, developed by Meta (Facebook), engineered for building fast, declarative UIs. It mandates a one-way data flow and utilizes a Virtual DOM mechanism to ensure efficient, predictable updates to the user interface. Developers construct complex UIs by composing small, encapsulated components; this architecture promotes code reusability and simplifies state management across large applications. The library employs JSX (a syntax extension) to integrate HTML-like markup directly within JavaScript logic, supporting development for both web (React DOM) and native mobile platforms (React Native).

- Official technology site: https://react.dev/
- Public AI Tinkerers demos and talks: 219
- Result page: 3 of 10

## Recent Public Talks and Demos

### [How I Built a Presentation Coaching App in 4 days — With AI as My Engineering Partner](https://hong-kong.aitinkerers.org/talks/rsvp_XloItk_-8gA)

After Chinese New Year this year, I was preparing to teach two modules in the Masters of Economics programme at The University of Hong Kong. My sessions aren't lectures. They involve constant class interaction — students learning by doing, presenting, and getting real-time feedback. Four days before I was due to teach Effective Public Speaking on February 23rd, a thought hit me: what if there was an app for this? Not a slide deck. Not a worksheet. A proper interactive platform that could guide students through the entire process of building a presentation — from structuring their argument to generating slides. That idea became SpeakReady. ## The Approach: Discipline First, Speed Second I could have hacked something together over a weekend. Instead, I chose to treat this like a professional software project — and used AI as my development partner to make that possible. The technology behind SpeakReady is modern (Next.js, React, TypeScript, Firebase, OpenAI), but the real story isn't the tech stack. It's the engineering discipline I was able to maintain, even as a solo builder working at speed. Every feature followed the same rigorous process: define requirements, design the solution, write tests, build it, scan it for quality issues, and ship it through a proper pipeline. AI didn't replace that discipline — it made it achievable. ## Discovery Before Code Before a single line of code is written for any feature, the process starts with discovery. I write detailed design documents that explore the problem, propose two or three architectural approaches with trade-offs, and arrive at a recommended solution. These aren't vague briefs — they specify API contracts, data flows, component hierarchies, and error handling strategies. For example, when I built the AI Wand feature (a button that helps students generate content for any text field using context from their previous work), the design document defined the API request and response shapes, the prompt engineering strategy, rate limiting rules, and exactly how the feature would integrate with five different form types — all before implementation began. Every design document is committed to the repository alongside the code it describes. Requirements aren't lost in chat threads or email chains. They live with the project. ## Testing as a First-Class Citizen Quality isn't something I bolt on at the end. The project uses three layers of quality assurance. **BDD Feature Files.** Every major feature is described in plain-English Gherkin scenarios before development starts. Statements like *"Given I have a team project, When I click Invite, Then I should see the member with Pending status"* define exactly what success looks like — in language anyone can read and validate. **End-to-End Tests.** Fourteen Playwright test suites cover the application's critical flows: authentication, the student dashboard, admin functions, framework forms, AI generation, team collaboration, mobile responsiveness, and more. These tests run against real Firebase emulators, testing the full stack from browser to database. **SonarQube Scans.** Every change is scanned for code quality, security vulnerabilities, and maintainability issues. The scanner analyses the TypeScript source code and flags anything that falls below professional standards. ## Git as the Backbone The project uses Git not just for version control, but as an orchestration layer. Each feature is developed in an isolated worktree — a completely separate working copy of the codebase — so multiple features can progress in parallel without interfering with each other. Branches map to issues. Design documents, feature files, and implementation code all flow through the same pipeline: branch, build, test, review, merge. At last count, the project had managed over twenty parallel worktrees across its development history. That's a level of organisational rigour that would be impressive for a team. For a solo builder with AI assistance, it's transformative. ## What This Means for You You don't need to be a software engineer to take something away from this story. The barrier to building real, professional-quality tools has dropped dramatically. What matters now isn't whether you can write code — it's whether you can clearly define what you want, insist on quality at every step, and use AI to bridge the gap between idea and execution. Four days before I walked into a classroom at HKU, SpeakReady was just a thought. The discipline made it real. The AI made the discipline possible.

- Event context: AI Tinkerers Hong Kong GBA at the Hive: Creative AI Demos & Technical Show-and-Tell — 2026-03-26 — Hong Kong
- Public talk page: https://hong-kong.aitinkerers.org/talks/rsvp_XloItk_-8gA

### [Solving Cold Start GTM with Claude Code (and Zero Headcount)](https://seattle.aitinkerers.org/talks/rsvp_saEaMuqlges)

Loupe is a luxury watch market intelligence and tool platform designed for collectors and dealers. With a one-person team and Claude Code, we ship SEO landing pages, Instagram content (carousels, reels, stories), editorial guides, across 22+ watch brands, all from CC. In this demo, I'll walk through the actual workflows: how a single CLI session can research a topic, query Supabase for watch data, generate templated visuals with Puppeteer, compose ffmpeg reels with Ken Burns and transition effects, and push a finished landing page and associated Instagram reel to production. Leveraging Claude Code with custom slash commands, custom MCP integrations, and a growing skills library that turns repetitive GTM work into repeatable pipelines. I'll show the real session transcripts, the messy iterations, and the parts that broke. Leveraging this method, we've grown from 0 to 100 followers in a week.

- Event context: AI Tinkerers Seattle: GTM Track — March — 2026-03-26 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_saEaMuqlges

### [Miró: Synthetic Audience Analysis using LLM Agents and Graph Database](https://manizales.aitinkerers.org/talks/rsvp_QJ7Kot1_hP8)

In this demo, I will do a code deep-dive into "Miró", an engine I built to forecast the social and critical reception of upcoming books using synthetic readers. Instead of a product pitch, I will focus entirely on the technical architecture and the integration layer between LLMs and Graph Database. I'll walk through the code live, showing: Agent Generation Pipeline: How I parse static PDFs containing psychological profiles and translate them into "Synthetic Reader" nodes with their respective master prompts. The Predictive Engine: The orchestration code that drives how agents "read" the book, interact with each other, and how these interactions continuously update the graph database state. Graph-based Memory Management: A look into how I solved the challenge of persistent agent memory by dynamically creating complex relationships (such as CHATTED_ABOUT) and appending conversation histories as extendable edge properties using RAG. Analysis Dashboard: A quick look at how the Python backend consumes this dynamic graph network to feed an interactive react frontend, rendering resonance, friction, and abandonment connections.

- Event context: 🚀 ¡14vo Encuentro de AI Tinkerers Manizales! 🤖 — 2026-03-25 — Manizales
- Public talk page: https://manizales.aitinkerers.org/talks/rsvp_QJ7Kot1_hP8

### [\[UofT\] Give Your Local File System Memory - Intelligent Document Reference](https://toronto.aitinkerers.org/talks/rsvp_xdm4yT8hgkU)

Our application is an intelligent document search and question-answering system designed to help users quickly find information within their personal files. Instead of relying on file names or exact keyword matches, the system analyzes the actual content of documents and allows users to search using natural language queries. The application automatically indexes files from the user’s file system, extracts their content, and organizes the information in a way that makes it easy to retrieve later. When a user asks a question or searches for a topic, the system identifies the most relevant files and sections of text, then returns either the file paths or a summarized answer supported with citations to the original documents. The system supports multiple file formats, including documents, spreadsheets, images, and text files, enabling users to search across different types of data in one place. By combining semantic search with AI-powered reasoning, the application helps users navigate large collections of files more efficiently and quickly locate the information they need.

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

### [Experience Vibing with metaMe](https://nyc.aitinkerers.org/talks/rsvp_fPIx41io4cs)

metaMe is a registry-driven agent runtime and studio that dynamically composes AI interfaces and experiences from structured context rather than fixed screens. For the demo, I’ll show how the metaMe Runtime, Studio, and Registry work together to generate live experience surfaces based on three active layers of context: persona, agent/model, and cartridge/codex. Instead of treating UI as a hardcoded frontend, the system resolves registry-defined primitives, policies, and active agents into runtime behavior such as smart menus, prompt surfaces, trust indicators, and domain-specific experience states. The demo will focus on the implementation: how context is modeled, how the runtime is hydrated, how dynamic rendering decisions are made, and how secure agent/tool execution is routed.

- Event context: March Demo Day, hosted by Flowglad — 2026-03-18 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_fPIx41io4cs

### [How to Raise Seed, VC or EU Grant Money Fast — And the Solutions I'm Building to Speed Up Money in Europe](https://valencia.aitinkerers.org/talks/rsvp_-XYoYU91Rc8)

In Europe we have a problem on many planes: bureaucracy, lack of know-how about how money actually moves, what VCs look like, how to become investable, how to find hubs and get exposure for your traction. I'll break down the landscape and show the tools I'm building at EUACC.AI to help accelerate Europe. I'll explain how I fine-tuned my model to be hyper-competent at writing grant applications using agentic tool calling and a new skill training environment called Dojo.md, how it works, and how you could build something similar for your own domain.

- Event context: AI Tinkerers Valencia March Meetup — 2026-03-17 — Valencia
- Public talk page: https://valencia.aitinkerers.org/talks/rsvp_-XYoYU91Rc8

### [Building a Live Digital Ecosystem Intelligence Layer (DEIP.app)](https://valencia.aitinkerers.org/talks/rsvp_0XSNT1ucZeg)

Most companies don’t actually know how their digital ecosystem works - they just use tools. In this demo, I’ll show how I’m building DEIP.app - a live intelligence layer that maps tools, costs, dependencies, data flows, and AI agents into a structured system that both humans and AI can understand. I’ll walk through: - The data model (how tools, services, AI, Workflows, people, and costs are structured) - How I built the hierarchy (categories → subcategories → items → relations) - How cost calculations work - How I connect it to AI agents via MCP/APIs - How relations are visualized (1D lists → 2D maps → 3D/VR maps) - How does this becomes usable context for AI systems

- Event context: AI Tinkerers Valencia March Meetup — 2026-03-17 — Valencia
- Public talk page: https://valencia.aitinkerers.org/talks/rsvp_0XSNT1ucZeg

### [Turning Claude Code into a Self-Improving Agentic Development Platform](https://orange-county.aitinkerers.org/talks/rsvp_iO2rjPLhMOE)

Every AI coding session is a chain-of-thought reasoning trace — step-by-step problem solving with verifiable outcomes. BashGym captures these traces and uses them to train a reasoning language model with the same techniques behind frontier RLMs: GRPO for reinforcement learning, RLVR for verifiable reward signals from test results, and distillation to transfer reasoning from a large teacher into a small local model. The result is a personal RLM trained on how you actually think through code — your conventions, your repos, your patterns.

- Event context: AI Tinkerers OC - March 11, 2026 Meetup — 2026-03-12 — Orange County
- Public talk page: https://orange-county.aitinkerers.org/talks/rsvp_iO2rjPLhMOE

### [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

### [Code > Prompts: Why Your Agent Should Think in Code, Not English](https://seattle.aitinkerers.org/talks/rsvp_Sx9TEh092FI)

What if your agent's "reasoning" was code, not English? Live code walkthrough: I'll build two agents side-by-side, a standard ReAct tool-caller and one using OpenSymbolicAI, where the LLM's job isn't to "reason" in English, it's to emit typed execution plans as Python. Same model, same tools, same question. You'll watch the ReAct agent burn tokens re-reading its own verbose reasoning while the behavioral agent plans once and executes deterministically. Then I'll add 17 lines of code live and turn a failing agent into one that wins the race. No slides.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — March 9th, 2026 — 2026-03-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_Sx9TEh092FI

### [Local LLMs, Free Guy and Text Adventure Games](https://columbus.aitinkerers.org/talks/rsvp_RMcE14lZOPg)

Watching a Guy Royse talk at CodeMash this year sparked ideas of how far a local LLM could go to both run and build a text-based adventure game generator. Using Cursor, I am building a web editor for building your worlds filled with AI generation of every aspect of the game. Demoing the world, we will modify to show you can play those changes and interact (and watch the LLM create interactive objects that you didn’t build in).

- Event context: AI Tinkerers - Columbus March Meetup — 2026-03-02 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_RMcE14lZOPg

### [wayyOS ~ agentic swarm management in a desktop environment](https://nyc.aitinkerers.org/talks/rsvp_IrbSmsOYhnI)

We’re building and we want to share our openClaw hack show. Come one and all to see what windows 95 would have looked like if it was running an agentic swarm We will discuss architecture, global context management, interAi-synchronicity (messaging), and much more

- Event context: 🦞ClawHack NY with Convos, ft ElevenLabs, Convex, & more — 2026-02-28 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_IrbSmsOYhnI

### [From Tool Call to React Component: Building Generative UI for Agentic Workflows](https://san-diego.aitinkerers.org/talks/rsvp_d-XLZk6YEb8)

Live demo of a production pattern where AI agents render interactive React components — forms, profile cards, video embeds — directly inline in chat instead of returning plain text. I'll trigger real agent workflows, show the components appearing in the conversation stream, and walk through the completion callback loop where user interaction feeds back into the agent. I'll close with how we codify these multi-step integration patterns as reusable Agent Skills to ship new tools fast.

- Event context: AI Tinkerers San Diego: February Meetup at Google — 2026-02-27 — San Diego
- Public talk page: https://san-diego.aitinkerers.org/talks/rsvp_d-XLZk6YEb8

### [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

### [Get Shit Done: De idea a SaaS en producción en 7 días con Claude Code](https://bogota.aitinkerers.org/talks/rsvp_Ibf98jRs5c4)

Voy a mostrar cómo construí KeepItX — una plataforma SaaS para captura colaborativa de fotos en eventos — en exactamente una semana usando el framework "Get Shit Done" y Claude Code como mi copiloto de desarrollo. Voy a hacer un walkthrough del código real: la arquitectura Next.js + Supabase, cómo estructuré los prompts y sesiones con Claude Code para maximizar velocidad, las decisiones técnicas que tomé (y las que delegué al AI), y el flujo completo desde el primer commit hasta tener usuarios reales pagando $99 por evento. Sin slides, puro código y terminal.

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

### [Grok like system but home made](https://montreal.aitinkerers.org/talks/rsvp_4jmt53Nli5M)

Scrappy implementation of how you can use tool base model to fetch from database / web url or even other to enable end user into a SQL like language for your own workflow in simple

- Event context: AI Tinkerers Montreal - February 2026 Meetup — 2026-02-24 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_4jmt53Nli5M

### [I built a browser that works without tabs](https://la.aitinkerers.org/talks/rsvp__xNwjDh60CI)

A browser without tabs? Yes, imagine a big canvas, like figma but the rectangles are actually chat windows, text editors, images, and regular browser windows. Everything is observed by a cognitive layer (called the "canopy") that gets all user-interactions at runtime and models the user behavior to create propositions. The founders vision on how AI-native operation systems can look like: https://disambiguate.substack.com/p/ai-wants-to-be-connective-tissue

- Event context: AI Tinkerers LA: February Builder Meetup & Live Demos — 2026-02-24 — Los Angeles
- Public talk page: https://la.aitinkerers.org/talks/rsvp__xNwjDh60CI

### [Using AI to make the science behind Kabuki Syndrome more accessible](https://boston.aitinkerers.org/talks/rsvp_JYH_omkmLYc)

Kabuki Syndrome is a rare disease affecting 1 in 32,000 births. There is currently no cure, but there is a fair clip of research being conducted and published every month. As a parent of a child with Kabuki, I have long struggled to read and comprehend the dense, jargon-filled academic papers that report on this research, despite my great curiosity. Due to the rarity of the condition, there is little to no journalistic reporting on these kinds of academic papers. I will share a project I'm working on that is intended to bridge that gap with AI, using the latest LLMs to craft stories more accessible to the broader Kabuki community. In the demo I will show how I use AI to break down the papers into their individual claims, then how I transform those claims, using multiple prompts and workflows, into easy-to-read plain english versions. These plain-english versions live in a UI that has two goals. One is to be polished and reader-friendly, up to the standard of a national magazine, with subheaders, pull quotes, etc. Another is to provide an inline interactive lens onto the original text of the article, with individual sentences that can morph to show the claims and sentences in the original paper they are based on.

- Event context: {Cancelled due to Blizzard Warning } AI Tinkerers Boston: February 2026 Meetup — 2026-02-23 — Boston
- Public talk page: https://boston.aitinkerers.org/talks/rsvp_JYH_omkmLYc

### [OpenClaw-Powered Port: Turning a Figma Plugin into a Standalone Web App with Claude + Grok](https://tokyo.aitinkerers.org/talks/rsvp_WdjiLvvXPiU)

I'll demo how I migrated Humation — a hand-drawn avatar system used by 60k+ people — from Figma Plugin to standalone web app using ONLY AI agents via OpenClaw (Claude Opus + Grok). No manual coding: I'll live-show the prompts, iterative generations, debugging hacks, SVG handling quirks, performance fixes, and unexpected failures/successes that made it work. Core logic remains simple part-layering, but AI handled the entire porting chaos.

- Event context: AI Tinkerers Tokyo - Toranomon Meetup - February 19, 2026 — 2026-02-19 — Tokyo
- Public talk page: https://tokyo.aitinkerers.org/talks/rsvp_WdjiLvvXPiU

### [Claude in the Channel: Building an Autonomous Frontend Agent for No-Code Teams](https://tokyo.aitinkerers.org/talks/rsvp_ILK68XIsX3A)

I’ll demonstrate how I turned a Slack channel into a functional "Frontend Desk" where designers and admin staff ship production code without touching an IDE, or having to pay for a no-code platform or a content delivery network (CDN). The system connects a Slack bot to a Claude-powered agent sitting on a server with a live clone of our React/Vite/Tailwind repository. I’ll walk through the technical plumbing that allows the bot to: * Ingest design specs and SVGs directly from Slack threads. * Contextualize those assets within a complex codebase to perform precise UI updates. * Trigger a password-protected staging environment for instant visual feedback. * Execute a `/approve` flow that handles the merging and deployment to GitHub Pages.

- Event context: AI Tinkerers Tokyo - Toranomon Meetup - February 19, 2026 — 2026-02-19 — Tokyo
- Public talk page: https://tokyo.aitinkerers.org/talks/rsvp_ILK68XIsX3A

### [Building a 32-Character Murder Mystery Game Generator](https://valencia.aitinkerers.org/talks/rsvp_JIVtHp5Lz5M)

I'll walk through building a production murder mystery generator that creates full games with 6-32 characters using Claude's API. The talk covers the real costs and constraints of AI at scale, my automation architecture using Make.com for orchestration, and the specific technical challenges I hit when generating complex JSON structures for game content. I'll show the actual webhook flows, how I handle character generation failures, and my debugging approach when Claude outputs invalid JSON that breaks the entire workflow.

- Event context: AI Tinkerers Valencia February Meetup — 2026-02-17 — Valencia
- Public talk page: https://valencia.aitinkerers.org/talks/rsvp_JIVtHp5Lz5M

### [Breaking free from the chat box](https://valencia.aitinkerers.org/talks/rsvp_CUsWcGBWN20)

AI has the potential to be far more powerful than a simple chat interface. Applications are already starting to be appear that do this, but how can we take it to the next level? At Legala, the application needs to enable the user to enter complex information in a structured way. A dynamic interface driven by interaction with an AI agent can enable this. The demo will cover the cycle of response to a user message, include user intent inference, mode switching, tool use, and dynamic UI generation and presentation.

- Event context: AI Tinkerers Valencia February Meetup — 2026-02-17 — Valencia
- Public talk page: https://valencia.aitinkerers.org/talks/rsvp_CUsWcGBWN20

### [Radiology Lab - Medical Imaging Segmentation Lab](https://raleigh.aitinkerers.org/talks/rsvp_M1DsMV5sU6A)

An early preview of a web application built to create segmentation and 3D modeling training data directly within research and clinical workflows in Medical Imaging, using SAM3 and Gaussian Splatting APIs. It supports multiple imaging modalities; including Cardiac MRI, Cardiac CT, CCTA, and Brain MRI. This training data can be quickly plugged in to fine-tune or build machine learning models, which can loop back into the web application. Creating an iterative cycle of improving machine learning models, segmentations and 3D models across all modalities in Medical Imaging.

- Event context: AI Tinkerers Raleigh Meetup — February 11, 2026 — 2026-02-11 — Raleigh
- Public talk page: https://raleigh.aitinkerers.org/talks/rsvp_M1DsMV5sU6A

### [Solibox](https://conakry.aitinkerers.org/talks/rsvp_qAI5FNo6z5g)

Transformez votre surplus solaire en revenus Avec SoliBox, l'électricité que vous n'utilisez pas alimente vos voisins et vous génère un revenu passif.

- Event context: AI Tinkerers – Conakry: Inaugural AI Conference @ Afrinov Tech Expo — 2026-02-11 — Conakry
- Public talk page: https://conakry.aitinkerers.org/talks/rsvp_qAI5FNo6z5g

## 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
- [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
- [Node](https://aitinkerers.org/technologies/node) ([Markdown](https://aitinkerers.org/technologies/node.md)) — 99 public demos
- [PostgreSQL](https://aitinkerers.org/technologies/postgresql) ([Markdown](https://aitinkerers.org/technologies/postgresql.md)) — 105 public demos
- [Supabase](https://aitinkerers.org/technologies/supabase) ([Markdown](https://aitinkerers.org/technologies/supabase.md)) — 90 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 173 public demos
- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 214 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 147 public demos
- [Gemini](https://aitinkerers.org/technologies/gemini) ([Markdown](https://aitinkerers.org/technologies/gemini.md)) — 188 public demos
- [LangChain](https://aitinkerers.org/technologies/langchain) ([Markdown](https://aitinkerers.org/technologies/langchain.md)) — 445 public demos
- [GPT-4](https://aitinkerers.org/technologies/gpt-4) ([Markdown](https://aitinkerers.org/technologies/gpt-4.md)) — 529 public demos
- [Vite](https://aitinkerers.org/technologies/vite) ([Markdown](https://aitinkerers.org/technologies/vite.md)) — 17 public demos
- [MongoDB](https://aitinkerers.org/technologies/mongodb) ([Markdown](https://aitinkerers.org/technologies/mongodb.md)) — 15 public demos
- [Ollama](https://aitinkerers.org/technologies/ollama) ([Markdown](https://aitinkerers.org/technologies/ollama.md)) — 77 public demos
- [OpenAI](https://aitinkerers.org/technologies/openai) ([Markdown](https://aitinkerers.org/technologies/openai.md)) — 112 public demos

## More Results

- Previous: https://aitinkerers.org/technologies/react.md?page=2
- Next: https://aitinkerers.org/technologies/react.md?page=4