# Embeddings Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/embeddings
> Markdown URL: https://aitinkerers.org/technologies/embeddings.md
> Technology record last updated: 2026-02-25T10:17:42Z
> Generated: 2026-09-20T21:48:51Z

Embeddings are dense, low-dimensional vectors that translate complex data (text, images, audio) into a mathematical space, enabling machines to process and understand semantic relationships.

Embeddings are the crucial machine learning technique for transforming discrete data (like words or images) into continuous, dense vectors of real numbers. This vectorization maps objects into a high-dimensional space where proximity directly correlates with semantic similarity: closer vectors mean more related objects. For example, a BERT model might generate a 768-dimensional vector for a sentence, capturing its full context. This is foundational for AI applications, including semantic search, where a query vector finds document vectors that are mathematically near, and for recommendation systems, which use vector distance to suggest similar items. The entire process is learned via neural networks (e.g., Word2Vec, GloVe), automating the capture of complex, nuanced relationships in the data.

- Official technology site: https://www.ibm.com/topics/embedding
- Public AI Tinkerers demos and talks: 22
- Result page: 1 of 1

## Recent Public Talks and Demos

### [Orquestração multi-agente em n8n: sub-workflows virando tools dinâmicas](https://curitiba.aitinkerers.org/talks/rsvp_F61Msr-AenQ)

Construí um sistema multi-agente que opera o assistente de WhatsApp de uma marca brasileira de suplementos "clean label" com catálogo de 20+ SKUs em 8 categorias (sono, estética, emagrecimento, imunidade, saúde feminina 40+, entre outros) e dois canais ativos de WhatsApp para quiosque físico e delivery. O problema real: volume de perguntas simultâneas sobre produtos específicos (composição, indicação, contraindicação, disponibilidade), mix de intenções radicalmente diferentes: consumidora final comprando pela primeira vez, cliente em recompra, nutricionista prescrevendo e a necessidade de escalar atendimento sem perder o tom consultivo que a marca construiu. Em vez de LangGraph ou CrewAI, usei n8n como orquestrador e Claude como motor de decisão. Mensagens chegam via Evolution API num webhook do n8n; o Claude classifica a intenção (tool use) e roteia para a tool certa; mas cada "tool" é um sub-workflow n8n separado, chamado via Execute Workflow. Cada sub-workflow tem seu próprio prompt, seu próprio acesso ao Supabase (RAG sobre o catálogo completo com pgvector, histórico de pedidos, perfil do cliente) e seu próprio guard-rail. Quando a confiança do Claude cai especialmente em perguntas clínicas sobre contraindicações, o agente passa para humano via Chatwoot. Tudo self-hosted na Hetzner (Docker Swarm + Traefik). Na demo ao vivo mostro: uma mensagem real chegando no WhatsApp, o painel do n8n executando nó a nó, o sub-workflow correto ativando como tool, e os logs no Supabase. Compartilho o padrão "sub-workflow-as-tool" e o JSON exportado.

- Event context: AI Tinkerers Curitiba: Evento Inaugural — 2026-06-10 — Curitiba
- Public talk page: https://curitiba.aitinkerers.org/talks/rsvp_F61Msr-AenQ

### [Building Document Consciousness: How I Taught Gemini to Think in 6 Dimensions](https://san-diego.aitinkerers.org/talks/rsvp_CuPjQckMXvM)

I'll demo Clasio, a document intelligence platform I built solo on a 100% Google Cloud stack, showing how I use Gemini 2.5 Flash (extensible to Gemini 3 in a few keystrokes) to extract what I call "6D Document Consciousness" - analyzing every uploaded document across What, Who, When, Where, Why, and How dimensions simultaneously. I received $25K in credits from Google Cloud for Startups for Clasio. The technical meat of the talk: - How I built an async AI queue that processes 25 documents in 75 seconds using 30 parallel Gemini workers on Cloud Run - The structured extraction prompt engineering that gets Gemini to reliably output 6D consciousness JSON (and what failed before it worked) - A 6-tier search waterfall that goes from exact consciousness match down to fuzzy vector similarity using pgvector on Cloud SQL - returning direct answers, not document lists - How I handle connection pool management when you have 30 concurrent Gemini API calls each taking 2-10 seconds (spoiler: release the DB connection before the API call, not after) - Live demo: upload a stack of immigration documents and watch the system classify, extract entities, detect deadlines, and answer natural language questions in real time This is a solo founder build - no team, no VC money, just a product person who learned TypeScript and shipped to production on GCP.

