# RAG sin base vectorial aparte: búsqueda vectorial nativa en Turso

> Turso guarda embeddings y busca por similitud con SQL, en la misma base que tus datos. Qué ofrece el motor Turso Database, qué ofrecen libSQL y Turso Cloud con el índice DiskANN, y cuándo alcanza.

- URL: https://entropyvision.pro/blog/rag-sin-base-vectorial-aparte-busqueda-vectorial-nativa-en-turso
- Publicado: 2026-10-15
- Categoría: Supabase
- Autor: Mark-Co Digital (investigado y publicado de forma automatizada con Claude)
- Sitio: Mark-Co Digital — https://entropyvision.pro

Sí, con Turso podés armar un sistema de RAG (generación aumentada por recuperación) sin sumar una base de datos vectorial separada: los embeddings se guardan en una columna de la misma tabla que tus datos y la búsqueda por similitud se hace con SQL. Lo que tenés que saber es que hay dos implementaciones distintas: la del motor nuevo **Turso Database**, que hoy hace búsqueda exacta por recorrido completo, y la de **libSQL y Turso Cloud**, que suma un índice aproximado DiskANN para colecciones grandes. Elegir bien depende de cuántos vectores vas a tener.

Este artículo es parte de la serie "Turso en español" de Mark-Co Digital. Si venís del post sobre [una base de datos por agente de IA](https://markco.digital/blog/una-base-de-datos-por-agente-de-ia-la-arquitectura-que-propone-turso), esta es la pieza que le da memoria semántica a cada agente.

## Por qué no sumar otra base de datos

La arquitectura típica de RAG junta tres cosas: la base relacional con tus datos, una base vectorial para los embeddings y un proceso que mantenga ambas sincronizadas. En el post "You Don't Need A Separate Vector Database", Jamie Barton defiende en el blog de Turso la idea de tener los vectores junto a los datos relacionales, y cita al blog de Timescale para describir el dolor de malabarear tres sistemas.

Las ventajas concretas de tenerlo todo en una base:

- Un solo backup, un solo permiso, una sola fuente de verdad.
- Podés filtrar por columnas normales (fecha, cliente, categoría) en la misma consulta que busca por similitud.
- Si usás una base por cliente o por agente, cada una tiene sus propios vectores aislados. La página de soluciones para agentes de IA de Turso destaca justamente la búsqueda vectorial en la misma base que el estado del agente.

La documentación general de Turso lo resume como búsqueda por similitud nativa para apps de IA y flujos de RAG, sin extensiones.

## Turso Database: vectores nativos con búsqueda exacta

En el motor reescrito en Rust, los vectores son nativos: no hay que cargar ninguna extensión.

### Tipos y funciones

La referencia de funciones vectoriales lista estos tipos:

TipoQué es`vector32`32 bits por dimensión (4 bytes)`vector64`64 bits por dimensión (8 bytes)`vector`por defecto, floats de 32 bits`vector8`cuantizado`vector1bit`binario`vector32_sparse`dispersoY estas funciones de distancia: `vector_distance_cos` (coseno), `vector_distance_l2` (euclídea), `vector_distance_dot` (producto punto negativo) y `vector_distance_jaccard`. También hay utilidades como `vector_extract`, `vector_concat` y `vector_slice`.

### Un ejemplo completo

La guía de búsqueda vectorial de Turso usa una tabla de documentos con una columna `BLOB` para el embedding:

```sql
CREATE TABLE documents (
    id INTEGER PRIMARY KEY,
    title TEXT,
    content TEXT,
    embedding BLOB
);

```

Se insertan los documentos con su vector (en la vida real, el vector lo genera un modelo de embeddings; acá son 4 dimensiones para que se entienda):

```sql
INSERT INTO documents (title, content, embedding) VALUES
    ('Machine learning basics', 'An introduction to ML concepts...', vector32('[0.2, 0.5, 0.1, 0.8]')),
    ('Database fundamentals', 'How relational databases work...', vector32('[0.1, 0.3, 0.9, 0.2]')),
    ('Neural networks guide', 'Deep learning architectures...', vector32('[0.3, 0.6, 0.2, 0.7]'));

```

Y se busca ordenando por distancia a la consulta:

```sql
SELECT title,
       vector_distance_cos(embedding, vector32('[0.25, 0.55, 0.15, 0.75]')) AS distance
FROM documents
ORDER BY distance
LIMIT 5;

```

### Límites que conviene conocer

- **Búsqueda por recorrido lineal:** según la guía, las búsquedas de similitud recorren la tabla. El README del motor lo describe como soporte vectorial con búsqueda exacta. Es preciso, pero el costo crece con la cantidad de filas.
- **Índice experimental:** la referencia menciona un método de índice vectorial disperso experimental, detrás del flag `--experimental-index-method`. No encontramos documentación de un índice DiskANN en este motor.
- **Hasta 65.536 dimensiones.**
- Con `vector1bit` no hay distancia L2, y el coseno devuelve distancia de Hamming.

## libSQL y Turso Cloud: el índice DiskANN

Si tu base corre sobre libSQL (el fork de SQLite, que es el motor por defecto al crear una base en Turso Cloud sin `--tursodb`), tenés otra implementación con índice de vecinos aproximados.

### Columnas e índice

La página de IA y embeddings documenta tipos de columna como `F32_BLOB` (el recomendado), `F64_BLOB`, `F16_BLOB`, `FB16_BLOB`, `F8_BLOB` y `F1BIT_BLOB`. Sobre una tabla con una de esas columnas, el índice se crea con `libsql_vector_idx`:

```sql
CREATE INDEX movies_idx ON movies(libsql_vector_idx(embedding));

```

Admite parámetros, como la métrica o la compresión de vecinos:

```sql
CREATE INDEX movies_idx
ON movies(libsql_vector_idx(embedding, 'metric=l2', 'compress_neighbors=float8'));

```

### Consultar con vector\_top\_k

La función `vector_top_k` devuelve los k vecinos más cercanos usando el índice, y podés unir el resultado con la tabla para aplicar filtros normales:

```sql
SELECT title, year
FROM vector_top_k('movies_idx', vector32('[0.064, 0.777, 0.661, 0.687]'), 3)
JOIN movies ON movies.rowid = id
WHERE year >= 2020;

```

Algunos detalles de la documentación: la métrica por defecto es coseno; hay parámetros como `max_neighbors`, `alpha`, `search_l` e `insert_l` para ajustar precisión y velocidad; y la tabla necesita ROWID o una PRIMARY KEY simple. El límite también es de 65.536 dimensiones.

## Un pipeline real: Turso y Voyage AI

En julio de 2026, Jeff Olson (Turso) e Ian Ward (MongoDB) publicaron en el blog de Turso una guía para armar un pipeline de recuperación con Turso y Voyage AI. Usa columnas `F32_BLOB(1024)`, `vector32()`, `vector_distance_cos()`, el índice `libsql_vector_idx` y `vector_top_k()`, es decir, la implementación de libSQL. Según el post, la combinación reduce la pila habitual de RAG con varios servicios a una base embebible y una API de recuperación.

## La tabla para no confundirse

Turso Database (Rust)libSQL / Turso CloudVectores nativosSí (`vector32`, `vector64`, etc.)Sí (`F32_BLOB`, etc.)Búsqueda exactaSí, por recorrido linealSí, con funciones de distanciaÍndice aproximadoÍndice disperso experimentalDiskANN con `libsql_vector_idx`Consulta top-k con índiceNo documentada`vector_top_k`Máximo de dimensiones65.53665.536## Qué significa para tu proyecto

Para una pyme, el caso típico es un asistente que responde sobre documentos propios: manuales, preguntas frecuentes, fichas de productos o normativas internas. Si hablamos de cientos o pocos miles de fragmentos, la búsqueda exacta del motor nuevo probablemente alcance y te ahorra configurar índices; igual, medilo con tu volumen. Si hablamos de colecciones grandes, el índice DiskANN de libSQL en Turso Cloud es la opción documentada hoy.

Además, la búsqueda vectorial también llega a otros entornos: la guía de Drizzle cubre columnas vectoriales, y los bindings de React Native de Turso incluyen búsqueda vectorial en el dispositivo. El caso de Kin, un asistente de IA que según Turso guarda todos los datos en el dispositivo, es un buen ejemplo de RAG local.

Recomendaciones prácticas:

1. Decidí el motor antes de escribir SQL: las funciones de índice no son las mismas.
2. Guardá el texto original junto al vector para poder mostrar la fuente de cada respuesta.
3. Si tenés una base por cliente o por agente, aprovechá ese aislamiento: la búsqueda nunca mezcla datos de otro.

Para el contexto de por qué Supabase anunció la compra de Turso pensando en agentes, mirá [nuestro post sobre Supabase Select 2026 y la compra de Turso](https://markco.digital/blog/supabase-select-2026-y-la-compra-de-turso-que-cambia-para-tu-backend).

## Preguntas frecuentes

### ¿Necesito instalar una extensión para guardar embeddings en Turso?

No. Tanto en Turso Database como en libSQL y Turso Cloud los tipos y funciones vectoriales vienen integrados.

### ¿Puedo usar vector\_top\_k en una base creada con --tursodb?

La documentación de `vector_top_k` y `libsql_vector_idx` corresponde a libSQL y Turso Cloud. En la referencia del motor Turso Database no aparece; ahí la búsqueda es por recorrido lineal, con un índice disperso experimental.

### ¿Qué métrica de distancia conviene para embeddings de texto?

La que recomiende el proveedor de tu modelo de embeddings. Coseno es el valor por defecto del índice DiskANN y la que usan los ejemplos oficiales.

### ¿Cuántas dimensiones admite un vector?

Hasta 65.536, en los dos motores, según la documentación.

## Cómo seguimos

Si querés un asistente o agente de IA que responda con la información de tu empresa, en Mark-Co Digital diseñamos e implementamos [agentes de IA a medida](https://markco.digital/servicios/automatizacion-n8n/chatbots-y-agentes-de-ia/agentes-a-medida), incluida la base de datos que guarda su conocimiento, evaluando opciones como Turso y Supabase. Conocé también nuestro servicio de [agentes de IA](https://markco.digital/servicios/automatizacion-n8n/chatbots-y-agentes-de-ia/agentes-de-ia) o [escribinos](https://markco.digital/contacto).

## Fuentes

- [Turso Docs: Vector search guide](https://docs.turso.tech/guides/vector-search.md)
- [Turso Docs: Vector functions](https://docs.turso.tech/sql-reference/functions/vector.md)
- [Turso Docs: AI and embeddings (libSQL y Turso Cloud)](https://docs.turso.tech/features/ai-and-embeddings.md)
- [Turso Database en GitHub](https://github.com/tursodatabase/turso)
- [Jeff Olson e Ian Ward: Building a Retrieval Pipeline with Turso and Voyage AI](https://turso.tech/blog/building-a-retrieval-pipeline-with-turso-and-voyage-ai)
- [Jamie Barton: You Don't Need A Separate Vector Database](https://turso.tech/blog/you-dont-need-a-separate-vector-database)
- [Turso Docs: Introduction](https://docs.turso.tech/introduction)
- [Turso: solución para agentes de IA](https://turso.tech/solutions/ai-agents)
- [Turso: Kin y la búsqueda vectorial en el dispositivo](https://turso.tech/blog/local-first-ai-assistant-kin-leverages-tursos-libsql-for-on-device-native-vector-search)
- [Turso Docs: Drizzle](https://docs.turso.tech/sdk/ts/orm/drizzle.md)
- [Nikita Sivukhin: Introducing React Native bindings for Turso](https://turso.tech/blog/react-native-bindings-for-turso)