Oracle 26ai Búsqueda Vectorial de IA

February 8, 2026

Oracle 26ai Búsqueda Vectorial de IA

Tiempo de lectura: 6 minutos

1. ¿Por Qué los Vectores de IA Importan Ahora?

Los vectores están omnipresentes en las aplicaciones modernas de IA. Cuando se ejecuta una búsqueda semántica, recomendación de productos, detección de fraude, o un agente de IA razona sobre documentos corporativos, la interrogante subyacente es: ¿qué elemento posee mayor similitud con este?

Históricamente, la construcción de estos sistemas implicaba:

Depender de una base de datos vectorial separada (Pinecone, Weaviate, Qdrant).
Mantener la sincronización de datos entre el almacén transaccional y el vectorial.
Gestionar dos pilas de operaciones y recuperación.
Lidiar con la latencia de red entre sistemas heterogéneos.

Oracle 23ai transformó este paradigma al integrar el almacenamiento de vectores, la búsqueda y la IA generativa como características nativas de la base de datos. Oracle 26ai profundiza esta integración: transaccionalidad completa, índices híbridos, agentes de IA integrados y rendimiento de nivel Exadata.

En el contexto de datos empresariales, la generación de respuestas de IA o la construcción de aplicaciones conversacionales, Oracle AI Vector Search representa el punto de consolidación real.

2. Conceptos Fundamentales

2.1 Vectores: El Puente Entre Lenguaje y Números

Un vector es una lista ordenada de números (típicamente entre 384 y 4096 de longitud) que codifica el significado de un texto, imagen o concepto en un espacio matemático multidimensional.

[Imagen sugerida: Visualización de incrustaciones vectoriales mapeando texto a espacio 3D destacando proximidad semántica]

Ejemplo: La oración “¿Cuál es nuestra política de devoluciones?” se transforma en una representación numérica similar a:

[0.12, -0.45, 0.78, 0.03, ..., 0.21]

La proximidad de dos vectores en este espacio indica similitud semántica, independientemente de si comparten palabras exactas. Esto contrasta con la búsqueda por palabras clave, que exige una coincidencia terminológica precisa.

2.2 Modelos de Incrustación (Embeddings)

Un modelo de incrustación consiste en una red neuronal entrenada que procesa texto (o imagen) como entrada y genera un vector como salida. Oracle incorpora modelos pregenerados residentes en la base de datos:

ALL_MINILM_L12_V2: Modelo de 384 dimensiones de propósito general (Sentence Transformers).
MULTILINGUAL_MINILM: Optimizado para documentos en múltiples idiomas.
Modelos personalizados ONNX: Permite la carga de modelos de terceros propios.

La ventaja crítica reside en que los vectores se generan dentro del motor de la base de datos, eliminando la latencia de red asociada a servicios externos.

2.3 Funciones de Distancia

La comparación entre vectores se realiza mediante funciones de distancia. Una menor distancia indica mayor similitud de contenido.

Coseno (Cosine): Mide el ángulo entre vectores. Es el estándar para similitud semántica (0 = idéntico, 2 = opuesto).
Euclidiana (Euclidean): Mide la distancia de línea recta en el espacio de incrustación.
Producto Punto (Dot Product): Multiplicación escalar. Ofrece velocidad, pero requiere vectores normalizados.

2.4 Índices Vectoriales

En ausencia de un índice, la búsqueda del vector más similar obligaría a comparar la consulta contra cada vector en la tabla (escaneo completo). Los índices vectoriales organizan los datos para una recuperación eficiente.

Oracle soporta dos familias principales de índices:

HNSW (Hierarchical Navigable Small World):

Estructura de grafo navegable.
Búsqueda de alta velocidad: sub-milisegundos en millones de registros.
Residente en memoria (gestionado vía VECTOR_MEMORY_SIZE).
Novedad en 26ai: escrituras transaccionales completas y replicación en RAC.

IVF (Índice de Archivo Invertido):

Divide el espacio vectorial en clusters.
Menor consumo de memoria en comparación con HNSW.
Búsqueda rápida (se prueba un bajo porcentaje de clusters).
Enfoque conservador, recomendado para despliegues iniciales.