- 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_CuPjQckMXvM

### [How We Build Pipelines to Detect Product Issues and Fix Them with Coding Agents](https://prague.aitinkerers.org/talks/rsvp_C35CGsy9rLA)

I'll walk through how we built a pipeline that detects product issues from multiple data sources (session recordings, error logs, support tickets, LLM traces) and routes them to coding agents that generate PRs. * Step 1: Signal. Render videos from session recordings, transcribe them, and analyze, searching for issues. * Step 2: Cluster. Group signals from different sources and decide what’s worth fixing. * Step 3: Code. Preview of Twig ADE (AI Development Environment), where confirmed tasks get handed off to coding agents.

- Event context: Product Engineering: Apify x PostHog — 2026-02-26 — Prague
- Public talk page: https://prague.aitinkerers.org/talks/rsvp_C35CGsy9rLA

### [Oracle & NVIDIA AI‑Q: A Blueprint for High‑Performance Research Automation](https://singapore.aitinkerers.org/talks/rsvp_M4Vy0ySvk_Y)

Oracle & Nvidia will be presenting a technical deep-dive demo of an AI Research Assistant built using the NVIDIA AI‑Q blueprint approach, implemented with an enterprise-grade Oracle + NVIDIA stack—using Oracle Database 26ai as the system of record for vectors and retrieval, and NVIDIA’s accelerated AI software for embedding, retrieval optimization, and inference. At a high level, this presentation shows how to build and run a production-ready Retrieval-Augmented Generation (RAG) + agentic workflow where: Enterprise documents are ingested and embedded, using NVIDIA’s AI software stack (including NIM microservices and retrieval components). Embeddings are stored directly inside Oracle Database 26ai using its native VECTOR data type—so we don’t need a separate vector database. Semantic retrieval happens in Oracle Database 26ai using SQL (AI Vector Search), enabling vector similarity search combined with enterprise relational filters and governance. The retrieved context is then fed into a reasoning model to generate grounded answers and structured insights. What the Audience Will Learn / Take Away 1) How Oracle + NVIDIA changes enterprise AI architecture NVIDIA AI Enterprise is available natively through the OCI Console, reducing friction in provisioning AI software and accelerating adoption. Oracle and NVIDIA are co‑engineering deeper integrations, including NVIDIA NIM microservices support and NeMo Retriever integration with Oracle Database 26ai, enabling smoother RAG pipelines. 2) Why Oracle Database 26ai is a key differentiator for RAG Instead of deploying a separate vector DB, I’ll show how Oracle Database 26ai provides AI Vector Search directly inside the database, using the VECTOR data type—letting teams store embeddings next to business data and query semantically in SQL. 3) How to build a faster, simpler, more governable RAG workflow The demo will highlight architectural improvements that enterprise teams care about: - fewer moving parts, - less data duplication, - simpler security and governance patterns, - and a clean operational model that aligns with existing Oracle enterprise data platforms. What we’ll Show in the Demo (Step-by-Step) - Document ingestion (technical PDFs and enterprise materials) - Embedding generation using NVIDIA-optimized AI tooling (NIM microservices / retrieval stack). - Semantic retrieval using Oracle AI Vector Search in SQL (top‑K similarity search + filters). - Answer generation using reasoning over retrieved context

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

### [Más allá del RAG: Grafos universales para datos no universales](https://santiago.aitinkerers.org/talks/rsvp_Ic5kPKxkc3I)

Hoy, la mayoría de los sistemas de information retrieval usan arquitecturas tipo RAG o GraphRAG: se basan en búsqueda semántica, embeddings y modelos de lenguaje para recuperar información relevante.

- Event context: Estructura, Risa y Ecosistemas: el nuevo ADN de la IA Chilena — 2025-10-29 — Santiago
- Public talk page: https://santiago.aitinkerers.org/talks/rsvp_Ic5kPKxkc3I

### [🎹🎻🎸 Searching for similar music tracks 🎼🎶](https://paris.aitinkerers.org/talks/rsvp_meD97sDCnH4)

In this session, we will use the principles of vector search to find pieces of music that are (maybe) similar to others.

