LLM-Powered Recommendation & Search

"You do not need to know what you want. Just tell me how you feel, and I will find it for you."

Deploy, Emotionally Perceptive AI Agent

1. LLMs as Recommendation Engines

LLMs can serve as recommendation engines by leveraging their world knowledge and reasoning abilities.

Given a description of user preferences, past interactions, and a catalog of items, an LLM can generate personalized recommendations with natural language explanations. This approach excels for cold-start scenarios (new users with no history) and for nuanced preferences that are difficult to capture with traditional feature vectors. Code Fragment 28.4.2 below puts this into practice.

# implement recommend_items
# Key operations: visualization, API interaction
from openai import OpenAI
import json

client = OpenAI()

def recommend_items(user_profile: str, catalog: list, n: int = 5) -> dict:
 response = client.chat.completions.create(
 model="gpt-4o-mini",
 messages=[
 {"role": "system", "content": f"""You are a recommendation engine.
Given a user profile and catalog, recommend {n} items.
Return JSON with 'recommendations' array, each having:
'item_id', 'score' (0-1), 'reasoning' (brief explanation)."""},
 {"role": "user", "content": f"""User Profile: {user_profile}
Catalog: {json.dumps(catalog)}"},
 ],
 response_format={"type": "json_object"},
 )
 return json.loads(response.choices[0].message.content)

recs = recommend_items(
 user_profile="Enjoys sci-fi with strong worldbuilding, dislikes romance subplots",
 catalog=[
 {"id": "b1", "title": "Dune", "genre": "sci-fi"},
 {"id": "b2", "title": "The Notebook", "genre": "romance"},
 {"id": "b3", "title": "Neuromancer", "genre": "sci-fi"},
 ],
)

2. LLM-Powered Search

LLM-powered search systems like Perplexity represent a paradigm shift from "ten blue links" to direct answers with cited sources. The architecture combines a search engine (retrieving relevant web pages), a reader model (extracting key information from each source), and a generator model (synthesizing a coherent answer with inline citations). This is essentially RAG (Chapter 20) applied at web scale. Figure 28.4.1 shows the LLM-powered search architecture. Code Fragment 28.4.3 below puts this into practice.

# Building a simple LLM-powered search with RAG
from openai import OpenAI
import requests

client = OpenAI()

def llm_search(query: str, search_results: list) -> str:
 # Format search results as context
 context = "\n\n".join([
 f"[Source {i+1}] {r['title']}\nURL: {r['url']}\n{r['snippet']}"
 for i, r in enumerate(search_results)
 ])

 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": """Answer the user's query using the provided sources.
Cite sources inline using [Source N] notation. Be concise and factual.
If sources conflict, note the disagreement."""},
 {"role": "user", "content": f"Query: {query}\n\nSources:\n{context}"},
 ],
 )
 return response.choices[0].message.content

3. Conversational Recommendation

Conversational recommendation combines dialogue management with recommendation logic. Instead of a one-shot recommendation, the system engages in a multi-turn conversation to elicit preferences, clarify constraints, and refine suggestions. This is particularly valuable for high-consideration purchases (electronics, travel, real estate) where user needs are complex and evolving. Code Fragment 28.4.2 below puts this into practice.

# Define ConversationalRecommender; implement __init__, chat
# Key operations: results display, API interaction
from openai import OpenAI

client = OpenAI()

class ConversationalRecommender:
 def __init__(self, catalog_context: str):
 self.messages = [{
 "role": "system",
 "content": f"""You are a helpful product recommendation assistant.
Ask clarifying questions to understand user needs before recommending.
Available products:\n{catalog_context}
Always explain why each recommendation fits the user's stated needs."""
 }]

 def chat(self, user_message: str) -> str:
 self.messages.append({"role": "user", "content": user_message})
 response = client.chat.completions.create(
 model="gpt-4o-mini",
 messages=self.messages,
 )
 reply = response.choices[0].message.content
 self.messages.append({"role": "assistant", "content": reply})
 return reply

recommender = ConversationalRecommender(catalog_context="...")
print(recommender.chat("I need a laptop for data science work"))

4. User Preference Modeling

LLMs can build rich user preference models from natural language interactions, product reviews, and browsing histories. Rather than reducing preferences to sparse feature vectors, LLMs maintain a natural language summary of what the user likes, dislikes, and values. This "preference narrative" can be updated through conversation and used to condition future recommendations.

5. Automated Analytics and NL-to-Dashboard

One of the most transformative applications of LLMs in information access is the ability to translate natural language questions into data queries, execute those queries, generate visualizations, and narrate the results. This NL-to-Analytics pipeline democratizes data analysis by letting business users ask questions like "What were our top 5 products by revenue last quarter, broken down by region?" and receive a chart with an accompanying narrative, all without writing SQL or Python.

5.1 The NL-to-Analytics Pipeline

The full pipeline has four stages. First, the user poses a question in natural language. Second, the LLM translates that question into executable code, typically SQL for database queries or Python for statistical analysis. Third, the system executes the generated code against the data source and captures the results. Fourth, the LLM generates a visualization specification and a written narrative that explains the key insights. Each stage introduces potential errors, so production systems include validation checks between stages to catch hallucinated table names, syntactically invalid queries, and misleading chart configurations.

5.2 Text-to-SQL with LLMs

The most critical step in the pipeline is translating natural language to SQL. This requires schema linking: the LLM must identify which database tables and columns correspond to the entities and attributes in the user's question. For instance, "revenue by region" must be mapped to the correct table (perhaps orders) and columns (total_amount, shipping_region). Modern approaches use few-shot prompting with example question-SQL pairs specific to the database schema. The DIN-SQL method (Pourreza and Rafiei, 2023) decomposes complex queries into sub-problems, solving schema linking, query classification, and SQL generation in separate stages. The DAIL-SQL approach (Gao et al., 2024) uses efficient example selection to choose the most informative few-shot examples based on query similarity, achieving state-of-the-art results on the Spider benchmark. These techniques connect directly to the Text-to-SQL coverage in Section 20.5.

import json
from openai import OpenAI

client = OpenAI()

# Database schema provided as context for schema linking
DB_SCHEMA = """Tables:
 orders(order_id, customer_id, product_id, total_amount, order_date, region)
 products(product_id, product_name, category, unit_price)
 customers(customer_id, name, segment, signup_date)"""

def nl_to_sql(question: str, schema: str = DB_SCHEMA) -> dict:
 """Translate a natural language question to SQL with explanation."""
 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": f"""You are a SQL generation assistant. Given a database schema
and a natural language question, generate a valid SQL query.

Database schema:
{schema}

Return JSON with:
 "sql": the SQL query (read-only SELECT statements only)
 "explanation": brief description of what the query does
 "tables_used": list of tables referenced
 "assumptions": any assumptions made about the question"""},
 {"role": "user", "content": question},
 ],
 response_format={"type": "json_object"},
 temperature=0.0,
 )
 return json.loads(response.choices[0].message.content)

result = nl_to_sql("What are the top 5 product categories by total revenue this year?")
print("SQL:", result["sql"])
print("Explanation:", result["explanation"])

5.3 NL-to-Visualization

Once query results are available, the LLM can generate visualization specifications. The most common approach uses declarative formats like Vega-Lite (a JSON-based grammar for interactive graphics) or matplotlib code. The Chat2Vis system (Maddigan and Susnjak, 2023) demonstrated that LLMs can select appropriate chart types, map data fields to visual channels, and configure axes and legends from a natural language description alone. The NL4DV framework (Narechania et al., 2021) takes a more structured approach, decomposing the visualization generation into attribute inference, task inference, and visualization design. In production, the LLM examines the shape of the query results (number of dimensions, data types, cardinality) and selects a chart type accordingly: bar charts for categorical comparisons, line charts for time series, scatter plots for correlations, and tables for detailed breakdowns.

def generate_chart_spec(question: str, query_results: list[dict]) -> dict:
 """Generate a Vega-Lite chart spec from query results."""
 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": """Generate a Vega-Lite JSON specification for the data.
Choose the most appropriate chart type for the question and data shape.
Include: title, axis labels, color encoding if useful, and a tooltip.
Also include a key "narrative" field with 2 to 3 sentences summarizing
the main insight visible in the data."""},
 {"role": "user", "content": f"""Question: {question}
Data (first 5 rows): {json.dumps(query_results[:5])}
Total rows: {len(query_results)}"},
 ],
 response_format={"type": "json_object"},
 )
 return json.loads(response.choices[0].message.content)