2.5 Recuperación Aumentada por Generación (RAG)

El patrón clásico en aplicaciones con IA sigue este flujo:

El usuario formula una pregunta.
El sistema ejecuta una búsqueda vectorial en la base de conocimiento.
Se recuperan los documentos más similares como “contexto”.
Este contexto se envía a un LLM junto con la pregunta original.
El LLM genera una respuesta fundamentada exclusivamente en dicho contexto.

Este proceso de “aumento” mitiga las alucinaciones, asegurando que el LLM se limite a la información existente en la empresa.

3. Estructura de Datos y Sintaxis en Oracle

3.1 El Tipo de Dato VECTOR

En Oracle 23ai/26ai, el vector se implementa como un tipo de dato nativo:

CREATE TABLE knowledge_base (
  id          NUMBER PRIMARY KEY,
  doc_text    CLOB,
  embedding   VECTOR(384, FLOAT32)  -- 384 dimensiones, precisión simple
);

El especificador es VECTOR(dimensiones, formato):

Dimensiones: 1 a 65535.
Formato: FLOAT32 (32-bit), FLOAT64 (64-bit, 23ai+), INT8 (8-bit, 26ai+), BINARY (1 bit, 26ai+).

Notas sobre formatos:

FLOAT32: Estándar equilibrado. ~1.5 MB para 1 millón de vectores.
FLOAT64: Mayor precisión, doble consumo de memoria. Rara vez necesario.
INT8: 4× más compacto que FLOAT32, con un sacrificio mínimo de precisión. Ideal para escalabilidad.
BINARY: 32× más compacto. Para 1 billón de vectores, requiere ~4 TB frente a los 128 TB de FLOAT32.

3.2 Función VECTOR_EMBEDDING()

Para generar un vector a partir de texto, se utiliza la siguiente sintaxis:

SELECT doc_id, doc_text,
       VECTOR_EMBEDDING(ALL_MINILM_L12_V2 USING doc_text AS DATA) AS embedding
FROM raw_documents;

El modelo ALL_MINILM_L12_V2 reside en la base de datos. La salida es un VECTOR(384, FLOAT32).

Es posible especificar el formato de salida: VECTOR_EMBEDDING(model USING text AS DATA FORMAT INT8).

3.3 Función VECTOR_DISTANCE()

Cálculo de la similitud entre dos vectores:

SELECT id, doc_text,
       VECTOR_DISTANCE(embedding,
         VECTOR_EMBEDDING(ALL_MINILM_L12_V2 USING 'consulta de ejemplo' AS DATA), COSINE) AS distance
FROM knowledge_base
ORDER BY distance
FETCH FIRST 5 ROWS ONLY;

Los parámetros de función de distancia admitidos son: COSINE, EUCLIDEAN, o DOT_PRODUCT.

3.4 Función VECTOR_SIMILARITY()

Alternativa conveniente que invierte la lógica de distancia (valor más alto = mayor similitud):

SELECT id, doc_text,
       VECTOR_SIMILARITY(embedding,
         VECTOR_EMBEDDING(ALL_MINILM_L12_V2 USING 'consulta de ejemplo' AS DATA), COSINE) AS similarity
FROM knowledge_base
ORDER BY similarity DESC
FETCH FIRST 5 ROWS ONLY;

4. Creación e Indexación de Vectores

4.1 Flujo Básico: Desde Documentos Hasta Búsqueda

Paso 1: Creación de tabla con columna VECTOR

CREATE TABLE documents (
  id        NUMBER PRIMARY KEY,
  title     VARCHAR2(500),
  content   CLOB,
  embedding VECTOR(384, FLOAT32)
);

Paso 2: Generación de incrustaciones

INSERT INTO documents (id, title, content, embedding)
SELECT doc_id, doc_title, doc_content,
       VECTOR_EMBEDDING(ALL_MINILM_L12_V2 USING doc_content AS DATA)
FROM source_table;
COMMIT;

Paso 3: Creación del índice vectorial

CREATE VECTOR INDEX idx_doc_embed ON documents(embedding)
ORGANIZATION HNSW
  PARAMETERS (TYPE HNSW, NUMBER_OF_NEIGHBORS 32, MAX_NEIGHBORS 64, DISTANCE_METRIC COSINE);