- Event context: AI Tinkerers - Paris Meetup on January 30th — 2025-01-30 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp_meD97sDCnH4

### [Bootstrapping products that create order from chaos with AI](https://portland.aitinkerers.org/talks/rsvp_bzKW_dQ4M0w)

I present a novel embeddings-based visualization technique to reveal the structure in your unstructured data, and tell the story of how I arrived at it by bootstrapping two AI products. Along the way I tell the story of our community driven development and how it's shaped our work.

- Event context: Portland Women AI Entrepreneurs and Free AI MVP Class / Workshop — 2025-01-29 — Portland
- Public talk page: https://portland.aitinkerers.org/talks/rsvp_bzKW_dQ4M0w

### [NParks Camera Trapping Video Animal Recognition, Using Foundational Models' Embeddings for Zero-shot Classification](https://singapore.aitinkerers.org/talks/rsvp_D3CY7_XnQlI)

As part of Singapore National Park's Youth Stewards for Nature 2024 volunteer program, we built a system to recognize animals in camera trapping videos. In addition to fine-tuning a supervised trained model, we were able to use Foundational Models' zero-shot learning capability to classify frames. This method is competitive with supervised finetuning on a large amount of in-domain data, while requiring no training, and re-formulating the model training task into a data curation task, making it more accessible to the laymen.

- Event context: AI Tinkerers Singapore: 4th Meetup - January 10th, 2025 — 2025-01-10 — Singapore
- Public talk page: https://singapore.aitinkerers.org/talks/rsvp_D3CY7_XnQlI

### [Covariate Search](https://hong-kong.aitinkerers.org/talks/rsvp_bHTSKW0CfRo)

The first practical application of covariate search (with the potential of revolutionizing the search industry) by introducing a new modality. In the demo I am showcasing how we can vectorize a set of keywords semantically and perform a search on other sets (this is not currently possible with semantic search).

- Event context: AI Tinkerers - Hong Kong Meetup (December) - Inauguration — 2024-12-19 — Hong Kong
- Public talk page: https://hong-kong.aitinkerers.org/talks/rsvp_bHTSKW0CfRo

### [AI Fashion assistant](https://paris.aitinkerers.org/talks/rsvp_a18BJzmpnyY)

AI fashion personal shopper for flexible contextual search and product recommendation

- Event context: AI Tinkerers - Paris Meetup on December 10th — 2024-12-10 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp_a18BJzmpnyY

### [Steering LLMs and Embeddings with SAEs](https://mumbai.aitinkerers.org/talks/rsvp_pYismAp8lgc)

In this demo, we'll explore how Sparse Autoencoders (SAEs) can be utilized to steer Large Language Models (LLMs) and their embeddings. By leveraging tools like Goodfire's API and Google's Gemma Scope, we'll demonstrate how SAEs can interpret and modify the internal activations of LLMs, enabling precise control over their knowledge selection behaviors. This approach addresses challenges such as context-memory knowledge conflicts, enhancing the reliability and accuracy of AI-generated outputs.

- Event context: AI Tinkerers Mumbai Chapter - 2nd Event Incoming! — 2024-11-23 — Mumbai
- Public talk page: https://mumbai.aitinkerers.org/talks/rsvp_pYismAp8lgc

### [How great context selection leveled up Bismuth](https://sf.aitinkerers.org/talks/rsvp_RKZ7c8Zh1PE)

Bismuth is a coding agent that works right in your terminal. It can build projects from scratch, or work in well established projects to help boost productivity. Bismuth is able to automatically select the right context from projects (even some of the largest open source projects like Django), discover and run build commands on its own and complete development tasks without human interaction. The demo will be a live running of our project and talk through what is happening step by step as things run live, no slides! We plan to demo the file selection step, the code symbol selection step, how both of those steps seed our graph rag system for larger projects in our pipeline and how this all needs to come together to select the right file context for an agent to be able to implement a user's change request for a large open source project like Django so people can get a feel for the steps needed to search and build context for coding agents tackling large code projects. The audience will see visually our agent working on a system, side by side with the live backend logs showing all of these steps executing, including files selected, symbols selected, results from our rag system and then the execution and updates on the open source project with the ultimate result being a patch that applies the actual changes we're going to ask it to make for the demo. Then we'll switch to our project and dive in to the specific implementation code in our IDE for each step to understand what design considerations we had to make to make that all happen. This includes considerations like, what model are we using to vectorize the code, what libraries are we using the build our graph rag system since it is all homegrown, were there any optimization issues we ran into (spoilers there were) and explaining wow are we doing all of our code analysis and how much of it is custom knowledge versus how far can you get off the shelf and what tools we can suggest their like TreeSitter. This demo will include how we handle Bismuth's context selection which includes a bunch of custom code parsing, file selection, AST breakdown and code symbol selection. This is a key piece of coding agents which all begin with selecting the right context based on the users request.

