Snowflake Intelligence es el ecosistema de agentes cognitivos dentro de Snowflake Cortex que combina Cortex Analytics (text-to-SQL) y Cortex Search (RAG sobre documentos) para responder preguntas complejas mediante orquestación automática de herramientas.

Componentes Principales:

1. Cortex Analytics (Text-to-SQL)

• Traduce preguntas en lenguaje natural a SQL ejecutable
• Usa embeddings para comprensión semántica del esquema
• Genera consultas SQL válidas y seguras

1. Cortex Search (RAG Vectorial)

• Búsqueda semántica sobre documentos usando embeddings
• Índices vectoriales optimizados con métrica COSINE
• Filtros híbridos: semánticos + metadatos estructurados

1. Agente Orquestador

• Planifica y ejecuta automáticamente herramientas
• Decide cuándo usar Analytics vs Search vs ambos
• Gestiona contexto, memoria y validación

---

Ejemplos de Consultas y Pipelines RAG

1. Consulta Vectorial con Cortex Search

-- Búsqueda semántica híbrida con filtros
WITH semantic_search AS (
  SELECT
    doc_id,
    content,
    metadata,
    VECTOR_COSINE_DISTANCE(
      embedding_vector,
      SNOWFLAKE.CORTEX.EMBED_TEXT('snowflake-arctic-embed-m',
        '¿Cómo configurar replicación de datos?')
    ) AS similarity_score
  FROM docs_embeddings
  WHERE metadata:"dept" = 'IT'  -- Filtro estructural
    AND similarity_score < 0.25  -- Umbral de relevancia
  ORDER BY similarity_score ASC
  LIMIT 5  -- top_k
)
SELECT * FROM semantic_search;

2. Cortex Analytics (Text-to-SQL)

-- Generación de SQL desde lenguaje natural
SELECT SNOWFLAKE.CORTEX.COMPLETE(
  'snowflake-arctic-embed-m',
  'mi-llm-asistente',
  CONCAT(
    'Contexto de esquema: ',
    (SELECT LISTAGG(DISTINCT '"' || TABLE_SCHEMA || '"."' || TABLE_NAME || '" (' ||
      LISTAGG(COLUMN_NAME, ', ') WITHIN GROUP (ORDER BY ORDINAL_POSITION) || ')', '; ')
     FROM INFORMATION_SCHEMA.COLUMNS
     WHERE TABLE_SCHEMA = 'VENTAS'),
    '. Pregunta: ¿Cuáles fueron las ventas totales por región en el último trimestre?',
    ' Instrucción: Genera una única consulta SQL válida para Snowflake.'
  )
) AS generated_sql;

3. Pipeline RAG Híbrido Completo (Python)

import snowflake.connector
from typing import List, Dict