4.2 HNSW vs IVF: Criterios de Selección

HNSW:

✅ Latencia sub-milisegundo en millones de registros.
✅ 26ai: Escrituras transaccionales completas (INSERT, UPDATE, DELETE).
✅ 26ai: Replicación automática en Oracle RAC.
❌ Consumo de memoria.

IVF:

✅ Menor consumo de memoria.
✅ Optimizado para datasets masivos.
✅ Construcción de índices más veloz.
❌ Latencia más variable.

Estrategia recomendada: Iniciar con IVF para despliegues iniciales. Migrar a HNSW una vez validados los patrones de carga y si se requiere latencia sub-milisegundo.

4.3 Indexación Híbrida (26ai)

Novedad en 26ai: el Índice de Vectores Híbrido (HVI) indexa columnas de vectores y texto en una estructura unificada.

CREATE VECTOR INDEX idx_docs_hybrid
  ON documents(embedding, title)
  ORGANIZATION HNSW
    PARAMETERS (TYPE HNSW, VECTOR_DISTANCE_METRIC COSINE);

Esto permite combinar coincidencia vectorial y textual en una sola consulta:

SELECT id, title, content,
       VECTOR_DISTANCE(embedding, ..., COSINE) AS vec_distance
FROM documents
WHERE title LIKE '%política%'
  AND VECTOR_DISTANCE(embedding, VECTOR_EMBEDDING(...)) < 0.5
ORDER BY vec_distance
FETCH FIRST 10 ROWS ONLY;

4.4 Persistencia de Índices HNSW (26ai)

En 26ai, HNSW persiste en disco. El reinicio de la base de datos recupera el índice desde la imagen en disco en segundos, eliminando horas de espera. No se requiere sintaxis especial.

5. Búsqueda Vectorial: Sintaxis y Patrones

5.1 Búsqueda Semántica Básica (Top-K)

DECLARE
  l_query_vec VECTOR(384, FLOAT32);
BEGIN
  l_query_vec := VECTOR_EMBEDDING(ALL_MINILM_L12_V2 
    USING 'Como restablezco mi contraseña?' AS DATA);

  FOR rec IN (
    SELECT id, title, content,
           VECTOR_DISTANCE(embedding, l_query_vec, COSINE) AS distance
    FROM documents
    ORDER BY distance
    FETCH FIRST 5 ROWS ONLY
  ) LOOP
    DBMS_OUTPUT.PUT_LINE(rec.id || ': ' || rec.title || ' (' || rec.distance || ')');
  END LOOP;
END;
/

5.2 Búsqueda con Filtros (Predicado Vectorial)

SELECT id, title, content, category,
       VECTOR_DISTANCE(embedding, ..., COSINE) AS distance
FROM documents
WHERE category = 'Soporte'
  AND VECTOR_DISTANCE(embedding, VECTOR_EMBEDDING(ALL_MINILM_L12_V2
    USING 'problema de conexión' AS DATA), COSINE) < 1.0
ORDER BY distance
FETCH FIRST 10 ROWS ONLY;

5.3 Búsqueda Aproximada vs Exacta

-- Búsqueda Aproximada (rápida, usa índice)
SELECT id FROM documents
WHERE VECTOR_DISTANCE(embedding, q_vec, COSINE) < 0.5;

-- Búsqueda Exacta (lenta, escaneo completo)
SELECT id FROM documents
WHERE VECTOR_DISTANCE_WITH_EXACT(embedding, q_vec, COSINE) < 0.5;

6. Recuperación Aumentada por Generación (RAG) + Select AI

6.1 RAG Manual

DECLARE
  l_context  CLOB;
  l_question VARCHAR2(4000) := '¿Cuál es nuestra política de devoluciones?';