- Event context: AI Tinkerers - San Francisco - November 2024 Meetup - Securing Agentic Systems — 2024-11-22 — San Francisco
- Public talk page: https://sf.aitinkerers.org/talks/rsvp_RKZ7c8Zh1PE

### [How we dealt with ambient agent system concurrency issues at Revo.pm](https://palo-alto.aitinkerers.org/talks/rsvp_j901dzJ13l8)

# Managing Concurrency in LLM-powered Ambient Agents ## Introduction - Brief intro to Revo.pm: "We're building an ambient AI Copilot powered by LLMs" - Core challenge: "LLMs need uninterrupted context to maintain coherent reasoning, but our agent handles multiple concurrent events" ## The Problem: LLM Context Management ### Real-world Example - "Let me show you how LLM context gets corrupted..." - Demo scenario: Website monitoring + reminder conflict - Highlight the LLM-specific failures: - Context window pollution from parallel requests - Chain-of-thought reasoning breaks - Token waste from repeated prompting - Example prompt corruption: ```text Initial prompt: "Monitor website hourly..." Corrupted context: [Previous reminder data mixed in] Result: LLM loses track of original task ``` ## Our Solution: LLM-aware Concurrency ### 1. Intelligent Lock System with Context Preservation ```python # Show the lock acquisition with LLM context management Log.Information("acquiring lock for {@llmContext}", ctxLogObject); await using var @lock = await context.AcquireLock(copilot, cancellationToken); // Preserve LLM conversation history and embeddings await context.PreserveLLMState(copilot.CurrentConversation); ``` - Key point: "Maintains clean LLM context for each interaction" ### 2. LLM-aware State Machine ```python public interface IRevoStateMachine { // State transitions consider LLM context Task Reduce(State currentState, RevoChainOfThought chainOfThought); // Handle different types of LLM interactions Task Reduce(State currentState, LLMResponse response); Task Reduce(State currentState, UserMessage message); } ``` - Demo: Show how state transitions preserve LLM reasoning ### 3. Chain of Thought Management ```python public interface IRevoChainOfThoughtProvider { // Manages LLM reasoning across events Task GetChainOfThought( IRevoState state, LLMContext context, CancellationToken cancellationToken = default ); } ``` - Demo the LLM reasoning flow: - Context window management - Embedding preservation - Multi-step reasoning across events ## Results & LLM Performance Monitoring - Show monitoring dashboard with LLM metrics: - Token usage optimization: - Before: 2.3M tokens/day wasted on context reloading - After: 850K tokens/day saved - Reasoning consistency: - 97% reduction in context-related reasoning failures - 99.9% task completion rate - Response latency: - 300ms average lock acquisition - No impact on LLM response time - Cost implications: - 40% reduction in token costs - Eliminated duplicate LLM calls ## Wrap-up & Questions - Core benefits for LLM systems: - Preserved reasoning chains - Optimized token usage - Reliable concurrent operations - Technical innovations: - LLM-aware state management - Context preservation system - Efficient token utilization ### Speaker Notes - Focus on LLM-specific challenges and solutions - Show real monitoring data when discussing metrics - Prepare for questions about: - LLM context window management - Token optimization strategies - Scaling with multiple LLM providers - Handling different types of LLM models - Cost optimization techniques - Have specific examples ready for: - Before/after prompts - Token usage graphs - Reasoning chain preservation

- Event context: AI Tinkerers - Palo Alto - November 2024 Meetup — 2024-11-21 — Palo Alto
- Public talk page: https://palo-alto.aitinkerers.org/talks/rsvp_j901dzJ13l8

### [Searching Millions of Tables with AI](https://nyc.aitinkerers.org/talks/rsvp_1hKK26gH1VY)