class CortexRAGAgent:
    def __init__(self, conn_params: Dict):
        self.conn = snowflake.connector.connect(**conn_params)
        self.llm_model = 'mistral-large'
        self.embed_model = 'snowflake-arctic-embed-m'

    def retrieve_hybrid(self, query: str, top_k: int = 5, score_threshold: float = 0.3) -> List[Dict]:
        """Recuperación híbrida: semántica + filtros"""
        # 1. Embedding de la consulta
        embed_cursor = self.conn.cursor()
        embed_cursor.execute(f"""
            SELECT SNOWFLAKE.CORTEX.EMBED_TEXT('{self.embed_model}', %s) AS query_vec
        """, (query,))
        query_vector = embed_cursor.fetchone()[0]

        # 2. Búsqueda vectorial con filtros
        retrieve_cursor = self.conn.cursor()
        retrieve_cursor.execute("""
            SELECT
                doc_id,
                doc_content,
                metadata,
                VECTOR_COSINE_DISTANCE(embedding_vector, %s) AS score
            FROM docs_embeddings
            WHERE metadata:"dept" = 'IT'
                AND score < %s
            ORDER BY score ASC
            LIMIT %s
        """, (query_vector, score_threshold, top_k))

        return [{"id": r[0], "content": r[1], "score": r[3]}
                for r in retrieve_cursor.fetchall()]

    def generate_with_context(self, query: str, contexts: List[str]) -> Dict:
        """Generación aumentada por contexto"""
        context_str = "\n---\n".join(contexts)
        prompt = f"""
        Eres un asistente experto. Responde basándote únicamente en el contexto.
        Contexto:
        {context_str}
        Pregunta: {query}
        Respuesta:
        """

        gen_cursor = self.conn.cursor()
        gen_cursor.execute(f"""
            SELECT SNOWFLAKE.CORTEX.COMPLETE('{self.embed_model}', '{self.llm_model}', %s)
        """, (prompt,))

        return {"answer": gen_cursor.fetchone()[0], "contexts_used": len(contexts)}

    def execute_agent_flow(self, user_query: str) -> Dict:
        """Flujo completo: Recuperar -> Razonar -> Generar -> Validar"""
        # Paso 1: Recuperación
        chunks = self.retrieve_hybrid(user_query, top_k=5)
        if not chunks:
            return {"error": "No se encontró contexto relevante."}

        # Paso 2: Extraer contextos relevantes
        contexts = [c["content"] for c in chunks if c["score"] < 0.25]

        # Paso 3: Generación
        response = self.generate_with_context(user_query, contexts)

        # Paso 4: Retorno con metadatos
        return {
            "final_answer": response["answer"],
            "sources": [c["id"] for c in chunks],
            "retrieval_scores": [c["score"] for c in chunks],
            "contexts_used": response["contexts_used"]
        }

# Uso del agente
agent = CortexRAGAgent({
    "user": "your_user",
    "password": "your_password",
    "account": "your_account",
    "warehouse": "COMPUTE_WH",
    "database": "CORTEX_DB",
    "schema": "RAG_SCHEMA"
})

result = agent.execute_agent_flow("¿Cuál es la política de backup de la base de datos?")
print(result)

4. Orquestación via REST API

{
  "session_id": "user_123_session",
  "query": "¿Cuáles fueron las ventas del Q1 2024 y qué tendencias predictivas hay?",
  "tools": [
    {
      "name": "cortex_search",
      "parameters": {
        "collection": "sales_reports",
        "query_vector": "EMBEDDING_PLACEHOLDER",
        "filters": {"quarter": "Q1", "year": 2024},
        "top_k": 5,
        "score_threshold": 0.75
      }
    },
    {
      "name": "cortex_analytics",
      "parameters": {
        "function": "FORECAST",
        "target_column": "revenue",
        "time_column": "date",
        "horizon": 30
      }
    }
  ],
  "reasoning_config": {
    "max_steps": 5,
    "fallback_action": "ask_user_for_clarification"
  }
}

---

Flujo de Trabajo Típico:

1. Ingesta: Documentos → Stage Snowflake → Chunking → Embedding → Tabla vectorial
2. Recuperación: Query → Embedding → Búsqueda vectorial + filtros → Top-K chunks
3. Planificación: Agente decide herramientas necesarias (Analytics, Search, o ambas)
4. Ejecución:

• Cortex Search: Recupera documentos relevantes
• Cortex Analytics: Genera y ejecuta SQL

1. Síntesis: LLM combina resultados en respuesta coherente
2. Validación: Verifica consistencia, evita alucinaciones, registra auditoría

---

Referencias RAG:

(RAG: cortex_doc_tool) La arquitectura de Snowflake Intelligence combina el Cortex Agent API, el orquestador y las herramientas como componentes modulares.

(RAG: cortex_doc_tool) Cortex Analyst para text-to-SQL y Cortex Search para RAG sobre documentos son componentes centrales para la analítica de self-service.

(RAG: cortex_doc_tool) La evolución hacia una «plataforma de acción inteligente» con agentes personalizados y flujos autónomos respaldados por Cortex AI está alineada con el diseño de pipelines híbridos.

(RAG: cortex_doc_tool) Los datos nunca salen de Snowflake para el procesamiento de Cortex, manteniendo el cumplimiento de soberanía de datos y regulaciones como GDPR.