# Example: visualize revenue by category
sample_data = [
 {"category": "Electronics", "total_revenue": 1250000},
 {"category": "Clothing", "total_revenue": 890000},
 {"category": "Home", "total_revenue": 720000},
]
spec = generate_chart_spec("Top product categories by revenue", sample_data)
print("Chart type:", spec.get("mark", "unknown"))
print("Narrative:", spec.get("narrative", ""))

5.4 Augmented Analytics Platforms

Several commercial products have integrated LLMs into their analytics workflows, creating what the industry calls "augmented analytics." Tableau AI (Salesforce) lets users type questions about their data and receive auto-generated visualizations with narrative explanations. ThoughtSpot Sage uses an LLM to translate natural language into its proprietary search query language, enabling business users to explore data conversationally. Microsoft Copilot for Power BI allows users to describe the report they want, and the system generates DAX queries, visualizations, and written summaries. These platforms share a common design pattern: the analyst-in-the-loop approach, where the LLM generates a first draft of the analysis and the human analyst reviews, refines, and validates before sharing. This mirrors the "AI as triage" pattern from Section 28.2 on financial applications.

5.5 Challenges in NL-to-Analytics

The NL-to-Analytics pipeline faces several significant challenges. Hallucinated SQL is the most dangerous: the LLM may reference tables or columns that do not exist, join tables on incorrect keys, or apply aggregate functions incorrectly. Schema validation (checking that all referenced objects exist) and result sanity checks (verifying row counts and value ranges) are essential guardrails. Schema misinterpretation occurs when column names are ambiguous; a column named date could refer to order date, ship date, or creation date, and the LLM must disambiguate from context or ask clarifying questions. Data confidentiality is a concern when using cloud LLM APIs: sending database schemas and query results to external services may violate data governance policies, pushing some organizations toward self-hosted models. Finally, trust in automated insights remains a barrier, because users may accept a generated chart at face value without verifying that the underlying query correctly represents their question. The analyst-in-the-loop pattern mitigates this risk by making review a required step.

