Rethinking Enterprise Search with Cortex Search

In line with Stack Overflow and Atlassian, builders lose between 6 and 10 hours each week trying to find info or clarifying unclear documentation. For a 50-developer crew, that provides as much as $675,000–$1.1 million in wasted productiveness yearly. This isn’t only a tooling difficulty. It’s a retrieval downside.
Enterprises have loads of information however lack quick, dependable methods to seek out the appropriate info. Conventional search fails as programs develop advanced, slowing onboarding, choices, and help. On this article, we discover how trendy enterprise search solves these gaps.

Why Conventional Enterprise Search Falls Quick

Most enterprise search programs had been constructed for a distinct period. They assume comparatively static content material, predictable bugs and queries, and handbook tuning to remain related. In trendy information surroundings none of these assumptions maintain significance. 

Groups work throughout quickly altering datasets. Queries are ambiguous and conversational. Context issues as a lot as Key phrases. But many search instruments nonetheless depend on brittle guidelines and actual matches, forcing customers guess the appropriate phrasing reasonably than expressing actual intent.  

The result’s acquainted. Individuals search repeatedly, refine queries manually or abandon search altogether. In AI-powered purposes, the issue turns into extra severe. Poor retrieval doesn’t simply sluggish customers down. It usually feeds incomplete or irrelevant context into language fashions, growing the chance of low-quality or deceptive outputs.  

The Swap to Hybrid Retrieval

The subsequent era of enterprise search is constructed on hybrid retrieval. As an alternative of selecting between key phrase search and semantic search, trendy programs mix each of them.  

Key phrase search excels at precision. Vector search captures that means and intent. Collectively, they allow search experiences which are quick, versatile and resilient throughout a variety of queries. 

Cortex Search is designed orienting this hybrid method from the beginning. It gives low latency, high-quality fuzzy search immediately over Snowflake information, with out requiring groups to handle embeddings and tune relevance parameters or keep customized infrastructure. The retrieval layer adapts to the info, not the opposite approach round. 

Moderately than treating search as an add on characteristic, Coretx Search makes it a foundational functionality that scales with enterprise information complexity. 

Cortex Search because the Retrieval Layer for AI and Enterprise Search

Cortex Search helps two main use instances which are more and more central to trendy information methods. 

First is Retrieval Augmented Era. Cortex Search acts because the retrieval engine that provides giant language fashions with correct, up-to-date enterprise context. This grounding layer is what permits AI chat purposes to ship responses which are particular, related and aligned with proprietary information reasonably than generic patterns. 

Second is Enterprise Search. Cortex Search can energy high-quality search experiences embedded immediately into purposes, instruments and workflows. Customers ask questions in pure language and obtain outcomes ranked by each semantic relevance and key phrase precision.

Underneath the hood, cortex search indexes textual content information, applies hybrid retrieval and makes use of semantic reranking to floor essentially the most related outcomes. Refreshes are automated and incremental, so search outcomes keep aligned with the present state of the info with out handbook intervention. 

This issues as a result of retrieval high quality immediately shapes consumer belief. When search works persistently, individuals depend on it. When it doesn’t, they cease utilizing it and fall again to slower, costlier paths. 

How Cortex Search Works in Apply

At a excessive stage, Cortex Search abstracts away the toughest elements of constructing a contemporary retrieval system. 

Instance: Powering RAG Functions with Cortex Search

What we’ll Construct: A buyer help AI assistant that solutions consumer questions by retrieving grounded context from historic help tickets and transcripts: then passing that context to a Snowflake Cortex LLM to generate correct, particular solutions.

Stipulations

Organising Snowflake account

1. Head over to trial.snowflake.com and Join the Enterprise account

2. Now you will notice one thing like this:

Step 1 — Set Up Snowflake Atmosphere

Run the next in a Snowflake Worksheet to create the database, schema 

First create a brand new sql file.

CREATE DATABASE IF NOT EXISTS SUPPORT_DB;

CREATE WAREHOUSE IF NOT EXISTS COMPUTE_WH
WAREHOUSE_SIZE = 'X-SMALL'
AUTO_SUSPEND = 60
AUTO_RESUME = TRUE;

USE DATABASE SUPPORT_DB;
USE WAREHOUSE COMPUTE_WH;

Step 2 — Create and Populate the Supply Desk

This desk simulates historic help tickets. In manufacturing, this might be a reside desk synced out of your CRM, ticketing system, or information pipeline.

CREATE TABLE IF NOT EXISTS SUPPORT_DB.PUBLIC.support_tickets (
    ticket_id VARCHAR(20),
    issue_category VARCHAR(100),
    user_query TEXT,
    decision TEXT,
    created_at TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP()
);