BEGIN
  -- Paso 1: Búsqueda semántica
  SELECT LISTAGG(doc_text, CHR(10)) INTO l_context
  FROM (
    SELECT doc_text FROM knowledge_base
    ORDER BY VECTOR_DISTANCE(embedding, VECTOR_EMBEDDING(all_minilm_l12_v2 USING l_question AS data), COSINE)
    FETCH FIRST 5 ROWS ONLY
  );

  -- Paso 2: Generación con Select AI
  SELECT DBMS_CLOUD_AI.GENERATE(
    prompt       => 'Basado en: ' || l_context || ' Responda: ' || l_question,
    profile_name => 'MY_AI_PROFILE'
  ) INTO l_response FROM DUAL;
END;
/

6.2 Select AI Agent (26ai): RAG Automatizado

DECLARE
  l_response CLOB;
BEGIN
  SELECT ai_agent.invoke(
    conversation_id => DBMS_RANDOM.VALUE(),
    question        => '¿Cuál es nuestra política de devoluciones?',
    context_source  => 'SELECT doc_text FROM knowledge_base',
    retrieval_mode  => 'VECTOR',
    vector_column   => 'embedding',
    model_name      => 'ALL_MINILM_L12_V2'
  ) INTO l_response FROM DUAL;

  DBMS_OUTPUT.PUT_LINE(l_response);
END;
/

7. Evolución de Capacidades: 23ai → 26ai

Capacidad	23ai	26ai
Tipo de dato VECTOR	FLOAT32, FLOAT64	+ INT8, BINARY
Índice HNSW + DML	Tablas de solo lectura	Consistencia transaccional completa
HNSW en RAC	Solo instancia única	Replicado entre nodos
Índice de Vectores Híbrido	❌	✅ Búsqueda unificada
Funciones personalizadas	Estándar	JavaScript (User Defined)
Persistencia HNSW	Reconstrucción al reiniciar	Persistencia en disco
Select AI Agent	❌	✅ Flujos agénticos

8. Software del Sistema Exadata 25ai

El Software del Sistema Exadata 25ai incorpora optimizaciones aceleradas por hardware:

Escaneo Inteligente de IA: Traslada el cálculo de distancia a los servidores de almacenamiento.
Aceleración INT8 y BINARY: Cálculo de distancia hasta 8× y 32× más rápido.
Filtrado Top-K Adaptativo: Reduce el tráfico de red enviando solo candidatos relevantes.

9. Integración de Marcos (LangChain)

from langchain_oracledb.vectorstores.oraclevs import OracleVS
from langchain_oracledb.embeddings import OracleEmbeddings

# Uso de modelo residente en DB
embeddings = OracleEmbeddings(
    conn=connection,
    params={"provider": "database", "model": "ALL_MINILM_L12_V2"}
)

# Búsqueda híbrida
retriever = OracleHybridSearchRetriever(
    vector_store=vs, idx_name="IDX_DOCS_HYB",
    search_mode="hybrid", k=5
)
results = retriever.invoke("problemas de conectividad")

10. Lista de Verificación del Profesional

Revisión del SQL generado: Se recomienda validar el código generado por APEX AI Assistant o Select AI antes de producción.
Metadatos del modelo: Es crucial rastrear nombre y versión del modelo; la reconstrucción de índices es costosa si se pierde esta información.
Comentarios de columna: AI Vector Search utiliza el diccionario de datos para enriquecer el prompt.
Escalabilidad (IVF a HNSW): Usar IVF inicialmente; migrar a HNSW solo si se requiere latencia extrema.
BINARY/INT8: Esencial para datasets masivos (32× menos almacenamiento).
Búsqueda híbrida: Priorizar para casos intensivos en documentos.

11. Entornos de Prueba

Nivel Siempre Libre de Oracle: Autonomous Database en OCI.
apex.oracle.com: Espacio de trabajo gratuito con soporte vectorial.
Oracle LiveLabs: Talleres guiados.
Docker: Imagen de Oracle Database Free 23ai.

Referencias

Oracle Corporation. (2024). AI Vector Search User’s Guide (26ai). Recuperado de docs.oracle.com
Oracle Corporation. (2024). Hybrid Vector Index Documentation. Recuperado de docs.oracle.com
Kolk, B. (2024). AI Vector Search Tutorial. ORACLE-BASE.
LangChain. (2024). Oracle Vector Store Integration Guide. docs.langchain.com

Older Post

Archives

Categories