# Map-reduce text analytics over a corpus
from openai import OpenAI
import json
from concurrent.futures import ThreadPoolExecutor

client = OpenAI()

def map_analyze(text: str, doc_id: str) -> dict:
 """Map phase: analyze a single document."""
 response = client.chat.completions.create(
 model="gpt-4o-mini", # small model for classification
 messages=[{
 "role": "user",
 "content": (
 "Analyze this customer review. Return JSON with:\n"
 "- sentiment: positive/negative/mixed\n"
 "- themes: list of 1-3 topic tags\n"
 "- key_quote: the most informative sentence\n"
 "- feature_requests: list (empty if none)\n\n"
 f"Review: {text}"
 )
 }],
 response_format={"type": "json_object"},
 temperature=0,
 )
 result = json.loads(response.choices[0].message.content)
 result["doc_id"] = doc_id
 return result

def reduce_synthesize(summaries: list[dict]) -> str:
 """Reduce phase: synthesize all map results into a report."""
 summary_text = json.dumps(summaries, indent=1)
 response = client.chat.completions.create(
 model="gpt-4o", # large model for synthesis
 messages=[{
 "role": "user",
 "content": (
 "You are a product analytics expert. Given these per-review "
 "summaries, produce a report with:\n"
 "1. Top 5 themes ranked by frequency\n"
 "2. Overall sentiment breakdown (% positive/negative/mixed)\n"
 "3. Top feature requests with supporting quotes\n"
 "4. Three actionable recommendations\n\n"
 f"Review summaries:\n{summary_text}"
 )
 }],
 temperature=0.3,
 )
 return response.choices[0].message.content

# Execute map phase in parallel
reviews = [{"id": f"r{i}", "text": t} for i, t in enumerate(all_reviews)]

with ThreadPoolExecutor(max_workers=10) as pool:
 futures = [pool.submit(map_analyze, r["text"], r["id"]) for r in reviews]
 mapped = [f.result() for f in futures]

# Execute reduce phase
report = reduce_synthesize(mapped)
print(report)