The challenges with AI data analysis mirror those of humans--the hard part is finding and prepping the data, and the analysis itself is the easy part. Current AI tech mostly relies on humans to deal with the hard part by constraining the scale to a handful of tables and requiring human curation via data warehouses, databases, and other tabular file formats. I'll demo a prototype I've built that discovers open datasets across the web & indexes them so that users (and AI agents!) can search across millions of tables/columns along dimensions like semantic similarity, joinability, data shape, data quality, etc.

- Event context: AI Tinkerers - New York City - November 2024 Meetup | Win Meta Ray-Bans — 2024-11-12 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_1hKK26gH1VY

### [WeMadeThis.World - A Collaborative Worldbuilding Tool](https://seattle.aitinkerers.org/talks/rsvp_K3PRH10O1WI)

I'm excited to present WeMadeThis.World, a web application and Discord bot that enables collaborative world-building through interactive role-play with a language model (LLM). Instead of having the LLM generate content, I've flipped the script to use it for extracting and organizing user-generated content through role-play sessions with an LLM-based interviewer. In this system, the AI prompts you! Live Demo Highlights: - Main Functionality: I'll demonstrate how users can jump into character and contribute to the world's lore, while the LLM extracts key "facts" in real-time. - Discord Bot Integration: I'll explore how the Discord bot brings this experience directly into Discord servers, making it easy for communities to engage. - Dynamic Wiki Showcase: I'll highlight the dynamically generated wiki that updates in real-time, showing how both the taxonomy and content evolve as users contribute. - Real-Time Fact Extraction: I'll run a large-scale fact extraction during the demo to showcase how the system efficiently handles extensive data inputs.

- Event context: AI Tinkerers - Seattle - October 2024 Meetup — 2024-10-25 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_K3PRH10O1WI

### [Layer](https://nyc.aitinkerers.org/talks/rsvp_HpxoqDDooHg)

Layer is a platform that enables companies who build APIs and SDKs to build their own VS Code extensions that make it easier for developers to use their product. The way our system works is our customers put in a link to their documentation, and we automatically crawl, scrape, and embed each of the pages into an AI Chat (RAG) system. We then have a deployment pipeline that deploys this AI chat system trained on the customers documentation to VS Code so that developers trying to integrate their products can easily ask questions and get relevant answers without having to leave their code editor.

- Event context: October Meetup at AI Tinkerers! — 2024-10-17 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_HpxoqDDooHg

### [From text to graph and back again, with entity extraction and GraphRAG Q&A.](https://berlin.aitinkerers.org/talks/rsvp_wnnCu9MBJ1g)

Usually you only see text + embeddings with LLMs but many advanced RAG patterns need more structure. In a knowledge graph you can represent that structure and use it to provide better context for Q&A. But how to get there from text documents? You can use the language skills of LLMs to extract entities and relationships from texts and store them in the graph connected to the original documents and chunks. The application and code I'll show will demonstrate how to get from text to graph to GraphRAG and I will highlight the good and the difficult aspects of this approach.

- Event context: Ollama & Friends coming to AI Tinkerers Berlin — 2024-07-18 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_wnnCu9MBJ1g

### [Hacker News search engine](https://berlin.aitinkerers.org/talks/rsvp_m12qQTo08cw)

I'm building a search engine for browsing Hacker News. Basically bringing together methods from data science and AI, using embeddings but also leveraging Llama models for text classification. This started as a data science project, which I'm now turning into a UI you can interact with. So a WIP, but I have a proof of concept. Added a link to the streamlit app I used to demo the data science part, as well as the repo where i'm working on the web app now.

- Event context: Ollama & Friends coming to AI Tinkerers Berlin — 2024-07-18 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_m12qQTo08cw

### [Semanticards](https://zurich.aitinkerers.org/talks/rsvp_fG0sWkGTeMc)

A hobby project that uses embeddings, vector similarity and user feedback to span a space of semantically correct answers for flashcards.

- Event context: AI Tinkerers Zurich - May 8 — 2024-05-08 — Zürich
- Public talk page: https://zurich.aitinkerers.org/talks/rsvp_fG0sWkGTeMc

### [How we build the next generation embeddings and rerank model](https://berlin.aitinkerers.org/talks/rsvp_3BFEbL0Qshs)