INSERT INTO SUPPORT_DB.PUBLIC.support_tickets (ticket_id, issue_category, user_query, decision) VALUES
('TKT-001', 'Connectivity',
'My web retains dropping each jiffy. The router lights look regular.',
'Agent checked line diagnostics. Discovered intermittent sign degradation on the coax line. Dispatched technician to exchange splitter. Concern resolved after {hardware} swap.'),

('TKT-002', 'Connectivity',
'Web may be very sluggish throughout evenings however high-quality within the morning.',
'Community congestion detected in buyer phase throughout peak hours (6–10 PM). Upgraded buyer to a much less congested node. Speeds normalized inside 24 hours.'),

('TKT-003', 'Billing',
'I used to be charged twice for a similar month. Want a refund.',
'Duplicate billing confirmed as a result of fee gateway retry error. Refund of $49.99 issued. Buyer notified through e mail. Root trigger patched in billing system.'),

('TKT-004', 'System Setup',
'My new router isn't exhibiting up within the Wi-Fi record on my laptop computer.',
'Router was broadcasting on 5GHz solely. Buyer laptop computer had outdated Wi-Fi driver that didn't help 5GHz. Guided buyer to replace driver. Each 2.4GHz and 5GHz bands now seen.'),

('TKT-005', 'Connectivity',
'Frequent packet loss throughout video calls. Wired connection additionally affected.',
'Packet loss traced to defective ethernet port on modem. Changed modem below guarantee. Buyer confirmed secure connection post-replacement.'),

('TKT-006', 'Account',
'Can't log into the shopper portal. Password reset emails will not be arriving.',
'Electronic mail supply blocked by SPF document misconfiguration on buyer area. Suggested buyer to supply help area. Reset e mail delivered efficiently.'),

('TKT-007', 'Connectivity',
'Web unstable solely when microwave is operating within the kitchen.',
'2.4GHz Wi-Fi interference attributable to microwave proximity to router. Really helpful switching router channel from 6 to 11 and enabling 5GHz band. Concern eradicated.'),

('TKT-008', 'Pace',
'Marketed pace is 500Mbps however I solely get round 120Mbps on speedtest.',
'Pace take a look at confirmed 480Mbps at node. Buyer router restricted to 100Mbps as a result of Quick Ethernet port. Really helpful router improve. Submit-upgrade pace confirmed at 470Mbps.');

Step 3 — Create the Cortex Search Service

This single SQL command handles embedding era, indexing, and hybrid retrieval setup routinely. The ON clause specifies which column to index for full-text and semantic search. ATTRIBUTES defines filterable metadata columns.

CREATE OR REPLACE CORTEX SEARCH SERVICE SUPPORT_DB.PUBLIC.support_search_svc
ON decision
ATTRIBUTES issue_category, ticket_id
WAREHOUSE = COMPUTE_WH
TARGET_LAG = '1 minute'
AS (
    SELECT
        ticket_id,
        issue_category,
        user_query,
        decision
    FROM SUPPORT_DB.PUBLIC.support_tickets
);

What occurs right here: Snowflake routinely generates vector embeddings for the decision column, builds each a key phrase index and a vector index, and exposes a unified hybrid retrieval endpoint. No embedding mannequin administration, no separate vector database.

You may confirm the service is energetic:

SHOW CORTEX SEARCH SERVICES IN SCHEMA SUPPORT_DB.PUBLIC;

Output:

Step 4 — Question the Search Service from Python

Connect with Snowflake and use the snowflake-core SDK to question the service:

First Set up required packages:

pip set up snowflake-snowpark-python snowflake-core

Now to seek out your account particulars go to your account and click on on “Join a device to Snowflake”

from snowflake.snowpark import Session
from snowflake.core import Root

# --- Connection config ---
connection_params = {
    "account": "YOUR_ACCOUNT_IDENTIFIER",  # e.g. abc12345.us-east-1
    "consumer": "YOUR_USERNAME",
    "password": "YOUR_PASSWORD",
    "position": "SYSADMIN",
    "warehouse": "COMPUTE_WH",
    "database": "SUPPORT_DB",
    "schema": "PUBLIC",
}

# --- Create Snowpark session ---
session = Session.builder.configs(connection_params).create()
root = Root(session)

# --- Reference the Cortex Search service ---
search_svc = (
    root.databases["SUPPORT_DB"]
    .schemas["PUBLIC"]
    .cortex_search_services["SUPPORT_SEARCH_SVC"]
)

def retrieve_context(question: str, category_filter: str = None, top_k: int = 3):
    """Run hybrid search in opposition to the Cortex Search service."""
    filter_expr = {"@eq": {"issue_category": category_filter}} if category_filter else None

    response = search_svc.search(
        question=question,
        columns=["ticket_id", "issue_category", "user_query", "resolution"],
        filter=filter_expr,
        restrict=top_k,
    )
    return response.outcomes

# --- Take a look at retrieval ---
user_question = "Why is my web unstable?"
outcomes = retrieve_context(user_question, top_k=3)

print(f"n🔍 Question: {user_question}n")
print("=" * 60)

for i, r in enumerate(outcomes, 1):
    print(f"n[Result {i}]")
    print(f"  Ticket ID : {r['ticket_id']}")
    print(f"  Class  : {r['issue_category']}")
    print(f"  Consumer Question: {r['user_query']}")
    print(f"  Decision: {r['resolution'][:200]}...")

Output:

Step 5 — Construct the Full RAG Pipeline

Now cross the retrieved context into Snowflake Cortex LLM (mistral-large or llama3.1-70b) to generate a grounded reply:

import json

def build_rag_prompt(user_question: str, retrieved_results: record) -> str:
    """Format retrieved context into an LLM-ready immediate."""
    context_blocks = []
    for r in retrieved_results:
        context_blocks.append(
            f"- Ticket {r['ticket_id']} ({r['issue_category']}): "
            f"Buyer reported '{r['user_query']}'. "
            f"Decision: {r['resolution']}"
        )
    context_str = "n".be a part of(context_blocks)

    return f"""You're a useful buyer help assistant. Use ONLY the context beneath
to reply the shopper's query. Be particular and concise.

CONTEXT FROM HISTORICAL TICKETS:
{context_str}

CUSTOMER QUESTION: {user_question}
ANSWER:"""

def ask_rag_assistant(user_question: str, mannequin: str = "mistral-large2"):
    """Full RAG pipeline: retrieve → increase → generate."""
    print(f"n📡 Retrieving context for: '{user_question}'")
    outcomes = retrieve_context(user_question, top_k=3)
    print(f"   ✅ Retrieved {len(outcomes)} related tickets")

    immediate = build_rag_prompt(user_question, outcomes)

    safe_prompt = immediate.exchange("'", "'")
    sql = f"""
        SELECT SNOWFLAKE.CORTEX.COMPLETE(
            '{mannequin}',
            '{safe_prompt}'
        ) AS reply
    """

    outcome = session.sql(sql).accumulate()
    reply = outcome[0]["ANSWER"]
    return reply, outcomes

# --- Run the assistant ---
questions = [
    "Why is my internet unstable?",
    "I'm being charged incorrectly, what should I do?",
    "My router is not visible on my devices",
]

for q in questions:
    reply, ctx = ask_rag_assistant(q)
    print(f"n{'='*60}")
    print(f"❓ Buyer: {q}")
    print(f"n🤖 AI Assistant:n{reply.strip()}")
    print(f"n📎 Grounded in tickets: {[r['ticket_id'] for r in ctx]}")

Output:

Key takeaway: The AI by no means generates generic solutions. Each response is traceable to particular historic tickets, dramatically lowering hallucination danger and making outputs auditable.

Instance: Constructing Enterprise Search into Functions

What we’ll construct: 

A pure language help ticket search interface — embedded immediately into an utility — that lets brokers and prospects search historic tickets utilizing plain English. No new infrastructure is required: this instance reuses the very same support_tickets desk and support_search_svc Cortex Search service created within the RAG part above.

This exhibits how the identical Cortex Search service can energy two completely completely different surfaces: an AI assistant on one hand, and a browsable search UI on the opposite.

Step 1 — Verify the Current Service is Lively

Confirm the service created within the earlier part continues to be operating:

USE DATABASE SUPPORT_DB;

USE SCHEMA PUBLIC;

SHOW CORTEX SEARCH SERVICES IN SCHEMA RAG_SCHEMA;

Output:

Step 2 — Construct the Enterprise Search Shopper

This module connects to the identical Snowpark session and support_search_svc service, and exposes a search operate with class filtering and ranked outcome show — the sort of interface you’d embed right into a help portal, an inner information device, or an agent dashboard.

# enterprise_search.py

from snowflake.snowpark import Session
from snowflake.core import Root

# --- Connection config ---
connection_params = {
    "account": "YOUR_ACCOUNT_IDENTIFIER",  # e.g. abc12345.us-east-1
    "consumer": "YOUR_USERNAME",
    "password": "YOUR_PASSWORD",
    "position": "SYSADMIN",
    "warehouse": "COMPUTE_WH",
    "database": "SUPPORT_DB",
    "schema": "PUBLIC",
}

session = Session.builder.configs(connection_params).create()
root = Root(session)

# --- Similar service because the RAG instance — no new service wanted ---
search_svc = (
    root.databases["SUPPORT_DB"]
    .schemas["RAG_SCHEMA"]
    .cortex_search_services["SUPPORT_SEARCH_SVC"]
)

def search_tickets(question: str, class: str = None, top_k: int = 5) -> record:
    """Pure language ticket search with elective class filter."""
    filter_expr = {"@eq": {"issue_category": class}} if class else None

    response = search_svc.search(
        question=question,
        columns=["ticket_id", "issue_category", "user_query", "resolution"],
        filter=filter_expr,
        restrict=top_k,
    )
    return response.outcomes

def display_tickets(question: str, outcomes: record, filter_label: str = None):
    """Render search outcomes as a formatted ticket record."""
    label = f" [{filter_label}]" if filter_label else ""

    print(f"n🔎 Search{label}: "{question}"")
    print(f"   {len(outcomes)} ticket(s) foundn")
    print("-" * 72)

    for i, r in enumerate(outcomes, 1):
        print(f"  #{i}  {r['ticket_id']}  |  Class: {r['issue_category']}")
        print(f"       Buyer: {r['user_query']}")
        print(f"       Decision: {r['resolution'][:160]}...n")

Step 3 — Run Pure Language Ticket Searches

# --- Search 1: Semantic question — no actual match wanted ---
outcomes = search_tickets("system not connecting to the community")
display_tickets("system not connecting to the community", outcomes)

Output:

# --- Search 2: Class-filtered search (Billing solely) ---
outcomes = search_tickets(
    question="incorrect fee or refund request",
    class="Billing"
)

display_tickets(
    "incorrect fee or refund request",
    outcomes,
    filter_label="Billing"
)

2nd Output:

# --- Search 3: Account & entry points ---
outcomes = search_tickets("cannot log in or entry my account", class="Account")
display_tickets("cannot log in or entry my account", outcomes, filter_label="Account")

Output:

Step 4 — Expose as a Flask Search API (Elective)

Wrap the search operate in a REST endpoint to embed it into any help portal, inner device, or chatbot backend:

# app.py

from flask import Flask, request, jsonify
from enterprise_search import search_tickets

app = Flask(__name__)

@app.route("/tickets/search", strategies=["GET"])

def ticket_search():
    question    = request.args.get("q", "")
    class = request.args.get("class")        # elective filter
    top_k    = int(request.args.get("restrict", 5))

    if not question:
        return jsonify({"error": "Question parameter 'q' is required"}), 400

    outcomes = search_tickets(question, class=class, top_k=top_k)

    return jsonify({
        "question":    question,
        "class": class,
        "rely":    len(outcomes),
        "outcomes":  outcomes,
    })

if __name__ == "__main__":
    app.run(port=5001, debug=True)

Take a look at with curl:

# Free-text pure language search
curl "http://localhost:5001/tickets/search?q=web+retains+dropping&restrict=3"

Output:

# Filtered by class

curl "http://localhost:5001/tickets/search?q=charged+incorrectly&class=Billing"

Output:

Key takeaway: The identical Cortex Search service that grounds the RAG assistant additionally powers a completely purposeful enterprise search UI — no duplication of infrastructure, no second index to keep up. One service definition delivers each experiences, and each keep routinely in sync as tickets are added or up to date.

The Enterprise Affect of Higher Retrieval

Poor information search strategies quietly erode enterprise efficiency. Time is misplaced to repeated queries and rework. However, help groups get entangled in resolving questions that ought to have been self-served within the first place. New hires and prospects take longer to succeed in productiveness. AI initiatives stall when outputs can’t be trusted. 

Against this, sturdy retrieval adjustments how organizations function. 

Groups transfer quicker as a result of solutions are simpler to seek out. AI purposes carry out higher as a result of they’re grounded in related, present information. Function adoption improves as a result of customers can uncover and perceive capabilities with out friction. Assist prices decline as search absorbs routine questions. 

Cortex Search turns retrieval from a background utility right into a strategic lever. It helps enterprises unlock the worth already current of their information by making it accessible, searchable and usable at scale.  

Steadily Requested Questions

Dentsu’s world functionality heart, Dentsu International Providers (DGS), is shaping the longer term as an innovation engine. DGS has 5,600+ consultants specializing in digital platforms, efficiency advertising and marketing, product engineering, information science, automation and AI, with media transformation on the core. DGS delivers AI-first, scalable options by means of dentsu’s community seamlessly integrating individuals, expertise, and craft. They mix human creativity and superior expertise, constructing a various, future-focused group that adapts shortly to consumer wants whereas guaranteeing reliability, collaboration and excellence in each engagement.

DGS brings collectively world-class expertise, breakthrough expertise and daring concepts to ship affect at scale—for dentsu’s purchasers, its individuals and the world. It’s a future-focused, industry-leading office the place expertise meets alternative. At DGS, workers can speed up their profession, collaborate with world groups and contribute to work that shapes the longer term. Discover out extra: Dentsu International Providers