We build the SOTA rerank and embeddings model, which outperforms OpenAIs text-embedding-v3. In this talk we will explain how we did and how it boost your AI system.

- Event context: AI Tinkerers Berlin - March 21 — 2024-03-21 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_3BFEbL0Qshs

### [How to fix vector search for long documents](https://munich.aitinkerers.org/talks/rsvp_mV7upH2iftY)

A common approach when building vector search for long documents is to divide documents into small text chunks of around 200 words and embed these chunks into vectors. This leads to a problem. Each vector contains information about its local context, but does not take global context of the full document into account. We at midpage are building a genAI research and drafting platform for US lawyers and are working on semantic search for long legal documents. We would like to share our ideas and findings.

- Event context: AI Tinkerers Munich - January 18 — 2024-01-18 — Munich
- Public talk page: https://munich.aitinkerers.org/talks/rsvp_mV7upH2iftY

### [Embedding Playground](https://sf.aitinkerers.org/talks/rsvp_BaSs5JHByG0)

We've built a playground to evaluate different embedding models for retrieving information from Wikipedia articles. The playground also lets you generate a chat model response with and without RAG to see how augmenting language models with various datasets can improve responses.

- Event context: AI Tinkerers SF - September Meetup🤖🔄🧠 — 2023-09-22 — San Francisco
- Public talk page: https://sf.aitinkerers.org/talks/rsvp_BaSs5JHByG0

## Related Technologies

- [RAG](https://aitinkerers.org/technologies/rag) ([Markdown](https://aitinkerers.org/technologies/rag.md)) — 147 public demos
- [Vector Search](https://aitinkerers.org/technologies/vector-search) ([Markdown](https://aitinkerers.org/technologies/vector-search.md)) — 12 public demos
- [BERT](https://aitinkerers.org/technologies/bert) ([Markdown](https://aitinkerers.org/technologies/bert.md)) — 179 public demos
- [GPT-3](https://aitinkerers.org/technologies/gpt-3) ([Markdown](https://aitinkerers.org/technologies/gpt-3.md)) — 191 public demos
- [GPT-4](https://aitinkerers.org/technologies/gpt-4) ([Markdown](https://aitinkerers.org/technologies/gpt-4.md)) — 529 public demos
- [semantic search](https://aitinkerers.org/technologies/semantic-search) ([Markdown](https://aitinkerers.org/technologies/semantic-search.md)) — 5 public demos
- [Apache Lucene](https://aitinkerers.org/technologies/apache-lucene) ([Markdown](https://aitinkerers.org/technologies/apache-lucene.md)) — 2 public demos
- [BLOOM](https://aitinkerers.org/technologies/bloom) ([Markdown](https://aitinkerers.org/technologies/bloom.md)) — 115 public demos
- [BM25](https://aitinkerers.org/technologies/bm25) ([Markdown](https://aitinkerers.org/technologies/bm25.md)) — 5 public demos
- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 214 public demos
- [Discord](https://aitinkerers.org/technologies/discord) ([Markdown](https://aitinkerers.org/technologies/discord.md)) — 10 public demos
- [Elasticsearch](https://aitinkerers.org/technologies/elasticsearch) ([Markdown](https://aitinkerers.org/technologies/elasticsearch.md)) — 5 public demos
- [FAISS](https://aitinkerers.org/technologies/faiss) ([Markdown](https://aitinkerers.org/technologies/faiss.md)) — 17 public demos
- [HNSW](https://aitinkerers.org/technologies/hnsw) ([Markdown](https://aitinkerers.org/technologies/hnsw.md)) — 7 public demos
- [Llama-2](https://aitinkerers.org/technologies/llama-2) ([Markdown](https://aitinkerers.org/technologies/llama-2.md)) — 227 public demos
- [PaLM 2](https://aitinkerers.org/technologies/palm-2) ([Markdown](https://aitinkerers.org/technologies/palm-2.md)) — 116 public demos
- [pgvector](https://aitinkerers.org/technologies/pgvector) ([Markdown](https://aitinkerers.org/technologies/pgvector.md)) — 25 public demos
- [RoBERTa](https://aitinkerers.org/technologies/roberta) ([Markdown](https://aitinkerers.org/technologies/roberta.md)) — 118 public demos